Skip to main content

hoike_sign/
verify.rs

1//! OCSP response signature verification.
2//!
3//! Verifies the signature on a DER-encoded `OcspResponse` by parsing the
4//! `BasicOcspResponse`, extracting the signer's public key from the embedded
5//! certificate chain, and dispatching to the correct verifier based on the
6//! `signatureAlgorithm` OID.
7
8use der::{Decode, Encode};
9use x509_ocsp::{BasicOcspResponse, OcspResponse, OcspResponseStatus};
10
11use crate::error::{Result, SignError};
12use crate::ml_dsa_bridge::{ML_DSA_44_OID, ML_DSA_65_OID, ML_DSA_87_OID};
13
14const ECDSA_WITH_SHA256_OID: &str = "1.2.840.10045.4.3.2";
15
16/// Verify the signature on a DER-encoded `OcspResponse`.
17///
18/// Extracts the `BasicOcspResponse`, re-encodes the `tbsResponseData` to DER,
19/// and verifies the signature using the public key from the first embedded
20/// certificate. Returns `Ok(())` if the signature is valid.
21pub fn verify_ocsp_response_signature(response_der: &[u8]) -> Result<()> {
22    let ocsp_resp = OcspResponse::from_der(response_der)
23        .map_err(|e| SignError::Verify(format!("parse OcspResponse: {e}")))?;
24
25    if ocsp_resp.response_status != OcspResponseStatus::Successful {
26        return Ok(());
27    }
28
29    let response_bytes = ocsp_resp
30        .response_bytes
31        .ok_or_else(|| SignError::Verify("successful response has no responseBytes".into()))?;
32
33    let basic = BasicOcspResponse::from_der(response_bytes.response.as_bytes())
34        .map_err(|e| SignError::Verify(format!("parse BasicOcspResponse: {e}")))?;
35
36    let tbs_der = basic
37        .tbs_response_data
38        .to_der()
39        .map_err(|e| SignError::Verify(format!("re-encode tbsResponseData: {e}")))?;
40
41    let sig_bytes = basic.signature.raw_bytes();
42
43    let sig_alg_oid = basic.signature_algorithm.oid.to_string();
44
45    let pub_key_bytes = extract_public_key(&basic)?;
46
47    match sig_alg_oid.as_str() {
48        ECDSA_WITH_SHA256_OID => verify_ecdsa_p256(&tbs_der, sig_bytes, &pub_key_bytes),
49        ML_DSA_44_OID => verify_ml_dsa::<ml_dsa::MlDsa44>(&tbs_der, sig_bytes, &pub_key_bytes),
50        ML_DSA_65_OID => verify_ml_dsa::<ml_dsa::MlDsa65>(&tbs_der, sig_bytes, &pub_key_bytes),
51        ML_DSA_87_OID => verify_ml_dsa::<ml_dsa::MlDsa87>(&tbs_der, sig_bytes, &pub_key_bytes),
52        other => Err(SignError::Verify(format!(
53            "unsupported signature algorithm: {other}"
54        ))),
55    }
56}
57
58fn extract_public_key(basic: &BasicOcspResponse) -> Result<Vec<u8>> {
59    let cert = basic
60        .certs
61        .as_ref()
62        .and_then(|c| c.first())
63        .ok_or(SignError::NoCert)?;
64
65    let raw = cert
66        .tbs_certificate
67        .subject_public_key_info
68        .subject_public_key
69        .raw_bytes();
70
71    Ok(raw.to_vec())
72}
73
74fn verify_ecdsa_p256(tbs_der: &[u8], sig_bytes: &[u8], pub_key_bytes: &[u8]) -> Result<()> {
75    use p256::ecdsa::{DerSignature, VerifyingKey};
76    // ecdsa 0.17 verifies via signature v3 (p256's re-export).
77    use p256::ecdsa::signature::Verifier;
78
79    let vk = VerifyingKey::from_sec1_bytes(pub_key_bytes)
80        .map_err(|e| SignError::Verify(format!("invalid P-256 public key: {e}")))?;
81
82    let sig = DerSignature::try_from(sig_bytes)
83        .map_err(|e| SignError::Verify(format!("invalid ECDSA DER signature: {e}")))?;
84
85    vk.verify(tbs_der, &sig)
86        .map_err(|_| SignError::Verify("ECDSA-P256 signature verification failed".into()))
87}
88
89fn verify_ml_dsa<P>(tbs_der: &[u8], sig_bytes: &[u8], pub_key_bytes: &[u8]) -> Result<()>
90where
91    P: ml_dsa::MlDsaParams,
92{
93    use ml_dsa::Verifier;
94
95    let encoded = ml_dsa::EncodedVerifyingKey::<P>::try_from(pub_key_bytes).map_err(|_| {
96        SignError::Verify(format!(
97            "invalid ML-DSA public key (expected {} bytes)",
98            std::mem::size_of::<ml_dsa::EncodedVerifyingKey<P>>()
99        ))
100    })?;
101
102    let vk = ml_dsa::VerifyingKey::<P>::decode(&encoded);
103
104    let sig = ml_dsa::Signature::<P>::try_from(sig_bytes)
105        .map_err(|_| SignError::Verify("invalid ML-DSA signature".into()))?;
106
107    vk.verify(tbs_der, &sig)
108        .map_err(|_| SignError::Verify("ML-DSA signature verification failed".into()))
109}
110
111#[cfg(test)]
112mod tests {
113    use super::*;
114
115    #[test]
116    fn verify_ecdsa_bundle_entries() {
117        use crate::{
118            demo_ecdsa_p256_key,
119            generate::GenerationConfig,
120            produce_bundle,
121            source::{CaIdentity, CertificateStatus, StatusSnapshot},
122        };
123        use std::collections::BTreeMap;
124
125        let signer = demo_ecdsa_p256_key();
126        let seal_key = crate::SealKey::EcdsaP256(demo_ecdsa_p256_key());
127        let seal_cert = crate::generate_seal_cert_for_key(&seal_key).unwrap();
128        let responder_cert = crate::generate_seal_cert(&signer).unwrap();
129
130        let ca = CaIdentity {
131            label: "test-ca".into(),
132            issuer_name_der: b"CN=Test CA".to_vec(),
133            issuer_key_bytes: vec![0x42; 32],
134        };
135
136        let mut entries = BTreeMap::new();
137        entries.insert(vec![0x01], CertificateStatus::Good);
138        entries.insert(vec![0x02], CertificateStatus::Good);
139        let snapshot = StatusSnapshot {
140            entries,
141            this_update: crate::source::unix_now().unwrap(),
142            next_update: Some(crate::source::unix_now().unwrap() + 86400),
143            ..Default::default()
144        };
145
146        let config = GenerationConfig {
147            producer_id: "test".into(),
148            epoch: 1,
149            ..Default::default()
150        };
151
152        let bundle_bytes = produce_bundle::<_, crate::EcdsaSignatureBytes>(
153            &ca,
154            &snapshot,
155            &config,
156            &mut crate::EcdsaP256Signer::new(signer),
157            |m| crate::create_cms_seal(m, &seal_key, &seal_cert),
158            Some(&responder_cert),
159        )
160        .unwrap();
161
162        let bundle = ahu::Bundle::from_bytes(&bundle_bytes).unwrap();
163        let mut count = 0;
164        for record in &bundle.index {
165            if let Some(entry_bytes) = bundle.entry_bytes(record) {
166                verify_ocsp_response_signature(entry_bytes).unwrap();
167                count += 1;
168            }
169        }
170        assert!(count >= 2);
171    }
172
173    #[test]
174    fn verify_ml_dsa_signature_direct() {
175        use ml_dsa::{Keypair, MlDsa87, Signer as Signer3, SigningKey};
176
177        let sk = SigningKey::<MlDsa87>::from_seed((&[42u8; 32]).into());
178        let vk = sk.verifying_key();
179        let msg = b"test message for ML-DSA verification";
180
181        let sig = sk.sign(msg);
182        let sig_bytes = sig.encode();
183        let vk_encoded = vk.encode();
184
185        verify_ml_dsa::<MlDsa87>(msg, sig_bytes.as_ref(), vk_encoded.as_ref()).unwrap();
186    }
187
188    #[test]
189    fn verify_ml_dsa_44_signature_direct() {
190        use ml_dsa::{Keypair, MlDsa44, Signer as Signer3, SigningKey};
191
192        let sk = SigningKey::<MlDsa44>::from_seed((&[1u8; 32]).into());
193        let vk = sk.verifying_key();
194        let msg = b"ML-DSA-44 verification test";
195
196        let sig = sk.sign(msg);
197        let sig_bytes = sig.encode();
198        let vk_encoded = vk.encode();
199
200        verify_ml_dsa::<MlDsa44>(msg, sig_bytes.as_ref(), vk_encoded.as_ref()).unwrap();
201    }
202
203    #[test]
204    fn verify_wrong_message_fails() {
205        use ml_dsa::{Keypair, MlDsa65, Signer as Signer3, SigningKey};
206
207        let sk = SigningKey::<MlDsa65>::from_seed((&[5u8; 32]).into());
208        let vk = sk.verifying_key();
209
210        let sig = sk.sign(b"correct message");
211        let sig_bytes = sig.encode();
212        let vk_encoded = vk.encode();
213
214        let result =
215            verify_ml_dsa::<MlDsa65>(b"wrong message", sig_bytes.as_ref(), vk_encoded.as_ref());
216        assert!(result.is_err());
217    }
218
219    #[test]
220    fn verify_no_embedded_cert_errors() {
221        use crate::{
222            demo_ecdsa_p256_key,
223            generate::GenerationConfig,
224            produce_bundle,
225            source::{CaIdentity, CertificateStatus, StatusSnapshot},
226        };
227        use std::collections::BTreeMap;
228
229        let signer = demo_ecdsa_p256_key();
230        let seal_key = crate::SealKey::EcdsaP256(demo_ecdsa_p256_key());
231        let seal_cert = crate::generate_seal_cert_for_key(&seal_key).unwrap();
232
233        let ca = CaIdentity {
234            label: "test".into(),
235            issuer_name_der: b"CN=Test".to_vec(),
236            issuer_key_bytes: vec![0x42; 32],
237        };
238
239        let mut entries = BTreeMap::new();
240        entries.insert(vec![0x01], CertificateStatus::Good);
241        let snapshot = StatusSnapshot {
242            entries,
243            this_update: crate::source::unix_now().unwrap(),
244            next_update: Some(crate::source::unix_now().unwrap() + 86400),
245            ..Default::default()
246        };
247        let config = GenerationConfig {
248            producer_id: "test".into(),
249            epoch: 1,
250            ..Default::default()
251        };
252
253        let bundle_bytes = produce_bundle::<_, crate::EcdsaSignatureBytes>(
254            &ca,
255            &snapshot,
256            &config,
257            &mut crate::EcdsaP256Signer::new(signer),
258            |m| crate::create_cms_seal(m, &seal_key, &seal_cert),
259            None,
260        )
261        .unwrap();
262
263        let bundle = ahu::Bundle::from_bytes(&bundle_bytes).unwrap();
264        for record in &bundle.index {
265            if let Some(entry_bytes) = bundle.entry_bytes(record) {
266                let result = verify_ocsp_response_signature(entry_bytes);
267                assert!(result.is_err());
268                assert!(matches!(
269                    result.unwrap_err(),
270                    crate::error::SignError::NoCert
271                ));
272            }
273        }
274    }
275}