Skip to main content

hoike_sign/
live.rs

1//! On-demand OCSP response signing with a client-supplied nonce.
2//!
3//! Used by `nonce_policy = "live"` on signer/combined nodes. The signer
4//! already has the certificate's status (from the loaded bundle) and the
5//! signing key — it re-signs a fresh response with the nonce embedded,
6//! without round-tripping to the CA.
7
8use der::asn1::OctetString;
9use der::{Decode, Encode};
10use sha1::Sha1;
11use sha2::Digest;
12use signature::Signer;
13use spki::{DynSignatureAlgorithmIdentifier, SignatureBitStringEncoding};
14use x509_ocsp::builder::OcspResponseBuilder;
15use x509_ocsp::{
16    BasicOcspResponse, CertId, CertStatus, OcspGeneralizedTime, OcspResponse, ResponderId,
17    SingleResponse, ext::Nonce,
18};
19
20use crate::error::{Result, SignError};
21use crate::generate::ocsp_time;
22use x509_cert::Certificate as CertificateForLive;
23
24/// Certificate status for live signing.
25#[derive(Debug, Clone)]
26pub enum LiveCertStatus {
27    Good,
28    Unknown,
29    Revoked {
30        revocation_time: u64,
31        reason: Option<x509_cert::ext::pkix::CrlReason>,
32    },
33}
34
35/// Sign a fresh OCSP response on demand with the client's nonce embedded.
36///
37/// This is the hot path for `nonce_policy = "live"`. It builds a
38/// `BasicOCSPResponse` containing one `SingleResponse` for the requested
39/// CertID, adds the nonce as a response extension, and signs it.
40#[allow(clippy::too_many_arguments)]
41pub fn sign_live_response<S, Sig>(
42    cert_id_der: &[u8],
43    status: LiveCertStatus,
44    nonce_bytes: &[u8],
45    responder_key_bytes: &[u8],
46    signer: &mut S,
47    now: u64,
48    validity_secs: u64,
49    responder_cert_der: Option<&[u8]>,
50) -> Result<Vec<u8>>
51where
52    S: Signer<Sig> + DynSignatureAlgorithmIdentifier,
53    Sig: SignatureBitStringEncoding,
54{
55    let next = now
56        .checked_add(validity_secs)
57        .ok_or_else(|| SignError::Config("live validity overflow".into()))?;
58    sign_live_response_with_window(
59        cert_id_der,
60        status,
61        nonce_bytes,
62        responder_key_bytes,
63        signer,
64        now,
65        now,
66        next,
67        responder_cert_der,
68    )
69}
70
71/// Sign only within the authenticated source window; producedAt is signing time,
72/// thisUpdate remains the time the source actually established the status.
73#[allow(clippy::too_many_arguments)]
74pub fn sign_live_response_with_window<S, Sig>(
75    cert_id_der: &[u8],
76    status: LiveCertStatus,
77    nonce_bytes: &[u8],
78    responder_key_bytes: &[u8],
79    signer: &mut S,
80    now: u64,
81    source_this_update: u64,
82    source_next_update: u64,
83    responder_cert_der: Option<&[u8]>,
84) -> Result<Vec<u8>>
85where
86    S: Signer<Sig> + DynSignatureAlgorithmIdentifier,
87    Sig: SignatureBitStringEncoding,
88{
89    if source_this_update > now
90        || source_next_update <= now
91        || source_next_update <= source_this_update
92    {
93        return Err(SignError::Config(
94            "live source is not currently valid".into(),
95        ));
96    }
97    let mut next_update_epoch = source_next_update;
98    if let Some(bytes) = responder_cert_der {
99        let cert = CertificateForLive::from_der(bytes).map_err(SignError::Der)?;
100        let validity = &cert.tbs_certificate.validity;
101        let before = validity.not_before.to_unix_duration().as_secs();
102        let after = validity.not_after.to_unix_duration().as_secs();
103        if now < before || now >= after {
104            return Err(SignError::Config(
105                "responder certificate is not currently valid".into(),
106            ));
107        }
108        next_update_epoch = next_update_epoch.min(after);
109    }
110    let cert_id = CertId::from_der(cert_id_der).map_err(SignError::Der)?;
111
112    let cert_status = match status {
113        LiveCertStatus::Good => CertStatus::good(),
114        LiveCertStatus::Unknown => CertStatus::unknown(),
115        LiveCertStatus::Revoked {
116            revocation_time,
117            reason,
118        } => {
119            let revoked_info = x509_ocsp::RevokedInfo {
120                revocation_time: ocsp_time(revocation_time)?,
121                revocation_reason: reason,
122            };
123            CertStatus::revoked(revoked_info)
124        }
125    };
126
127    let this_update = ocsp_time(source_this_update)?;
128    let next_update = ocsp_time(next_update_epoch)?;
129    let produced_at = ocsp_time(now)?;
130
131    let single =
132        SingleResponse::new(cert_id, cert_status, this_update).with_next_update(next_update);
133
134    let responder_key_hash = Sha1::digest(responder_key_bytes);
135    let responder_id =
136        ResponderId::ByKey(OctetString::new(responder_key_hash.to_vec()).map_err(SignError::Der)?);
137
138    let nonce = Nonce::new(nonce_bytes.to_vec()).map_err(SignError::Der)?;
139
140    let builder = OcspResponseBuilder::new(responder_id)
141        .with_single_response(single)
142        .with_extension(nonce)
143        .map_err(|e| SignError::OcspBuilder(e.to_string()))?;
144
145    let certs = responder_cert_der
146        .map(|c| {
147            let cert = x509_cert::Certificate::from_der(c).map_err(SignError::Der)?;
148            Ok::<_, SignError>(vec![cert])
149        })
150        .transpose()?;
151    let ocsp_response = builder
152        .sign(signer, certs, produced_at)
153        .map_err(SignError::from)?;
154
155    ocsp_response.to_der().map_err(SignError::Der)
156}
157
158/// DER-encoded ECDSA signature produced by either live signer backend.
159///
160/// Both backends emit an ECDSA-Sig-Value DER SEQUENCE; this wrapper gives them
161/// one concrete `Sig` type so `sign_live_response` can be called with either.
162#[derive(Clone)]
163pub struct LiveEcdsaSignature {
164    der_bytes: Vec<u8>,
165}
166
167impl From<LiveEcdsaSignature> for Vec<u8> {
168    fn from(sig: LiveEcdsaSignature) -> Vec<u8> {
169        sig.der_bytes
170    }
171}
172
173impl signature::SignatureEncoding for LiveEcdsaSignature {
174    type Repr = Vec<u8>;
175}
176
177impl TryFrom<&[u8]> for LiveEcdsaSignature {
178    type Error = signature::Error;
179    fn try_from(bytes: &[u8]) -> std::result::Result<Self, Self::Error> {
180        Ok(LiveEcdsaSignature {
181            der_bytes: bytes.to_vec(),
182        })
183    }
184}
185
186impl AsRef<[u8]> for LiveEcdsaSignature {
187    fn as_ref(&self) -> &[u8] {
188        &self.der_bytes
189    }
190}
191
192impl SignatureBitStringEncoding for LiveEcdsaSignature {
193    fn to_bitstring(&self) -> der::Result<der::asn1::BitString> {
194        der::asn1::BitString::from_bytes(&self.der_bytes)
195    }
196}
197
198/// On-demand signer backing: a software P-256 key or a PKCS#11 HSM key.
199///
200/// The enum implements the exact trait set `sign_live_response` requires, so
201/// `nonce_policy = "live"` works with `[ca.signing_key] type = "pkcs11"` —
202/// the same HSM keys the pre-signed batch path uses.
203pub enum LiveSignerKey {
204    Software(p256::ecdsa::SigningKey),
205    #[cfg(feature = "pkcs11")]
206    Pkcs11(crate::pkcs11::Pkcs11SignerBridge),
207}
208
209impl LiveSignerKey {
210    /// The verifying key, when the backing key is software.
211    ///
212    /// `None` for HSM-backed keys — the private key never leaves the module,
213    /// so callers verify key identity by signing (see `load_live_material`).
214    pub fn verifying_key(&self) -> Option<p256::ecdsa::VerifyingKey> {
215        match self {
216            Self::Software(key) => Some(*key.verifying_key()),
217            #[cfg(feature = "pkcs11")]
218            Self::Pkcs11(_) => None,
219        }
220    }
221}
222
223impl signature::Signer<LiveEcdsaSignature> for LiveSignerKey {
224    fn try_sign(&self, msg: &[u8]) -> std::result::Result<LiveEcdsaSignature, signature::Error> {
225        match self {
226            Self::Software(key) => {
227                // ecdsa 0.17 signs via signature v3; bridge to the v2 world.
228                use p256::ecdsa::signature::Signer as SignerV3;
229                let sig: p256::ecdsa::Signature =
230                    SignerV3::try_sign(key, msg).map_err(|_| signature::Error::new())?;
231                let der = sig.to_der();
232                Ok(LiveEcdsaSignature {
233                    der_bytes: der.as_bytes().to_vec(),
234                })
235            }
236            #[cfg(feature = "pkcs11")]
237            Self::Pkcs11(bridge) => {
238                let sig: crate::pkcs11::Pkcs11EcdsaSignature = bridge.try_sign(msg)?;
239                Ok(LiveEcdsaSignature {
240                    der_bytes: sig.into(),
241                })
242            }
243        }
244    }
245}
246
247impl DynSignatureAlgorithmIdentifier for LiveSignerKey {
248    fn signature_algorithm_identifier(&self) -> spki::Result<spki::AlgorithmIdentifierOwned> {
249        match self {
250            // Delegate so each backend keeps its exact current encoding.
251            Self::Software(_) => Ok(spki::AlgorithmIdentifierOwned {
252                oid: const_oid::ObjectIdentifier::new_unwrap(crate::ECDSA_WITH_SHA256_OID),
253                parameters: None,
254            }),
255            #[cfg(feature = "pkcs11")]
256            Self::Pkcs11(bridge) => {
257                DynSignatureAlgorithmIdentifier::signature_algorithm_identifier(bridge)
258            }
259        }
260    }
261}
262
263/// Validated signing material, shared by startup and rotation.
264pub struct LiveSigningMaterial {
265    pub key: LiveSignerKey,
266    pub responder_key_bytes: Vec<u8>,
267    pub responder_cert_der: Option<Vec<u8>>,
268}
269
270pub fn load_live_material(
271    ca: &hoike_core::config::CaConfig,
272) -> std::result::Result<LiveSigningMaterial, String> {
273    use hoike_core::config::SigningKeyConfig;
274    let key = match &ca.signing_key {
275        Some(SigningKeyConfig::File { path }) => {
276            LiveSignerKey::Software(crate::load_ecdsa_p256_key(path).map_err(|e| e.to_string())?)
277        }
278        Some(SigningKeyConfig::Demo) => LiveSignerKey::Software(crate::demo_ecdsa_p256_key()),
279        #[cfg(feature = "pkcs11")]
280        Some(SigningKeyConfig::Pkcs11 { .. }) => {
281            let pkcs11_config = crate::orchestrate::resolve_pkcs11_config(ca)?;
282            let signer = crate::Pkcs11Signer::new(&pkcs11_config).map_err(|e| e.to_string())?;
283            LiveSignerKey::Pkcs11(crate::Pkcs11SignerBridge::new(signer))
284        }
285        _ => {
286            return Err(
287                "live signing requires an ECDSA file, PKCS#11 key (pkcs11 feature), \
288                 or explicit demo key"
289                    .into(),
290            );
291        }
292    };
293    let cert_der = crate::orchestrate::load_responder_cert(ca)?;
294    let responder_key_bytes = if let Some(bytes) = &cert_der {
295        let cert = CertificateForLive::from_der(bytes).map_err(|e| e.to_string())?;
296        let now = std::time::SystemTime::now()
297            .duration_since(std::time::UNIX_EPOCH)
298            .map_err(|e| e.to_string())?
299            .as_secs();
300        if now
301            < cert
302                .tbs_certificate
303                .validity
304                .not_before
305                .to_unix_duration()
306                .as_secs()
307            || now
308                >= cert
309                    .tbs_certificate
310                    .validity
311                    .not_after
312                    .to_unix_duration()
313                    .as_secs()
314        {
315            return Err("live responder certificate is outside its validity period".into());
316        }
317        let bytes = cert
318            .tbs_certificate
319            .subject_public_key_info
320            .subject_public_key
321            .as_bytes()
322            .ok_or_else(|| "responder public key has unused bits".to_string())?;
323        let certificate_key =
324            p256::ecdsa::VerifyingKey::from_sec1_bytes(bytes).map_err(|e| e.to_string())?;
325        match &key {
326            LiveSignerKey::Software(software_key) => {
327                if certificate_key != *software_key.verifying_key() {
328                    return Err("live signing key does not match responder certificate".into());
329                }
330            }
331            // An HSM key has no extractable verifying key: prove the match by
332            // signing a preflight message and verifying it with the cert's
333            // public key.
334            #[cfg(feature = "pkcs11")]
335            LiveSignerKey::Pkcs11(_) => {
336                verify_hsm_key_matches(&key, &certificate_key)?;
337            }
338        }
339        bytes.to_vec()
340    } else {
341        let bytes = crate::orchestrate::decode_issuer_key(ca)?;
342        if !matches!(ca.signing_key, Some(SigningKeyConfig::Demo)) {
343            let issuer_key = p256::ecdsa::VerifyingKey::from_sec1_bytes(&bytes)
344                .map_err(|e| format!("CA-direct issuer key: {e}"))?;
345            match &key {
346                LiveSignerKey::Software(software_key) => {
347                    if issuer_key != *software_key.verifying_key() {
348                        return Err("CA-direct signing key does not match issuer key".into());
349                    }
350                }
351                #[cfg(feature = "pkcs11")]
352                LiveSignerKey::Pkcs11(_) => {
353                    verify_hsm_key_matches(&key, &issuer_key).map_err(|_| {
354                        "CA-direct signing key does not match issuer key".to_string()
355                    })?;
356                }
357            }
358        }
359        bytes
360    };
361    Ok(LiveSigningMaterial {
362        key,
363        responder_key_bytes,
364        responder_cert_der: cert_der,
365    })
366}
367
368/// Prove an HSM-backed live signing key matches a known public key.
369///
370/// The private key never leaves the HSM, so the software-key equality check is
371/// impossible. Instead, sign a fixed preflight message through the same
372/// `Signer` path live signing uses and verify the signature with the public
373/// key — a mismatch fails exactly like the software path would.
374#[cfg(feature = "pkcs11")]
375fn verify_hsm_key_matches(
376    key: &LiveSignerKey,
377    public_key: &p256::ecdsa::VerifyingKey,
378) -> std::result::Result<(), String> {
379    // LiveSignerKey signs via signature v2; VerifyingKey verifies via v3.
380    use p256::ecdsa::signature::Verifier as _;
381    use signature::Signer as _;
382
383    const PREFLIGHT_MESSAGE: &[u8] = b"hoike live-signing material preflight";
384
385    let signature: LiveEcdsaSignature = key
386        .try_sign(PREFLIGHT_MESSAGE)
387        .map_err(|e| format!("HSM preflight signing failed: {e}"))?;
388    let der_signature = p256::ecdsa::DerSignature::from_bytes(signature.as_ref())
389        .map_err(|e| format!("HSM preflight signature parse: {e}"))?;
390    public_key
391        .verify(PREFLIGHT_MESSAGE, &der_signature)
392        .map_err(|_| "live signing key does not match responder certificate".to_string())
393}
394
395/// Status and authenticated freshness from exactly one matching SingleResponse.
396pub struct LiveResponseSource {
397    pub status: LiveCertStatus,
398    pub this_update: u64,
399    pub next_update: u64,
400}
401
402pub fn extract_status_for_cert(
403    response_der: &[u8],
404    cert_id_der: &[u8],
405) -> Result<LiveResponseSource> {
406    let requested = CertId::from_der(cert_id_der).map_err(SignError::Der)?;
407    let basic = parse_basic(response_der)?;
408    let mut matches = basic
409        .tbs_response_data
410        .responses
411        .iter()
412        .filter(|r| r.cert_id == requested);
413    let single = matches
414        .next()
415        .ok_or_else(|| SignError::OcspBuilder("requested CertID absent from response".into()))?;
416    if matches.next().is_some() {
417        return Err(SignError::OcspBuilder(
418            "ambiguous duplicate CertID in response".into(),
419        ));
420    }
421    let next = single
422        .next_update
423        .as_ref()
424        .ok_or_else(|| SignError::OcspBuilder("live source requires nextUpdate".into()))?;
425    Ok(LiveResponseSource {
426        status: status_from_single(single),
427        this_update: generalized_time_to_epoch(&single.this_update),
428        next_update: generalized_time_to_epoch(next),
429    })
430}
431
432fn parse_basic(response_der: &[u8]) -> Result<BasicOcspResponse> {
433    let response = OcspResponse::from_der(response_der).map_err(SignError::Der)?;
434    if response.response_status != x509_ocsp::OcspResponseStatus::Successful {
435        return Err(SignError::OcspBuilder(
436            "source OCSP response was not successful".into(),
437        ));
438    }
439    let bytes = response
440        .response_bytes
441        .ok_or_else(|| SignError::OcspBuilder("missing responseBytes".into()))?;
442    if bytes.response_type.to_string() != "1.3.6.1.5.5.7.48.1.1" {
443        return Err(SignError::OcspBuilder("unsupported response type".into()));
444    }
445    BasicOcspResponse::from_der(bytes.response.as_bytes()).map_err(SignError::Der)
446}
447
448fn status_from_single(single: &SingleResponse) -> LiveCertStatus {
449    match &single.cert_status {
450        CertStatus::Good(_) => LiveCertStatus::Good,
451        CertStatus::Unknown(_) => LiveCertStatus::Unknown,
452        CertStatus::Revoked(info) => LiveCertStatus::Revoked {
453            revocation_time: generalized_time_to_epoch(&info.revocation_time),
454            reason: info.revocation_reason,
455        },
456    }
457}
458
459/// Diagnostic compatibility API. Batched sources require explicit CertID selection.
460pub fn extract_status_from_response(response_der: &[u8]) -> Result<LiveCertStatus> {
461    let basic = parse_basic(response_der)?;
462    if basic.tbs_response_data.responses.len() != 1 {
463        return Err(SignError::OcspBuilder(
464            "CertID required for a batched response".into(),
465        ));
466    }
467    Ok(status_from_single(&basic.tbs_response_data.responses[0]))
468}
469
470fn generalized_time_to_epoch(gt: &OcspGeneralizedTime) -> u64 {
471    gt.0.to_unix_duration().as_secs()
472}
473
474#[cfg(test)]
475mod tests {
476    use super::*;
477    use der::Encode;
478    use p256::ecdsa::SigningKey;
479
480    fn test_key() -> SigningKey {
481        SigningKey::from_bytes((&[1u8; 32]).into()).unwrap()
482    }
483
484    #[test]
485    fn live_signer_key_software_signs_verifiable_der() {
486        use p256::ecdsa::signature::Verifier as _;
487        use signature::Signer as _;
488
489        let software_key = test_key();
490        let live_key = LiveSignerKey::Software(software_key.clone());
491        let message = b"hoike live signer key test";
492
493        let signature: LiveEcdsaSignature = live_key.try_sign(message).unwrap();
494        let der_signature = p256::ecdsa::DerSignature::from_bytes(signature.as_ref()).unwrap();
495        software_key
496            .verifying_key()
497            .verify(message, &der_signature)
498            .expect("LiveSignerKey software path must produce a verifiable DER signature");
499    }
500
501    #[test]
502    fn sign_live_response_with_live_signer_key() {
503        let sha256_oid = const_oid::ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.2.1");
504        let cert_id = CertId {
505            hash_algorithm: spki::AlgorithmIdentifierOwned {
506                oid: sha256_oid,
507                parameters: Some(der::asn1::Null.into()),
508            },
509            issuer_name_hash: OctetString::new(vec![0xAA; 32]).unwrap(),
510            issuer_key_hash: OctetString::new(vec![0xBB; 32]).unwrap(),
511            serial_number: x509_cert::serial_number::SerialNumber::new(&[7u8]).unwrap(),
512        };
513        let cert_id_der = cert_id.to_der().unwrap();
514        let nonce = vec![0x42; 16];
515
516        let mut live_key = LiveSignerKey::Software(test_key());
517        let resp_der = sign_live_response::<LiveSignerKey, LiveEcdsaSignature>(
518            &cert_id_der,
519            LiveCertStatus::Good,
520            &nonce,
521            &[0xBB; 32],
522            &mut live_key,
523            1700000000,
524            86400,
525            None,
526        )
527        .unwrap();
528
529        let resp = OcspResponse::from_der(&resp_der).unwrap();
530        assert_eq!(
531            resp.response_status,
532            x509_ocsp::OcspResponseStatus::Successful
533        );
534        let basic =
535            BasicOcspResponse::from_der(resp.response_bytes.unwrap().response.as_bytes()).unwrap();
536        let resp_nonce = basic.nonce().expect("response should contain nonce");
537        assert_eq!(resp_nonce.0.as_bytes(), &nonce);
538    }
539
540    #[test]
541    fn sign_live_good_with_nonce() {
542        let sha256_oid = const_oid::ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.2.1");
543        let cert_id = CertId {
544            hash_algorithm: spki::AlgorithmIdentifierOwned {
545                oid: sha256_oid,
546                parameters: Some(der::asn1::Null.into()),
547            },
548            issuer_name_hash: OctetString::new(vec![0xAA; 32]).unwrap(),
549            issuer_key_hash: OctetString::new(vec![0xBB; 32]).unwrap(),
550            serial_number: x509_cert::serial_number::SerialNumber::new(&[42u8]).unwrap(),
551        };
552        let cert_id_der = cert_id.to_der().unwrap();
553
554        let nonce = vec![
555            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
556            0x0F, 0x10,
557        ];
558
559        let mut key = crate::EcdsaP256Signer::new(test_key());
560        let resp_der = sign_live_response::<_, crate::EcdsaSignatureBytes>(
561            &cert_id_der,
562            LiveCertStatus::Good,
563            &nonce,
564            &[0xBB; 32],
565            &mut key,
566            1700000000,
567            86400,
568            None,
569        )
570        .unwrap();
571
572        let resp = OcspResponse::from_der(&resp_der).unwrap();
573        assert_eq!(
574            resp.response_status,
575            x509_ocsp::OcspResponseStatus::Successful
576        );
577
578        let basic =
579            BasicOcspResponse::from_der(resp.response_bytes.unwrap().response.as_bytes()).unwrap();
580
581        // Verify nonce is in the response
582        let resp_nonce = basic.nonce().expect("response should contain nonce");
583        assert_eq!(resp_nonce.0.as_bytes(), &nonce);
584    }
585
586    #[test]
587    fn sign_live_revoked_with_nonce() {
588        let sha256_oid = const_oid::ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.2.1");
589        let cert_id = CertId {
590            hash_algorithm: spki::AlgorithmIdentifierOwned {
591                oid: sha256_oid,
592                parameters: Some(der::asn1::Null.into()),
593            },
594            issuer_name_hash: OctetString::new(vec![0xAA; 32]).unwrap(),
595            issuer_key_hash: OctetString::new(vec![0xBB; 32]).unwrap(),
596            serial_number: x509_cert::serial_number::SerialNumber::new(&[100u8]).unwrap(),
597        };
598        let cert_id_der = cert_id.to_der().unwrap();
599
600        let nonce = vec![0xAA; 16];
601
602        let mut key = crate::EcdsaP256Signer::new(test_key());
603        let resp_der = sign_live_response::<_, crate::EcdsaSignatureBytes>(
604            &cert_id_der,
605            LiveCertStatus::Revoked {
606                revocation_time: 1699900000,
607                reason: Some(x509_cert::ext::pkix::CrlReason::KeyCompromise),
608            },
609            &nonce,
610            &[0xBB; 32],
611            &mut key,
612            1700000000,
613            86400,
614            None,
615        )
616        .unwrap();
617
618        let resp = OcspResponse::from_der(&resp_der).unwrap();
619        assert_eq!(
620            resp.response_status,
621            x509_ocsp::OcspResponseStatus::Successful
622        );
623    }
624
625    #[test]
626    fn extract_status_round_trip() {
627        let sha256_oid = const_oid::ObjectIdentifier::new_unwrap("2.16.840.1.101.3.4.2.1");
628        let cert_id = CertId {
629            hash_algorithm: spki::AlgorithmIdentifierOwned {
630                oid: sha256_oid,
631                parameters: Some(der::asn1::Null.into()),
632            },
633            issuer_name_hash: OctetString::new(vec![0xAA; 32]).unwrap(),
634            issuer_key_hash: OctetString::new(vec![0xBB; 32]).unwrap(),
635            serial_number: x509_cert::serial_number::SerialNumber::new(&[42u8]).unwrap(),
636        };
637        let cert_id_der = cert_id.to_der().unwrap();
638
639        let mut key = crate::EcdsaP256Signer::new(test_key());
640        let resp_der = sign_live_response::<_, crate::EcdsaSignatureBytes>(
641            &cert_id_der,
642            LiveCertStatus::Good,
643            &[0xFF; 16],
644            &[0xBB; 32],
645            &mut key,
646            1700000000,
647            86400,
648            None,
649        )
650        .unwrap();
651
652        let extracted = extract_status_from_response(&resp_der).unwrap();
653        assert!(matches!(extracted, LiveCertStatus::Good));
654    }
655}