1use cms::content_info::ContentInfo;
11use cms::signed_data::{
12 CertificateSet, DigestAlgorithmIdentifiers, EncapsulatedContentInfo, SignedData, SignerInfo,
13 SignerInfos,
14};
15use der_v08::asn1::{ObjectIdentifier, OctetString, SetOfVec};
16use der_v08::{Any, Decode, Encode};
17use sha2::{Digest, Sha256};
18use tracing::warn;
19use x509_cert_v03::attr::{Attribute, AttributeValue, Attributes};
20use x509_cert_v03::certificate::Certificate;
21
22use crate::error::{Result, SignError};
23use crate::ml_dsa_bridge::{ML_DSA_44_OID, ML_DSA_65_OID, ML_DSA_87_OID};
24
25const ID_SIGNED_DATA: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.7.2");
27const ID_CT_DATA: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.7.1");
28const ID_CONTENT_TYPE: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.9.3");
29const ID_MESSAGE_DIGEST: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.113549.1.9.4");
30const ID_SHA256: ObjectIdentifier = ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.2.1");
31const ID_ECDSA_SHA256: ObjectIdentifier = ObjectIdentifier::new_unwrap("1.2.840.10045.4.3.2");
32
33#[derive(Clone)]
35pub enum SealKey {
36 EcdsaP256(p256::ecdsa::SigningKey),
37 MlDsa44(ml_dsa::SigningKey<ml_dsa::MlDsa44>),
38 MlDsa65(ml_dsa::SigningKey<ml_dsa::MlDsa65>),
39 MlDsa87(ml_dsa::SigningKey<ml_dsa::MlDsa87>),
40}
41
42impl SealKey {
43 fn sign_attrs(&self, attrs_der: &[u8]) -> Result<Vec<u8>> {
44 match self {
45 SealKey::EcdsaP256(key) => {
46 use p256::ecdsa::signature::hazmat::PrehashSigner;
47 let hash = Sha256::digest(attrs_der);
48 let sig: p256::ecdsa::Signature = key
49 .sign_prehash(&hash)
50 .map_err(|e| SignError::Seal(format!("ECDSA sign: {e}")))?;
51 Ok(ecdsa_raw_to_der(&sig.to_bytes()))
52 }
53 SealKey::MlDsa44(key) => sign_ml_dsa(key, attrs_der),
54 SealKey::MlDsa65(key) => sign_ml_dsa(key, attrs_der),
55 SealKey::MlDsa87(key) => sign_ml_dsa(key, attrs_der),
56 }
57 }
58
59 fn algorithm_oid(&self) -> ObjectIdentifier {
60 match self {
61 SealKey::EcdsaP256(_) => ID_ECDSA_SHA256,
62 SealKey::MlDsa44(_) => ObjectIdentifier::new_unwrap(ML_DSA_44_OID),
63 SealKey::MlDsa65(_) => ObjectIdentifier::new_unwrap(ML_DSA_65_OID),
64 SealKey::MlDsa87(_) => ObjectIdentifier::new_unwrap(ML_DSA_87_OID),
65 }
66 }
67
68 fn digest_algorithm_oid(&self) -> ObjectIdentifier {
69 match self {
70 SealKey::EcdsaP256(_) => ID_SHA256,
71 SealKey::MlDsa44(_) | SealKey::MlDsa65(_) | SealKey::MlDsa87(_) => ID_SHA256,
73 }
74 }
75}
76
77fn sign_ml_dsa<P>(key: &ml_dsa::SigningKey<P>, data: &[u8]) -> Result<Vec<u8>>
78where
79 P: ml_dsa::MlDsaParams,
80 ml_dsa::SigningKey<P>: ml_dsa::Signer<ml_dsa::Signature<P>>,
81{
82 use ml_dsa::Signer as Signer3;
83 let sig: ml_dsa::Signature<P> = key
84 .try_sign(data)
85 .map_err(|e| SignError::Seal(format!("ML-DSA sign: {e}")))?;
86 let encoded = sig.encode();
87 let bytes: &[u8] = encoded.as_ref();
88 Ok(bytes.to_vec())
89}
90
91pub fn create_cms_seal(
96 manifest_bytes: &[u8],
97 seal_key: &SealKey,
98 seal_cert_der: &[u8],
99) -> Result<Vec<u8>> {
100 let manifest_digest = Sha256::digest(manifest_bytes);
101
102 let cert = Certificate::from_der(seal_cert_der)
103 .map_err(|e| SignError::Seal(format!("parse seal cert: {e}")))?;
104
105 let content_type_attr = build_content_type_attr()?;
106 let message_digest_attr = build_message_digest_attr(&manifest_digest)?;
107
108 let signed_attrs = Attributes::try_from(vec![content_type_attr, message_digest_attr])
109 .map_err(|e| SignError::Seal(format!("build signed attrs: {e}")))?;
110
111 let signed_attrs_der = signed_attrs
112 .to_der()
113 .map_err(|e| SignError::Seal(format!("encode signed attrs: {e}")))?;
114
115 let sig_bytes = seal_key.sign_attrs(&signed_attrs_der)?;
116
117 let signer_info = SignerInfo {
118 version: cms::content_info::CmsVersion::V1,
119 sid: cms::signed_data::SignerIdentifier::from(&cert),
120 digest_alg: spki_v08::AlgorithmIdentifierOwned {
121 oid: seal_key.digest_algorithm_oid(),
122 parameters: None,
123 },
124 signed_attrs: Some(signed_attrs),
125 signature_algorithm: spki_v08::AlgorithmIdentifierOwned {
126 oid: seal_key.algorithm_oid(),
127 parameters: None,
128 },
129 signature: OctetString::new(sig_bytes)
130 .map_err(|e| SignError::Seal(format!("sig octet string: {e}")))?,
131 unsigned_attrs: None,
132 };
133
134 let digest_alg = spki_v08::AlgorithmIdentifierOwned {
135 oid: ID_SHA256,
136 parameters: None,
137 };
138 let digest_algorithms = DigestAlgorithmIdentifiers::try_from(vec![digest_alg])
139 .map_err(|e| SignError::Seal(format!("digest algs: {e}")))?;
140
141 let cert_set = CertificateSet::try_from(vec![cms::cert::CertificateChoices::Certificate(cert)])
142 .map_err(|e| SignError::Seal(format!("cert set: {e}")))?;
143
144 let signer_infos = SignerInfos::try_from(vec![signer_info])
145 .map_err(|e| SignError::Seal(format!("signer infos: {e}")))?;
146
147 let encap_content_info = EncapsulatedContentInfo {
149 econtent_type: ID_CT_DATA,
150 econtent: None,
151 };
152
153 let signed_data = SignedData {
154 version: cms::content_info::CmsVersion::V1,
155 digest_algorithms,
156 encap_content_info,
157 certificates: Some(cert_set),
158 crls: None,
159 signer_infos,
160 };
161
162 let signed_data_der = signed_data
164 .to_der()
165 .map_err(|e| SignError::Seal(format!("encode SignedData: {e}")))?;
166
167 let content_info = ContentInfo {
168 content_type: ID_SIGNED_DATA,
169 content: Any::from_der(&signed_data_der)
170 .map_err(|e| SignError::Seal(format!("wrap ContentInfo: {e}")))?,
171 };
172
173 content_info
174 .to_der()
175 .map_err(|e| SignError::Seal(format!("encode ContentInfo: {e}")))
176}
177
178fn build_content_type_attr() -> Result<Attribute> {
179 let oid_der = ID_CT_DATA
180 .to_der()
181 .map_err(|e| SignError::Seal(format!("encode content type OID: {e}")))?;
182 let attr_val = AttributeValue::from_der(&oid_der)
183 .map_err(|e| SignError::Seal(format!("attr value from OID: {e}")))?;
184 let mut values = SetOfVec::new();
185 values
186 .insert(attr_val)
187 .map_err(|e| SignError::Seal(format!("insert content type: {e}")))?;
188 Ok(Attribute {
189 oid: ID_CONTENT_TYPE,
190 values,
191 })
192}
193
194fn build_message_digest_attr(digest: &[u8]) -> Result<Attribute> {
195 let octet_string = OctetString::new(digest.to_vec())
196 .map_err(|e| SignError::Seal(format!("digest octet string: {e}")))?;
197 let octet_der = octet_string
198 .to_der()
199 .map_err(|e| SignError::Seal(format!("encode digest: {e}")))?;
200 let attr_val = AttributeValue::from_der(&octet_der)
201 .map_err(|e| SignError::Seal(format!("attr value from digest: {e}")))?;
202 let mut values = SetOfVec::new();
203 values
204 .insert(attr_val)
205 .map_err(|e| SignError::Seal(format!("insert message digest: {e}")))?;
206 Ok(Attribute {
207 oid: ID_MESSAGE_DIGEST,
208 values,
209 })
210}
211
212const SEAL_PREFLIGHT_PAYLOAD: &[u8] = b"hoike:seal-preflight:v1";
215
216pub fn load_seal_certificate(path: &std::path::Path) -> Result<Vec<u8>> {
223 let data = std::fs::read(path)
224 .map_err(|e| SignError::Seal(format!("read seal certificate {}: {e}", path.display())))?;
225 let der = if data.starts_with(b"-----BEGIN") {
226 let pem = String::from_utf8(data).map_err(|e| {
227 SignError::Seal(format!(
228 "seal certificate {} PEM is not valid UTF-8: {e}",
229 path.display()
230 ))
231 })?;
232 let first_line = pem.lines().next().unwrap_or("");
234 if !first_line.contains("CERTIFICATE") {
235 return Err(SignError::Seal(format!(
236 "seal certificate {} has unexpected PEM label: {} — expected CERTIFICATE",
237 path.display(),
238 first_line.trim()
239 )));
240 }
241 let mut b64 = String::new();
242 for line in pem.lines() {
243 if line.starts_with("-----") {
244 continue;
245 }
246 b64.push_str(line.trim());
247 }
248 use base64::Engine;
249 base64::engine::general_purpose::STANDARD
250 .decode(&b64)
251 .map_err(|e| {
252 SignError::Seal(format!(
253 "seal certificate {} PEM base64 decode: {e}",
254 path.display()
255 ))
256 })?
257 } else {
258 data
259 };
260 Certificate::from_der(&der)
261 .map_err(|e| SignError::Seal(format!("parse seal certificate {}: {e}", path.display())))?;
262 Ok(der)
263}
264
265pub fn validate_seal_materials(key: &SealKey, cert_der: &[u8], now: u64) -> Result<()> {
273 let seal = create_cms_seal(SEAL_PREFLIGHT_PAYLOAD, key, cert_der)?;
274 ahu::verify_seal_with_pins(SEAL_PREFLIGHT_PAYLOAD, &seal, &[cert_der.to_vec()], now)
275 .map_err(|e| SignError::Seal(format!("seal material preflight: {e}")))?;
276 Ok(())
277}
278
279const SEAL_OCSP_KEY_SEPARATION_MESSAGE: &[u8] = b"hoike:seal-ocsp-key-separation:v1";
283
284pub fn ensure_distinct_ecdsa_seal_key<S, Sig>(signer: &S, seal: &SealKey) -> Result<()>
298where
299 S: signature::Signer<Sig>,
300 Sig: spki::SignatureBitStringEncoding,
301{
302 let seal_verifying = match seal {
303 SealKey::EcdsaP256(key) => p256::ecdsa::VerifyingKey::from(key),
304 SealKey::MlDsa44(_) | SealKey::MlDsa65(_) | SealKey::MlDsa87(_) => return Ok(()),
307 };
308 let sig = signer
309 .try_sign(SEAL_OCSP_KEY_SEPARATION_MESSAGE)
310 .map_err(|e| SignError::Seal(format!("seal/OCSP key separation proof signing: {e}")))?;
311 let der_sig = p256::ecdsa::DerSignature::try_from(
312 sig.to_bitstring()
313 .map_err(|e| {
314 SignError::Seal(format!("seal/OCSP key separation signature encoding: {e}"))
315 })?
316 .as_bytes()
317 .ok_or_else(|| {
318 SignError::Seal("seal/OCSP key separation signature has unused bits".into())
319 })?,
320 )
321 .map_err(|e| {
322 SignError::Seal(format!(
323 "seal/OCSP key separation signature is not valid DER ECDSA: {e}"
324 ))
325 })?;
326 use p256::ecdsa::signature::Verifier;
328 if seal_verifying
329 .verify(SEAL_OCSP_KEY_SEPARATION_MESSAGE, &der_sig)
330 .is_ok()
331 {
332 return Err(SignError::Seal(
333 "the OCSP signing key and the seal key are the same key — configure distinct \
334 seal material (ahu spec §2.3)"
335 .into(),
336 ));
337 }
338 Ok(())
339}
340
341fn ecdsa_raw_to_der(raw: &[u8]) -> Vec<u8> {
343 if raw.len() != 64 {
344 return raw.to_vec();
345 }
346 let r = &raw[..32];
347 let s = &raw[32..];
348
349 fn encode_integer(val: &[u8]) -> Vec<u8> {
350 let start = val.iter().position(|&b| b != 0).unwrap_or(val.len() - 1);
351 let val = &val[start..];
352 let needs_pad = val.first().is_some_and(|&b| b & 0x80 != 0);
353 let len = val.len() + usize::from(needs_pad);
354 let mut out = vec![0x02, len as u8];
355 if needs_pad {
356 out.push(0x00);
357 }
358 out.extend_from_slice(val);
359 out
360 }
361
362 let r_enc = encode_integer(r);
363 let s_enc = encode_integer(s);
364 let total = r_enc.len() + s_enc.len();
365 let mut out = vec![0x30, total as u8];
366 out.extend_from_slice(&r_enc);
367 out.extend_from_slice(&s_enc);
368 out
369}
370
371pub fn generate_seal_cert(signing_key: &p256::ecdsa::SigningKey) -> Result<Vec<u8>> {
373 generate_seal_cert_for_key(&SealKey::EcdsaP256(signing_key.clone()))
374}
375
376pub fn demo_ephemeral_seal_key() -> p256::ecdsa::SigningKey {
383 use rand_core::{OsRng, RngCore};
388 loop {
389 let mut bytes = p256::FieldBytes::default();
390 OsRng.fill_bytes(&mut bytes);
391 if let Ok(key) = p256::ecdsa::SigningKey::from_bytes(&bytes) {
392 return key;
393 }
394 }
395}
396
397pub fn load_or_generate_seal_material(
413 seal_key: Option<&std::path::Path>,
414 seal_cert: Option<&std::path::Path>,
415 demo: bool,
416) -> std::result::Result<(SealKey, Vec<u8>), String> {
417 let (seal_key, seal_cert_der) = match (seal_key, seal_cert) {
418 (Some(key_path), Some(cert_path)) => {
419 let ecdsa_key = crate::load_ecdsa_p256_key(key_path)
420 .map_err(|e| format!("load seal key {}: {e}", key_path.display()))?;
421 let cert =
422 load_seal_certificate(cert_path).map_err(|e| format!("load seal cert: {e}"))?;
423 (SealKey::EcdsaP256(ecdsa_key), cert)
424 }
425 (Some(_), None) | (None, Some(_)) => {
426 return Err("seal_key and seal_cert must be configured together — \
427 a half-configured seal pair is always an error"
428 .into());
429 }
430 (None, None) => {
431 if !demo {
432 return Err("production signing requires a persistent seal_key and \
433 seal_cert pair — configure both, or use the demo signing \
434 key for testing"
435 .into());
436 }
437 warn!(
438 "no seal material configured — generating a distinct ephemeral \
439 demo seal pair (NOT FOR PRODUCTION)"
440 );
441 let key = demo_ephemeral_seal_key();
442 let cert = generate_seal_cert_for_key(&SealKey::EcdsaP256(key.clone()))
443 .map_err(|e| format!("generate demo seal cert: {e}"))?;
444 (SealKey::EcdsaP256(key), cert)
445 }
446 };
447 let now = crate::source::unix_now().map_err(|e| format!("clock: {e}"))?;
452 validate_seal_materials(&seal_key, &seal_cert_der, now).map_err(|e| e.to_string())?;
453 Ok((seal_key, seal_cert_der))
454}
455
456pub fn generate_seal_cert_for_key(seal_key: &SealKey) -> Result<Vec<u8>> {
458 let (pub_key_bytes, alg_id_der) = match seal_key {
459 SealKey::EcdsaP256(key) => {
460 let vk = p256::ecdsa::VerifyingKey::from(key);
461 let pub_key = p256::PublicKey::from(vk).to_sec1_bytes().to_vec();
462 (pub_key, encode_ecdsa_alg_id())
463 }
464 SealKey::MlDsa44(key) => {
465 use ml_dsa::Keypair;
466 (
467 key.verifying_key().encode().to_vec(),
468 encode_ml_dsa_alg_id(ML_DSA_44_OID),
469 )
470 }
471 SealKey::MlDsa65(key) => {
472 use ml_dsa::Keypair;
473 (
474 key.verifying_key().encode().to_vec(),
475 encode_ml_dsa_alg_id(ML_DSA_65_OID),
476 )
477 }
478 SealKey::MlDsa87(key) => {
479 use ml_dsa::Keypair;
480 (
481 key.verifying_key().encode().to_vec(),
482 encode_ml_dsa_alg_id(ML_DSA_87_OID),
483 )
484 }
485 };
486
487 let spki_der = match seal_key {
488 SealKey::EcdsaP256(_) => encode_ecdsa_spki(&pub_key_bytes),
489 _ => encode_ml_dsa_spki(&pub_key_bytes, &alg_id_der),
490 };
491
492 let mut tbs = Vec::new();
493 tbs.extend_from_slice(&[0xA0, 0x03, 0x02, 0x01, 0x02]);
494 tbs.extend_from_slice(&[0x02, 0x01, 0x01]);
495 tbs.extend_from_slice(&alg_id_der);
496 let name = encode_cn("hoike-seal");
497 tbs.extend_from_slice(&name);
498 tbs.extend_from_slice(&encode_validity()?);
499 tbs.extend_from_slice(&name);
500 tbs.extend_from_slice(&spki_der);
501 let tbs_seq = wrap_seq(&tbs);
502
503 let sig_bytes = seal_key.sign_attrs(&tbs_seq)?;
504
505 let mut cert = Vec::new();
506 cert.extend_from_slice(&tbs_seq);
507 cert.extend_from_slice(&alg_id_der);
508 cert.extend_from_slice(&encode_bitstring(&sig_bytes));
509
510 Ok(wrap_seq(&cert))
511}
512
513fn encode_bitstring(data: &[u8]) -> Vec<u8> {
514 let bs_len = data.len() + 1; let mut bs = vec![0x03];
516 encode_der_length(&mut bs, bs_len);
517 bs.push(0x00); bs.extend_from_slice(data);
519 bs
520}
521
522fn encode_der_length(out: &mut Vec<u8>, len: usize) {
524 if len < 128 {
525 out.push(len as u8);
526 } else if len < 256 {
527 out.push(0x81);
528 out.push(len as u8);
529 } else if len < 65536 {
530 out.push(0x82);
531 out.push((len >> 8) as u8);
532 out.push((len & 0xFF) as u8);
533 } else {
534 out.push(0x83);
535 out.push((len >> 16) as u8);
536 out.push(((len >> 8) & 0xFF) as u8);
537 out.push((len & 0xFF) as u8);
538 }
539}
540
541fn encode_ecdsa_alg_id() -> Vec<u8> {
542 let oid = &[0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02];
543 wrap_seq(oid)
544}
545
546fn encode_ml_dsa_alg_id(oid_str: &str) -> Vec<u8> {
547 let oid = ObjectIdentifier::new_unwrap(oid_str);
548 let oid_der = oid.to_der().unwrap();
549 wrap_seq(&oid_der)
550}
551
552fn encode_cn(cn: &str) -> Vec<u8> {
553 let cn_oid = &[0x06, 0x03, 0x55, 0x04, 0x03];
554 let cn_val = tlv(0x0C, cn.as_bytes());
555 let mut attr = Vec::new();
556 attr.extend_from_slice(cn_oid);
557 attr.extend_from_slice(&cn_val);
558 let attr_seq = wrap_seq(&attr);
559 let rdn_set = tlv(0x31, &attr_seq);
560 wrap_seq(&rdn_set)
561}
562
563fn encode_validity() -> Result<Vec<u8>> {
568 let now = std::time::SystemTime::now()
569 .duration_since(std::time::UNIX_EPOCH)
570 .map_err(|e| SignError::Seal(format!("clock: {e}")))?;
571 let not_before = now.as_secs().saturating_sub(300);
572 let not_after = now.as_secs().saturating_add(2 * 365 * 86400);
573 let mut v = Vec::new();
574 v.extend_from_slice(&tlv(0x17, format_utc_time(not_before).as_bytes()));
577 v.extend_from_slice(&tlv(0x17, format_utc_time(not_after).as_bytes()));
578 Ok(wrap_seq(&v))
579}
580
581fn format_utc_time(unix_secs: u64) -> String {
584 let days = unix_secs / 86400;
585 let secs = unix_secs % 86400;
586 let z = days as i64 + 719_468;
588 let era = z.div_euclid(146_097);
589 let doe = z.rem_euclid(146_097);
590 let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146_096) / 365;
591 let year = yoe + era * 400;
592 let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
593 let mp = (5 * doy + 2) / 153;
594 let day = doy - (153 * mp + 2) / 5 + 1;
595 let month = if mp < 10 { mp + 3 } else { mp - 9 };
596 let year = if month <= 2 { year + 1 } else { year };
597 format!(
598 "{:02}{:02}{:02}{:02}{:02}{:02}Z",
599 year % 100,
600 month,
601 day,
602 secs / 3600,
603 (secs % 3600) / 60,
604 secs % 60
605 )
606}
607
608fn encode_ecdsa_spki(pub_key_uncompressed: &[u8]) -> Vec<u8> {
609 let ec_oid = &[0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01];
610 let p256_oid = &[0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07];
611 let mut alg = Vec::new();
612 alg.extend_from_slice(ec_oid);
613 alg.extend_from_slice(p256_oid);
614 let alg_seq = wrap_seq(&alg);
615
616 let mut spki = Vec::new();
617 spki.extend_from_slice(&alg_seq);
618 spki.extend_from_slice(&encode_bitstring(pub_key_uncompressed));
619 wrap_seq(&spki)
620}
621
622fn encode_ml_dsa_spki(pub_key_bytes: &[u8], alg_id_der: &[u8]) -> Vec<u8> {
623 let mut spki = Vec::new();
624 spki.extend_from_slice(alg_id_der);
625 spki.extend_from_slice(&encode_bitstring(pub_key_bytes));
626 wrap_seq(&spki)
627}
628
629fn wrap_seq(content: &[u8]) -> Vec<u8> {
630 tlv(0x30, content)
631}
632
633fn tlv(tag: u8, content: &[u8]) -> Vec<u8> {
634 let mut out = vec![tag];
635 encode_der_length(&mut out, content.len());
636 out.extend_from_slice(content);
637 out
638}
639
640#[cfg(test)]
641mod tests {
642 use super::*;
643
644 fn test_key() -> p256::ecdsa::SigningKey {
645 let secret = [7u8; 32];
646 p256::ecdsa::SigningKey::from_bytes((&secret).into()).unwrap()
647 }
648
649 #[test]
650 fn generate_seal_cert_parseable() {
651 let key = test_key();
652 let cert_der = generate_seal_cert(&key).unwrap();
653 let cert = Certificate::from_der(&cert_der).unwrap();
654 assert_eq!(cert.tbs_certificate().serial_number().as_bytes(), &[0x01]);
655 }
656
657 #[test]
661 fn load_or_generate_seal_material_policy() {
662 use p256::pkcs8::EncodePrivateKey;
663
664 let dir = tempfile::tempdir().unwrap();
665 let now = std::time::SystemTime::now()
666 .duration_since(std::time::UNIX_EPOCH)
667 .unwrap()
668 .as_secs();
669 let key = test_key();
670 let cert_der = generate_seal_cert(&key).unwrap();
671 let key_path = dir.path().join("seal.p8");
672 std::fs::write(&key_path, key.to_pkcs8_der().unwrap().as_bytes()).unwrap();
673 let cert_path = dir.path().join("seal.der");
674 std::fs::write(&cert_path, &cert_der).unwrap();
675 let missing = dir.path().join("missing");
676
677 let (loaded, cert) =
679 load_or_generate_seal_material(Some(&key_path), Some(&cert_path), false).unwrap();
680 assert!(matches!(loaded, SealKey::EcdsaP256(_)));
681 assert_eq!(cert, cert_der);
682
683 for demo in [false, true] {
686 let err = load_or_generate_seal_material(Some(&key_path), None, demo)
687 .err()
688 .expect("half pair (key only) must error");
689 assert!(err.contains("half-configured"), "demo={demo}: {err}");
690 let err = load_or_generate_seal_material(None, Some(&cert_path), demo)
691 .err()
692 .expect("half pair (cert only) must error");
693 assert!(err.contains("half-configured"), "demo={demo}: {err}");
694 }
695
696 let err = load_or_generate_seal_material(None, None, false)
698 .err()
699 .expect("production without seal material must error");
700 assert!(err.contains("persistent"), "{err}");
701
702 let (demo_seal, demo_cert) = load_or_generate_seal_material(None, None, true).unwrap();
704 let SealKey::EcdsaP256(demo_key) = &demo_seal else {
705 panic!("demo seal material must be ECDSA P-256");
706 };
707 assert_ne!(
708 demo_key.verifying_key(),
709 crate::demo_ecdsa_p256_key().verifying_key(),
710 "demo seal key must be distinct from the demo OCSP key"
711 );
712 let (second, _) = load_or_generate_seal_material(None, None, true).unwrap();
713 let SealKey::EcdsaP256(second_key) = &second else {
714 panic!("demo seal material must be ECDSA P-256");
715 };
716 assert_ne!(
717 second_key.verifying_key(),
718 demo_key.verifying_key(),
719 "ephemeral demo seal keys must be freshly generated"
720 );
721 assert!(validate_seal_materials(&demo_seal, &demo_cert, now).is_ok());
722
723 assert!(
725 load_or_generate_seal_material(Some(&missing), Some(&cert_path), false).is_err(),
726 "unreadable seal key must fail the load"
727 );
728 assert!(
729 load_or_generate_seal_material(Some(&key_path), Some(&missing), false).is_err(),
730 "unreadable seal certificate must fail the load"
731 );
732 }
733
734 #[test]
735 fn seal_round_trip() {
736 let key = test_key();
737 let seal_key = SealKey::EcdsaP256(key.clone());
738 let cert_der = generate_seal_cert(&key).unwrap();
739 let manifest = b"test manifest data for seal verification";
740
741 let seal = create_cms_seal(manifest, &seal_key, &cert_der).unwrap();
742 assert!(!seal.is_empty());
743
744 let ci = ContentInfo::from_der(&seal).unwrap();
745 assert_eq!(ci.content_type, ID_SIGNED_DATA);
746
747 let sd = ci.content.decode_as::<SignedData>().unwrap();
748 assert!(sd.certificates.is_some());
749 assert_eq!(sd.signer_infos.0.len(), 1);
750 assert!(sd.encap_content_info.econtent.is_none());
751 }
752
753 #[test]
754 fn seal_has_message_digest_attr() {
755 let key = test_key();
756 let seal_key = SealKey::EcdsaP256(key.clone());
757 let cert_der = generate_seal_cert(&key).unwrap();
758 let manifest = b"manifest";
759
760 let seal = create_cms_seal(manifest, &seal_key, &cert_der).unwrap();
761 let ci = ContentInfo::from_der(&seal).unwrap();
762 let sd = ci.content.decode_as::<SignedData>().unwrap();
763 let si = &sd.signer_infos.0.as_slice()[0];
764
765 let attrs = si.signed_attrs.as_ref().expect("signed_attrs required");
766 assert!(
767 attrs.iter().any(|a| a.oid == ID_MESSAGE_DIGEST),
768 "must contain message-digest attribute"
769 );
770 assert!(
771 attrs.iter().any(|a| a.oid == ID_CONTENT_TYPE),
772 "must contain content-type attribute"
773 );
774 }
775
776 #[test]
777 fn ml_dsa_87_seal_cert_parseable() {
778 let sk = ml_dsa::SigningKey::<ml_dsa::MlDsa87>::from_seed((&[42u8; 32]).into());
779 let seal_key = SealKey::MlDsa87(sk);
780 let cert_der = generate_seal_cert_for_key(&seal_key).unwrap();
781 let cert = Certificate::from_der(&cert_der).unwrap();
782 assert_eq!(cert.tbs_certificate().serial_number().as_bytes(), &[0x01]);
783 }
784
785 #[test]
786 fn ml_dsa_87_seal_round_trip() {
787 let sk = ml_dsa::SigningKey::<ml_dsa::MlDsa87>::from_seed((&[99u8; 32]).into());
788 let seal_key = SealKey::MlDsa87(sk);
789 let cert_der = generate_seal_cert_for_key(&seal_key).unwrap();
790 let manifest = b"ML-DSA sealed manifest";
791
792 let seal = create_cms_seal(manifest, &seal_key, &cert_der).unwrap();
793 assert!(!seal.is_empty());
794
795 let ci = ContentInfo::from_der(&seal).unwrap();
796 let sd = ci.content.decode_as::<SignedData>().unwrap();
797 let si = &sd.signer_infos.0.as_slice()[0];
798
799 let sig_alg = si.signature_algorithm.oid.to_string();
800 assert_eq!(sig_alg, ML_DSA_87_OID);
801 assert!(
802 si.signature.as_bytes().len() > 4000,
803 "ML-DSA-87 sig should be ~4627 bytes"
804 );
805 }
806}