lber 0.5.1

An ASN.1/BER parser/encoder based on nom
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

use super::ASNTag;
use crate::common::TagClass;
use crate::structure;
use crate::universal;

use std::default;

/// Integer value.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Integer {
    pub id: u64,
    pub class: TagClass,
    pub inner: i64,
}

/// Integer with a different tag.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Enumerated {
    pub id: u64,
    pub class: TagClass,
    pub inner: i64,
}

fn i_e_into_structure(id: u64, class: TagClass, inner: i64) -> structure::StructureTag {
    let mut count = 0u8;
    let mut rem: i64 = if inner >= 0 { inner } else { -inner };
    while {
        count += 1;
        rem >>= 8;
        rem > 0
    } {}

    // Ensure that the most significant bit is always 0, because BER uses signed numbers.
    // We shift away all but the most significant bit and check that.
    // See #21
    if inner > 0 && inner >> ((8 * count) - 1) == 1 {
        count += 1;
    }

    let mut count = count as usize;
    let mut out: Vec<u8> = Vec::with_capacity(count);
    let repr = inner.to_be_bytes();
    if count > repr.len() {
        out.push(0);
        count -= 1;
    }
    out.extend_from_slice(&repr[repr.len() - count..]);

    structure::StructureTag {
        id,
        class,
        payload: structure::PL::P(out),
    }
}

impl ASNTag for Integer {
    fn into_structure(self) -> structure::StructureTag {
        i_e_into_structure(self.id, self.class, self.inner)
    }
}

impl ASNTag for Enumerated {
    fn into_structure(self) -> structure::StructureTag {
        i_e_into_structure(self.id, self.class, self.inner)
    }
}

impl default::Default for Integer {
    fn default() -> Integer {
        Integer {
            id: universal::Types::Integer as u64,
            class: TagClass::Universal,
            inner: 0i64,
        }
    }
}

impl default::Default for Enumerated {
    fn default() -> Enumerated {
        Enumerated {
            id: universal::Types::Enumerated as u64,
            class: TagClass::Universal,
            inner: 0i64,
        }
    }
}

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

    use crate::common::TagClass;
    use crate::structure;

    #[test]
    fn test_not_unnecessary_octets() {
        // 127 can be encoded into 8 bits
        let result = i_e_into_structure(2, TagClass::Universal, 127);
        let correct = structure::PL::P(vec![127]);
        assert_eq![result.payload, correct];
    }

    #[test]
    fn test_not_positive_getting_negative() {
        // 128 can be encoded cannot be encoded into a 8 bit signed number
        // See #21
        let result = i_e_into_structure(2, TagClass::Universal, 128);
        let correct = structure::PL::P(vec![0, 128]);
        assert_eq![result.payload, correct];
    }
}