red_asn1 0.4.6

A little library to encode/decode ASN1 DER
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use crate::tag::{Tag, TagClass};
use crate::error as asn1err;
use crate::length::{build_length, parse_length};

/// A trait to allow objects to be built/parsed from ASN1-DER
pub trait Asn1Object: Sized + Default {

    /// Method to retrieve the tag of the object, used to identify each object in ASN1
    fn tag() -> Tag;

    /// Method which indicates how object value must be built
    fn build_value(&self) -> Vec<u8>;

    /// Method which indicates how object value must be parsed
    fn parse_value(&mut self, raw: &[u8]) -> asn1err::Result<()>;

    /// To encode the object to DER, generally does not need to be overwritten.
    /// Usually, just encode_value should be overwritten
    fn build(&self) -> Vec<u8> {
        let mut encoded = Self::tag().build();
        let mut encoded_length_value = self.build_length_value();
        encoded.append(&mut encoded_length_value);
        return encoded;
    }

    /// To just build the length and value, in case the type tag is not used
    /// like in case of implicit tag
    fn build_length_value(&self) -> Vec<u8> {
        let mut encoded_value = self.build_value();
        let mut encoded_length = build_length(encoded_value.len());

        let mut encoded = Vec::new();
        encoded.append(&mut encoded_length);
        encoded.append(&mut encoded_value);

        return encoded;
    }

    /// To parse the object from DER, generally does not need to be overwritten.
    /// Usually, just parse_value should be overwritten
    fn parse(raw: &[u8]) -> asn1err::Result<(&[u8], Self)> {
        let (raw, parsed_tag) = Tag::parse(raw)?;
        if parsed_tag != Self::tag() {
            return Err(asn1err::Error::UnmatchedTag(TagClass::Universal))?;
        }

        return Self::parse_length_value(raw);
    }

    /// To just parse the length and value, in case the the type tag is not used
    /// like in case of implicit tag
    fn parse_length_value(raw: &[u8]) -> asn1err::Result<(&[u8], Self)> {
        let (raw, length) = parse_length(raw)?;
        if length > raw.len() {
            return Err(asn1err::Error::NoDataForLength)?;
        }

        let (raw_value, raw) = raw.split_at(length);
        let mut asn1obj = Self::default();
        asn1obj.parse_value(raw_value)?;

        return Ok((raw, asn1obj));
    }

}


#[cfg(test)]
mod tests {
    use super::*;

    #[derive(Default)]
    struct TestObject {
    }

    impl TestObject {}

    impl Asn1Object for TestObject {
        fn tag() -> Tag {
            return Tag::default();
        }
        fn build_value(&self) -> Vec<u8> {
            return vec![];
        }

        fn parse_value(&mut self, _raw: &[u8]) -> asn1err::Result<()> {
            return Ok(());
        }

    }

    #[should_panic (expected = "NoDataForLength")]
    #[test]
    fn test_parse_with_excesive_length_for_data() {
        TestObject::parse(&[0x0, 0x3, 0x0]).unwrap();
    }

}