1use std::collections::HashMap;
26use std::sync::OnceLock;
27
28use anyhow::{bail, Result};
29
30use super::{ALG_ED25519, ALG_ML_DSA_65};
31
32#[derive(Debug, Clone)]
38pub enum ComponentKey {
39 Ed25519(ed25519_dalek::VerifyingKey),
40 MlDsa65(Box<crate::crypto::pq::MlDsaVerifyingKey>),
41}
42
43impl ComponentKey {
44 pub fn alg(&self) -> i64 {
46 match self {
47 Self::Ed25519(_) => ALG_ED25519,
48 Self::MlDsa65(_) => ALG_ML_DSA_65,
49 }
50 }
51
52 pub fn encoded(&self) -> Vec<u8> {
55 match self {
56 Self::Ed25519(k) => k.to_bytes().to_vec(),
57 Self::MlDsa65(k) => crate::crypto::pq::ml_dsa_vk_bytes(k),
58 }
59 }
60
61 pub fn verify(&self, sig: &[u8], data: &[u8]) -> Result<()> {
63 match self {
64 Self::Ed25519(k) => {
65 use ed25519_dalek::Verifier;
66 let bytes: [u8; 64] = sig
67 .try_into()
68 .map_err(|_| anyhow::anyhow!("Ed25519 signature must be 64 bytes"))?;
69 k.verify(data, &ed25519_dalek::Signature::from_bytes(&bytes))
70 .map_err(|_| anyhow::anyhow!("Ed25519 verification failed"))
71 }
72 Self::MlDsa65(k) => crate::crypto::pq::ml_dsa_verify(k, data, sig),
73 }
74 }
75}
76
77#[derive(Debug, Clone)]
80pub struct EnrolledComponent {
81 pub alg: i64,
82 pub kid: Vec<u8>,
83 pub key: ComponentKey,
84}
85
86impl EnrolledComponent {
87 pub fn new(kid: impl Into<Vec<u8>>, key: ComponentKey) -> Self {
88 Self {
89 alg: key.alg(),
90 kid: kid.into(),
91 key,
92 }
93 }
94}
95
96#[derive(Debug, Clone, Copy, PartialEq, Eq)]
101pub enum SignerRole {
102 Primary,
104 Approver,
106 Service,
108}
109
110#[derive(Debug, Clone)]
113pub struct SignerSuiteRecord {
114 pub principal: String,
117 pub suite_id: String,
119 pub components: Vec<EnrolledComponent>,
121 pub epoch: u64,
124 pub role: SignerRole,
126 pub approver_role: Option<String>,
130 pub enrollment_policy_id: String,
140 pub not_after: u64,
142 pub revoked: bool,
144}
145
146impl SignerSuiteRecord {
147 pub fn check_usable(&self, now: u64, proof_exp: u64, role: SignerRole) -> Result<()> {
151 if self.revoked {
152 bail!("enrollment for principal '{}' is revoked", self.principal);
153 }
154 if self.role != role {
155 bail!(
156 "enrollment for principal '{}' is enrolled as {:?}, presented as {:?}",
157 self.principal,
158 self.role,
159 role
160 );
161 }
162 if now >= self.not_after {
163 bail!(
164 "enrollment for principal '{}' expired at {}",
165 self.principal,
166 self.not_after
167 );
168 }
169 if proof_exp > self.not_after {
170 bail!(
171 "proof exp {} exceeds credential/session expiry {} for principal '{}'",
172 proof_exp,
173 self.not_after,
174 self.principal
175 );
176 }
177 Ok(())
178 }
179
180 pub fn pins_ed25519(&self, key: &ed25519_dalek::VerifyingKey) -> bool {
183 self.components.iter().any(|c| match &c.key {
184 ComponentKey::Ed25519(k) => k.to_bytes() == key.to_bytes(),
185 ComponentKey::MlDsa65(_) => false,
186 })
187 }
188
189 pub fn component(&self, alg: i64, kid: &[u8]) -> Option<&EnrolledComponent> {
191 self.components
192 .iter()
193 .find(|c| c.alg == alg && c.kid == kid)
194 }
195
196 pub fn replay_thumbprint(&self) -> [u8; 32] {
204 let keys = self
205 .components
206 .iter()
207 .map(|c| c.key.encoded())
208 .collect::<Vec<_>>();
209 authenticated_replay_namespace(&self.suite_id, &keys, self.epoch)
210 }
211}
212
213pub fn authenticated_replay_namespace(
218 suite: &str,
219 ordered_public_keys: &[Vec<u8>],
220 epoch: u64,
221) -> [u8; 32] {
222 super::thumbprint::authenticated(suite, ordered_public_keys, epoch)
223}
224
225pub trait EnrollmentResolver: Send + Sync {
236 fn resolve_primary(&self, cnf: &ed25519_dalek::VerifyingKey) -> Option<SignerSuiteRecord>;
239
240 fn resolve_approver(&self, kid: &[u8]) -> Option<SignerSuiteRecord>;
243
244 fn resolve_service(&self, service_domain: &str) -> Option<SignerSuiteRecord>;
246}
247
248#[derive(Default)]
253pub struct InMemoryEnrollmentResolver {
254 primary: HashMap<[u8; 32], SignerSuiteRecord>,
256 approver: HashMap<Vec<u8>, SignerSuiteRecord>,
258 service: HashMap<String, SignerSuiteRecord>,
260}
261
262impl InMemoryEnrollmentResolver {
263 pub fn new() -> Self {
264 Self::default()
265 }
266
267 pub fn enrol_primary(
273 &mut self,
274 cnf: &ed25519_dalek::VerifyingKey,
275 record: SignerSuiteRecord,
276 ) -> Result<()> {
277 if record.role != SignerRole::Primary {
278 bail!("enrol_primary: record role is {:?}", record.role);
279 }
280 if !record.pins_ed25519(cnf) {
281 bail!("enrol_primary: cnf key is not a pinned component of the record");
282 }
283 self.primary.insert(cnf.to_bytes(), record);
284 Ok(())
285 }
286
287 pub fn enrol_approver(&mut self, record: SignerSuiteRecord) -> Result<()> {
289 if record.role != SignerRole::Approver {
290 bail!("enrol_approver: record role is {:?}", record.role);
291 }
292 let kid = record
293 .components
294 .first()
295 .ok_or_else(|| anyhow::anyhow!("enrol_approver: record has no components"))?
296 .kid
297 .clone();
298 self.approver.insert(kid, record);
299 Ok(())
300 }
301
302 pub fn enrol_service(&mut self, service_domain: &str, record: SignerSuiteRecord) -> Result<()> {
304 if record.role != SignerRole::Service {
305 bail!("enrol_service: record role is {:?}", record.role);
306 }
307 self.service.insert(service_domain.to_owned(), record);
308 Ok(())
309 }
310}
311
312impl EnrollmentResolver for InMemoryEnrollmentResolver {
313 fn resolve_primary(&self, cnf: &ed25519_dalek::VerifyingKey) -> Option<SignerSuiteRecord> {
314 self.primary.get(&cnf.to_bytes()).cloned()
315 }
316
317 fn resolve_approver(&self, kid: &[u8]) -> Option<SignerSuiteRecord> {
318 self.approver.get(kid).cloned()
319 }
320
321 fn resolve_service(&self, service_domain: &str) -> Option<SignerSuiteRecord> {
322 self.service.get(service_domain).cloned()
323 }
324}
325
326static ENROLLMENT_RESOLVER: OnceLock<Box<dyn EnrollmentResolver>> = OnceLock::new();
331
332pub fn set_global_enrollment_resolver(
335 resolver: Box<dyn EnrollmentResolver>,
336) -> std::result::Result<(), Box<dyn EnrollmentResolver>> {
337 ENROLLMENT_RESOLVER.set(resolver)
338}
339
340pub fn global_enrollment_resolver() -> Option<&'static dyn EnrollmentResolver> {
341 ENROLLMENT_RESOLVER.get().map(|r| &**r)
342}
343
344#[cfg(test)]
345#[allow(clippy::unwrap_used, clippy::expect_used)]
346mod tests {
347 use super::*;
348
349 fn ed(seed: u8) -> ed25519_dalek::VerifyingKey {
350 ed25519_dalek::SigningKey::from_bytes(&[seed; 32]).verifying_key()
351 }
352
353 fn record(role: SignerRole, key: ed25519_dalek::VerifyingKey) -> SignerSuiteRecord {
354 SignerSuiteRecord {
355 principal: "p".into(),
356 suite_id: super::super::SUITE_CLASSICAL.into(),
357 components: vec![EnrolledComponent::new(
358 b"kid-1".to_vec(),
359 ComponentKey::Ed25519(key),
360 )],
361 epoch: 1,
362 role,
363 approver_role: None,
364 enrollment_policy_id: "test-enrollment-v1".to_owned(),
365 not_after: 2_000,
366 revoked: false,
367 }
368 }
369
370 #[test]
371 fn revoked_enrollment_is_rejected() {
372 let mut r = record(SignerRole::Primary, ed(1));
373 r.revoked = true;
374 assert!(r.check_usable(1_000, 1_010, SignerRole::Primary).is_err());
375 }
376
377 #[test]
378 fn expired_enrollment_is_rejected() {
379 let r = record(SignerRole::Primary, ed(1));
380 assert!(r.check_usable(2_000, 2_010, SignerRole::Primary).is_err());
381 }
382
383 #[test]
384 fn proof_outliving_the_credential_is_rejected() {
385 let r = record(SignerRole::Primary, ed(1));
386 assert!(r.check_usable(1_000, 2_001, SignerRole::Primary).is_err());
387 assert!(r.check_usable(1_000, 2_000, SignerRole::Primary).is_ok());
388 }
389
390 #[test]
391 fn a_record_cannot_be_used_in_another_role() {
392 let approver = record(SignerRole::Approver, ed(1));
393 assert!(approver
394 .check_usable(1_000, 1_010, SignerRole::Primary)
395 .is_err());
396 let service = record(SignerRole::Service, ed(1));
397 assert!(service
398 .check_usable(1_000, 1_010, SignerRole::Approver)
399 .is_err());
400 }
401
402 #[test]
403 fn primary_enrollment_requires_the_cnf_key_to_be_pinned() {
404 let mut resolver = InMemoryEnrollmentResolver::new();
405 let r = record(SignerRole::Primary, ed(1));
406 assert!(resolver.enrol_primary(&ed(2), r.clone()).is_err());
407 assert!(resolver.enrol_primary(&ed(1), r).is_ok());
408 }
409
410 #[test]
411 fn a_role_mismatch_cannot_be_enrolled() {
412 let mut resolver = InMemoryEnrollmentResolver::new();
413 assert!(resolver
414 .enrol_primary(&ed(1), record(SignerRole::Approver, ed(1)))
415 .is_err());
416 assert!(resolver
417 .enrol_approver(record(SignerRole::Primary, ed(1)))
418 .is_err());
419 assert!(resolver
420 .enrol_service("svc", record(SignerRole::Primary, ed(1)))
421 .is_err());
422 }
423
424 #[test]
427 fn replay_thumbprint_binds_suite_keys_and_epoch() {
428 let base = record(SignerRole::Primary, ed(1));
429 let mut rotated = base.clone();
430 rotated.epoch = 2;
431 let mut other_key = base.clone();
432 other_key.components[0].key = ComponentKey::Ed25519(ed(9));
433 let mut other_suite = base.clone();
434 other_suite.suite_id = super::super::SUITE_HYBRID.into();
435
436 assert_ne!(base.replay_thumbprint(), rotated.replay_thumbprint());
437 assert_ne!(base.replay_thumbprint(), other_key.replay_thumbprint());
438 assert_ne!(base.replay_thumbprint(), other_suite.replay_thumbprint());
439
440 let mut renamed = base.clone();
442 renamed.principal = "someone-else".into();
443 assert_eq!(base.replay_thumbprint(), renamed.replay_thumbprint());
444 }
445
446 #[test]
449 fn approver_membership_does_not_change_the_primary_namespace() {
450 let primary = record(SignerRole::Primary, ed(1));
451 let before = primary.replay_thumbprint();
452 let _approver = record(SignerRole::Approver, ed(2));
453 assert_eq!(before, primary.replay_thumbprint());
454 }
455}