1 use der_parser::ber::*;
2 use der_parser::der::*;
3 use der_parser::error::*;
4 use der_parser::oid::Oid;
5 use hex_literal::hex;
6 use nom::*;
7
8 #[test]
test_flat_take()9 fn test_flat_take() {
10 let empty = &b""[..];
11 assert_eq!(
12 parse_ber_bool(&[0x01, 0x01, 0xff]),
13 Ok((empty, BerObject::from_obj(BerObjectContent::Boolean(true))))
14 );
15 assert_eq!(
16 parse_ber_bool(&[0x01, 0x01, 0x00]),
17 Ok((empty, BerObject::from_obj(BerObjectContent::Boolean(false))))
18 );
19 assert_eq!(
20 ber_read_element_content_as(&[0xff], BerTag::Boolean, 0x01.into(), false, MAX_RECURSION),
21 Ok((empty, BerObjectContent::Boolean(true)))
22 );
23 assert_eq!(
24 ber_read_element_content_as(&[0x00], BerTag::Boolean, 0x01.into(), false, MAX_RECURSION),
25 Ok((empty, BerObjectContent::Boolean(false)))
26 );
27 }
28
29 #[test]
test_oid()30 fn test_oid() {
31 let empty = &b""[..];
32 assert_eq!(
33 parse_der(&[0x06, 0x06, 42, 129, 122, 1, 16, 9]),
34 Ok((
35 empty,
36 BerObject::from_obj(BerObjectContent::OID(
37 Oid::from(&[1, 2, 250, 1, 16, 9]).unwrap()
38 ))
39 ))
40 );
41 // Dubuisson 433
42 assert_eq!(
43 parse_der(&[0x0d, 0x05, 129, 122, 1, 16, 9]),
44 Ok((
45 empty,
46 BerObject::from_obj(BerObjectContent::RelativeOID(
47 Oid::from_relative(&[250, 1, 16, 9]).unwrap()
48 ))
49 ))
50 );
51 }
52
53 #[test]
test_rel_oid()54 fn test_rel_oid() {
55 let empty = &b""[..];
56 assert_eq!(
57 parse_der(&[0x0d, 0x04, 0xc2, 0x7b, 0x03, 0x02]),
58 Ok((
59 empty,
60 BerObject::from_obj(BerObjectContent::RelativeOID(
61 Oid::from_relative(&[8571, 3, 2]).unwrap()
62 ))
63 ))
64 );
65 }
66
67 #[rustfmt::skip::macros(oid)]
68 #[test]
test_oid_iter_length_check()69 fn test_oid_iter_length_check() {
70 use der_parser::oid;
71 use std::borrow::Cow;
72 // empty
73 assert!(Oid::new(Cow::Borrowed(&[])).iter().is_some());
74 assert!(Oid::new_relative(Cow::Borrowed(&[])).iter().is_some());
75 // ok
76 assert!(oid!(0).iter().is_some());
77 assert!(oid!(1.2).iter().is_some());
78 assert!(oid!(1.2.3456.23.54).iter().is_some());
79 // too long
80 assert!(oid!(1.2.18445618199572250625).iter().is_none());
81 assert!(oid!(rel 18445618199572250625).iter().is_none());
82 }
83
84 #[test]
test_unknown_tag()85 fn test_unknown_tag() {
86 let bytes = hex!("1d 01 00");
87 let res = parse_ber(&bytes).expect("parsing failed");
88 assert!(res.0.is_empty());
89 assert_eq!(
90 res.1,
91 BerObject::from_obj(BerObjectContent::Unknown(BerTag(0x1d), &bytes[2..]))
92 );
93 let res = parse_der(&bytes).expect("parsing failed");
94 assert!(res.0.is_empty());
95 assert_eq!(
96 res.1,
97 BerObject::from_obj(BerObjectContent::Unknown(BerTag(0x1d), &bytes[2..]))
98 );
99 }
100
101 #[test]
test_unknown_context_specific()102 fn test_unknown_context_specific() {
103 let bytes = hex!("80 01 00");
104 let res = parse_ber(&bytes).expect("parsing failed");
105 assert!(res.0.is_empty());
106 assert_eq!(
107 res.1,
108 BerObject {
109 header: BerObjectHeader::new(BerClass::ContextSpecific, 0, BerTag(0), 1)
110 .with_raw_tag(Some(&[0x80])),
111 content: BerObjectContent::Unknown(BerTag(0x0), &bytes[2..]),
112 }
113 );
114 }
115
116 #[test]
test_unknown_long_tag()117 fn test_unknown_long_tag() {
118 let bytes = hex!("9f 22 01 00");
119 let res = parse_ber(&bytes).expect("parsing failed");
120 assert!(res.0.is_empty());
121 assert_eq!(
122 res.1,
123 BerObject {
124 header: BerObjectHeader::new(BerClass::ContextSpecific, 0, BerTag(0x22), 1)
125 .with_raw_tag(Some(&[0x9f, 0x22])),
126 content: BerObjectContent::Unknown(BerTag(0x22), &bytes[3..]),
127 }
128 );
129 }
130
131 #[test]
test_unknown_longer_tag()132 fn test_unknown_longer_tag() {
133 let bytes = hex!("9f a2 22 01 00");
134 let res = parse_ber(&bytes).expect("parsing failed");
135 assert!(res.0.is_empty());
136 assert_eq!(
137 res.1,
138 BerObject {
139 header: BerObjectHeader::new(BerClass::ContextSpecific, 0, BerTag(0x1122), 1)
140 .with_raw_tag(Some(&[0x9f, 0xa2, 0x22])),
141 content: BerObjectContent::Unknown(BerTag(0x1122), &bytes[4..]),
142 }
143 );
144 }
145
146 #[test]
test_incomplete_tag()147 fn test_incomplete_tag() {
148 let bytes = hex!("9f a2 a2");
149 let res = parse_ber(&bytes);
150 assert!(res.is_err());
151 }
152
153 #[test]
test_overflow_tag()154 fn test_overflow_tag() {
155 let bytes = hex!("9f a2 a2 a2 a2 a2 22 01 00");
156 let res = parse_ber(&bytes);
157 assert!(res.is_err());
158 }
159
160 #[test]
test_incomplete_length()161 fn test_incomplete_length() {
162 let bytes = hex!("30");
163 let res = parse_ber(&bytes).err().expect("expected error");
164 assert_eq!(res, Err::Incomplete(Needed::new(1)));
165 let res = parse_der(&bytes).err().expect("expected error");
166 assert_eq!(res, Err::Incomplete(Needed::new(1)));
167 let bytes = hex!("02");
168 let res = parse_ber(&bytes).err().expect("expected error");
169 assert_eq!(res, Err::Incomplete(Needed::new(1)));
170 let bytes = hex!("02 05");
171 let _ = parse_ber(&bytes).err().expect("expected error");
172 let bytes = hex!("02 85");
173 let res = parse_ber(&bytes).err().expect("expected error");
174 assert_eq!(res, Err::Incomplete(Needed::new(5)));
175 let bytes = hex!("02 85 ff");
176 let res = parse_ber(&bytes).err().expect("expected error");
177 assert_eq!(res, Err::Incomplete(Needed::new(4)));
178 }
179
180 #[test]
test_invalid_length()181 fn test_invalid_length() {
182 let bytes = hex!("02 ff 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10");
183 let _ = parse_ber(&bytes).err().expect("expected error");
184 let _ = ber_read_element_header(&bytes)
185 .err()
186 .expect("expected error");
187 let bytes = hex!("02 85 ff ff ff ff ff 00");
188 let res = parse_ber(&bytes).expect_err("parsing should have returned error");
189 // get error
190 match res {
191 Err::Error(e) => {
192 assert_eq!(e, BerError::InvalidLength);
193 }
194 _ => panic!("not the expected nom error kind {:?}", res),
195 }
196 let bytes = hex!("02 02 00");
197 let res = parse_der(&bytes).err().expect("expected error");
198 assert_eq!(res, Err::Incomplete(Needed::new(2)));
199 }
200
201 #[test]
test_pretty_print()202 fn test_pretty_print() {
203 let bytes = hex!("01 01 ff");
204 let obj = parse_der(&bytes).map(|(_, b)| b).expect("expected error");
205 println!("{:?}", obj.as_pretty(0, 2));
206
207 // controlling the pretty-printer
208 let mut pp = obj.as_pretty(0, 4);
209 pp.set_flag(PrettyPrinterFlag::ShowHeader);
210 println!("{:?}", pp);
211 }
212