red_asn1 0.2.1

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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use crate::error::{Error, Result};
use nom::number::complete::be_u8;

pub fn build_length(value_size: usize) -> Vec<u8> {
    if value_size < 128 {
        return vec![value_size as u8];
    }

    let mut shifted_length = value_size;
    let mut octets_count: u8 = 0;
    let mut encoded_length: Vec<u8> = Vec::new();

    while shifted_length > 0 {
        octets_count += 1;
        encoded_length.push(shifted_length as u8);
        shifted_length >>= 8;
    }

    encoded_length.push(octets_count | 0b10000000);

    encoded_length.reverse();

    return encoded_length;
}

/// To parse the object value length from DER, should not be overwritten
pub fn parse_length(raw: &[u8]) -> Result<(&[u8], usize)> {
    let (mut raw, len_byte) =
        be_u8(raw).map_err(|_: nom::Err<(&[u8], nom::error::ErrorKind)>| {
            Error::LengthEmpty
        })?;

    let is_short_form = (len_byte & 0x80) == 0;
    let length = (len_byte & 0x7F) as usize;
    if is_short_form {
        return Ok((raw, length));
    }

    let length_of_length = length;
    let mut length = 0;

    for _ in 1..(length_of_length + 1) {
        length <<= 8;
        let (raw_tmp, len_byte) = be_u8(raw).map_err(
            |_: nom::Err<(&[u8], nom::error::ErrorKind)>| {
                Error::NotEnoughLengthOctects
            },
        )?;
        length += len_byte as usize;
        raw = raw_tmp;
    }
    return Ok((raw, length));
}

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

    #[test]
    fn test_build_length() {
        assert_eq!(vec![0x0], build_length(0));
        assert_eq!(vec![0x1], build_length(1));
        assert_eq!(vec![0x7F], build_length(127));
        assert_eq!(vec![0x81, 0x80], build_length(128));
        assert_eq!(vec![0x81, 0xFF], build_length(255));
        assert_eq!(vec![0x82, 0x01, 0x00], build_length(256));
        assert_eq!(vec![0x82, 0xFF, 0xFF], build_length(65535));
        assert_eq!(vec![0x83, 0x01, 0x00, 0x00], build_length(65536));

        assert_eq!(
            vec![0x84, 0x10, 0xf3, 0x91, 0xbd],
            build_length(0x10f391bd)
        );
        assert_eq!(vec![0x84, 0x0f, 0xc4, 0x69, 0x89], build_length(0xfc46989));
        assert_eq!(
            vec![0x84, 0x31, 0xb2, 0x50, 0x42],
            build_length(0x31b25042)
        );
        assert_eq!(
            vec![0x84, 0x13, 0x93, 0xaa, 0x93],
            build_length(0x1393aa93)
        );
        assert_eq!(vec![0x84, 0x05, 0x71, 0x6f, 0xa9], build_length(0x5716fa9));
    }

    #[test]
    fn test_parse_length() {
        let x: &[u8] = &[];
        assert_eq!((x, 0), parse_length(&[0x0]).unwrap());
        assert_eq!((x, 1), parse_length(&[0x1]).unwrap());
        assert_eq!((x, 127), parse_length(&[0x7F]).unwrap());
        assert_eq!((x, 128), parse_length(&[0x81, 0x80]).unwrap());
        assert_eq!((x, 255), parse_length(&[0x81, 0xFF]).unwrap());
        assert_eq!((x, 256), parse_length(&[0x82, 0x01, 0x00]).unwrap());
        assert_eq!((x, 65535), parse_length(&[0x82, 0xFF, 0xFF]).unwrap());
        assert_eq!(
            (x, 65536),
            parse_length(&[0x83, 0x01, 0x00, 0x00]).unwrap()
        );

        assert_eq!(
            (x, 0x10f391bd),
            parse_length(&[0x84, 0x10, 0xf3, 0x91, 0xbd]).unwrap()
        );
        assert_eq!(
            (x, 0xfc46989),
            parse_length(&[0x84, 0x0f, 0xc4, 0x69, 0x89]).unwrap()
        );
        assert_eq!(
            (x, 0x31b25042),
            parse_length(&[0x84, 0x31, 0xb2, 0x50, 0x42]).unwrap()
        );
        assert_eq!(
            (x, 0x1393aa93),
            parse_length(&[0x84, 0x13, 0x93, 0xaa, 0x93]).unwrap()
        );
        assert_eq!(
            (x, 0x5716fa9),
            parse_length(&[0x84, 0x05, 0x71, 0x6f, 0xa9]).unwrap()
        );
    }
}