1use 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#[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#[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#[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#[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
198pub enum LiveSignerKey {
204 Software(p256::ecdsa::SigningKey),
205 #[cfg(feature = "pkcs11")]
206 Pkcs11(crate::pkcs11::Pkcs11SignerBridge),
207}
208
209impl LiveSignerKey {
210 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 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 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
263pub 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 #[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#[cfg(feature = "pkcs11")]
375fn verify_hsm_key_matches(
376 key: &LiveSignerKey,
377 public_key: &p256::ecdsa::VerifyingKey,
378) -> std::result::Result<(), String> {
379 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
395pub 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
459pub 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 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}