1use 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
16pub 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 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}