synta-certificate 0.2.6

//! Fluent builder for DER-encoded `OCSPRequest` (RFC 6960).
//!
//! [`OCSPRequestBuilder`] assembles a complete unsigned `OCSPRequest` DER blob
//! via [`OCSPRequestBuilder::build_tbs`], suitable for direct submission to an
//! OCSP responder.  When a signature is required, pass the inner `TBSRequest`
//! bytes (obtained from [`OCSPRequestBuilder::build_tbs_inner`]) to an
//! external signer, then call [`OCSPRequestBuilder::assemble`] to produce the
//! signed `OCSPRequest`.
//!
//! # Example — unsigned request (most common)
//!
//! ```rust,ignore
//! use synta_certificate::{OCSPRequestBuilder, CertIDSpec};
//!
//! let ocsp_der = OCSPRequestBuilder::new()
//!     .add_request(CertIDSpec {
//!         hash_algorithm_der: &alg_id_der,
//!         issuer_name_hash: &issuer_name_hash,
//!         issuer_key_hash: &issuer_key_hash,
//!         serial: &serial_bytes,
//!     })
//!     .build_tbs()   // returns the complete unsigned OCSPRequest DER
//!     .unwrap();
//! ```
//!
//! # Example — signed request
//!
//! ```rust,ignore
//! use synta_certificate::{OCSPRequestBuilder, CertIDSpec};
//!
//! let tbs_inner = OCSPRequestBuilder::new()
//!     .add_request(CertIDSpec { /* … */ })
//!     .build_tbs_inner()  // inner TBSRequest bytes for signing
//!     .unwrap();
//! // sign tbs_inner externally, then:
//! let ocsp_der = OCSPRequestBuilder::assemble(&tbs_inner, &sig_alg_der, &sig_bytes).unwrap();
//! ```

use synta::{BitStringRef, Decoder, Encoding, Integer, OctetStringRef};

use crate::ocsp_2024_88_types::{OCSPRequest, Request, Signature, TBSRequest};
use crate::{AlgorithmIdentifier, GeneralName};

// ── CertID input / storage ────────────────────────────────────────────────────

/// Input parameters for one `Request` entry (carrying a `CertID`) in an
/// OCSP request.
///
/// Used with [`OCSPRequestBuilder::add_request`].
pub struct CertIDSpec<'a> {
    /// Pre-encoded `AlgorithmIdentifier` DER TLV (e.g. SHA-1).
    pub hash_algorithm_der: &'a [u8],
    /// Raw hash bytes of the issuer name (OCTET STRING value, no TLV wrapper).
    pub issuer_name_hash: &'a [u8],
    /// Raw hash bytes of the issuer public key (OCTET STRING value, no TLV).
    pub issuer_key_hash: &'a [u8],
    /// Big-endian DER INTEGER value bytes of the certificate serial number.
    pub serial: &'a [u8],
}

/// All data needed to build one `Request` entry, stored as owned bytes
/// until `build_tbs` is called.
struct PendingRequest {
    /// DER-encoded `AlgorithmIdentifier` TLV for the hash algorithm.
    hash_algorithm_der: Vec<u8>,
    /// Raw hash bytes for `issuerNameHash` (OCTET STRING value, no TLV).
    issuer_name_hash: Vec<u8>,
    /// Raw hash bytes for `issuerKeyHash` (OCTET STRING value, no TLV).
    issuer_key_hash: Vec<u8>,
    /// Big-endian DER INTEGER value bytes for the serial number.
    serial: Vec<u8>,
}

// ── Internal helpers ──────────────────────────────────────────────────────────

/// Build a `TBSRequest<'_>` from owned `PendingRequest` entries and an optional
/// pre-encoded `GeneralName` DER slice.  The returned value borrows from the
/// inputs, so callers must keep them alive.
fn make_tbs_request<'a>(
    requests: &'a [PendingRequest],
    requestor_name_der: Option<&'a [u8]>,
) -> Result<TBSRequest<'a>, String> {
    let requestor_name = requestor_name_der
        .map(|der| {
            Decoder::new(der, Encoding::Der)
                .decode::<GeneralName<'_>>()
                .map_err(|e| format!("re-decode requestorName failed: {e}"))
        })
        .transpose()?;

    let mut request_list: Vec<Request<'_>> = Vec::with_capacity(requests.len());
    for r in requests {
        let hash_algorithm: AlgorithmIdentifier<'_> =
            Decoder::new(&r.hash_algorithm_der, Encoding::Der)
                .decode()
                .map_err(|e| format!("re-decode hash_algorithm_der failed: {e}"))?;
        let cert_id = crate::ocsp_2024_88_types::CertID {
            hash_algorithm,
            issuer_name_hash: OctetStringRef::new(&r.issuer_name_hash),
            issuer_key_hash: OctetStringRef::new(&r.issuer_key_hash),
            serial_number: Integer::from_unsigned_bytes(&r.serial),
        };
        request_list.push(Request {
            req_cert: cert_id,
            single_request_extensions: None,
        });
    }

    Ok(TBSRequest {
        version: None,
        requestor_name,
        request_list,
        request_extensions: None,
    })
}

/// Build and DER-encode a `TBSRequest`.
fn encode_tbs_request(
    requests: &[PendingRequest],
    requestor_name_der: Option<&[u8]>,
) -> Result<Vec<u8>, String> {
    make_tbs_request(requests, requestor_name_der)?
        .to_der()
        .map_err(|e| format!("TBSRequest encode error: {e}"))
}

// ── OCSPRequestBuilder ────────────────────────────────────────────────────────

/// Fluent builder for a DER-encoded `OCSPRequest` (RFC 6960 §4.1.1).
///
/// [`build_tbs`](Self::build_tbs) produces the complete unsigned `OCSPRequest`
/// DER blob (inner `TBSRequest` wrapped in the outer `SEQUENCE`).  For signed
/// requests, use [`build_tbs_inner`](Self::build_tbs_inner) to obtain the bare
/// `TBSRequest` bytes, sign them externally, then call
/// [`assemble`](Self::assemble).
///
/// # Example
///
/// ```rust,ignore
/// use synta_certificate::{OCSPRequestBuilder, CertIDSpec};
///
/// let ocsp_der = OCSPRequestBuilder::new()
///     .add_request(CertIDSpec {
///         hash_algorithm_der: &alg_der,
///         issuer_name_hash: &name_hash,
///         issuer_key_hash: &key_hash,
///         serial: &serial,
///     })
///     .build_tbs()
///     .unwrap();
/// let signed_ocsp_der =
///     OCSPRequestBuilder::assemble(&tbs_inner, &sig_alg_der, &sig_bytes).unwrap();
/// ```
pub struct OCSPRequestBuilder {
    /// Pre-encoded DER GeneralName TLV for `requestorName`, or `None`.
    requestor_name_der: Option<Vec<u8>>,
    /// Accumulated `Request` entries.
    requests: Vec<PendingRequest>,
    /// First error encountered; subsequent builder calls are no-ops.
    error: Option<String>,
}

impl Default for OCSPRequestBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl OCSPRequestBuilder {
    /// Create a new, empty `OCSPRequestBuilder`.
    pub fn new() -> Self {
        Self {
            requestor_name_der: None,
            requests: Vec::new(),
            error: None,
        }
    }

    // ── Fluent setters ─────────────────────────────────────────────────────────

    /// Set the optional `requestorName` from a pre-encoded DER `GeneralName` TLV.
    ///
    /// The bytes are validated by attempting to decode them as `GeneralName`.
    pub fn requestor_name(mut self, name_der: &[u8]) -> Self {
        if self.error.is_some() {
            return self;
        }
        match Decoder::new(name_der, Encoding::Der).decode::<GeneralName<'_>>() {
            Ok(_) => self.requestor_name_der = Some(name_der.to_vec()),
            Err(e) => self.error = Some(format!("invalid requestorName GeneralName DER: {e}")),
        }
        self
    }

    /// Add a `Request` entry (one certificate whose status is being queried).
    ///
    /// All parameters are supplied via [`CertIDSpec`].
    pub fn add_request(mut self, spec: CertIDSpec<'_>) -> Self {
        if self.error.is_some() {
            return self;
        }
        // Validate the AlgorithmIdentifier DER.
        if let Err(e) =
            Decoder::new(spec.hash_algorithm_der, Encoding::Der).decode::<AlgorithmIdentifier<'_>>()
        {
            self.error = Some(format!("invalid hash_algorithm_der: {e}"));
            return self;
        }
        self.requests.push(PendingRequest {
            hash_algorithm_der: spec.hash_algorithm_der.to_vec(),
            issuer_name_hash: spec.issuer_name_hash.to_vec(),
            issuer_key_hash: spec.issuer_key_hash.to_vec(),
            serial: spec.serial.to_vec(),
        });
        self
    }

    // ── Build ──────────────────────────────────────────────────────────────────

    /// Shared construction: validates state, builds `TBSRequest`, and returns
    /// the owned buffers needed to borrow from.
    fn build_tbs_struct(self) -> Result<(Vec<PendingRequest>, Option<Vec<u8>>), String> {
        if let Some(e) = self.error {
            return Err(e);
        }
        if self.requests.is_empty() {
            return Err("requestList is empty: add at least one request via add_request()".into());
        }
        Ok((self.requests, self.requestor_name_der))
    }

    /// Build the DER-encoded inner `TBSRequest` SEQUENCE.
    ///
    /// These bytes are intended for external signing.  After signing, call
    /// [`assemble`](Self::assemble) with the `TBSRequest` bytes and the
    /// signature to produce the complete `OCSPRequest`.
    ///
    /// For unsigned submission, use [`build_tbs`](Self::build_tbs) instead,
    /// which wraps the `TBSRequest` in the outer `OCSPRequest` SEQUENCE.
    pub fn build_tbs_inner(self) -> Result<Vec<u8>, String> {
        let (requests, requestor_name_der) = self.build_tbs_struct()?;
        encode_tbs_request(&requests, requestor_name_der.as_deref())
    }

    /// Build the DER-encoded complete unsigned `OCSPRequest`.
    ///
    /// Required: at least one `Request` entry added via [`OCSPRequestBuilder::add_request`].
    ///
    /// The returned bytes are the complete `OCSPRequest` SEQUENCE (with
    /// `TBSRequest` inside but no `optionalSignature`), ready for direct
    /// submission to an OCSP responder.
    ///
    /// Returns `Err` if any required field is absent, if a DER value was
    /// malformed, or if DER encoding fails.
    pub fn build_tbs(self) -> Result<Vec<u8>, String> {
        let (requests, requestor_name_der) = self.build_tbs_struct()?;
        let tbs = make_tbs_request(&requests, requestor_name_der.as_deref())?;
        let ocsp_request = OCSPRequest {
            tbs_request: tbs,
            optional_signature: None,
        };
        ocsp_request
            .to_der()
            .map_err(|e| format!("OCSPRequest encode error: {e}"))
    }

    /// Assemble a DER-encoded `OCSPRequest` from a signed `TBSRequest`.
    ///
    /// # Structure produced
    ///
    /// ```text
    /// OCSPRequest ::= SEQUENCE {
    ///   tbsRequest TBSRequest,
    ///   optionalSignature [0] EXPLICIT Signature {
    ///     signatureAlgorithm AlgorithmIdentifier,
    ///     signature BIT STRING
    ///   }
    /// }
    /// ```
    ///
    /// # Parameters
    ///
    /// - `tbs_der` — DER-encoded inner `TBSRequest` from
    ///   [`build_tbs_inner`](Self::build_tbs_inner)
    /// - `sig_alg_der` — DER-encoded `AlgorithmIdentifier` for the signature
    /// - `signature` — raw signature bytes (BIT STRING value; unused-bits = 0 is added)
    ///
    /// Returns the complete DER-encoded signed `OCSPRequest`.
    pub fn assemble(
        tbs_der: &[u8],
        sig_alg_der: &[u8],
        signature: &[u8],
    ) -> Result<Vec<u8>, String> {
        let tbs: TBSRequest<'_> = Decoder::new(tbs_der, Encoding::Der)
            .decode()
            .map_err(|e| format!("assemble: tbs_der decode error: {e}"))?;
        let sig_algorithm: AlgorithmIdentifier<'_> = Decoder::new(sig_alg_der, Encoding::Der)
            .decode()
            .map_err(|e| format!("assemble: sig_alg_der decode error: {e}"))?;
        let sig_bstr = BitStringRef::new(signature, 0)
            .map_err(|e| format!("assemble: signature BIT STRING error: {e}"))?;

        let ocsp_sig = Signature {
            signature_algorithm: sig_algorithm,
            signature: sig_bstr,
            certs: None,
        };

        let ocsp_request = OCSPRequest {
            tbs_request: tbs,
            optional_signature: Some(ocsp_sig),
        };

        ocsp_request
            .to_der()
            .map_err(|e| format!("OCSPRequest encode error: {e}"))
    }
}

// ── Tests ──────────────────────────────────────────────────────────────────────

#[cfg(test)]
mod tests {
    use super::*;

    // SHA-1 AlgorithmIdentifier: SEQUENCE { OID 1.3.14.3.2.26, NULL }
    // 30 09 06 05 2b 0e 03 02 1a 05 00
    fn sha1_alg_der() -> &'static [u8] {
        &[
            0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00,
        ]
    }

    // SHA-256withRSA AlgorithmIdentifier for outer signature.
    // 30 0d 06 09 2a 86 48 86 f7 0d 01 01 0b 05 00
    fn sha256_rsa_alg_der() -> &'static [u8] {
        &[
            0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05,
            0x00,
        ]
    }

    /// Round-trip: build an unsigned OCSPRequest with one request entry,
    /// then decode back and verify the structure.
    #[test]
    fn build_unsigned_ocsp_request() {
        let name_hash = [0x01u8; 20];
        let key_hash = [0x02u8; 20];
        let serial = [0x03u8];

        let ocsp_der = OCSPRequestBuilder::new()
            .add_request(CertIDSpec {
                hash_algorithm_der: sha1_alg_der(),
                issuer_name_hash: &name_hash,
                issuer_key_hash: &key_hash,
                serial: &serial,
            })
            .build_tbs()
            .expect("build_tbs should succeed");

        assert!(!ocsp_der.is_empty(), "OCSPRequest DER must not be empty");

        // Decode back as OCSPRequest.
        let decoded: OCSPRequest<'_> = Decoder::new(&ocsp_der, Encoding::Der)
            .decode()
            .expect("OCSPRequest round-trip decode failed");

        assert!(decoded.optional_signature.is_none());
        assert_eq!(decoded.tbs_request.request_list.len(), 1);
        assert!(decoded.tbs_request.requestor_name.is_none());
        assert_eq!(
            decoded.tbs_request.request_list[0]
                .req_cert
                .issuer_name_hash
                .as_bytes(),
            &name_hash
        );
        assert_eq!(
            decoded.tbs_request.request_list[0]
                .req_cert
                .issuer_key_hash
                .as_bytes(),
            &key_hash
        );
    }

    /// Round-trip: build a signed OCSPRequest and decode back.
    #[test]
    fn assemble_signed_request() {
        let name_hash = [0xaau8; 20];
        let key_hash = [0xbbu8; 20];
        let serial = [0x01u8];
        let fake_sig = [0xdeu8; 32];

        let tbs_inner = OCSPRequestBuilder::new()
            .add_request(CertIDSpec {
                hash_algorithm_der: sha1_alg_der(),
                issuer_name_hash: &name_hash,
                issuer_key_hash: &key_hash,
                serial: &serial,
            })
            .build_tbs_inner()
            .expect("build_tbs_inner should succeed");

        let ocsp_der = OCSPRequestBuilder::assemble(&tbs_inner, sha256_rsa_alg_der(), &fake_sig)
            .expect("assemble should succeed");

        let decoded: OCSPRequest<'_> = Decoder::new(&ocsp_der, Encoding::Der)
            .decode()
            .expect("OCSPRequest round-trip decode failed");

        assert!(
            decoded.optional_signature.is_some(),
            "signature must be present"
        );
        assert_eq!(decoded.tbs_request.request_list.len(), 1);
    }

    /// Calling `build_tbs()` with no requests must return `Err`.
    #[test]
    fn empty_request_list_returns_error() {
        let result = OCSPRequestBuilder::new().build_tbs();
        assert!(result.is_err(), "expected error for empty request list");
        let msg = result.unwrap_err();
        assert!(
            msg.contains("requestList"),
            "error message must mention 'requestList', got: {msg}"
        );
    }

    /// An invalid AlgorithmIdentifier DER must record an error and propagate.
    #[test]
    fn invalid_alg_id_propagates() {
        let result = OCSPRequestBuilder::new()
            .add_request(CertIDSpec {
                hash_algorithm_der: &[0xff, 0x00], // garbage
                issuer_name_hash: &[0x01u8; 20],
                issuer_key_hash: &[0x02u8; 20],
                serial: &[0x01u8],
            })
            .build_tbs();
        assert!(result.is_err());
    }

    /// Multiple `add_request` calls accumulate all entries.
    #[test]
    fn multiple_requests_accumulated() {
        let name_hash = [0x01u8; 20];
        let key_hash = [0x02u8; 20];
        let serial1 = [0x01u8];
        let serial2 = [0x02u8];
        let serial3 = [0x03u8];

        let ocsp_der = OCSPRequestBuilder::new()
            .add_request(CertIDSpec {
                hash_algorithm_der: sha1_alg_der(),
                issuer_name_hash: &name_hash,
                issuer_key_hash: &key_hash,
                serial: &serial1,
            })
            .add_request(CertIDSpec {
                hash_algorithm_der: sha1_alg_der(),
                issuer_name_hash: &name_hash,
                issuer_key_hash: &key_hash,
                serial: &serial2,
            })
            .add_request(CertIDSpec {
                hash_algorithm_der: sha1_alg_der(),
                issuer_name_hash: &name_hash,
                issuer_key_hash: &key_hash,
                serial: &serial3,
            })
            .build_tbs()
            .expect("build_tbs should succeed with three entries");

        let decoded: OCSPRequest<'_> = Decoder::new(&ocsp_der, Encoding::Der)
            .decode()
            .expect("OCSPRequest decode failed");

        assert_eq!(decoded.tbs_request.request_list.len(), 3);
    }

    /// An invalid `requestorName` GeneralName DER must be recorded and propagated.
    #[test]
    fn invalid_requestor_name_propagates() {
        let result = OCSPRequestBuilder::new()
            .requestor_name(&[0xff, 0x00]) // not a valid GeneralName
            .add_request(CertIDSpec {
                hash_algorithm_der: sha1_alg_der(),
                issuer_name_hash: &[0x01u8; 20],
                issuer_key_hash: &[0x02u8; 20],
                serial: &[0x01u8],
            })
            .build_tbs();
        assert!(
            result.is_err(),
            "expected error for invalid requestorName DER"
        );
        let msg = result.unwrap_err();
        assert!(
            msg.contains("requestorName"),
            "error must mention 'requestorName', got: {msg}"
        );
    }

    /// `assemble` with invalid `tbs_der` must return an error.
    #[test]
    fn assemble_invalid_tbs_returns_error() {
        let result = OCSPRequestBuilder::assemble(&[0xff, 0x00], sha256_rsa_alg_der(), &[0u8; 32]);
        assert!(result.is_err(), "expected error for garbage tbs_der");
    }

    /// `assemble` with invalid `sig_alg_der` must return an error.
    #[test]
    fn assemble_invalid_sig_alg_returns_error() {
        let name_hash = [0xaau8; 20];
        let key_hash = [0xbbu8; 20];
        let serial = [0x01u8];
        let tbs_inner = OCSPRequestBuilder::new()
            .add_request(CertIDSpec {
                hash_algorithm_der: sha1_alg_der(),
                issuer_name_hash: &name_hash,
                issuer_key_hash: &key_hash,
                serial: &serial,
            })
            .build_tbs_inner()
            .expect("build_tbs_inner should succeed");

        let result = OCSPRequestBuilder::assemble(&tbs_inner, &[0xff, 0x00], &[0u8; 32]);
        assert!(result.is_err(), "expected error for garbage sig_alg_der");
    }
}