structured_pkix/ocsp/
authority.rs

1//! Explicit issuer scope, separate from request/time/revocation acceptance.
2
3use super::{DelegateFacts, Lookup, ResponderRevocation, SignedResponse};
4use crate::Certificate;
5use crate::algorithm::digest::AsnDigest;
6use crate::error::{CallbackResult, Error, Result};
7use crate::path::WorkingKey;
8use structured_asn1::memory::{MemoryError, Work};
9
10/// How the caller-bound signer is related to the selected target issuer.
11#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12pub enum AuthoritySource {
13    /// The actual target issuing key itself signed the response.
14    Issuer,
15    /// Common local path and explicit purpose established direct delegation.
16    Delegate {
17        /// The delegate's revocation exemption or unresolved checking fact.
18        revocation: ResponderRevocation,
19    },
20    /// Caller explicitly selected a locally configured trusted responder for
21    /// this issuer. This branch is never selected from response content.
22    Configured,
23}
24
25/// Completed source/key-scope rejection, distinct from resource errors.
26#[derive(Debug, Clone, Copy, PartialEq, Eq)]
27pub enum AuthorityFailure {
28    /// Effective issuing key is not bound to the supplied issuer certificate.
29    IssuerKeyBinding,
30    /// Signed response's actual signer does not match the selected authority.
31    Signer,
32    /// Signature was checked with a different effective parameter state.
33    EffectiveKey,
34    /// Present keyUsage allows neither applicable object-signing use.
35    KeyUsage,
36}
37
38/// Signature and issuer-scope facts. Caller trust provenance, intended recipient,
39/// pending delegate revocation, nonce, time and critical demands remain explicit.
40#[derive(Debug, Clone, Copy)]
41pub struct ScopedResponse<'r, 'a> {
42    signed: SignedResponse<'r, 'a>,
43    issuer: &'r Certificate<'a>,
44    // Keep the actual input SPKI provenance as well as inherited parameters.
45    // Rebuilding from an equal issuer certificate could change parser/source
46    // identity and its lazy-reading ceilings, even if its DER bytes agree.
47    issuing_key: Option<WorkingKey<'a>>,
48    source: AuthoritySource,
49}
50
51impl<'r, 'a> ScopedResponse<'r, 'a> {
52    /// Original authenticated response/signing source.
53    #[must_use]
54    pub fn signed(self) -> SignedResponse<'r, 'a> {
55        self.signed
56    }
57    /// Selected target issuer, never inferred from included certificates.
58    #[must_use]
59    pub fn issuer(self) -> &'r Certificate<'a> {
60        self.issuer
61    }
62    /// Actual effective issuer key used by issuer-signature or delegation
63    /// authentication. Explicit configured-responder trust does not run that
64    /// operation and honestly returns None, never a fabricated standing key.
65    #[must_use]
66    pub fn issuing_key(self) -> Option<WorkingKey<'a>> {
67        self.issuing_key
68    }
69    /// Explicit scope source, including unresolved delegated revocation.
70    #[must_use]
71    pub fn source(self) -> AuthoritySource {
72        self.source
73    }
74    /// Select a target assertion using the same issuer as the signer binding.
75    pub fn find<
76        't,
77        'd,
78        T: crate::revocation::RevocationTarget<'t>,
79        D: AsnDigest<'d> + ?Sized,
80        E: Work,
81    >(
82        self,
83        target: &T,
84        digest: &'d D,
85        execution: &E,
86    ) -> CallbackResult<Lookup<'r, 'a>, D::Error> {
87        self.signed.find(target, self.issuer, digest, execution)
88    }
89}
90
91/// Completed issuer-scope binding outcome.
92#[derive(Debug, Clone, Copy)]
93#[expect(
94    clippy::large_enum_variant,
95    reason = "return the original response and actual issuing key in-place without a new allocation during authentication"
96)]
97pub enum AuthorityBinding<'r, 'a> {
98    /// Scope established; this is not the final status-acceptance decision.
99    Bound(ScopedResponse<'r, 'a>),
100    /// Completed mismatch.
101    Rejected(AuthorityFailure),
102}
103
104fn equal_bytes<E: Work>(left: &[u8], right: &[u8], execution: &E, at: u64) -> Result<bool> {
105    let work = u64::try_from(left.len().max(right.len()))
106        .ok()
107        .and_then(|n| n.checked_mul(2))
108        .and_then(|n| n.checked_add(1))
109        .ok_or_else(|| Error::resource(MemoryError::WorkExceeded, "ocspResponse.authority", at))?;
110    execution
111        .charge_work(work)
112        .map_err(|reason| Error::resource(reason, "ocspResponse.authority", at))?;
113    Ok(left == right)
114}
115
116fn equal_key<E: Work>(
117    left: WorkingKey<'_>,
118    right: WorkingKey<'_>,
119    execution: &E,
120    at: u64,
121) -> Result<bool> {
122    if !equal_bytes(left.key().as_bytes(), right.key().as_bytes(), execution, at)? {
123        return Ok(false);
124    }
125    match (left.parameters(), right.parameters()) {
126        (None, None) => Ok(true),
127        (Some(left), Some(right)) => equal_bytes(left, right, execution, at),
128        _ => Ok(false),
129    }
130}
131
132pub(super) fn signing_usage<E: Work>(certificate: &Certificate<'_>, execution: &E) -> Result<bool> {
133    // RFC5280 §§4.2.1.3/4.2.1.12: OCSP is neither a certificate nor a CRL
134    // signature; digitalSignature and/or contentCommitment are applicable.
135    // <https://www.rfc-editor.org/rfc/rfc5280#section-4.2.1.12>
136    Ok(certificate
137        .tbs()
138        .extensions()
139        .key_usage(execution)?
140        .is_none_or(|usage| usage.digital_signature() || usage.content_commitment()))
141}
142
143impl<'r, 'a> SignedResponse<'r, 'a> {
144    /// Bind issuer-signed response to the actual authenticated target issuing
145    /// key, including inherited parameters. Caller supplies issuer trust and
146    /// current validity from its target path; a matching DN alone is inadequate.
147    /// RFC6960 §4.2.2.2: <https://www.rfc-editor.org/rfc/rfc6960#section-4.2.2.2>
148    pub fn bind_issuer<E: Work>(
149        self,
150        issuer: &'r Certificate<'a>,
151        issuing_key: WorkingKey<'a>,
152        execution: &E,
153    ) -> Result<AuthorityBinding<'r, 'a>> {
154        let at = self.response().span().start;
155        if !equal_bytes(
156            issuer.tbs().public_key().as_bytes(),
157            issuing_key.key().as_bytes(),
158            execution,
159            at,
160        )? {
161            return Ok(AuthorityBinding::Rejected(
162                AuthorityFailure::IssuerKeyBinding,
163            ));
164        }
165        if !equal_bytes(
166            self.signer().tbs().public_key().as_bytes(),
167            issuer.tbs().public_key().as_bytes(),
168            execution,
169            at,
170        )? || !self
171            .signer()
172            .tbs()
173            .subject()
174            .matches(issuer.tbs().subject(), execution)?
175        {
176            return Ok(AuthorityBinding::Rejected(AuthorityFailure::Signer));
177        }
178        if !equal_key(self.key(), issuing_key, execution, at)? {
179            return Ok(AuthorityBinding::Rejected(AuthorityFailure::EffectiveKey));
180        }
181        if !signing_usage(issuer, execution)? {
182            return Ok(AuthorityBinding::Rejected(AuthorityFailure::KeyUsage));
183        }
184        Ok(AuthorityBinding::Bound(ScopedResponse {
185            signed: self,
186            issuer,
187            issuing_key: Some(issuing_key),
188            source: AuthoritySource::Issuer,
189        }))
190    }
191
192    /// Attach completed direct local delegation to this exact actual signer.
193    /// An unresolved revocation fact remains unresolved in the returned source.
194    pub fn bind_delegate<E: Work>(
195        self,
196        facts: DelegateFacts<'a>,
197        execution: &E,
198    ) -> Result<AuthorityBinding<'r, 'a>>
199    where
200        'a: 'r,
201    {
202        let at = self.response().span().start;
203        if !equal_bytes(
204            self.signer().as_bytes(),
205            facts.responder().as_bytes(),
206            execution,
207            at,
208        )? {
209            return Ok(AuthorityBinding::Rejected(AuthorityFailure::Signer));
210        }
211        if !equal_key(self.key(), facts.key(), execution, at)? {
212            return Ok(AuthorityBinding::Rejected(AuthorityFailure::EffectiveKey));
213        }
214        Ok(AuthorityBinding::Bound(ScopedResponse {
215            signed: self,
216            issuer: facts.issuer(),
217            issuing_key: Some(facts.issuing_key()),
218            source: AuthoritySource::Delegate {
219                revocation: facts.revocation(),
220            },
221        }))
222    }
223
224    /// Explicit caller assertion of locally configured responder trust for this
225    /// target issuer, the separate RFC6960 §4.2.2.2 branch. Never call this merely
226    /// because a certificate was included or carried an OCSP EKU. No traversal,
227    /// allocation, trust discovery or policy selection occurs in this operation.
228    #[must_use]
229    pub fn trust_for_issuer(self, issuer: &'r Certificate<'a>) -> ScopedResponse<'r, 'a> {
230        ScopedResponse {
231            signed: self,
232            issuer,
233            issuing_key: None,
234            source: AuthoritySource::Configured,
235        }
236    }
237}
structured_pkix/ocsp/authority.rs

structured_pkix/ocsp/
authority.rs
