Skip to main content

hyprstream_rpc/auth/
composite.rs

1//! Atomic exact-pair authority for composite JWT signing and verification.
2
3use std::path::PathBuf;
4use std::sync::{Arc, OnceLock};
5
6use parking_lot::RwLock;
7
8use ed25519_dalek::{SigningKey, VerifyingKey};
9
10use crate::crypto::pq::{MlDsaSigningKey, MlDsaVerifyingKey};
11
12/// The local issuer path that is authorized to mint with an exact pair.
13#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
14pub enum CompositePairRole {
15    OAuth,
16    Policy,
17}
18
19/// Lifecycle state of an exact pair.
20#[derive(Clone, Copy, Debug, Eq, PartialEq)]
21pub enum CompositePairState {
22    Active,
23    Drain,
24}
25
26/// One exact ML-DSA-65 + Ed25519 pair in the authoritative ledger.
27#[derive(Clone)]
28pub struct CompositeKeyPair {
29    kid: String,
30    ml_dsa: MlDsaVerifyingKey,
31    ed25519: VerifyingKey,
32    role: CompositePairRole,
33    state: CompositePairState,
34    not_before: i64,
35    expires_at: i64,
36    ml_dsa_signing: Option<Arc<MlDsaSigningKey>>,
37    ed25519_signing: Option<Arc<SigningKey>>,
38}
39
40impl CompositeKeyPair {
41    #[allow(clippy::too_many_arguments)]
42    pub fn signing(
43        kid: String,
44        ml_dsa: Arc<MlDsaSigningKey>,
45        ed25519: Arc<SigningKey>,
46        role: CompositePairRole,
47        state: CompositePairState,
48        not_before: i64,
49        expires_at: i64,
50    ) -> Self {
51        let ml_dsa_vk = ml_dsa::Keypair::verifying_key(&*ml_dsa).clone();
52        let ed25519_vk = ed25519.verifying_key();
53        Self {
54            kid,
55            ml_dsa: ml_dsa_vk,
56            ed25519: ed25519_vk,
57            role,
58            state,
59            not_before,
60            expires_at,
61            ml_dsa_signing: Some(ml_dsa),
62            ed25519_signing: Some(ed25519),
63        }
64    }
65
66    #[allow(clippy::too_many_arguments)]
67    pub fn verifying(
68        kid: String,
69        ml_dsa: MlDsaVerifyingKey,
70        ed25519: VerifyingKey,
71        role: CompositePairRole,
72        state: CompositePairState,
73        not_before: i64,
74        expires_at: i64,
75    ) -> Self {
76        Self {
77            kid,
78            ml_dsa,
79            ed25519,
80            role,
81            state,
82            not_before,
83            expires_at,
84            ml_dsa_signing: None,
85            ed25519_signing: None,
86        }
87    }
88
89    pub fn kid(&self) -> &str {
90        &self.kid
91    }
92    pub fn ml_dsa(&self) -> &MlDsaVerifyingKey {
93        &self.ml_dsa
94    }
95    pub fn ed25519(&self) -> &VerifyingKey {
96        &self.ed25519
97    }
98    pub fn role(&self) -> CompositePairRole {
99        self.role
100    }
101    pub fn state(&self) -> CompositePairState {
102        self.state
103    }
104    pub fn not_before(&self) -> i64 {
105        self.not_before
106    }
107    pub fn expires_at(&self) -> i64 {
108        self.expires_at
109    }
110
111    pub fn signing_keys(&self) -> Option<(Arc<MlDsaSigningKey>, Arc<SigningKey>)> {
112        Some((
113            self.ml_dsa_signing.as_ref()?.clone(),
114            self.ed25519_signing.as_ref()?.clone(),
115        ))
116    }
117}
118
119/// One immutable view of the exact-pair ledger.
120#[derive(Clone)]
121pub struct CompositeKeySetSnapshot {
122    version: u64,
123    component_digest: Arc<str>,
124    pairs: Arc<[CompositeKeyPair]>,
125}
126
127impl CompositeKeySetSnapshot {
128    pub fn version(&self) -> u64 {
129        self.version
130    }
131    pub fn component_digest(&self) -> &str {
132        &self.component_digest
133    }
134    pub fn pairs(&self) -> &[CompositeKeyPair] {
135        &self.pairs
136    }
137
138    pub fn pair(&self, kid: &str) -> Option<&CompositeKeyPair> {
139        self.pairs.iter().find(|pair| pair.kid == kid)
140    }
141
142    pub fn active_signing_pair(&self, role: CompositePairRole) -> Option<&CompositeKeyPair> {
143        self.pairs.iter().find(|pair| {
144            pair.role == role
145                && pair.state == CompositePairState::Active
146                && pair.ml_dsa_signing.is_some()
147                && pair.ed25519_signing.is_some()
148        })
149    }
150}
151
152/// Process-shared atomic publication point for exact composite pairs.
153pub struct CompositeKeySet {
154    snapshot: RwLock<Arc<CompositeKeySetSnapshot>>,
155    authority: RwLock<Option<CompositeAuthorityPaths>>,
156}
157
158#[derive(Clone)]
159struct CompositeAuthorityPaths {
160    ledger: PathBuf,
161    committed: PathBuf,
162    committed_ledger_prefix: PathBuf,
163    ledger_lock: PathBuf,
164}
165
166impl Default for CompositeKeySet {
167    fn default() -> Self {
168        Self {
169            snapshot: RwLock::new(Arc::new(CompositeKeySetSnapshot {
170                version: 0,
171                component_digest: Arc::from(""),
172                pairs: Arc::from([]),
173            })),
174            authority: RwLock::new(None),
175        }
176    }
177}
178
179impl CompositeKeySet {
180    pub fn snapshot(&self) -> Arc<CompositeKeySetSnapshot> {
181        self.snapshot.read().clone()
182    }
183
184    /// Whether an on-disk composite signing authority has been configured for
185    /// this process. `false` means first bootstrap — no ledger exists yet —
186    /// which is distinct from a configured authority whose
187    /// [`CompositeKeySet::mint_snapshot`] fails (stale or pending cutover).
188    pub fn authority_configured(&self) -> bool {
189        self.authority.read().is_some()
190    }
191
192    pub fn configure_authority(
193        &self,
194        ledger: PathBuf,
195        committed: PathBuf,
196        committed_ledger_prefix: PathBuf,
197        ledger_lock: PathBuf,
198    ) {
199        *self.authority.write() = Some(CompositeAuthorityPaths {
200            ledger,
201            committed,
202            committed_ledger_prefix,
203            ledger_lock,
204        });
205    }
206
207    /// Return a signing snapshot only when it matches the committed disk generation.
208    pub fn mint_snapshot(&self) -> anyhow::Result<Arc<CompositeKeySetSnapshot>> {
209        let (snapshot, _authority_lock) = self.mint_snapshot_locked()?;
210        Ok(snapshot)
211    }
212
213    fn mint_snapshot_locked(
214        &self,
215    ) -> anyhow::Result<(Arc<CompositeKeySetSnapshot>, std::fs::File)> {
216        use nix::fcntl::{flock, FlockArg};
217        use std::os::fd::AsRawFd;
218        let authority = self
219            .authority
220            .read()
221            .clone()
222            .ok_or_else(|| anyhow::anyhow!("composite authority is not configured"))?;
223        let lock = std::fs::OpenOptions::new()
224            .create(true)
225            .truncate(false)
226            .read(true)
227            .write(true)
228            .open(&authority.ledger_lock)?;
229        flock(lock.as_raw_fd(), FlockArg::LockShared)?;
230        let committed: serde_json::Value =
231            serde_json::from_slice(&std::fs::read(&authority.committed)?)?;
232        let committed_version = committed
233            .get("version")
234            .and_then(serde_json::Value::as_u64)
235            .ok_or_else(|| anyhow::anyhow!("committed composite version missing"))?;
236        let committed_digest = committed
237            .get("component_digest")
238            .and_then(serde_json::Value::as_str)
239            .filter(|digest| !digest.is_empty())
240            .ok_or_else(|| anyhow::anyhow!("committed component digest missing"))?;
241        let prefix_name = authority
242            .committed_ledger_prefix
243            .file_name()
244            .and_then(|name| name.to_str())
245            .ok_or_else(|| anyhow::anyhow!("committed ledger prefix has no file name"))?;
246        let committed_ledger = authority.committed_ledger_prefix.with_file_name(format!(
247            "{prefix_name}-{committed_version}-{committed_digest}.json"
248        ));
249        let ledger_bytes = match std::fs::read(&committed_ledger) {
250            Ok(bytes) => bytes,
251            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
252                // Legacy migration is safe only while the mutable ledger still
253                // names the exact generation selected by the commit marker.
254                std::fs::read(&authority.ledger)?
255            }
256            Err(error) => return Err(error.into()),
257        };
258        let ledger: serde_json::Value = serde_json::from_slice(&ledger_bytes)?;
259        let disk_version = ledger
260            .get("version")
261            .and_then(serde_json::Value::as_u64)
262            .ok_or_else(|| anyhow::anyhow!("composite ledger version missing"))?;
263        let disk_digest = ledger
264            .get("component_digest")
265            .and_then(serde_json::Value::as_str)
266            .filter(|digest| !digest.is_empty())
267            .ok_or_else(|| anyhow::anyhow!("composite ledger component digest missing"))?;
268        let snapshot = self.snapshot();
269        anyhow::ensure!(
270            snapshot.version == disk_version
271                && snapshot.version == committed_version
272                && snapshot.component_digest() == disk_digest
273                && snapshot.component_digest() == committed_digest,
274            "composite signing authority is stale or cutover is pending"
275        );
276        Ok((snapshot, lock))
277    }
278
279    /// Attach local private handles to the exact already-committed public snapshot.
280    /// This does not publish a generation or change any pair's authority metadata.
281    /// Keep the disk lock through the atomic compare-and-attach so a cutover cannot
282    /// authorize stale handles while this process is being promoted to a signer.
283    pub fn attach_committed_signing_keys(
284        &self,
285        version: u64,
286        component_digest: &str,
287        pairs: Vec<CompositeKeyPair>,
288    ) -> anyhow::Result<()> {
289        let (observed, _authority_lock) = self.mint_snapshot_locked()?;
290        self.attach_signing_keys_to_snapshot(&observed, version, component_digest, pairs)
291    }
292
293    fn attach_signing_keys_to_snapshot(
294        &self,
295        observed: &Arc<CompositeKeySetSnapshot>,
296        version: u64,
297        component_digest: &str,
298        pairs: Vec<CompositeKeyPair>,
299    ) -> anyhow::Result<()> {
300        let mut guard = self.snapshot.write();
301        anyhow::ensure!(
302            Arc::ptr_eq(&guard, observed)
303                && guard.version == version
304                && guard.component_digest() == component_digest,
305            "committed composite snapshot changed before signer attachment"
306        );
307        anyhow::ensure!(
308            pairs.len() == guard.pairs.len(),
309            "composite pair set changed"
310        );
311        let mut seen = std::collections::HashSet::new();
312        let mut attached = Vec::with_capacity(pairs.len());
313        for pair in pairs {
314            anyhow::ensure!(seen.insert(pair.kid.clone()), "duplicate composite kid");
315            let current = guard
316                .pair(&pair.kid)
317                .ok_or_else(|| anyhow::anyhow!("signer pair is not committed"))?;
318            anyhow::ensure!(
319                pair.role == current.role
320                    && pair.state == current.state
321                    && pair.not_before == current.not_before
322                    && pair.expires_at == current.expires_at
323                    && pair.ed25519 == current.ed25519
324                    && crate::crypto::pq::ml_dsa_vk_bytes(&pair.ml_dsa)
325                        == crate::crypto::pq::ml_dsa_vk_bytes(&current.ml_dsa),
326                "signer pair differs from committed public authority"
327            );
328            if let Some((pq, ed)) = pair.signing_keys() {
329                anyhow::ensure!(
330                    ed.verifying_key() == current.ed25519
331                        && crate::crypto::pq::ml_dsa_vk_bytes(&ml_dsa::Keypair::verifying_key(
332                            &*pq
333                        )) == crate::crypto::pq::ml_dsa_vk_bytes(&current.ml_dsa),
334                    "private signer does not match committed public pair"
335                );
336                attached.push(pair);
337            } else {
338                // A verifier-only input must never remove an existing private handle.
339                attached.push(current.clone());
340            }
341        }
342        *guard = Arc::new(CompositeKeySetSnapshot {
343            version,
344            component_digest: Arc::clone(&observed.component_digest),
345            pairs: attached.into(),
346        });
347        Ok(())
348    }
349
350    /// Atomically replace the complete ledger. Versions must increase.
351    pub fn publish(
352        &self,
353        version: u64,
354        component_digest: String,
355        pairs: Vec<CompositeKeyPair>,
356    ) -> anyhow::Result<()> {
357        let mut guard = self.snapshot.write();
358        anyhow::ensure!(
359            version > guard.version,
360            "composite key-set version must increase"
361        );
362        anyhow::ensure!(
363            !component_digest.is_empty(),
364            "composite component digest must not be empty"
365        );
366        let mut kids = std::collections::HashSet::new();
367        let mut active_roles = std::collections::HashSet::new();
368        for pair in &pairs {
369            anyhow::ensure!(kids.insert(pair.kid.clone()), "duplicate composite kid");
370            if pair.state == CompositePairState::Active {
371                anyhow::ensure!(
372                    active_roles.insert(pair.role),
373                    "multiple active composite pairs for one issuer role"
374                );
375            }
376            anyhow::ensure!(
377                pair.kid == super::jwt::composite_kid(&pair.ml_dsa, &pair.ed25519),
378                "composite kid does not bind its exact key pair"
379            );
380        }
381        *guard = Arc::new(CompositeKeySetSnapshot {
382            version,
383            component_digest: Arc::from(component_digest),
384            pairs: pairs.into(),
385        });
386        Ok(())
387    }
388}
389
390static GLOBAL_COMPOSITE_KEY_SET: OnceLock<Arc<CompositeKeySet>> = OnceLock::new();
391
392pub fn global_composite_key_set() -> Arc<CompositeKeySet> {
393    GLOBAL_COMPOSITE_KEY_SET
394        .get_or_init(|| Arc::new(CompositeKeySet::default()))
395        .clone()
396}
397
398#[cfg(test)]
399#[allow(clippy::unwrap_used)]
400mod tests {
401    use super::*;
402    use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
403    use ed25519_dalek::Signer as _;
404    use std::sync::Barrier;
405
406    fn pair_from_keys(
407        pq: Arc<MlDsaSigningKey>,
408        ed: Arc<SigningKey>,
409        state: CompositePairState,
410    ) -> CompositeKeyPair {
411        let kid =
412            crate::auth::composite_kid(&ml_dsa::Keypair::verifying_key(&*pq), &ed.verifying_key());
413        CompositeKeyPair::signing(kid, pq, ed, CompositePairRole::OAuth, state, 0, i64::MAX)
414    }
415
416    fn pair(seed: u8) -> CompositeKeyPair {
417        let ed = Arc::new(SigningKey::from_bytes(&[seed; 32]));
418        let (pq, _) = crate::crypto::pq::ml_dsa_generate_keypair();
419        pair_from_keys(Arc::new(pq), ed, CompositePairState::Active)
420    }
421
422    fn mint(pair: &CompositeKeyPair) -> String {
423        let (pq, ed) = pair.signing_keys().unwrap();
424        let header = format!(
425            r#"{{"alg":"ML-DSA-65-Ed25519","typ":"at+jwt","kid":"{}"}}"#,
426            pair.kid()
427        );
428        let now = chrono::Utc::now().timestamp();
429        let claims = crate::auth::Claims::new("subject".to_owned(), now, now + 3600)
430            .with_audience(Some("resource".to_owned()));
431        let input = format!(
432            "{}.{}",
433            URL_SAFE_NO_PAD.encode(header),
434            URL_SAFE_NO_PAD.encode(serde_json::to_vec(&claims).unwrap())
435        );
436        let pq_signature = crate::crypto::pq::ml_dsa_sign(&pq, input.as_bytes());
437        let ed_signature = ed.sign(input.as_bytes());
438        let mut signature = pq_signature;
439        signature.extend_from_slice(&ed_signature.to_bytes());
440        format!("{}.{}", input, URL_SAFE_NO_PAD.encode(signature))
441    }
442
443    fn verify(token: &str, snapshot: &CompositeKeySetSnapshot) -> bool {
444        let Ok(dispatch) = crate::auth::parse_composite_dispatch(token, &["at+jwt"]) else {
445            return false;
446        };
447        let Some(pair) = snapshot.pair(dispatch.kid()) else {
448            return false;
449        };
450        crate::auth::jwt::decode_composite(
451            token,
452            pair.ml_dsa(),
453            pair.ed25519(),
454            Some("resource"),
455            &dispatch,
456        )
457        .is_ok()
458    }
459
460    #[test]
461    fn publication_is_atomic_across_mint_verify_and_jwks_barriers() {
462        let keys = Arc::new(CompositeKeySet::default());
463        let old = pair(1);
464        let old_kid = old.kid().to_owned();
465        keys.publish(1, "generation-1".into(), vec![old.clone()])
466            .unwrap();
467        let ed_promotion = Arc::new(Barrier::new(2));
468        let pq_promotion = Arc::new(Barrier::new(2));
469        let mint_barrier = Arc::new(Barrier::new(2));
470        let publication_barrier = Arc::new(Barrier::new(2));
471        let verify_barrier = Arc::new(Barrier::new(2));
472        let jwks_barrier = Arc::new(Barrier::new(2));
473
474        let reader_keys = Arc::clone(&keys);
475        let reader_ed = Arc::clone(&ed_promotion);
476        let reader_pq = Arc::clone(&pq_promotion);
477        let reader_mint = Arc::clone(&mint_barrier);
478        let reader_publication = Arc::clone(&publication_barrier);
479        let reader_verify = Arc::clone(&verify_barrier);
480        let reader_jwks = Arc::clone(&jwks_barrier);
481        let reader_old_kid = old_kid.clone();
482        let reader = std::thread::spawn(move || {
483            reader_ed.wait();
484            reader_pq.wait();
485            let mint_snapshot = reader_keys.snapshot();
486            let token = mint(
487                mint_snapshot
488                    .active_signing_pair(CompositePairRole::OAuth)
489                    .unwrap(),
490            );
491            reader_mint.wait();
492            reader_publication.wait();
493            let verify_snapshot = reader_keys.snapshot();
494            let verify_version = verify_snapshot.version();
495            let token_verified = verify(&token, &verify_snapshot);
496            reader_verify.wait();
497            let jwks_snapshot = reader_keys.snapshot();
498            let jwks_has_old = jwks_snapshot.pair(&reader_old_kid).is_some();
499            let jwks_len = jwks_snapshot.pairs().len();
500            reader_jwks.wait();
501            (
502                token,
503                verify_version,
504                token_verified,
505                jwks_has_old,
506                jwks_len,
507            )
508        });
509
510        let promoted_ed = Arc::new(SigningKey::from_bytes(&[2; 32]));
511        ed_promotion.wait();
512        let (promoted_pq, _) = crate::crypto::pq::ml_dsa_generate_keypair();
513        pq_promotion.wait();
514        let promoted = pair_from_keys(
515            Arc::new(promoted_pq),
516            promoted_ed,
517            CompositePairState::Active,
518        );
519        let promoted_kid = promoted.kid().to_owned();
520        mint_barrier.wait();
521        let mut old_drain = old;
522        old_drain.state = CompositePairState::Drain;
523        keys.publish(2, "generation-2".into(), vec![old_drain, promoted.clone()])
524            .unwrap();
525        publication_barrier.wait();
526        verify_barrier.wait();
527        jwks_barrier.wait();
528        let (old_token, verify_version, token_verified, jwks_has_old, jwks_len) =
529            reader.join().unwrap();
530        assert_eq!(verify_version, 2);
531        assert!(token_verified, "a returned token became unverifiable");
532        assert!(jwks_has_old);
533        assert_eq!(jwks_len, 2);
534
535        // Drain expiry/revocation is a later atomic publication: the old pair
536        // disappears completely, while the new exact pair remains usable.
537        keys.publish(3, "generation-3".into(), vec![promoted])
538            .unwrap();
539        let after = keys.snapshot();
540        assert_eq!(after.version(), 3);
541        assert!(after.pair(&promoted_kid).is_some());
542        assert!(
543            after.pair(&old_kid).is_none(),
544            "evicted pair remained accepted"
545        );
546        assert!(!verify(&old_token, &after));
547        let new_token = mint(after.active_signing_pair(CompositePairRole::OAuth).unwrap());
548        assert!(verify(&new_token, &after));
549    }
550
551    #[test]
552    fn committed_signer_attachment_preserves_exact_authority_and_rejects_changes() {
553        let dir = std::env::temp_dir().join(format!("hyprstream-attach-{}", uuid::Uuid::new_v4()));
554        std::fs::create_dir_all(&dir).unwrap();
555        let keys = CompositeKeySet::default();
556        keys.configure_authority(
557            dir.join("ledger"),
558            dir.join("commit"),
559            dir.join("committed"),
560            dir.join("lock"),
561        );
562        let signing = pair(41);
563        let verifying = CompositeKeyPair::verifying(
564            signing.kid.clone(),
565            signing.ml_dsa.clone(),
566            signing.ed25519,
567            signing.role,
568            signing.state,
569            signing.not_before,
570            signing.expires_at,
571        );
572        keys.publish(1, "generation-1".into(), vec![verifying.clone()])
573            .unwrap();
574        assert!(
575            keys.attach_committed_signing_keys(1, "generation-1", vec![signing.clone()])
576                .is_err(),
577            "uncommitted authority gained a signer"
578        );
579        let committed = br#"{"version":1,"component_digest":"generation-1"}"#;
580        std::fs::write(dir.join("commit"), committed).unwrap();
581        std::fs::write(dir.join("committed-1-generation-1.json"), committed).unwrap();
582
583        for changed in [
584            {
585                let mut p = signing.clone();
586                p.role = CompositePairRole::Policy;
587                p
588            },
589            {
590                let mut p = signing.clone();
591                p.state = CompositePairState::Drain;
592                p
593            },
594            {
595                let mut p = signing.clone();
596                p.expires_at -= 1;
597                p
598            },
599            {
600                let mut p = signing.clone();
601                p.ed25519_signing = Some(Arc::new(SigningKey::from_bytes(&[42; 32])));
602                p
603            },
604            pair(43),
605        ] {
606            assert!(keys
607                .attach_committed_signing_keys(1, "generation-1", vec![changed])
608                .is_err());
609            assert!(keys
610                .snapshot()
611                .active_signing_pair(CompositePairRole::OAuth)
612                .is_none());
613        }
614        assert!(keys
615            .attach_committed_signing_keys(2, "generation-1", vec![signing.clone()])
616            .is_err());
617        assert!(keys
618            .attach_committed_signing_keys(1, "changed-digest", vec![signing.clone()])
619            .is_err());
620        keys.attach_committed_signing_keys(1, "generation-1", vec![signing.clone()])
621            .unwrap();
622        let restored = keys.mint_snapshot().unwrap();
623        assert_eq!(restored.version(), 1);
624        assert_eq!(restored.component_digest(), "generation-1");
625        assert!(verify(
626            &mint(
627                restored
628                    .active_signing_pair(CompositePairRole::OAuth)
629                    .unwrap()
630            ),
631            &restored
632        ));
633        // Idempotent attachment cannot strip handles; ordinary publication stays monotonic.
634        keys.attach_committed_signing_keys(1, "generation-1", vec![verifying])
635            .unwrap();
636        assert!(keys
637            .snapshot()
638            .active_signing_pair(CompositePairRole::OAuth)
639            .is_some());
640        assert!(keys
641            .publish(1, "generation-1".into(), vec![signing.clone()])
642            .is_err());
643
644        // Deterministically model a publication between the disk check and CAS.
645        let observed = keys.mint_snapshot().unwrap();
646        keys.publish(2, "generation-2".into(), vec![pair(44)])
647            .unwrap();
648        assert!(keys
649            .attach_signing_keys_to_snapshot(&observed, 1, "generation-1", vec![signing.clone()])
650            .is_err());
651        assert_eq!(keys.snapshot().version(), 2);
652        assert!(
653            keys.attach_committed_signing_keys(2, "generation-2", vec![signing])
654                .is_err(),
655            "memory ahead of committed disk gained a signer"
656        );
657        std::fs::remove_dir_all(dir).unwrap();
658    }
659
660    #[test]
661    fn mint_snapshot_fails_closed_for_missing_pending_and_stale_authority() {
662        let dir =
663            std::env::temp_dir().join(format!("hyprstream-composite-{}", uuid::Uuid::new_v4()));
664        std::fs::create_dir_all(&dir).unwrap();
665        let ledger = dir.join("ledger.json");
666        let committed = dir.join("committed");
667        let committed_ledger_prefix = dir.join("committed-ledger");
668        let keys = CompositeKeySet::default();
669        keys.configure_authority(
670            ledger.clone(),
671            committed.clone(),
672            committed_ledger_prefix.clone(),
673            dir.join("lock"),
674        );
675        keys.publish(1, "generation-1".into(), vec![pair(9)])
676            .unwrap();
677        assert!(keys.mint_snapshot().is_err());
678        std::fs::write(
679            &ledger,
680            br#"{"version":2,"component_digest":"generation-2"}"#,
681        )
682        .unwrap();
683        std::fs::write(
684            &committed,
685            br#"{"version":1,"component_digest":"generation-1"}"#,
686        )
687        .unwrap();
688        assert!(
689            keys.mint_snapshot().is_err(),
690            "legacy fallback accepted a pending mutable ledger"
691        );
692        std::fs::write(
693            dir.join("committed-ledger-1-generation-1.json"),
694            br#"{"version":1,"component_digest":"generation-1"}"#,
695        )
696        .unwrap();
697        assert_eq!(
698            keys.mint_snapshot().unwrap().version(),
699            1,
700            "pending mutable authority displaced the last committed snapshot"
701        );
702        std::fs::write(
703            &committed,
704            br#"{"version":2,"component_digest":"generation-2"}"#,
705        )
706        .unwrap();
707        assert!(keys.mint_snapshot().is_err(), "stale cache minted");
708        std::fs::write(
709            dir.join("committed-ledger-2-generation-2.json"),
710            br#"{"version":2,"component_digest":"generation-2"}"#,
711        )
712        .unwrap();
713        keys.publish(2, "generation-2".into(), vec![pair(10)])
714            .unwrap();
715        assert_eq!(keys.mint_snapshot().unwrap().version(), 2);
716        std::fs::remove_dir_all(dir).unwrap();
717    }
718}