Skip to main content

hyprstream_core/auth/
service_enrollment.rs

1//! Service enrollment manifest — the authority-owned declaration of service
2//! identity, target clearance, allowed audiences, and workload-session policy
3//! (v16 §11).
4//!
5//! One manifest per deployment lives at `<secrets>/service-enrollment.json`,
6//! produced by the wizard/bootstrap path. It is consumed once at startup:
7//!
8//! - service verifying keys carried here must AGREE with the hybrid
9//!   bootstrap-pubkeys file (the enrolled key set is the trust-anchor input —
10//!   a disagreement is a startup error, never a silent preference);
11//! - the target clearance stamped into service credentials at issuance and
12//!   renewal comes from here (renewal re-derives: authority removed from the
13//!   manifest cannot survive a renewal, and no issuance can exceed it);
14//! - the workload-session policy decides whether a service credential family
15//!   may carry a `workload_session_id` (a standalone service credential
16//!   omits it — v16 manufactures no session to populate a claim).
17//!
18//! Absence is legacy-tolerated for this staging wave (a loud warning; service
19//! tokens then carry no manifest-backed clearance). Presence with any
20//! malformed entry is a hard startup error — fail-closed.
21
22use 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
32/// Manifest file name within the resolved secrets directory.
33pub const SERVICE_ENROLLMENT_FILE: &str = "service-enrollment.json";
34
35/// Current manifest format version.
36pub const SERVICE_ENROLLMENT_VERSION: u32 = 1;
37
38/// One enrolled service: identity key, target clearance, audience ceiling,
39/// and workload-session policy.
40#[derive(Debug, Clone, Serialize, Deserialize)]
41pub struct ServiceEnrollment {
42    /// Ed25519 verifying key (base64url, 32 bytes) — must match the hybrid
43    /// bootstrap-pubkeys entry for the same service.
44    pub ed25519_pubkey: String,
45    /// ML-DSA-65 verifying key (base64url) for the hybrid identity. Optional
46    /// only for pre-hybrid legacy records; hybrid entries are the norm.
47    #[serde(default, skip_serializing_if = "Option::is_none")]
48    pub ml_dsa_pubkey: Option<String>,
49    /// Authority-issued target clearance for this service's credentials.
50    pub clearance: SecurityLabel,
51    /// Allowed credential audiences. `None` = unrestricted (legacy);
52    /// `Some(list)` = issuance for an audience outside the list denies.
53    #[serde(default, skip_serializing_if = "Option::is_none")]
54    pub allowed_audiences: Option<Vec<String>>,
55    /// Whether this service runs an enrolled workload credential family that
56    /// may carry a `workload_session_id`. Default false: a standalone service
57    /// credential carries no session identifier.
58    #[serde(default)]
59    pub workload_session: bool,
60}
61
62/// The parsed, validated manifest. Services are keyed by service name.
63#[derive(Debug, Clone, Serialize, Deserialize)]
64pub struct ServiceEnrollmentManifest {
65    /// Format version; must equal [`SERVICE_ENROLLMENT_VERSION`].
66    pub version: u32,
67    /// Enrolled services by name.
68    pub services: BTreeMap<String, ServiceEnrollment>,
69}
70
71impl ServiceEnrollmentManifest {
72    /// Load the manifest from the secrets directory. `Ok(None)` when the file
73    /// is absent (legacy deployment — logged by the caller). Any present but
74    /// malformed content is a hard error.
75    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    /// Structural validation: version, service-name syntax, key decodability.
91    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                // ML-DSA-65 verifying keys are 1952 bytes (FIPS 204).
111                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    /// The manifest must agree with the bootstrap trust anchors on BOTH key
128    /// halves: every bootstrap-registered service appears here with the SAME
129    /// Ed25519 key, the ML-DSA-65 half matches where either side carries one
130    /// (a present-but-different, missing, or extra PQ half is a mismatch),
131    /// and the manifest names no unknown service. Any divergence is a startup
132    /// error — the two trust-anchor inputs must never silently disagree.
133    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    /// Load the manifest and validate it against the bootstrap trust anchors
185    /// in one step — the startup path's helper. `Ok(None)` = absent (legacy);
186    /// any present-but-invalid or disagreeing manifest is a hard error.
187    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    /// Build a manifest from freshly provisioned bootstrap keys. The wizard
197    /// default target is `Internal` level with assurance DERIVED FROM THE
198    /// BOOTSTRAP KEY MATERIAL: a hybrid (Ed25519 + ML-DSA-65) identity gets
199    /// `PqHybrid`, a classical one `Classical` — a hybrid-authenticated
200    /// service must be able to dominate the reviewed generated dispatch
201    /// target (`internal:pq-hybrid`), which a Classical default would deny at
202    /// fresh boot. No session/audience restrictions by default; the operator
203    /// reviews every target label at gate 5.
204    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    /// Re-provision validation (wizard re-run). The manifest is authoritative
231    /// for key binding, so this NEVER rewrites it: a missing/extra service, a
232    /// changed Ed25519 key, or a missing/extra/changed PQ half is a hard
233    /// error until the operator deliberately edits the manifest (the
234    /// reviewed rotation). Fresh installation derives both artifacts once via
235    /// [`Self::from_bootstrap`]; re-provisioning only validates.
236    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    /// Persist the manifest (public keys + policy only — no secret material).
248    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    /// Authority-issued target clearance for a service, if enrolled.
255    pub fn clearance_for_service(&self, service: &str) -> Option<SecurityLabel> {
256        self.services.get(service).map(|e| e.clearance)
257    }
258
259    /// Whether issuance for `audience` is permitted for the service.
260    /// `None` audience list = unrestricted (legacy); `Some(list)` = the
261    /// effective audience must be PRESENT and a member — an enrolled service
262    /// with a declared list cannot mint without an exact allowed audience
263    /// (fail-closed).
264    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    /// Whether the service runs an enrolled workload credential family that
275    /// may carry a `workload_session_id`.
276    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
283/// Wizard default target clearance for a service: `Internal` level, with
284/// assurance derived from the bootstrap key material — hybrid identities get
285/// `PqHybrid` (so the service can dominate the reviewed generated dispatch
286/// target at fresh boot), classical identities `Classical`.
287fn 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
308/// Initialize only the node authority, without provisioning a service roster.
309/// Existing authority always wins; disagreement is an error, never rotation.
310pub 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
369/// Reconcile credentials for the exact already-provisioned local bootstrap set.
370/// Unlike the wizard, this never generates keys or changes bootstrap-pubkeys.
371/// Validate the entire retained authority before publishing any credentials.
372pub 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    // Validate both halves against the actual retained private identities,
416    // including on first manifest creation.
417    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
454// ── Process-global handle ─────────────────────────────────────────────────
455
456/// Process-global enrollment manifest, installed once at startup. `None`
457/// means a legacy deployment without a manifest — service credentials then
458/// carry no manifest-backed clearance (the legacy path), never a fabricated
459/// one.
460static GLOBAL_SERVICE_ENROLLMENT: std::sync::OnceLock<Arc<ServiceEnrollmentManifest>> =
461    std::sync::OnceLock::new();
462
463/// Install the process-global manifest. A second install is an error — two
464/// manifests in one process is a startup bug, not a race to absorb.
465pub 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/// Error returned when a second manifest install is attempted.
474#[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
485/// The installed manifest, if any.
486pub 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        // Legacy credentials do not survive without their clearance projection.
580        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"))); // None = unrestricted
716        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        // Bootstrap knows a service the manifest does not → error.
730        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        // Same name, different Ed25519 key → error.
740        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        // Manifest names a service bootstrap never registered → error.
750        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        // Matching hybrid on both sides → OK.
762        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        // Manifest carries a PQ half, bootstrap is classical → error.
778        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        // Bootstrap is hybrid, manifest lacks the PQ half → error.
788        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        // Both carry a PQ half but the bytes differ → error.
797        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        // A freshly generated manifest must agree with its own source keys.
828        manifest.validate_key_agreement(&pubkeys).unwrap();
829
830        // Round-trip through the file form.
831        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        // The reviewed generated dispatch target is internal:pq-hybrid; a
842        // hybrid-authenticated service's enrollment clearance must dominate
843        // it, or fresh boot denies registerServiceKey.
844        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        // Fresh provision: manifest derives from the bootstrap keys.
880        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        // Changed Ed25519 key → hard error.
891        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        // Changed PQ half → hard error.
902        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        // Hybrid → classical (PQ half dropped) → hard error.
911        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        // Extra service → hard error.
919        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        // Missing service → hard error.
929        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        // Absent → Ok(None), legacy tolerated.
938        assert!(ServiceEnrollmentManifest::load(dir.path())
939            .unwrap()
940            .is_none());
941
942        // Unparseable → hard error.
943        std::fs::write(&path, "{not json").unwrap();
944        assert!(ServiceEnrollmentManifest::load(dir.path()).is_err());
945
946        // Wrong version → hard error.
947        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        // Undecodable key → hard error.
954        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        // Valid structure but unknown to bootstrap → load_and_validate error.
959        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}