From b2b6ec62f20f17b5d4eebc8170f00a988a2881c2 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 17 Nov 2026 08:33:33 -0500 Subject: [PATCH] Delegate RFC 3161 request parsing to shared PKCS7 --- crates/sign/src/timestamp.rs | 106 ++++++++++++++++++++++++++++------- 1 file changed, 85 insertions(+), 21 deletions(-) diff --git a/crates/sign/src/timestamp.rs b/crates/sign/src/timestamp.rs index 01c17221ac..d9530b68b4 100644 --- a/crates/sign/src/timestamp.rs +++ b/crates/sign/src/timestamp.rs @@ -14,6 +14,7 @@ use crate::{SignError, Time}; const TST_INFO: &str = "1.2.840.113549.1.9.16.1.4"; const MAX_RESPONSE: usize = 4 * 1024 * 1024; const MAX_TOKEN: usize = 2 * 1024 * 1024; +#[cfg(test)] const MAX_REQUEST: usize = 1024 * 1024; /// RFC 3161 request data. `nonce` is optional but recommended for online requests. @@ -106,27 +107,24 @@ fn bad(message: impl Into) -> SignError { /// Decode a `TimeStampReq` as [`TimestampQuery::encode`] wrote it. pub fn parse_request(bytes: &[u8]) -> Result { - if bytes.is_empty() || bytes.len() > MAX_REQUEST { - return Err(bad("request is empty or exceeds the 1 MiB limit")); - } - let fields = Tlv::parse_all(bytes)?.expect(tag::SEQUENCE, "TimeStampReq")?.children()?; - let mut it = fields.into_iter(); - let _version = it.next().ok_or_else(|| bad("missing version"))?.u64()?; - let imprint = it.next().ok_or_else(|| bad("missing message imprint"))?.children()?; - let alg_oid = - imprint.first().ok_or_else(|| bad("missing imprint algorithm"))?.children()?.first().ok_or_else(|| bad("missing algorithm OID"))?.oid()?; - let digest = DigestAlg::from_oid(&alg_oid).ok_or_else(|| bad("unsupported imprint digest algorithm"))?; - let hash = imprint.get(1).ok_or_else(|| bad("missing imprint digest"))?.expect(tag::OCTET_STRING, "imprint digest")?.value.to_vec(); - let mut q = TimestampQuery::new(digest, hash)?; - for f in it { - match f.tag { - tag::OID => q.policy = Some(f.oid()?), - tag::INTEGER => q.nonce = Some(f.u64()?), - tag::BOOLEAN => q.certificate_request = f.value.first() == Some(&0xFF), - _ => {} - } - } - Ok(q) + let query = craft_pkcs7::timestamp::parse_request(bytes).map_err(der::app_error)?; + // Exhaustive mapping preserves the app's digest identity without reparsing or copying. + use craft_pkcs7::DigestAlg as Shared; + let digest = match query.digest { + Shared::Sha1 => DigestAlg::Sha1, + Shared::Sha224 => DigestAlg::Sha224, + Shared::Sha256 => DigestAlg::Sha256, + Shared::Sha384 => DigestAlg::Sha384, + Shared::Sha512 => DigestAlg::Sha512, + Shared::Sha512_224 => DigestAlg::Sha512_224, + Shared::Sha512_256 => DigestAlg::Sha512_256, + Shared::Sha3_224 => DigestAlg::Sha3_224, + Shared::Sha3_256 => DigestAlg::Sha3_256, + Shared::Sha3_384 => DigestAlg::Sha3_384, + Shared::Sha3_512 => DigestAlg::Sha3_512, + Shared::Ripemd160 => DigestAlg::Ripemd160, + }; + Ok(TimestampQuery { digest, imprint: query.imprint, policy: query.policy, nonce: query.nonce, certificate_request: query.certificate_request }) } /// Parse and validate a token (a bare CMS `ContentInfo`): TSTInfo content, bounded size, the @@ -251,3 +249,69 @@ mod tests { assert!(parse_request(&vec![0; MAX_REQUEST + 1]).is_err()); } } + +#[cfg(test)] +mod request_parity { + use super::*; + // Original request reader: Justin John; algorithm support: Thorsten Hirsch. + // Retained as an independent higher-level parser oracle (MIT OR Apache-2.0). + fn legacy_request(bytes: &[u8]) -> Result { + if bytes.is_empty() || bytes.len() > MAX_REQUEST { + return Err(bad("request is empty or exceeds the 1 MiB limit")); + } + let fields = Tlv::parse_all(bytes)?.expect(tag::SEQUENCE, "TimeStampReq")?.children()?; + let mut it = fields.into_iter(); + let _version = it.next().ok_or_else(|| bad("missing version"))?.u64()?; + let imprint = it.next().ok_or_else(|| bad("missing message imprint"))?.children()?; + let alg_oid = imprint + .first() + .ok_or_else(|| bad("missing imprint algorithm"))? + .children()? + .first() + .ok_or_else(|| bad("missing algorithm OID"))? + .oid()?; + let digest = DigestAlg::from_oid(&alg_oid).ok_or_else(|| bad("unsupported imprint digest algorithm"))?; + let hash = imprint.get(1).ok_or_else(|| bad("missing imprint digest"))?.expect(tag::OCTET_STRING, "imprint digest")?.value.to_vec(); + let mut q = TimestampQuery::new(digest, hash)?; + for f in it { + match f.tag { + tag::OID => q.policy = Some(f.oid()?), + tag::INTEGER => q.nonce = Some(f.u64()?), + tag::BOOLEAN => q.certificate_request = f.value.first() == Some(&0xFF), + _ => {} + } + } + Ok(q) + } + + fn compare(bytes: &[u8]) { + match (legacy_request(bytes), parse_request(bytes)) { + (Ok(a), Ok(b)) => assert_eq!(a, b), + (Err(a), Err(b)) => assert_eq!(format!("{a:?}"), format!("{b:?}")), + other => panic!("request parity mismatch: {other:?}"), + } + } + #[test] + fn shared_request_preserves_algorithms_fields_errors_and_limits() { + for digest in DigestAlg::ALL { + let mut query = TimestampQuery::new(digest, digest.digest(&[b"fixture"])).unwrap(); + query.policy = Some("1.2.3.4".into()); + query.nonce = Some(u64::MAX); + for cert in [false, true] { + query.certificate_request = cert; + let bytes = query.encode().unwrap(); + compare(&bytes); + for len in 0..bytes.len() { + compare(&bytes[..len]); + } + for pos in 0..bytes.len() { + let mut changed = bytes.clone(); + changed[pos] ^= 255; + compare(&changed); + } + } + } + compare(&vec![0; MAX_REQUEST]); + compare(&vec![0; MAX_REQUEST + 1]); + } +}