Skip to main content

hoike_sign/
seal.rs

1//! CMS SignedData seal creation for ahu bundles.
2//!
3//! Creates a detached CMS SignedData (RFC 5652) over the manifest bytes.
4//! The seal proves that a specific producer assembled the bundle; it does not
5//! make the OCSP responses more trustworthy (their own signatures do that).
6//!
7//! Uses the der 0.8 ecosystem (via cms crate), separate from the OCSP-side
8//! der 0.7 types. The p256 signing key bridges between them.
9
10use 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
25// OIDs
26const 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/// Algorithm-agnostic seal signing key.
34#[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            // ML-DSA is a full-message scheme — no external digest
72            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
91/// Create a detached CMS SignedData seal over the manifest bytes.
92///
93/// Accepts any `SealKey` variant (ECDSA-P256 or ML-DSA). ECDSA uses
94/// prehash signing; ML-DSA signs the raw signed attributes DER.
95pub 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    // Detached: no eContent
148    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    // Wrap in ContentInfo
163    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
212/// Synthetic payload for the seal material preflight. Domain-separated so a
213/// preflight seal can never be confused with a manifest seal.
214const SEAL_PREFLIGHT_PAYLOAD: &[u8] = b"hoike:seal-preflight:v1";
215
216/// Load a configured seal certificate, normalizing PEM or DER input to DER.
217///
218/// PEM input may carry ordinary line endings and whitespace; the label must
219/// be a CERTIFICATE. The result must parse as an X.509 certificate (same
220/// der 0.8 codec CMS seal creation uses) before it is returned, so malformed
221/// input fails here instead of at bundle publication.
222pub 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        // Validate the PEM label — reject non-certificate files.
233        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
265/// Prove the seal key/certificate pair before publication.
266///
267/// Creates a real CMS seal over the domain-separated preflight payload and
268/// verifies it with `ahu::verify_seal_with_pins` using the configured
269/// certificate as an exact pin at `now`. This exercises the actual signing
270/// algorithm, the key/certificate binding, validity, and the supported
271/// certificate profile.
272pub 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
279/// Domain-separated message signed by the OCSP signer to prove its key is
280/// not the seal key (F07). A signature over this message that verifies under
281/// the seal public key proves prohibited key reuse.
282const SEAL_OCSP_KEY_SEPARATION_MESSAGE: &[u8] = b"hoike:seal-ocsp-key-separation:v1";
283
284/// Prove that the OCSP signer's key is distinct from the configured seal
285/// key (F07).
286///
287/// Signs the domain-separated separation message with the OCSP signer through
288/// the same fallible `Signer`/`SignatureBitStringEncoding` bridge bundle
289/// production uses (software P-256 with `Sig = p256::ecdsa::DerSignature`, or
290/// the PKCS#11 bridge with `Sig = hoike_sign::Pkcs11EcdsaSignature`), parses
291/// the result as a valid DER P-256 signature, and rejects the configuration
292/// if it verifies under the seal key's public key — proving the same key
293/// material is configured for both roles even through different file names.
294/// ML-DSA seal keys are algorithm-distinct from ECDSA OCSP signers and always
295/// pass. Any signer or encoding error fails the preflight: this never
296/// silently skips the check.
297pub 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        // An ECDSA signature cannot verify under an ML-DSA seal key: the
305        // algorithms are distinct by construction.
306        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    // ecdsa 0.17 verifies via signature v3.
327    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
341/// Convert raw ECDSA P-256 signature (r || s, 64 bytes) to DER encoding.
342fn 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
371/// Generate a self-signed seal certificate for testing/demo use.
372pub 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
376/// Generate a fresh, random ECDSA P-256 seal key for explicit demo mode
377/// (F07).
378///
379/// Distinct from the fixed demo OCSP key and from any persistent seal key by
380/// construction, so the demo signing path can never trip — or silently
381/// satisfy — the OCSP/seal key-separation proof.
382pub fn demo_ephemeral_seal_key() -> p256::ecdsa::SigningKey {
383    // The p256 0.14 line draws randomness from rand_core 0.10, which is not
384    // the rand_core hoike-sign depends on — pull raw OS entropy here and
385    // construct the key from a secret scalar, rejecting the (negligible)
386    // zero-scalar case exactly like `Generate::try_generate_from_rng` does.
387    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
397/// Resolve seal material under the shared F07 policy — the single source of
398/// truth for the seal-material decision, consumed by the configured loader
399/// (`orchestrate::load_seal_materials`) and the one-shot `hoike sign` path.
400/// (`hoike-core`'s config validation mirrors the structural rules; it cannot
401/// depend on `hoike-sign`.)
402///
403/// - both `seal_key` and `seal_cert` → load the persistent pair (the
404///   certificate is PEM/DER-normalized) and prove it with the real CMS
405///   preflight;
406/// - exactly one → error: a half-configured seal pair is always an error;
407/// - neither → error for production; explicit demo generates a distinct
408///   ephemeral pair (warned, NOT FOR PRODUCTION) and proves it the same way.
409///
410/// Errors are policy messages without caller context; callers prefix their
411/// own scope (CA label, flag-name guidance).
412pub 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    // F08: prove the pair on every load — callers run this per signing pass
448    // (background loop, on-demand signing, post-rotation reload), so the
449    // verdict is never a startup-only cache. Failures propagate before any
450    // bundle is produced or published.
451    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
456/// Generate a self-signed seal certificate for any `SealKey` type.
457pub 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; // +1 for unused-bits byte
515    let mut bs = vec![0x03];
516    encode_der_length(&mut bs, bs_len);
517    bs.push(0x00); // unused bits
518    bs.extend_from_slice(data);
519    bs
520}
521
522/// Append a DER definite-length encoding to `out`.
523fn 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
563/// Fresh validity window for generated (demo) certificates, anchored at the
564/// generation time instead of a fixed historic range: backdated five minutes
565/// for clock skew and expiring two years out, so generated material is always
566/// freshly valid and never a fixed-window fixture.
567fn 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    // Tag 0x17 is UTCTime (YYMMDDHHMMSSZ), which der 0.7's `Time` CHOICE
575    // accepts for years 1950–2049.
576    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
581/// Format a unix timestamp as an RFC 5280 UTCTime `YYMMDDHHMMSSZ` literal
582/// (valid for years 1950–2049, which covers generated demo material).
583fn format_utc_time(unix_secs: u64) -> String {
584    let days = unix_secs / 86400;
585    let secs = unix_secs % 86400;
586    // Howard Hinnant's civil-from-days conversion.
587    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    /// F07: the shared seal-material policy decision. One implementation,
658    /// unit-tested here, consumed by the configured loader and the one-shot
659    /// CLI sign path.
660    #[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        // A complete pair loads and passes the CMS preflight.
678        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        // Exactly one input is always an error, in either direction, demo or
684        // not.
685        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        // Neither input errors for production...
697        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        // ...and generates distinct ephemeral material for explicit demo.
703        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        // Load failures propagate: unreadable key or certificate files.
724        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}