rasn 0.28.4

A safe no_std ASN.1 codec framework.
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use rasn::prelude::*;

#[derive(AsnType, Decode, Debug, Encode, PartialEq)]
#[rasn(tag(explicit(application, 1)), delegate)]
pub struct DelegateSequence(pub Sequence);

#[derive(AsnType, Decode, Debug, Encode, PartialEq)]
pub struct Sequence {
    b: bool,
}

#[derive(AsnType, Decode, Debug, Encode, PartialEq)]
pub struct SequenceWithDefault {
    #[rasn(tag(explicit(application, 1)), default = "default_bool")]
    b: bool,
}

#[derive(AsnType, Decode, Debug, Encode, PartialEq)]
pub struct SequenceWithMultiDefault {
    #[rasn(tag(explicit(application, 1)), default = "default_bool")]
    b: bool,
    #[rasn(tag(explicit(application, 2)), default = "default_bool")]
    b2: bool,
}
pub fn default_bool() -> bool {
    true
}

#[derive(AsnType, Decode, Debug, Encode, PartialEq)]
#[rasn(tag(explicit(application, 1)))]
pub struct InlineSequence {
    b: bool,
}

#[derive(AsnType, Decode, Debug, Encode, PartialEq)]
#[rasn(tag(application, 1))]
pub struct SequenceField {
    #[rasn(tag(explicit(universal, 16)))]
    b: bool,
}

#[derive(AsnType, Decode, Debug, Encode, PartialEq)]
#[rasn(set, tag(explicit(application, 1)))]
pub struct InlineSet {
    b: bool,
}

#[derive(AsnType, Decode, Debug, Encode, PartialEq)]
#[rasn(set, tag(application, 1))]
pub struct SetField {
    #[rasn(tag(explicit(universal, 16)))]
    b: bool,
}

#[derive(AsnType, Decode, Debug, Encode, PartialEq)]
#[rasn(choice)]
pub enum DelegateChoice {
    #[rasn(tag(explicit(application, 1)))]
    Sequence(Sequence),
}

#[derive(AsnType, Decode, Debug, Encode, PartialEq)]
#[rasn(choice)]
pub enum InlineChoice {
    #[rasn(tag(explicit(application, 1)))]
    Sequence { b: bool },
}

#[derive(AsnType, Decode, Debug, Encode, PartialEq)]
#[rasn(choice, tag(explicit(application, 1)))]
pub enum WrappedChoice {
    Sequence { b: bool },
}

const _: () = assert!(Tag::const_eq(
    DelegateSequence::TAG,
    &Tag::new(Class::Application, 1)
));

const _: () = assert!(Tag::const_eq(DelegateSequence::TAG, &InlineSequence::TAG,));

const _: () = assert!(Tag::const_eq(DelegateSequence::TAG, &InlineSet::TAG,));

#[test]
fn works() {
    const EXPECTED: &[u8] = &[0x61, 0x5, 0x30, 0x3, 0x01, 0x1, 0xFF];
    // Note that the explicitly tagged field is dropped.
    // This makes it a sequence with 0 elements
    const EXPECTED_DEFAULT: &[u8] = &[0x30, 0x00];
    const EXPECTED_NOT_DEFAULT: &[u8] = &[0x30, 0x05, 0x61, 0x03, 0x01, 0x01, 0x00];
    // NOTE: The explicit tag number is just different
    const EXPECTED_MULTI_DEFAULT: &[u8] = &[0x30, 0x05, 0x62, 0x03, 0x01, 0x01, 0x00];
    // This version of the output is what would be generated without a default check.
    // Using this for backward compat. verification
    const EXPECTED_MULTI_DEFAULT_FIELD_ENCODED: &[u8] = &[
        0x30, 0x0a, 0x61, 0x03, 0x01, 0x01, 0xff, 0x62, 0x03, 0x01, 0x01, 0x00,
    ];

    let delegate_seq = DelegateSequence(Sequence { b: true });
    let inline_seq = InlineSequence { b: true };
    let field_seq = SequenceField { b: true };
    let field_set = SetField { b: true };
    let inline_set = InlineSet { b: true };
    let delegate_choice = DelegateChoice::Sequence(Sequence { b: true });
    let inline_choice = InlineChoice::Sequence { b: true };
    let wrapped_choice = WrappedChoice::Sequence { b: true };
    let delegate_seq_enc = rasn::der::encode(&delegate_seq).unwrap();
    let inline_seq_enc = rasn::der::encode(&inline_seq).unwrap();
    let field_seq_enc = rasn::der::encode(&field_seq).unwrap();
    let field_set_enc = rasn::der::encode(&field_set).unwrap();
    let inline_set_enc = rasn::der::encode(&inline_set).unwrap();
    let delegate_choice_enc = rasn::der::encode(&delegate_choice).unwrap();
    let inline_choice_enc = rasn::der::encode(&inline_choice).unwrap();
    let wrapped_choice_enc = rasn::der::encode(&wrapped_choice).unwrap();

    // Set the field to match the default value to have it dropped
    let sequence_default = SequenceWithDefault { b: true };
    let sequence_non_default = SequenceWithDefault { b: false };
    let sequence_default_enc = rasn::der::encode(&sequence_default).unwrap();
    let sequence_non_default_enc = rasn::der::encode(&sequence_non_default).unwrap();
    // Verify it correctly includes encoded fields
    let sequence_multi_default = SequenceWithMultiDefault { b: true, b2: false };
    let sequence_multi_default_enc = rasn::der::encode(&sequence_multi_default).unwrap();

    assert_eq!(sequence_non_default_enc, EXPECTED_NOT_DEFAULT);
    assert_eq!(sequence_default_enc, EXPECTED_DEFAULT);
    assert_eq!(sequence_multi_default_enc, EXPECTED_MULTI_DEFAULT);
    assert_eq!(
        sequence_multi_default,
        rasn::der::decode(&sequence_multi_default_enc).unwrap()
    );
    assert_eq!(
        sequence_multi_default,
        rasn::der::decode(EXPECTED_MULTI_DEFAULT_FIELD_ENCODED).unwrap()
    );
    assert_eq!(delegate_seq_enc, EXPECTED);
    assert_eq!(inline_seq_enc, EXPECTED);
    assert_eq!(field_seq_enc, EXPECTED);
    assert_eq!(field_set_enc, EXPECTED);
    assert_eq!(inline_set_enc, EXPECTED);
    assert_eq!(delegate_choice_enc, EXPECTED);
    assert_eq!(inline_choice_enc, EXPECTED);
    assert_eq!(wrapped_choice_enc, EXPECTED);
    assert_eq!(delegate_seq, rasn::der::decode(EXPECTED).unwrap());
    assert_eq!(inline_seq, rasn::der::decode(EXPECTED).unwrap());
    assert_eq!(field_seq, rasn::der::decode(EXPECTED).unwrap());
    assert_eq!(field_set, rasn::der::decode(EXPECTED).unwrap());
    assert_eq!(inline_set, rasn::der::decode(EXPECTED).unwrap());
    assert_eq!(delegate_choice, rasn::der::decode(EXPECTED).unwrap());
    assert_eq!(inline_choice, rasn::der::decode(EXPECTED).unwrap());
    assert_eq!(wrapped_choice, rasn::der::decode(EXPECTED).unwrap());
}