Struct yasna::BERReader

pub struct BERReader<'a, 'b>where
    'a: 'b,{ /* private fields */ }

Expand description

A reader object for BER/DER-encoded ASN.1 data.

The two main sources of BERReaderSeq are:

The parse_ber/parse_der function, the starting point of DER serialization.
The next method of BERReaderSeq.

Examples

use yasna;
let data = &[2, 1, 10];
let asn = yasna::parse_der(data, |reader| {
    reader.read_i64()
}).unwrap();
assert_eq!(asn, 10);

Implementations§

impl<'a, 'b> BERReader<'a, 'b>

pub fn mode(&self) -> BERMode

Tells which format we are parsing, BER or DER.

pub fn read_bool(self) -> ASN1Result<bool>

Reads an ASN.1 BOOLEAN value as bool.

Examples

use yasna;
let data = &[1, 1, 255];
let asn = yasna::parse_der(data, |reader| {
    reader.read_bool()
}).unwrap();
assert_eq!(asn, true);

pub fn read_i64(self) -> ASN1Result<i64>

Reads an ASN.1 INTEGER value as i64.

Examples

use yasna;
let data = &[2, 4, 73, 150, 2, 210];
let asn = yasna::parse_der(data, |reader| {
    reader.read_i64()
}).unwrap();
assert_eq!(asn, 1234567890);

Errors

Except parse errors, it can raise integer overflow errors.

pub fn read_u64(self) -> ASN1Result<u64>

Reads an ASN.1 INTEGER value as u64.

Errors

Except parse errors, it can raise integer overflow errors.

pub fn read_i32(self) -> ASN1Result<i32>

Reads an ASN.1 INTEGER value as i32.

Errors

Except parse errors, it can raise integer overflow errors.

pub fn read_u32(self) -> ASN1Result<u32>

Reads an ASN.1 INTEGER value as u32.

Errors

Except parse errors, it can raise integer overflow errors.

pub fn read_i16(self) -> ASN1Result<i16>

Reads an ASN.1 INTEGER value as i16.

Errors

Except parse errors, it can raise integer overflow errors.

pub fn read_u16(self) -> ASN1Result<u16>

Reads an ASN.1 INTEGER value as u16.

Errors

Except parse errors, it can raise integer overflow errors.

pub fn read_i8(self) -> ASN1Result<i8>

Reads an ASN.1 INTEGER value as i8.

Errors

Except parse errors, it can raise integer overflow errors.

pub fn read_u8(self) -> ASN1Result<u8>

Reads an ASN.1 INTEGER value as u8.

Errors

Except parse errors, it can raise integer overflow errors.

pub fn read_bytes(self) -> ASN1Result<Vec<u8>>

Reads an ASN.1 OCTETSTRING value as Vec<u8>.

Examples

use yasna;
let data = &[36, 128, 4, 2, 72, 101, 4, 4, 108, 108, 111, 33, 0, 0];
let asn = yasna::parse_ber(data, |reader| {
    reader.read_bytes()
}).unwrap();
assert_eq!(&asn, b"Hello!");

pub fn read_null(self) -> ASN1Result<()>

Reads the ASN.1 NULL value.

Examples

use yasna;
let data = &[5, 0];
let asn = yasna::parse_der(data, |reader| {
    reader.read_null()
}).unwrap();
assert_eq!(asn, ());

pub fn read_oid(self) -> ASN1Result<ObjectIdentifier>

Reads an ASN.1 object identifier.

Examples

use yasna;
let data = &[6, 8, 42, 134, 72, 134, 247, 13, 1, 1];
let asn = yasna::parse_der(data, |reader| {
    reader.read_oid()
}).unwrap();
assert_eq!(&*asn.components(), &[1, 2, 840, 113549, 1, 1]);

pub fn read_utf8string(self) -> ASN1Result<String>

Reads an ASN.1 UTF8String.

Examples

use yasna;
let data = &[
    12, 29, 103, 110, 97, 119, 32, 207, 129, 206, 191, 206,
    186, 206, 177, 206, 189, 206, 175, 206, 182, 207,
    137, 32, 240, 170, 152, 130, 227, 130, 139];
let asn = yasna::parse_der(data, |reader| {
    reader.read_utf8string()
}).unwrap();
assert_eq!(&asn, "gnaw ροκανίζω 𪘂る");

pub fn read_sequence<T, F>(self, callback: F) -> ASN1Result<T>where
F: for<'c> FnOnce(&mut BERReaderSeq<'a, 'c>) -> ASN1Result<T>,

Reads an ASN.1 SEQUENCE value.

This function uses the loan pattern: callback is called back with a BERReaderSeq, from which the contents of the SEQUENCE is read.

Examples

use yasna;
let data = &[48, 6, 2, 1, 10, 1, 1, 255];
let asn = yasna::parse_der(data, |reader| {
    reader.read_sequence(|reader| {
        let i = try!(reader.next().read_i64());
        let b = try!(reader.next().read_bool());
        return Ok((i, b));
    })
}).unwrap();
assert_eq!(asn, (10, true));

pub fn read_sequence_of<F>(self, callback: F) -> ASN1Result<()>where
F: for<'c> FnMut(BERReader<'a, 'c>) -> ASN1Result<()>,

Reads an ASN.1 SEQUENCE OF value.

This function uses the loan pattern: callback is called back with a [BERReader][berreader], from which the contents of the SEQUENCE OF is read.

This function doesn’t return values. Instead, use mutable values to maintain read values. collect_set_of can be an alternative.

Examples

use yasna;
let data = &[48, 7, 2, 1, 10, 2, 2, 255, 127];
let asn = yasna::parse_der(data, |reader| {
    let mut numbers = Vec::new();
    try!(reader.read_sequence_of(|reader| {
        numbers.push(try!(reader.read_i64()));
        return Ok(());
    }));
    return Ok(numbers);
}).unwrap();
assert_eq!(&asn, &[10, -129]);

pub fn collect_sequence_of<T, F>(self, callback: F) -> ASN1Result<Vec<T>>where
F: for<'c> FnMut(BERReader<'a, 'c>) -> ASN1Result<T>,

Collects an ASN.1 SEQUENCE OF value.

This function uses the loan pattern: callback is called back with a BERReader, from which the contents of the SEQUENCE OF is read.

If you don’t like Vec, you can use read_sequence_of instead.

Examples

use yasna;
let data = &[48, 7, 2, 1, 10, 2, 2, 255, 127];
let asn = yasna::parse_der(data, |reader| {
    reader.collect_sequence_of(|reader| {
        reader.read_i64()
    })
}).unwrap();
assert_eq!(&asn, &[10, -129]);

pub fn read_set<T, F>(self, callback: F) -> ASN1Result<T>where
F: for<'c> FnOnce(&mut BERReaderSet<'a, 'c>) -> ASN1Result<T>,

Reads an ASN.1 SET value.

This function uses the loan pattern: callback is called back with a BERReaderSet, from which the contents of the SET are read.

For SET OF values, use read_set_of instead.

Examples

use yasna;
use yasna::tags::{TAG_INTEGER,TAG_BOOLEAN};
let data = &[49, 6, 1, 1, 255, 2, 1, 10];
let asn = yasna::parse_der(data, |reader| {
    reader.read_set(|reader| {
        let i = try!(try!(reader.next(&[TAG_INTEGER])).read_i64());
        let b = try!(try!(reader.next(&[TAG_BOOLEAN])).read_bool());
        return Ok((i, b));
    })
}).unwrap();
assert_eq!(asn, (10, true));

pub fn read_set_of<F>(self, callback: F) -> ASN1Result<()>where
F: for<'c> FnMut(BERReader<'a, 'c>) -> ASN1Result<()>,

Reads an ASN.1 SET OF value.

This function uses the loan pattern: callback is called back with a BERReader, from which the contents of the SET OF are read.

This function doesn’t return values. Instead, use mutable values to maintain read values. collect_set_of can be an alternative.

This function doesn’t sort the elements. In DER, it is assumed that the elements occur in an order determined by DER encodings of them.

For SET values, use read_set instead.

Examples

use yasna;
let data = &[49, 7, 2, 1, 10, 2, 2, 255, 127];
let asn = yasna::parse_der(data, |reader| {
    let mut numbers = Vec::new();
    try!(reader.read_set_of(|reader| {
        numbers.push(try!(reader.read_i64()));
        return Ok(());
    }));
    return Ok(numbers);
}).unwrap();
assert_eq!(asn, vec![10, -129]);

pub fn collect_set_of<T, F>(self, callback: F) -> ASN1Result<Vec<T>>where
F: for<'c> FnMut(BERReader<'a, 'c>) -> ASN1Result<T>,

Collects an ASN.1 SET OF value.

This function uses the loan pattern: callback is called back with a BERReader, from which the contents of the SET OF is read.

If you don’t like Vec, you can use read_set_of instead.

This function doesn’t sort the elements. In DER, it is assumed that the elements occur in an order determined by DER encodings of them.

Examples

use yasna;
let data = &[49, 7, 2, 1, 10, 2, 2, 255, 127];
let asn = yasna::parse_der(data, |reader| {
    reader.collect_set_of(|reader| {
        reader.read_i64()
    })
}).unwrap();
assert_eq!(asn, vec![10, -129]);

pub fn read_numeric_string(self) -> ASN1Result<String>

Reads an ASN.1 NumericString.

Examples

use yasna;
let data = &[18, 7, 49, 50, 56, 32, 50, 53, 54];
let asn = yasna::parse_der(data, |reader| {
    reader.read_numeric_string()
}).unwrap();
assert_eq!(&asn, "128 256");

pub fn read_printable_string(self) -> ASN1Result<String>

Reads an ASN.1 PrintableString.

Examples

use yasna;
let data = &[19, 9, 67, 111, 46, 44, 32, 76, 116, 100, 46];
let asn = yasna::parse_der(data, |reader| {
    reader.read_printable_string()
}).unwrap();
assert_eq!(&asn, "Co., Ltd.");

pub fn read_visible_string(self) -> ASN1Result<String>

Reads an ASN.1 VisibleString.

Examples

use yasna;
let data = &[26, 3, 72, 105, 33];
let asn = yasna::parse_der(data, |reader| {
    reader.read_visible_string()
}).unwrap();
assert_eq!(&asn, "Hi!");

pub fn read_tagged<T, F>(self, tag: Tag, callback: F) -> ASN1Result<T>where
F: for<'c> FnOnce(BERReader<'a, 'c>) -> ASN1Result<T>,

Reads a (explicitly) tagged value.

Examples

use yasna::{self,Tag};
let data = &[163, 3, 2, 1, 10];
let asn = yasna::parse_der(data, |reader| {
    reader.read_tagged(Tag::context(3), |reader| {
        reader.read_i64()
    })
}).unwrap();
assert_eq!(asn, 10);

pub fn read_tagged_implicit<T, F>(self, tag: Tag, callback: F) -> ASN1Result<T>where
F: for<'c> FnOnce(BERReader<'a, 'c>) -> ASN1Result<T>,

Reads an implicitly tagged value.

Examples

use yasna::{self,Tag};
let data = &[131, 1, 10];
let asn = yasna::parse_der(data, |reader| {
    reader.read_tagged_implicit(Tag::context(3), |reader| {
        reader.read_i64()
    })
}).unwrap();
assert_eq!(asn, 10);

pub fn lookahead_tag(&self) -> ASN1Result<Tag>

Lookaheads the tag in the next value. Used to parse CHOICE values.

Examples

use yasna;
use yasna::tags::*;
let data = &[48, 5, 2, 1, 10, 5, 0];
let asn = yasna::parse_der(data, |reader| {
    reader.collect_sequence_of(|reader| {
        let tag = try!(reader.lookahead_tag());
        let choice;
        if tag == TAG_INTEGER {
            choice = Some(try!(reader.read_i64()));
        } else {
            try!(reader.read_null());
            choice = None;
        }
        return Ok(choice);
    })
}).unwrap();
assert_eq!(&asn, &[Some(10), None]);

pub fn read_with_buffer<T, F>(self, callback: F) -> ASN1Result<(T, &'a [u8])>where
F: for<'c> FnOnce(BERReader<'a, 'c>) -> ASN1Result<T>,

Trait Implementations§

impl<'a, 'b> Debug for BERReader<'a, 'b>where
'a: 'b,

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

impl<'a, 'b> RefUnwindSafe for BERReader<'a, 'b>

impl<'a, 'b> Send for BERReader<'a, 'b>

impl<'a, 'b> Sync for BERReader<'a, 'b>

impl<'a, 'b> Unpin for BERReader<'a, 'b>where
'a: 'b,

impl<'a, 'b> !UnwindSafe for BERReader<'a, 'b>

Blanket Implementations§

impl<T> Any for Twhere
T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for Twhere
U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.