structured_pkix/
ocsp.rs

1//! OCSP response evidence over original caller-supplied DER ranges.
2//!
3//! Decoding does not authenticate a responder, validate a request binding or
4//! establish certificate status. No transport, clock or trust discovery occurs.
5
6use crate::algorithm::{self, AlgorithmIdentifier};
7use crate::error::{Error, ErrorCode, Located, Result};
8use crate::extension::{self, Extensions};
9use crate::name::{self, Name};
10use crate::{Certificate, Time, oid, time};
11use structured_asn1::memory::{Memory, OwnedVec, Work};
12use structured_asn1::{
13    BitString, Element, Encoding, Integer, Oid, Parser, Reader, Span, Tag, universal,
14};
15
16const FIELD: &str = "ocspResponse";
17const BASIC: &str = "ocspResponse.basic";
18const DATA: &str = "ocspResponse.responseData";
19const SINGLE: &str = "ocspResponse.singleResponse";
20
21mod digest;
22pub use digest::{CertMatch, Digest, DigestAlgorithm, ResolvedDigest};
23
24mod nonce;
25pub use nonce::{NonceBinding, NonceSizeError, RequestNonce};
26
27mod authentication;
28pub use authentication::{
29    SignatureAuthentication, SignatureError, SignatureFailure, SignedResponse,
30};
31
32mod delegation;
33pub(crate) use delegation::read_no_check;
34
35mod lookup;
36pub use delegation::{
37    DelegateFacts, Delegation, DelegationFailure, ResponderRevocation, check_delegate,
38};
39pub use lookup::Lookup;
40
41mod freshness;
42pub use freshness::UpdateWindow;
43
44mod authority;
45pub use authority::{AuthorityBinding, AuthorityFailure, AuthoritySource, ScopedResponse};
46
47mod extensions;
48pub use extensions::ExtensionProcessing;
49
50mod evidence;
51pub use evidence::{
52    BoundEvidence, Evaluation, Evidence, RecipientBinding, Request, TargetEvidence, TargetReading,
53};
54
55/// Unsigned protocol failure from RFC6960 §4.2.1, never a certificate verdict.
56#[derive(Debug, Clone, Copy, PartialEq, Eq)]
57pub enum Failure {
58    /// Request did not conform to the protocol.
59    MalformedRequest,
60    /// Responder reached an inconsistent state.
61    InternalError,
62    /// Responder cannot currently answer.
63    TryLater,
64    /// Responder requires a signed request.
65    SignatureRequired,
66    /// Request unauthorized or responder unable to answer authoritatively.
67    Unauthorized,
68}
69
70/// A decoded envelope preserves unsupported response types and unsigned errors.
71#[derive(Debug)]
72pub enum Response<'a> {
73    /// Successful wire envelope, whose typed body is decoded on demand.
74    Successful(ResponseBytes<'a>),
75    /// Protocol error. No signed status information accompanies it.
76    Failure {
77        /// Error code chosen by the responder.
78        failure: Failure,
79        /// Original envelope location.
80        span: Span,
81    },
82}
83
84/// Original successful response payload and its producing reader. Keeping the
85/// envelope separate avoids allocating a large basic response for protocol
86/// failures or unsupported types; decoding moves the existing reader.
87#[derive(Debug)]
88pub struct ResponseBytes<'a> {
89    kind: Oid<'a>,
90    payload: &'a [u8],
91    span: Span,
92    reader: Reader<'a>,
93}
94
95impl<'a> ResponseBytes<'a> {
96    /// Original response syntax identifier.
97    #[must_use]
98    pub fn kind(&self) -> Oid<'a> {
99        self.kind
100    }
101    /// Original encoded response payload.
102    #[must_use]
103    pub fn payload(&self) -> &'a [u8] {
104        self.payload
105    }
106    /// Original payload content location.
107    #[must_use]
108    pub fn span(&self) -> Span {
109        self.span
110    }
111    /// Borrows the original basic-response payload under a current operation.
112    /// The envelope is not consumed or cloned. Its original producing parser,
113    /// source offsets and actual depth remain active, while the supplied query
114    /// funds new decoding, catalogue growth and lazy certificate processing.
115    /// `None` is only an unsupported response syntax, never a malformed known
116    /// basic response or a source/current-operation resource refusal.
117    pub fn basic_in<'query>(&self, query: &Reader<'query>) -> Result<Option<BasicResponse<'query>>>
118    where
119        'a: 'query,
120    {
121        // RFC6960 §4.2.1 leaves an unsupported responseType's octets opaque.
122        // Classifying its OID consumes metadata work, not a payload nesting
123        // level. Keep both source and current query work ceilings before the
124        // comparison; only the known basic syntax opens a nested reader.
125        // https://www.rfc-editor.org/rfc/rfc6960.html#section-4.2.1
126        self.reader
127            .execution_query(query)
128            .charge_work(19)
129            .map_err(|reason| Error::resource(reason, FIELD, self.span.start))?;
130        if self.kind != oid::OCSP_BASIC {
131            return Ok(None);
132        }
133        let mut nested = self
134            .reader
135            .parser()
136            .read_nested_query_in(
137                query,
138                self.payload,
139                self.span.start,
140                Encoding::Der,
141                self.reader.depth(),
142            )
143            .field(BASIC)?;
144        let root = required(&mut nested, BASIC)?;
145        let basic = read_basic(&nested, &root)?;
146        end(&nested, BASIC)?;
147        Ok(Some(basic))
148    }
149    /// Decode the mandatory basic response syntax using current execution.
150    /// `None` means unsupported syntax. The producing reader's cumulative
151    /// work/depth limits remain active; no extra parser or reader copy is made.
152    pub fn into_basic(self, execution: &Memory) -> Result<Option<BasicResponse<'a>>> {
153        let reader = self.reader.with_execution(execution);
154        reader.charge(19).field(FIELD)?;
155        if self.kind != oid::OCSP_BASIC {
156            return Ok(None);
157        }
158        let mut nested = reader
159            .parser()
160            .read_nested_query_in(
161                &reader,
162                self.payload,
163                self.span.start,
164                Encoding::Der,
165                reader.depth(),
166            )
167            .field(BASIC)?;
168        let root = required(&mut nested, BASIC)?;
169        let basic = read_basic(&nested, &root)?;
170        end(&nested, BASIC)?;
171        Ok(Some(basic))
172    }
173}
174
175/// Responder identity used to locate the actual signing certificate.
176#[derive(Debug)]
177pub enum ResponderId<'a> {
178    /// Subject distinguished name of the signer.
179    Name(Name<'a>),
180    /// SHA-1 of original subjectPublicKey contents, excluding ASN.1 wrapper
181    /// and the BIT STRING unused-bits count (RFC6960 verified errata6165–6167).
182    KeyHash(&'a [u8]),
183}
184
185/// Certificate identity retains its original encoded hash algorithm and octets.
186#[derive(Debug, Clone, Copy)]
187pub struct CertId<'a> {
188    algorithm: AlgorithmIdentifier<'a>,
189    issuer_name_hash: &'a [u8],
190    issuer_key_hash: &'a [u8],
191    serial: Integer<'a>,
192    span: Span,
193}
194
195impl<'a> CertId<'a> {
196    /// Hash algorithm, including original parameters.
197    #[must_use]
198    pub fn algorithm(self) -> AlgorithmIdentifier<'a> {
199        self.algorithm
200    }
201    /// Hash of the target certificate's original issuer DER name.
202    #[must_use]
203    pub fn issuer_name_hash(self) -> &'a [u8] {
204        self.issuer_name_hash
205    }
206    /// Hash of the issuer's original subjectPublicKey BIT STRING contents.
207    #[must_use]
208    pub fn issuer_key_hash(self) -> &'a [u8] {
209        self.issuer_key_hash
210    }
211    /// Original arbitrary-width serial INTEGER.
212    #[must_use]
213    pub fn serial(self) -> Integer<'a> {
214        self.serial
215    }
216    /// Original `CertID` location.
217    #[must_use]
218    pub fn span(self) -> Span {
219        self.span
220    }
221}
222
223/// A responder's assertion, independently of authentication and applicability.
224#[derive(Debug, Clone, Copy, PartialEq, Eq)]
225pub enum Status {
226    /// Positive revocation inquiry; not proof that a certificate was issued.
227    Good,
228    /// Responder states revocation or hold, retaining its original date/reason.
229    Revoked {
230        /// Recorded revocation or hold time.
231        time: Time,
232        /// Encoded optional reason, without substituting a policy decision.
233        reason: Option<crate::crl::Reason>,
234    },
235    /// This responder does not know the requested certificate's status.
236    Unknown,
237}
238
239#[derive(Debug)]
240enum RecordedStatus {
241    Good,
242    Unknown,
243    Revoked {
244        time: Time,
245        reason: Option<crate::crl::Reason>,
246        offset: u64,
247    },
248}
249
250/// One signed assertion with deferred extension semantics.
251#[derive(Debug)]
252pub struct SingleResponse<'a> {
253    id: CertId<'a>,
254    status: RecordedStatus,
255    this_update: Time,
256    next_update: Option<Time>,
257    extensions: Extensions<'a>,
258    span: Span,
259}
260
261impl<'a> SingleResponse<'a> {
262    /// Original certificate identity.
263    #[must_use]
264    pub fn id(&self) -> CertId<'a> {
265        self.id
266    }
267    /// Unauthenticated status assertion.
268    #[must_use]
269    pub fn status(&self) -> Status {
270        match self.status {
271            RecordedStatus::Good => Status::Good,
272            RecordedStatus::Unknown => Status::Unknown,
273            RecordedStatus::Revoked { time, reason, .. } => Status::Revoked { time, reason },
274        }
275    }
276
277    /// UTC-qualified recorded revocation time, when this assertion is revoked.
278    /// This never decides whether a future date may be ignored by the product.
279    pub fn revocation_relation<W: Work>(
280        &self,
281        now: crate::temporal::Reading,
282        utc: &crate::temporal::LeapTable<'_>,
283        execution: &W,
284    ) -> Result<Option<crate::time::Relation>> {
285        match self.status {
286            RecordedStatus::Good | RecordedStatus::Unknown => Ok(None),
287            RecordedStatus::Revoked { time, offset, .. } => crate::time::relation_in(
288                time.instant(),
289                now,
290                utc,
291                execution,
292                ("ocspResponse.singleResponse.revocationTime", offset),
293            )
294            .map(Some),
295        }
296    }
297    /// Most recent time the responder knew this status to be correct.
298    #[must_use]
299    pub fn this_update(&self) -> Time {
300        self.this_update
301    }
302    /// Recommended update boundary, absent when newer information is always
303    /// available. No lifetime is invented for an absent value.
304    #[must_use]
305    pub fn next_update(&self) -> Option<Time> {
306        self.next_update
307    }
308    /// Deferred extensions, still using their source parser and current account.
309    #[must_use]
310    pub fn extensions(&self) -> &Extensions<'a> {
311        &self.extensions
312    }
313    /// Original assertion location.
314    #[must_use]
315    pub fn span(&self) -> Span {
316        self.span
317    }
318}
319
320/// `BasicOCSPResponse` retains the exact signed `ResponseData` encoding.
321#[derive(Debug)]
322pub struct BasicResponse<'a> {
323    responder: ResponderId<'a>,
324    produced_at: Time,
325    responses: OwnedVec<SingleResponse<'a>>,
326    extensions: Extensions<'a>,
327    algorithm: AlgorithmIdentifier<'a>,
328    signature: BitString<'a>,
329    certificates: OwnedVec<Certificate<'a>>,
330    signed: &'a [u8],
331    bytes: &'a [u8],
332    span: Span,
333}
334
335impl<'a> BasicResponse<'a> {
336    /// Original responder identity, not a resolved signing authority.
337    #[must_use]
338    pub fn responder(&self) -> &ResponderId<'a> {
339        &self.responder
340    }
341    /// Time the responder signed this response, not the status update time.
342    #[must_use]
343    pub fn produced_at(&self) -> Time {
344        self.produced_at
345    }
346    /// Signed assertions in original order; duplicates are not collapsed.
347    #[must_use]
348    pub fn responses(&self) -> &[SingleResponse<'a>] {
349        &self.responses
350    }
351    /// Response-wide deferred extensions.
352    #[must_use]
353    pub fn extensions(&self) -> &Extensions<'a> {
354        &self.extensions
355    }
356    /// Signature algorithm selected by the responder.
357    #[must_use]
358    pub fn signature_algorithm(&self) -> AlgorithmIdentifier<'a> {
359        self.algorithm
360    }
361    /// Original signature BIT STRING.
362    #[must_use]
363    pub fn signature(&self) -> BitString<'a> {
364        self.signature
365    }
366    /// Untrusted included certificates, not a discovered trust path.
367    #[must_use]
368    pub fn certificates(&self) -> &[Certificate<'a>] {
369        &self.certificates
370    }
371    /// Exact original DER `ResponseData` bytes supplied to signature verification.
372    #[must_use]
373    pub fn signed_bytes(&self) -> &'a [u8] {
374        self.signed
375    }
376    /// Original DER `BasicOCSPResponse` bytes.
377    #[must_use]
378    pub fn as_bytes(&self) -> &'a [u8] {
379        self.bytes
380    }
381    /// Original basic-response location inside the payload OCTET STRING.
382    #[must_use]
383    pub fn span(&self) -> Span {
384        self.span
385    }
386}
387
388impl<'a> Response<'a> {
389    /// Read exactly one OCSP response using the supplied source parser.
390    /// No new parser, budget reset or serialization bridge is introduced.
391    pub fn read(parser: &'a Parser, bytes: &'a [u8], base: u64) -> Result<Self> {
392        let mut reader = parser.read(bytes, base).field(FIELD)?;
393        let element = required(&mut reader, FIELD)?;
394        let result = Self::read_element(&reader, &element)?;
395        end(&reader, FIELD)?;
396        Ok(result)
397    }
398
399    /// Decode an embedded OCSP response under DER with its producing Reader.
400    /// RFC6960 §4 uses explicit tagging by default; §§4.2.1/4.2.2 require
401    /// original DER `ResponseData` for signatures and strict profile times.
402    /// <https://www.rfc-editor.org/rfc/rfc6960#section-4.2.1>
403    pub fn read_element(parent: &Reader<'a>, element: &Element<'a>) -> Result<Self> {
404        if element.tag() != Tag::constructed(universal::SEQUENCE) {
405            return Err(Error::new(
406                ErrorCode::Encoding(structured_asn1::ErrorCode::UnexpectedTag),
407                FIELD,
408                element.span().start,
409            ));
410        }
411        let mut distinguished = parent.reread(element, Encoding::Der).field(FIELD)?;
412        let root = distinguished
413            .expect(Tag::constructed(universal::SEQUENCE))
414            .field(FIELD)?;
415        let mut reader = distinguished.enter(&root).field(FIELD)?;
416        let code = reader.expect(Tag::primitive(10)).field(FIELD)?;
417        reader.charge(9).field(FIELD)?;
418        let code = reader.integer(&code).field(FIELD)?.as_u64();
419        let failure = match code {
420            Some(0) => None,
421            Some(1) => Some(Failure::MalformedRequest),
422            Some(2) => Some(Failure::InternalError),
423            Some(3) => Some(Failure::TryLater),
424            Some(5) => Some(Failure::SignatureRequired),
425            Some(6) => Some(Failure::Unauthorized),
426            _ => {
427                return Err(Error::new(
428                    ErrorCode::MalformedValue,
429                    FIELD,
430                    root.span().start,
431                ));
432            }
433        };
434        if let Some(failure) = failure {
435            // RFC6960 §4.2.1: error responses do not set responseBytes.
436            end(&reader, FIELD)?;
437            return Ok(Self::Failure {
438                failure,
439                span: root.span(),
440            });
441        }
442        let wrapper = reader.expect(Tag::context(true, 0)).field(FIELD)?;
443        end(&reader, FIELD)?;
444        let mut explicit = reader.enter(&wrapper).field(FIELD)?;
445        let response_bytes = explicit
446            .expect(Tag::constructed(universal::SEQUENCE))
447            .field(FIELD)?;
448        end(&explicit, FIELD)?;
449        let mut bytes_reader = explicit.enter(&response_bytes).field(FIELD)?;
450        let kind = bytes_reader.read_oid().field(FIELD)?;
451        let payload = bytes_reader
452            .expect(Tag::primitive(universal::OCTET_STRING))
453            .field(FIELD)?;
454        end(&bytes_reader, FIELD)?;
455        Ok(Self::Successful(ResponseBytes {
456            kind,
457            payload: payload.contents(),
458            span: payload.contents_span(),
459            reader: bytes_reader,
460        }))
461    }
462}
463
464fn read_basic<'a>(parent: &Reader<'a>, element: &Element<'a>) -> Result<BasicResponse<'a>> {
465    let mut reader = sequence(parent, element, BASIC)?;
466    let signed = required(&mut reader, DATA)?;
467    let mut data = sequence(&reader, &signed, DATA)?;
468    let responder = required(&mut data, DATA)?;
469    if responder.tag() == Tag::context(true, 0) {
470        let mut version = data.enter(&responder).field(DATA)?;
471        let value = version.read_integer().field(DATA)?;
472        version.charge(9).field(DATA)?;
473        end(&version, DATA)?;
474        return Err(Error::new(
475            if value.as_u64() == Some(0) {
476                ErrorCode::MalformedValue
477            } else {
478                ErrorCode::UnsupportedVersion
479            },
480            DATA,
481            responder.span().start,
482        ));
483    }
484    let responder = read_responder(&data, &responder)?;
485    let produced = required(&mut data, DATA)?;
486    let produced_at = generalized(&data, &produced, DATA)?;
487    let assertions = data
488        .expect(Tag::constructed(universal::SEQUENCE))
489        .field(DATA)?;
490    let mut assertions_reader = data.enter(&assertions).field(SINGLE)?;
491    let work = parent.execution();
492    let mut responses = work.vector();
493    while let Some(assertion) = assertions_reader.next_element().field(SINGLE)? {
494        responses
495            .try_push(read_single(&assertions_reader, &assertion)?)
496            .map_err(|reason| Error::resource(reason, SINGLE, assertion.span().start))?;
497    }
498    if responses.is_empty() {
499        return Err(Error::new(
500            ErrorCode::EmptySequence,
501            SINGLE,
502            assertions.span().start,
503        ));
504    }
505    let extensions = optional_extensions(&mut data, 1, DATA)?;
506    end(&data, DATA)?;
507    let algorithm = required(&mut reader, BASIC)?;
508    let algorithm = algorithm::read(&reader, &algorithm, BASIC)?;
509    let signature = reader.read_bit_string().field(BASIC)?;
510    let mut certificates = work.vector();
511    if let Some(wrapper) = reader.next_element().field(BASIC)? {
512        if wrapper.tag() != Tag::context(true, 0) {
513            return Err(Error::new(
514                ErrorCode::UnexpectedField,
515                BASIC,
516                wrapper.span().start,
517            ));
518        }
519        let mut explicit = reader.enter(&wrapper).field(BASIC)?;
520        let sequence = explicit
521            .expect(Tag::constructed(universal::SEQUENCE))
522            .field(BASIC)?;
523        end(&explicit, BASIC)?;
524        let mut inside = explicit.enter(&sequence).field(BASIC)?;
525        while let Some(certificate) = inside.next_element().field(BASIC)? {
526            certificates
527                .try_push(Certificate::read_element(&inside, &certificate)?)
528                .map_err(|reason| Error::resource(reason, BASIC, certificate.span().start))?;
529        }
530    }
531    end(&reader, BASIC)?;
532    Ok(BasicResponse {
533        responder,
534        produced_at,
535        responses: responses.into_owned(),
536        extensions,
537        algorithm,
538        signature,
539        certificates: certificates.into_owned(),
540        signed: signed.as_bytes(),
541        bytes: element.as_bytes(),
542        span: element.span(),
543    })
544}
545
546fn read_responder<'a>(parent: &Reader<'a>, element: &Element<'a>) -> Result<ResponderId<'a>> {
547    if element.tag() != Tag::context(true, 1) && element.tag() != Tag::context(true, 2) {
548        return Err(Error::new(
549            ErrorCode::UnexpectedField,
550            DATA,
551            element.span().start,
552        ));
553    }
554    let mut wrapper = parent.enter(element).field(DATA)?;
555    let value = required(&mut wrapper, DATA)?;
556    end(&wrapper, DATA)?;
557    match element.tag() {
558        tag if tag == Tag::context(true, 1) => {
559            Ok(ResponderId::Name(name::read(&wrapper, &value, DATA)?))
560        }
561        tag if tag == Tag::context(true, 2) => {
562            if value.tag() != Tag::primitive(universal::OCTET_STRING)
563                || value.contents().len() != 20
564            {
565                return Err(Error::new(
566                    ErrorCode::MalformedValue,
567                    DATA,
568                    value.span().start,
569                ));
570            }
571            Ok(ResponderId::KeyHash(value.contents()))
572        }
573        _ => Err(Error::new(
574            ErrorCode::UnexpectedField,
575            DATA,
576            element.span().start,
577        )),
578    }
579}
580
581fn read_single<'a>(parent: &Reader<'a>, element: &Element<'a>) -> Result<SingleResponse<'a>> {
582    let mut reader = sequence(parent, element, SINGLE)?;
583    let id = required(&mut reader, SINGLE)?;
584    let id = read_id(&reader, &id)?;
585    let status = required(&mut reader, SINGLE)?;
586    let status = match status.tag() {
587        tag if tag == Tag::context(false, 0) => {
588            reader.null(&status).field(SINGLE)?;
589            RecordedStatus::Good
590        }
591        tag if tag == Tag::context(false, 2) => {
592            reader.null(&status).field(SINGLE)?;
593            RecordedStatus::Unknown
594        }
595        tag if tag == Tag::context(true, 1) => {
596            let mut revoked = reader.enter(&status).field(SINGLE)?;
597            let date = required(&mut revoked, SINGLE)?;
598            let time = generalized(&revoked, &date, SINGLE)?;
599            let reason = if let Some(wrapper) = revoked.next_element().field(SINGLE)? {
600                if wrapper.tag() != Tag::context(true, 0) {
601                    return Err(Error::new(
602                        ErrorCode::UnexpectedField,
603                        SINGLE,
604                        wrapper.span().start,
605                    ));
606                }
607                let mut explicit = revoked.enter(&wrapper).field(SINGLE)?;
608                let reason = explicit.expect(Tag::primitive(10)).field(SINGLE)?;
609                end(&explicit, SINGLE)?;
610                Some(crate::crl::reason_element(&explicit, &reason, SINGLE)?)
611            } else {
612                None
613            };
614            end(&revoked, SINGLE)?;
615            RecordedStatus::Revoked {
616                time,
617                reason,
618                offset: date.span().start,
619            }
620        }
621        _ => {
622            return Err(Error::new(
623                ErrorCode::UnexpectedField,
624                SINGLE,
625                status.span().start,
626            ));
627        }
628    };
629    let this = required(&mut reader, SINGLE)?;
630    let this_update = generalized(&reader, &this, SINGLE)?;
631    let mut next = reader.next_element().field(SINGLE)?;
632    let next_update =
633        if let Some(wrapper) = next.filter(|element| element.tag() == Tag::context(true, 0)) {
634            let mut explicit = reader.enter(&wrapper).field(SINGLE)?;
635            let value = required(&mut explicit, SINGLE)?;
636            end(&explicit, SINGLE)?;
637            let value = generalized(&explicit, &value, SINGLE)?;
638            next = reader.next_element().field(SINGLE)?;
639            Some(value)
640        } else {
641            None
642        };
643    let extensions = extensions_element(&reader, next.as_ref(), 1, SINGLE)?;
644    end(&reader, SINGLE)?;
645    Ok(SingleResponse {
646        id,
647        status,
648        this_update,
649        next_update,
650        extensions,
651        span: element.span(),
652    })
653}
654
655fn read_id<'a>(parent: &Reader<'a>, element: &Element<'a>) -> Result<CertId<'a>> {
656    let mut reader = sequence(parent, element, SINGLE)?;
657    let algorithm = required(&mut reader, SINGLE)?;
658    let algorithm = algorithm::read(&reader, &algorithm, SINGLE)?;
659    let name = reader
660        .expect(Tag::primitive(universal::OCTET_STRING))
661        .field(SINGLE)?;
662    let key = reader
663        .expect(Tag::primitive(universal::OCTET_STRING))
664        .field(SINGLE)?;
665    let serial = reader.read_integer().field(SINGLE)?;
666    end(&reader, SINGLE)?;
667    Ok(CertId {
668        algorithm,
669        issuer_name_hash: name.contents(),
670        issuer_key_hash: key.contents(),
671        serial,
672        span: element.span(),
673    })
674}
675
676fn generalized(parent: &Reader<'_>, element: &Element<'_>, field: &'static str) -> Result<Time> {
677    if element.tag() != Tag::primitive(universal::GENERALIZED_TIME) {
678        return Err(Error::new(
679            ErrorCode::Encoding(structured_asn1::ErrorCode::UnexpectedTag),
680            field,
681            element.span().start,
682        ));
683    }
684    time::read_in(parent, element, field)
685}
686fn sequence<'a>(
687    parent: &Reader<'a>,
688    element: &Element<'a>,
689    field: &'static str,
690) -> Result<Reader<'a>> {
691    if element.tag() != Tag::constructed(universal::SEQUENCE) {
692        return Err(Error::new(
693            ErrorCode::Encoding(structured_asn1::ErrorCode::UnexpectedTag),
694            field,
695            element.span().start,
696        ));
697    }
698    parent.enter(element).field(field)
699}
700fn optional_extensions<'a>(
701    reader: &mut Reader<'a>,
702    tag: u32,
703    field: &'static str,
704) -> Result<Extensions<'a>> {
705    let element = reader.next_element().field(field)?;
706    extensions_element(reader, element.as_ref(), tag, field)
707}
708fn extensions_element<'a>(
709    parent: &Reader<'a>,
710    element: Option<&Element<'a>>,
711    tag: u32,
712    field: &'static str,
713) -> Result<Extensions<'a>> {
714    let Some(element) = element else {
715        return Ok(Extensions::empty(parent.memory()));
716    };
717    if element.tag() != Tag::context(true, tag) {
718        return Err(Error::new(
719            ErrorCode::UnexpectedField,
720            field,
721            element.span().start,
722        ));
723    }
724    let mut explicit = parent.enter(element).field(field)?;
725    let value = required(&mut explicit, field)?;
726    end(&explicit, field)?;
727    extension::read(&explicit, &value, field)
728}
729fn required<'a>(reader: &mut Reader<'a>, field: &'static str) -> Result<Element<'a>> {
730    let at = reader.offset();
731    reader
732        .next_element()
733        .field(field)?
734        .ok_or_else(|| Error::new(ErrorCode::MissingField, field, at))
735}
736fn end(reader: &structured_asn1::ScopedReader<'_, '_>, field: &'static str) -> Result<()> {
737    if reader.is_empty() {
738        Ok(())
739    } else {
740        Err(Error::new(ErrorCode::TrailingData, field, reader.offset()))
741    }
742}
structured_pkix/ocsp.rs

structured_pkix/
ocsp.rs
