Struct Pem

pub struct Pem {
    pub label: String,
    pub contents: Vec<u8>,
}

Representation of PEM data

Fields

label: String

The PEM label

contents: Vec<u8>

The PEM decoded data

Implementations

impl Pem

pub fn read(r: impl BufRead + Seek) -> Result<(Pem, usize), PEMError>

Read the next PEM-encoded structure, and decode the base64 data

Returns the certificate (encoded in DER) and the number of bytes read. Allocates a new buffer for the decoded data.

Note that a PEM file can contain multiple PEM blocks. This function returns the first decoded object, starting from the current reader position. To get all objects, call this function repeatedly until PEMError::MissingHeader is returned.

Examples

let file = std::fs::File::open("assets/certificate.pem").unwrap();
let subject = x509_parser::pem::Pem::read(std::io::BufReader::new(file))
     .unwrap().0
    .parse_x509().unwrap()
    .tbs_certificate.subject.to_string();
assert_eq!(subject, "CN=lists.for-our.info");

pub fn parse_x509(&self) -> Result<X509Certificate<'_>, Err<X509Error>>

Decode the PEM contents into a X.509 object

pub fn iter_from_buffer(i: &[u8]) -> PemIterator<Cursor<&[u8]>>

Returns an iterator over the PEM-encapsulated parts of a buffer

Only the sections enclosed in blocks starting with -----BEGIN xxx----- and ending with -----END xxx----- will be considered. Lines before, between or after such blocks will be ignored.

The iterator is fallible: next() returns a Result<Pem, PEMError> object. An error indicates a block is present but invalid.

If the buffer does not contain any block, iterator will be empty.

Examples found in repository

examples/print-cert.rs (line 402)

pub fn main() -> io::Result<()> {
    for file_name in env::args().skip(1) {
        println!("File: {}", file_name);
        let data = std::fs::read(file_name.clone()).expect("Unable to read file");
        if matches!((data[0], data[1]), (0x30, 0x81..=0x83)) {
            // probably DER
            handle_certificate(&file_name, &data)?;
        } else {
            // try as PEM
            for (n, pem) in Pem::iter_from_buffer(&data).enumerate() {
                match pem {
                    Ok(pem) => {
                        let data = &pem.contents;
                        println!("Certificate [{}]", n);
                        handle_certificate(&file_name, data)?;
                    }
                    Err(e) => {
                        eprintln!("Error while decoding PEM entry {}: {}", n, e);
                    }
                }
            }
        }
    }
    Ok(())
}

pub fn iter_from_reader<R: BufRead + Seek>(reader: R) -> PemIterator<R>

Returns an iterator over the PEM-encapsulated parts of a reader

Only the sections enclosed in blocks starting with -----BEGIN xxx----- and ending with -----END xxx----- will be considered. Lines before, between or after such blocks will be ignored.

The iterator is fallible: next() returns a Result<Pem, PEMError> object. An error indicates a block is present but invalid.

If the reader does not contain any block, iterator will be empty.

Trait Implementations

impl Clone for Pem

fn clone(&self) -> Pem

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Pem

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

Formats the value using the given formatter.

impl PartialEq for Pem

fn eq(&self, other: &Pem) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Pem

impl StructuralPartialEq for Pem