1use std::collections::{BTreeMap, HashMap};
23use std::path::Path;
24use std::sync::Arc;
25
26use anyhow::{anyhow, Context as _};
27use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
28use ed25519_dalek::VerifyingKey;
29use hyprstream_rpc::auth::mac::SecurityLabel;
30use serde::{Deserialize, Serialize};
31
32pub const SERVICE_ENROLLMENT_FILE: &str = "service-enrollment.json";
34
35pub const SERVICE_ENROLLMENT_VERSION: u32 = 1;
37
38#[derive(Debug, Clone, Serialize, Deserialize)]
41pub struct ServiceEnrollment {
42 pub ed25519_pubkey: String,
45 #[serde(default, skip_serializing_if = "Option::is_none")]
48 pub ml_dsa_pubkey: Option<String>,
49 pub clearance: SecurityLabel,
51 #[serde(default, skip_serializing_if = "Option::is_none")]
54 pub allowed_audiences: Option<Vec<String>>,
55 #[serde(default)]
59 pub workload_session: bool,
60}
61
62#[derive(Debug, Clone, Serialize, Deserialize)]
64pub struct ServiceEnrollmentManifest {
65 pub version: u32,
67 pub services: BTreeMap<String, ServiceEnrollment>,
69}
70
71impl ServiceEnrollmentManifest {
72 pub fn load(secrets_dir: &Path) -> anyhow::Result<Option<Self>> {
76 let path = secrets_dir.join(SERVICE_ENROLLMENT_FILE);
77 if !path.exists() {
78 return Ok(None);
79 }
80 let raw =
81 std::fs::read_to_string(&path).with_context(|| format!("read {}", path.display()))?;
82 let manifest: Self =
83 serde_json::from_str(&raw).with_context(|| format!("parse {}", path.display()))?;
84 manifest
85 .validate()
86 .with_context(|| format!("validate {}", path.display()))?;
87 Ok(Some(manifest))
88 }
89
90 fn validate(&self) -> anyhow::Result<()> {
92 if self.version != SERVICE_ENROLLMENT_VERSION {
93 anyhow::bail!(
94 "unsupported service-enrollment version {} (want {SERVICE_ENROLLMENT_VERSION})",
95 self.version
96 );
97 }
98 if self.services.is_empty() {
99 anyhow::bail!("service-enrollment manifest lists no services");
100 }
101 for (name, entry) in &self.services {
102 crate::auth::identity_store::validate_service_name(name)
103 .map_err(|e| anyhow!("invalid service name {name:?}: {e}"))?;
104 decode_ed25519(&entry.ed25519_pubkey)
105 .with_context(|| format!("service {name:?} ed25519_pubkey"))?;
106 if let Some(pq) = &entry.ml_dsa_pubkey {
107 let bytes = URL_SAFE_NO_PAD
108 .decode(pq)
109 .with_context(|| format!("service {name:?} ml_dsa_pubkey base64"))?;
110 if bytes.len() != 1952 {
112 anyhow::bail!(
113 "service {name:?} ml_dsa_pubkey is {} bytes, want 1952",
114 bytes.len()
115 );
116 }
117 }
118 if let Some(audiences) = &entry.allowed_audiences {
119 if audiences.iter().any(|a| a.trim().is_empty()) {
120 anyhow::bail!("service {name:?} has an empty allowed audience");
121 }
122 }
123 }
124 Ok(())
125 }
126
127 pub fn validate_key_agreement(
134 &self,
135 bootstrap_pubkeys: &HashMap<String, crate::auth::identity_store::BootstrapPubkey>,
136 ) -> anyhow::Result<()> {
137 for (name, bootstrap) in bootstrap_pubkeys {
138 let entry = self
139 .services
140 .get(name)
141 .ok_or_else(|| anyhow!("bootstrap service {name:?} has no enrollment entry"))?;
142 let enrolled = decode_ed25519(&entry.ed25519_pubkey)
143 .with_context(|| format!("service {name:?} ed25519_pubkey"))?;
144 if enrolled != bootstrap.ed25519 {
145 anyhow::bail!(
146 "service {name:?}: enrollment Ed25519 key disagrees with bootstrap-pubkeys"
147 );
148 }
149 let enrolled_pq = entry
150 .ml_dsa_pubkey
151 .as_deref()
152 .map(|b64| {
153 URL_SAFE_NO_PAD
154 .decode(b64)
155 .context("base64url decode")
156 .and_then(|bytes| {
157 if bytes.len() == 1952 {
158 Ok(bytes)
159 } else {
160 Err(anyhow!("ML-DSA-65 verifying key must be 1952 bytes"))
161 }
162 })
163 })
164 .transpose()
165 .with_context(|| format!("service {name:?} ml_dsa_pubkey"))?;
166 let bootstrap_pq = bootstrap
167 .ml_dsa_65
168 .as_ref()
169 .map(hyprstream_rpc::crypto::pq::ml_dsa_vk_bytes);
170 if enrolled_pq != bootstrap_pq {
171 anyhow::bail!(
172 "service {name:?}: enrollment ML-DSA-65 key disagrees with bootstrap-pubkeys (present/different/missing halves must match exactly)"
173 );
174 }
175 }
176 for name in self.services.keys() {
177 if !bootstrap_pubkeys.contains_key(name) {
178 anyhow::bail!("enrollment entry {name:?} is not a bootstrap service");
179 }
180 }
181 Ok(())
182 }
183
184 pub fn load_and_validate(secrets_dir: &Path) -> anyhow::Result<Option<Self>> {
188 let Some(manifest) = Self::load(secrets_dir)? else {
189 return Ok(None);
190 };
191 let bootstrap = crate::auth::identity_store::load_bootstrap_pubkeys_hybrid(secrets_dir)?;
192 manifest.validate_key_agreement(&bootstrap)?;
193 Ok(Some(manifest))
194 }
195
196 pub fn from_bootstrap(
205 pubkeys: &HashMap<String, crate::auth::identity_store::BootstrapPubkey>,
206 ) -> Self {
207 let services = pubkeys
208 .iter()
209 .map(|(name, entry)| {
210 (
211 name.clone(),
212 ServiceEnrollment {
213 ed25519_pubkey: URL_SAFE_NO_PAD.encode(entry.ed25519.to_bytes()),
214 ml_dsa_pubkey: entry.ml_dsa_65.as_ref().map(|vk| {
215 URL_SAFE_NO_PAD.encode(hyprstream_rpc::crypto::pq::ml_dsa_vk_bytes(vk))
216 }),
217 clearance: default_clearance_for(entry),
218 allowed_audiences: None,
219 workload_session: false,
220 },
221 )
222 })
223 .collect();
224 Self {
225 version: SERVICE_ENROLLMENT_VERSION,
226 services,
227 }
228 }
229
230 pub fn reconcile_with_bootstrap(
237 &self,
238 pubkeys: &HashMap<String, crate::auth::identity_store::BootstrapPubkey>,
239 ) -> anyhow::Result<()> {
240 self.validate()?;
241 self.validate_key_agreement(pubkeys)
242 .map_err(|e| anyhow::anyhow!(
243 "{e} — enrollment is authoritative for key binding; edit {SERVICE_ENROLLMENT_FILE} deliberately to rotate"
244 ))
245 }
246
247 pub fn write(&self, secrets_dir: &Path) -> anyhow::Result<()> {
249 let path = secrets_dir.join(SERVICE_ENROLLMENT_FILE);
250 let data = serde_json::to_vec_pretty(self).context("serialize enrollment manifest")?;
251 std::fs::write(&path, data).with_context(|| format!("write {}", path.display()))
252 }
253
254 pub fn clearance_for_service(&self, service: &str) -> Option<SecurityLabel> {
256 self.services.get(service).map(|e| e.clearance)
257 }
258
259 pub fn allows_audience(&self, service: &str, audience: Option<&str>) -> bool {
265 match self.services.get(service) {
266 Some(entry) => match &entry.allowed_audiences {
267 Some(list) => audience.is_some_and(|aud| list.iter().any(|a| a == aud)),
268 None => true,
269 },
270 None => false,
271 }
272 }
273
274 pub fn workload_session_policy(&self, service: &str) -> bool {
277 self.services
278 .get(service)
279 .is_some_and(|e| e.workload_session)
280 }
281}
282
283fn default_clearance_for(entry: &crate::auth::identity_store::BootstrapPubkey) -> SecurityLabel {
288 let assurance = if entry.is_hybrid() {
289 hyprstream_rpc::auth::mac::Assurance::PqHybrid
290 } else {
291 hyprstream_rpc::auth::mac::Assurance::Classical
292 };
293 SecurityLabel::new(
294 hyprstream_rpc::auth::mac::Level::Internal,
295 assurance,
296 hyprstream_rpc::auth::mac::CompartmentSet::EMPTY,
297 )
298}
299
300fn decode_ed25519(b64: &str) -> anyhow::Result<VerifyingKey> {
301 let bytes = URL_SAFE_NO_PAD.decode(b64).context("base64url decode")?;
302 let bytes: [u8; 32] = bytes
303 .try_into()
304 .map_err(|_| anyhow!("Ed25519 verifying key must be 32 bytes"))?;
305 VerifyingKey::from_bytes(&bytes).context("invalid Ed25519 verifying key")
306}
307
308pub fn ensure_node_authority(secrets_dir: &Path) -> anyhow::Result<()> {
311 use super::identity_store as ids;
312 anyhow::ensure!(
313 secrets_dir.join("ca-key").try_exists()?
314 || secrets_dir.join("signing-key").try_exists()?
315 || !(secrets_dir.join("ca-pubkey").try_exists()?
316 || secrets_dir.join("ca-mldsa-pubkey").try_exists()?),
317 "retained public CA exists without private authority; restore the original key"
318 );
319 let root = if secrets_dir.join("ca-key").try_exists()? {
320 ids::load_ca_signing_key(secrets_dir)?
321 } else {
322 ids::load_or_generate_node_signing_key(secrets_dir)?
323 };
324 if secrets_dir.join("signing-key").try_exists()? {
325 let signing = ids::load_existing_service_signing_key(
326 secrets_dir,
327 "policy",
328 ids::SecretsProfile::SharedDirectory,
329 )?;
330 anyhow::ensure!(
331 signing.verifying_key() == root.verifying_key(),
332 "node signing key disagrees with retained CA"
333 );
334 }
335 let ca = hyprstream_rpc::node_identity::derive_purpose_key(&root, "hyprstream-jwt-v1");
336 let pq = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(&ca);
337 let pq_vk = hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk(&pq);
338 let has_public = secrets_dir.join("ca-pubkey").try_exists()?;
339 let has_pq = secrets_dir.join("ca-mldsa-pubkey").try_exists()?;
340 if has_public {
341 anyhow::ensure!(
342 ids::load_ca_verifying_key(secrets_dir)? == ca.verifying_key(),
343 "retained CA verifying key mismatch"
344 );
345 }
346 if has_pq {
347 anyhow::ensure!(
348 hyprstream_rpc::crypto::pq::ml_dsa_vk_bytes(&ids::load_ca_ml_dsa_verifying_key(
349 secrets_dir
350 )?) == hyprstream_rpc::crypto::pq::ml_dsa_vk_bytes(&pq_vk),
351 "retained CA post-quantum key mismatch"
352 );
353 }
354 if !secrets_dir.join("ca-key").try_exists()? {
355 ids::write_ca_signing_key(secrets_dir, &root)?;
356 }
357 if !secrets_dir.join("signing-key").try_exists()? {
358 ids::write_secret(secrets_dir, "signing-key", &root.to_bytes())?;
359 }
360 if !has_public {
361 ids::write_ca_verifying_key(secrets_dir, &ca.verifying_key())?;
362 }
363 if !has_pq {
364 ids::write_ca_ml_dsa_verifying_key(secrets_dir, &pq_vk)?;
365 }
366 Ok(())
367}
368
369pub fn reconcile_existing_services(
373 secrets_dir: &Path,
374 issuer: &str,
375 now: i64,
376) -> anyhow::Result<usize> {
377 use super::identity_store::{self, BootstrapPubkey, SecretsProfile};
378 anyhow::ensure!(
379 !issuer.trim().is_empty(),
380 "service enrollment requires a local issuer"
381 );
382 let bootstrap = identity_store::load_bootstrap_pubkeys_hybrid(secrets_dir)?;
383 anyhow::ensure!(!bootstrap.is_empty(), "no provisioned bootstrap services");
384 identity_store::ensure_bootstrap_pubkeys_hybrid(&bootstrap)?;
385 let root = identity_store::load_ca_signing_key(secrets_dir)?;
386 let ca = hyprstream_rpc::node_identity::derive_purpose_key(&root, "hyprstream-jwt-v1");
387 anyhow::ensure!(
388 identity_store::load_ca_verifying_key(secrets_dir)? == ca.verifying_key(),
389 "retained CA verifying key disagrees with signing authority"
390 );
391 let pq = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(&ca);
392 anyhow::ensure!(
393 hyprstream_rpc::crypto::pq::ml_dsa_vk_bytes(&identity_store::load_ca_ml_dsa_verifying_key(
394 secrets_dir
395 )?) == hyprstream_rpc::crypto::pq::ml_dsa_vk_bytes(
396 &hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk(&pq)
397 ),
398 "retained CA post-quantum key disagrees with signing authority"
399 );
400 let mut local_keys = HashMap::new();
401 for name in bootstrap.keys() {
402 let key = identity_store::load_existing_service_signing_key(
403 secrets_dir,
404 name,
405 SecretsProfile::SharedDirectory,
406 )?;
407 if name == "policy" {
408 anyhow::ensure!(
409 key.verifying_key() == root.verifying_key(),
410 "Policy key disagrees with CA authority"
411 );
412 }
413 local_keys.insert(name.clone(), BootstrapPubkey::for_service_key(&key)?);
414 }
415 ServiceEnrollmentManifest::from_bootstrap(&bootstrap).validate_key_agreement(&local_keys)?;
418 let retained = ServiceEnrollmentManifest::load(secrets_dir)?;
419 let enrollment = retained
420 .clone()
421 .unwrap_or_else(|| ServiceEnrollmentManifest::from_bootstrap(&bootstrap));
422 enrollment.reconcile_with_bootstrap(&bootstrap)?;
423 let mut credentials = Vec::new();
424 for (name, key) in &bootstrap {
425 anyhow::ensure!(
426 enrollment.allows_audience(name, Some(issuer)),
427 "enrollment audience denies service {name}"
428 );
429 let jwt = super::service_jwt::issue_or_load_service_jwt(
430 secrets_dir,
431 name,
432 &ca,
433 key,
434 issuer,
435 now,
436 enrollment.clearance_for_service(name).as_ref(),
437 )?;
438 credentials.push((name, jwt));
439 }
440 if retained.is_none() {
441 let mut staged = tempfile::NamedTempFile::new_in(secrets_dir)?;
442 serde_json::to_writer_pretty(&mut staged, &enrollment)?;
443 staged.as_file().sync_all()?;
444 staged
445 .persist_noclobber(secrets_dir.join(SERVICE_ENROLLMENT_FILE))
446 .context("publish new service-enrollment manifest without replacing retained state")?;
447 }
448 for (name, jwt) in &credentials {
449 identity_store::write_service_jwt(secrets_dir, name, jwt)?;
450 }
451 Ok(credentials.len())
452}
453
454static GLOBAL_SERVICE_ENROLLMENT: std::sync::OnceLock<Arc<ServiceEnrollmentManifest>> =
461 std::sync::OnceLock::new();
462
463pub fn set_global_service_enrollment(
466 manifest: Arc<ServiceEnrollmentManifest>,
467) -> Result<(), ServiceEnrollmentAlreadySet> {
468 GLOBAL_SERVICE_ENROLLMENT
469 .set(manifest)
470 .map_err(|_| ServiceEnrollmentAlreadySet)
471}
472
473#[derive(Debug, Clone, Copy, PartialEq, Eq)]
475pub struct ServiceEnrollmentAlreadySet;
476
477impl std::fmt::Display for ServiceEnrollmentAlreadySet {
478 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
479 write!(f, "service enrollment manifest already installed")
480 }
481}
482
483impl std::error::Error for ServiceEnrollmentAlreadySet {}
484
485pub fn global_service_enrollment() -> Option<&'static Arc<ServiceEnrollmentManifest>> {
487 GLOBAL_SERVICE_ENROLLMENT.get()
488}
489
490#[cfg(test)]
491#[allow(clippy::unwrap_used)]
492mod tests {
493 use super::*;
494 use crate::auth::identity_store::BootstrapPubkey;
495 use hyprstream_rpc::auth::mac::{Assurance, CompartmentSet, Level};
496
497 fn retained_services() -> tempfile::TempDir {
498 use crate::auth::identity_store as ids;
499 let dir = tempfile::tempdir().unwrap();
500 let root = ed25519_dalek::SigningKey::from_bytes(&[71; 32]);
501 let discovery = ed25519_dalek::SigningKey::from_bytes(&[72; 32]);
502 let ca = hyprstream_rpc::node_identity::derive_purpose_key(&root, "hyprstream-jwt-v1");
503 ids::write_ca_signing_key(dir.path(), &root).unwrap();
504 ids::write_secret(dir.path(), "signing-key", &root.to_bytes()).unwrap();
505 ids::write_secret(
506 &dir.path().join("discovery"),
507 "signing-key",
508 &discovery.to_bytes(),
509 )
510 .unwrap();
511 ids::write_ca_verifying_key(dir.path(), &ca.verifying_key()).unwrap();
512 let pq = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(&ca);
513 ids::write_ca_ml_dsa_verifying_key(
514 dir.path(),
515 &hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk(&pq),
516 )
517 .unwrap();
518 ids::write_bootstrap_pubkeys_hybrid(
519 dir.path(),
520 &HashMap::from([
521 (
522 "policy".to_owned(),
523 BootstrapPubkey::for_service_key(&root).unwrap(),
524 ),
525 (
526 "discovery".to_owned(),
527 BootstrapPubkey::for_service_key(&discovery).unwrap(),
528 ),
529 ]),
530 )
531 .unwrap();
532 dir
533 }
534
535 #[test]
536 fn node_authority_is_idempotent_and_does_not_provision_a_roster() {
537 let dir = tempfile::tempdir().unwrap();
538 ensure_node_authority(dir.path()).unwrap();
539 let paths = ["ca-key", "signing-key", "ca-pubkey", "ca-mldsa-pubkey"];
540 let before: Vec<_> = paths
541 .iter()
542 .map(|p| std::fs::read(dir.path().join(p)).unwrap())
543 .collect();
544 ensure_node_authority(dir.path()).unwrap();
545 for (path, bytes) in paths.iter().zip(before) {
546 assert_eq!(std::fs::read(dir.path().join(path)).unwrap(), bytes);
547 }
548 assert!(!dir.path().join("bootstrap-pubkeys").exists());
549 assert!(!dir.path().join(SERVICE_ENROLLMENT_FILE).exists());
550 std::fs::remove_file(dir.path().join("signing-key")).unwrap();
551 ensure_node_authority(dir.path()).unwrap();
552 assert_eq!(
553 std::fs::read(dir.path().join("signing-key")).unwrap(),
554 std::fs::read(dir.path().join("ca-key")).unwrap()
555 );
556 std::fs::write(dir.path().join("signing-key"), [99; 32]).unwrap();
557 assert!(ensure_node_authority(dir.path()).is_err());
558 assert_eq!(
559 std::fs::read(dir.path().join("signing-key")).unwrap(),
560 [99; 32]
561 );
562 }
563
564 #[test]
565 fn retained_enrollment_reconciles_exact_services_and_preserves_keys_and_valid_tokens() {
566 use crate::auth::identity_store as ids;
567 let dir = retained_services();
568 let now = chrono::Utc::now().timestamp();
569 let paths = [
570 "ca-key",
571 "signing-key",
572 "discovery/signing-key",
573 "bootstrap-pubkeys",
574 ];
575 let before: Vec<_> = paths
576 .iter()
577 .map(|p| std::fs::read(dir.path().join(p)).unwrap())
578 .collect();
579 ids::write_service_jwt(dir.path(), "policy", "legacy-invalid-token").unwrap();
581 assert_eq!(
582 reconcile_existing_services(dir.path(), "https://node.invalid", now).unwrap(),
583 2
584 );
585 let manifest = ServiceEnrollmentManifest::load_and_validate(dir.path())
586 .unwrap()
587 .unwrap();
588 assert_eq!(manifest.services.len(), 2);
589 let mut tokens = Vec::new();
590 for name in ["policy", "discovery"] {
591 assert_eq!(
592 manifest.services[name].clearance.assurance,
593 Assurance::PqHybrid
594 );
595 let token = ids::load_service_jwt(dir.path(), name).unwrap().unwrap();
596 let payload: serde_json::Value = serde_json::from_slice(
597 &URL_SAFE_NO_PAD
598 .decode(token.split('.').nth(1).unwrap())
599 .unwrap(),
600 )
601 .unwrap();
602 assert!(payload.get("clearance").is_some());
603 assert_eq!(payload["sub"], format!("service:{name}"));
604 tokens.push(token);
605 }
606 reconcile_existing_services(dir.path(), "https://node.invalid", now + 1).unwrap();
607 for (name, token) in ["policy", "discovery"].iter().zip(tokens) {
608 assert!(
609 ids::load_service_jwt(dir.path(), name).unwrap().unwrap() == token,
610 "valid retained token must be reused"
611 );
612 }
613 for (path, bytes) in paths.iter().zip(before) {
614 assert_eq!(std::fs::read(dir.path().join(path)).unwrap(), bytes);
615 }
616 assert!(
617 !dir.path().join("registry").exists(),
618 "reconcile must not provision unrelated identities"
619 );
620 }
621
622 #[test]
623 fn retained_enrollment_refuses_malformed_mismatched_or_disallowed_authority_before_writes() {
624 use crate::auth::identity_store as ids;
625 for failure in [
626 "malformed",
627 "manifest-key",
628 "private-key",
629 "audience",
630 "missing-key",
631 ] {
632 let dir = retained_services();
633 reconcile_existing_services(dir.path(), "https://node.invalid", 1_700_000_000).unwrap();
634 let path = dir.path().join(SERVICE_ENROLLMENT_FILE);
635 let mut manifest = ServiceEnrollmentManifest::load(dir.path())
636 .unwrap()
637 .unwrap();
638 match failure {
639 "malformed" => std::fs::write(&path, b"{broken").unwrap(),
640 "manifest-key" => {
641 manifest.services.get_mut("policy").unwrap().ed25519_pubkey = test_key_b64().0;
642 manifest.write(dir.path()).unwrap();
643 }
644 "private-key" => {
645 ids::write_secret(&dir.path().join("discovery"), "signing-key", &[99; 32])
646 .unwrap();
647 }
648 "audience" => {
649 manifest
650 .services
651 .get_mut("discovery")
652 .unwrap()
653 .allowed_audiences = Some(vec!["https://other.invalid".into()]);
654 manifest.write(dir.path()).unwrap();
655 }
656 "missing-key" => {
657 std::fs::remove_file(dir.path().join("discovery/signing-key")).unwrap();
658 }
659 _ => unreachable!(),
660 }
661 let before = std::fs::read(&path).unwrap();
662 let token = ids::load_service_jwt(dir.path(), "policy").unwrap();
663 assert!(
664 reconcile_existing_services(dir.path(), "https://node.invalid", 1_800_000_000)
665 .is_err(),
666 "{failure}"
667 );
668 assert_eq!(std::fs::read(&path).unwrap(), before, "{failure}");
669 assert_eq!(
670 ids::load_service_jwt(dir.path(), "policy").unwrap(),
671 token,
672 "{failure}"
673 );
674 }
675 }
676
677 fn test_label() -> SecurityLabel {
678 SecurityLabel::new(Level::Internal, Assurance::Classical, CompartmentSet::EMPTY)
679 }
680
681 fn test_key_b64() -> (String, VerifyingKey) {
682 let sk = ed25519_dalek::SigningKey::from_bytes(&[0x42; 32]);
683 let vk = sk.verifying_key();
684 (URL_SAFE_NO_PAD.encode(vk.to_bytes()), vk)
685 }
686
687 fn manifest_with(name: &str, key_b64: &str) -> ServiceEnrollmentManifest {
688 let mut services = BTreeMap::new();
689 services.insert(
690 name.to_owned(),
691 ServiceEnrollment {
692 ed25519_pubkey: key_b64.to_owned(),
693 ml_dsa_pubkey: None,
694 clearance: test_label(),
695 allowed_audiences: None,
696 workload_session: false,
697 },
698 );
699 ServiceEnrollmentManifest {
700 version: SERVICE_ENROLLMENT_VERSION,
701 services,
702 }
703 }
704
705 #[test]
706 fn valid_manifest_round_trips_and_answers_queries() {
707 let (key_b64, vk) = test_key_b64();
708 let manifest = manifest_with("oauth", &key_b64);
709 let json = serde_json::to_string(&manifest).unwrap();
710 let parsed: ServiceEnrollmentManifest = serde_json::from_str(&json).unwrap();
711 parsed.validate().unwrap();
712
713 assert_eq!(parsed.clearance_for_service("oauth"), Some(test_label()));
714 assert_eq!(parsed.clearance_for_service("unknown"), None);
715 assert!(parsed.allows_audience("oauth", Some("anything"))); assert!(!parsed.allows_audience("unknown", Some("anything")));
717 assert!(!parsed.workload_session_policy("oauth"));
718
719 let mut pubkeys = HashMap::new();
720 pubkeys.insert("oauth".to_owned(), BootstrapPubkey::classical(vk));
721 parsed.validate_key_agreement(&pubkeys).unwrap();
722 }
723
724 #[test]
725 fn key_disagreement_and_unknown_services_are_hard_errors() {
726 let (key_b64, _vk) = test_key_b64();
727 let manifest = manifest_with("oauth", &key_b64);
728
729 let mut pubkeys = HashMap::new();
731 pubkeys.insert(
732 "registry".to_owned(),
733 BootstrapPubkey::classical(
734 ed25519_dalek::SigningKey::from_bytes(&[0x43; 32]).verifying_key(),
735 ),
736 );
737 assert!(manifest.validate_key_agreement(&pubkeys).is_err());
738
739 let mut wrong = HashMap::new();
741 wrong.insert(
742 "oauth".to_owned(),
743 BootstrapPubkey::classical(
744 ed25519_dalek::SigningKey::from_bytes(&[0x44; 32]).verifying_key(),
745 ),
746 );
747 assert!(manifest.validate_key_agreement(&wrong).is_err());
748
749 let m2 = manifest_with("oauth", &key_b64);
751 assert!(m2.validate_key_agreement(&HashMap::new()).is_err());
752 }
753
754 #[test]
755 fn pq_halves_must_agree_exactly() {
756 let (key_b64, vk) = test_key_b64();
757 let (pq_sk, pq_vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
758 let _ = pq_sk;
759 let pq_b64 = URL_SAFE_NO_PAD.encode(hyprstream_rpc::crypto::pq::ml_dsa_vk_bytes(&pq_vk));
760
761 let mut hybrid_manifest = manifest_with("oauth", &key_b64);
763 hybrid_manifest
764 .services
765 .get_mut("oauth")
766 .unwrap()
767 .ml_dsa_pubkey = Some(pq_b64.clone());
768 let mut hybrid_boot = HashMap::new();
769 hybrid_boot.insert(
770 "oauth".to_owned(),
771 BootstrapPubkey::hybrid(vk, pq_vk.clone()),
772 );
773 hybrid_manifest
774 .validate_key_agreement(&hybrid_boot)
775 .unwrap();
776
777 let mut classical_boot = HashMap::new();
779 classical_boot.insert("oauth".to_owned(), BootstrapPubkey::classical(vk));
780 assert!(
781 hybrid_manifest
782 .validate_key_agreement(&classical_boot)
783 .is_err(),
784 "extra PQ half in the manifest must fail"
785 );
786
787 let classical_manifest = manifest_with("oauth", &key_b64);
789 assert!(
790 classical_manifest
791 .validate_key_agreement(&hybrid_boot)
792 .is_err(),
793 "missing PQ half in the manifest must fail"
794 );
795
796 let (_sk2, pq_vk2) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
798 let mut wrong_pq = manifest_with("oauth", &key_b64);
799 wrong_pq.services.get_mut("oauth").unwrap().ml_dsa_pubkey =
800 Some(URL_SAFE_NO_PAD.encode(hyprstream_rpc::crypto::pq::ml_dsa_vk_bytes(&pq_vk2)));
801 assert!(
802 wrong_pq.validate_key_agreement(&hybrid_boot).is_err(),
803 "a different PQ half must fail"
804 );
805 }
806
807 #[test]
808 fn from_bootstrap_manifest_agrees_with_its_source_keys() {
809 let (sk, pq_vk) = {
810 let sk = ed25519_dalek::SigningKey::from_bytes(&[0x46; 32]);
811 let (_pq_sk, pq_vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
812 (sk, pq_vk)
813 };
814 let mut pubkeys = HashMap::new();
815 pubkeys.insert(
816 "oauth".to_owned(),
817 BootstrapPubkey::hybrid(sk.verifying_key(), pq_vk.clone()),
818 );
819 pubkeys.insert(
820 "registry".to_owned(),
821 BootstrapPubkey::classical(
822 ed25519_dalek::SigningKey::from_bytes(&[0x47; 32]).verifying_key(),
823 ),
824 );
825 let manifest = ServiceEnrollmentManifest::from_bootstrap(&pubkeys);
826 manifest.validate().unwrap();
827 manifest.validate_key_agreement(&pubkeys).unwrap();
829
830 let dir = tempfile::tempdir().unwrap();
832 manifest.write(dir.path()).unwrap();
833 let loaded = ServiceEnrollmentManifest::load(dir.path())
834 .unwrap()
835 .unwrap();
836 loaded.validate_key_agreement(&pubkeys).unwrap();
837 }
838
839 #[test]
840 fn default_clearance_derives_assurance_from_bootstrap_key() {
841 let reviewed_target =
845 SecurityLabel::new(Level::Internal, Assurance::PqHybrid, CompartmentSet::EMPTY);
846
847 let sk = ed25519_dalek::SigningKey::from_bytes(&[0x48; 32]);
848 let (_pq_sk, pq_vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
849 let mut pubkeys = HashMap::new();
850 pubkeys.insert(
851 "oauth".to_owned(),
852 BootstrapPubkey::hybrid(sk.verifying_key(), pq_vk.clone()),
853 );
854 pubkeys.insert(
855 "legacy".to_owned(),
856 BootstrapPubkey::classical(
857 ed25519_dalek::SigningKey::from_bytes(&[0x49; 32]).verifying_key(),
858 ),
859 );
860 let manifest = ServiceEnrollmentManifest::from_bootstrap(&pubkeys);
861
862 let hybrid_clearance = manifest.clearance_for_service("oauth").unwrap();
863 assert_eq!(hybrid_clearance.assurance, Assurance::PqHybrid);
864 assert!(
865 hybrid_clearance.can_access(&reviewed_target),
866 "hybrid service clearance must dominate the reviewed internal:pq-hybrid target"
867 );
868
869 let classical_clearance = manifest.clearance_for_service("legacy").unwrap();
870 assert_eq!(classical_clearance.assurance, Assurance::Classical);
871 assert!(
872 !classical_clearance.can_access(&reviewed_target),
873 "classical clearance must NOT dominate a pq-hybrid target"
874 );
875 }
876
877 #[test]
878 fn reprovision_key_drift_is_never_auto_authorized() {
879 let sk = ed25519_dalek::SigningKey::from_bytes(&[0x50; 32]);
881 let (_pq_sk, pq_vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
882 let mut pubkeys = HashMap::new();
883 pubkeys.insert(
884 "oauth".to_owned(),
885 BootstrapPubkey::hybrid(sk.verifying_key(), pq_vk.clone()),
886 );
887 let manifest = ServiceEnrollmentManifest::from_bootstrap(&pubkeys);
888 manifest.reconcile_with_bootstrap(&pubkeys).unwrap();
889
890 let mut drifted = HashMap::new();
892 drifted.insert(
893 "oauth".to_owned(),
894 BootstrapPubkey::hybrid(
895 ed25519_dalek::SigningKey::from_bytes(&[0x51; 32]).verifying_key(),
896 pq_vk,
897 ),
898 );
899 assert!(manifest.reconcile_with_bootstrap(&drifted).is_err());
900
901 let (_s2, pq_vk2) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
903 let mut drifted_pq = HashMap::new();
904 drifted_pq.insert(
905 "oauth".to_owned(),
906 BootstrapPubkey::hybrid(sk.verifying_key(), pq_vk2),
907 );
908 assert!(manifest.reconcile_with_bootstrap(&drifted_pq).is_err());
909
910 let mut downgraded = HashMap::new();
912 downgraded.insert(
913 "oauth".to_owned(),
914 BootstrapPubkey::classical(sk.verifying_key()),
915 );
916 assert!(manifest.reconcile_with_bootstrap(&downgraded).is_err());
917
918 let mut extra = pubkeys.clone();
920 extra.insert(
921 "registry".to_owned(),
922 BootstrapPubkey::classical(
923 ed25519_dalek::SigningKey::from_bytes(&[0x52; 32]).verifying_key(),
924 ),
925 );
926 assert!(manifest.reconcile_with_bootstrap(&extra).is_err());
927
928 assert!(manifest.reconcile_with_bootstrap(&HashMap::new()).is_err());
930 }
931
932 #[test]
933 fn malformed_manifest_content_fails_closed() {
934 let dir = tempfile::tempdir().unwrap();
935 let path = dir.path().join(SERVICE_ENROLLMENT_FILE);
936
937 assert!(ServiceEnrollmentManifest::load(dir.path())
939 .unwrap()
940 .is_none());
941
942 std::fs::write(&path, "{not json").unwrap();
944 assert!(ServiceEnrollmentManifest::load(dir.path()).is_err());
945
946 let (key_b64, _vk) = test_key_b64();
948 let mut manifest = manifest_with("oauth", &key_b64);
949 manifest.version = 99;
950 std::fs::write(&path, serde_json::to_string(&manifest).unwrap()).unwrap();
951 assert!(ServiceEnrollmentManifest::load(dir.path()).is_err());
952
953 let bad = manifest_with("oauth", "not-base64!!!");
955 std::fs::write(&path, serde_json::to_string(&bad).unwrap()).unwrap();
956 assert!(ServiceEnrollmentManifest::load(dir.path()).is_err());
957
958 std::fs::write(
960 &path,
961 serde_json::to_string(&manifest_with("oauth", &key_b64)).unwrap(),
962 )
963 .unwrap();
964 assert!(ServiceEnrollmentManifest::load(dir.path())
965 .unwrap()
966 .is_some());
967 assert!(
968 ServiceEnrollmentManifest::load_and_validate(dir.path()).is_err(),
969 "a manifest disagreeing with bootstrap anchors must fail startup validation"
970 );
971 }
972
973 #[test]
974 fn declared_audience_list_is_enforced_fail_closed() {
975 let (key_b64, _vk) = test_key_b64();
976 let mut manifest = manifest_with("oauth", &key_b64);
977 manifest
978 .services
979 .get_mut("oauth")
980 .unwrap()
981 .allowed_audiences = Some(vec!["https://aud.example".to_owned()]);
982 assert!(manifest.allows_audience("oauth", Some("https://aud.example")));
983 assert!(
984 !manifest.allows_audience("oauth", Some("https://other.example")),
985 "audience outside the declared list must deny"
986 );
987 assert!(
988 !manifest.allows_audience("oauth", None),
989 "a declared list denies audience-less minting"
990 );
991 }
992}