Struct x509_parser::certificate::TbsCertificate

pub struct TbsCertificate<'a> {
    pub version: X509Version,
    pub serial: BigUint,
    pub signature: AlgorithmIdentifier<'a>,
    pub issuer: X509Name<'a>,
    pub validity: Validity,
    pub subject: X509Name<'a>,
    pub subject_pki: SubjectPublicKeyInfo<'a>,
    pub issuer_uid: Option<UniqueIdentifier<'a>>,
    pub subject_uid: Option<UniqueIdentifier<'a>>,
    // some fields omitted
}

The sequence TBSCertificate contains information associated with the subject of the certificate and the CA that issued it.

RFC5280 definition:

  TBSCertificate  ::=  SEQUENCE  {
       version         [0]  EXPLICIT Version DEFAULT v1,
       serialNumber         CertificateSerialNumber,
       signature            AlgorithmIdentifier,
       issuer               Name,
       validity             Validity,
       subject              Name,
       subjectPublicKeyInfo SubjectPublicKeyInfo,
       issuerUniqueID  [1]  IMPLICIT UniqueIdentifier OPTIONAL,
                            -- If present, version MUST be v2 or v3
       subjectUniqueID [2]  IMPLICIT UniqueIdentifier OPTIONAL,
                            -- If present, version MUST be v2 or v3
       extensions      [3]  EXPLICIT Extensions OPTIONAL
                            -- If present, version MUST be v3
       }

Fields

version: X509Version

serial: BigUint

signature: AlgorithmIdentifier<'a>

issuer: X509Name<'a>

validity: Validity

subject: X509Name<'a>

subject_pki: SubjectPublicKeyInfo<'a>

issuer_uid: Option<UniqueIdentifier<'a>>

subject_uid: Option<UniqueIdentifier<'a>>

Implementations

impl<'a> TbsCertificate<'a>

pub fn extensions(&self) -> &[X509Extension<'_>]

Returns the certificate extensions

pub fn iter_extensions(&self) -> impl Iterator<Item = &X509Extension<'_>>

Returns an iterator over the certificate extensions

pub fn find_extension(&self, oid: &Oid<'_>) -> Option<&X509Extension<'_>>

Searches for an extension with the given Oid.

Note: if there are several extensions with the same Oid, the first one is returned.

pub fn extensions_map(
    &self
) -> Result<HashMap<Oid<'_>, &X509Extension<'_>>, X509Error>

Builds and returns a map of extensions.

If an extension is present twice, this will fail and return DuplicateExtensions.

pub fn basic_constraints(&self) -> Option<(bool, &BasicConstraints)>

pub fn key_usage(&self) -> Option<(bool, &KeyUsage)>

pub fn extended_key_usage(&self) -> Option<(bool, &ExtendedKeyUsage<'_>)>

pub fn policy_constraints(&self) -> Option<(bool, &PolicyConstraints)>

pub fn inhibit_anypolicy(&self) -> Option<(bool, &InhibitAnyPolicy)>

pub fn policy_mappings(&self) -> Option<(bool, &PolicyMappings<'_>)>

pub fn subject_alternative_name(
    &self
) -> Option<(bool, &SubjectAlternativeName<'_>)>

pub fn name_constraints(&self) -> Option<(bool, &NameConstraints<'_>)>

pub fn is_ca(&self) -> bool

Returns true if certificate has basicConstraints CA:true

pub fn raw_serial(&self) -> &[u8]

Get the raw bytes of the certificate serial number

pub fn raw_serial_as_string(&self) -> String

Get a formatted string of the certificate serial number, separated by ‘:’

Trait Implementations

impl<'a> AsRef<[u8]> for TbsCertificate<'a>

fn as_ref(&self) -> &[u8]

Performs the conversion.

impl<'a> Clone for TbsCertificate<'a>

fn clone(&self) -> TbsCertificate<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for TbsCertificate<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> FromDer<'a> for TbsCertificate<'a>

fn from_der(i: &'a [u8]) -> X509Result<'_, TbsCertificate<'a>>

Parse a DER-encoded TbsCertificate object

TBSCertificate  ::=  SEQUENCE  {
     version         [0]  Version DEFAULT v1,
     serialNumber         CertificateSerialNumber,
     signature            AlgorithmIdentifier,
     issuer               Name,
     validity             Validity,
     subject              Name,
     subjectPublicKeyInfo SubjectPublicKeyInfo,
     issuerUniqueID  [1]  IMPLICIT UniqueIdentifier OPTIONAL,
                          -- If present, version MUST be v2 or v3
     subjectUniqueID [2]  IMPLICIT UniqueIdentifier OPTIONAL,
                          -- If present, version MUST be v2 or v3
     extensions      [3]  Extensions OPTIONAL
                          -- If present, version MUST be v3 --  }

impl<'a> Parser<&'a [u8], TbsCertificate<'a>, X509Error> for TbsCertificateParser

fn parse(
    &mut self,
    input: &'a [u8]
) -> IResult<&'a [u8], TbsCertificate<'a>, X509Error>

A parser takes in input type, and returns a Result containing either the remaining input and the output value, or an error

fn map<G, O2>(self, g: G) -> Map<Self, G, O> where
    G: Fn(O) -> O2, 

Maps a function over the result of a parser

fn flat_map<G, H, O2>(self, g: G) -> FlatMap<Self, G, O> where
    G: Fn(O) -> H,
    H: Parser<I, O2, E>, 

Creates a second parser from the output of the first one, then apply over the rest of the input

fn and_then<G, O2>(self, g: G) -> AndThen<Self, G, O> where
    G: Parser<O, O2, E>, 

Applies a second parser over the output of the first one

fn and<G, O2>(self, g: G) -> And<Self, G> where
    G: Parser<I, O2, E>, 

Applies a second parser after the first one, return their results as a tuple

fn or<G>(self, g: G) -> Or<Self, G> where
    G: Parser<I, O, E>, 

Applies a second parser over the input if the first one failed

fn into<O2, E2>(self) -> Into<Self, O, O2, E, E2> where
    O2: From<O>,
    E2: From<E>, 

automatically converts the parser’s output and error values to another type, as long as they implement the From trait

impl<'a> PartialEq<TbsCertificate<'a>> for TbsCertificate<'a>

fn eq(&self, other: &TbsCertificate<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &TbsCertificate<'a>) -> bool

This method tests for !=.

impl Validate for TbsCertificate<'_>

This is supported on crate feature validate only.

fn validate<W, E>(&self, warn: W, err: E) -> bool where
    W: FnMut(&str),
    E: FnMut(&str), 

Attempts to validate current item.

fn validate_to_vec(&self) -> (bool, Vec<String>, Vec<String>)

Attempts to validate current item, storing warning and errors in Vec.

impl<'a> StructuralPartialEq for TbsCertificate<'a>