1 use der_parser::ber::*;
2 use der_parser::der::*;
3 use der_parser::error::*;
4 use der_parser::*;
5 use hex_literal::hex;
6 use nom::branch::alt;
7 use nom::combinator::{complete, eof, map, map_res};
8 use nom::error::ErrorKind;
9 use nom::multi::many0;
10 use nom::sequence::tuple;
11 use nom::*;
12 use oid::Oid;
13 use pretty_assertions::assert_eq;
14 use test_case::test_case;
15
16 #[derive(Debug, PartialEq)]
17 struct MyStruct<'a> {
18 a: BerObject<'a>,
19 b: BerObject<'a>,
20 }
21
parse_struct01(i: &[u8]) -> BerResult<MyStruct>22 fn parse_struct01(i: &[u8]) -> BerResult<MyStruct> {
23 parse_der_sequence_defined_g(|i: &[u8], _| {
24 let (i, a) = parse_ber_integer(i)?;
25 let (i, b) = parse_ber_integer(i)?;
26 Ok((i, MyStruct { a, b }))
27 })(i)
28 }
29
parse_struct01_complete(i: &[u8]) -> BerResult<MyStruct>30 fn parse_struct01_complete(i: &[u8]) -> BerResult<MyStruct> {
31 parse_der_sequence_defined_g(|i: &[u8], _| {
32 let (i, a) = parse_ber_integer(i)?;
33 let (i, b) = parse_ber_integer(i)?;
34 eof(i)?;
35 Ok((i, MyStruct { a, b }))
36 })(i)
37 }
38
39 // verifying tag
parse_struct04(i: &[u8], tag: BerTag) -> BerResult<MyStruct>40 fn parse_struct04(i: &[u8], tag: BerTag) -> BerResult<MyStruct> {
41 parse_der_container(|i: &[u8], hdr| {
42 if hdr.tag != tag {
43 return Err(Err::Error(BerError::InvalidTag));
44 }
45 let (i, a) = parse_ber_integer(i)?;
46 let (i, b) = parse_ber_integer(i)?;
47 eof(i)?;
48 Ok((i, MyStruct { a, b }))
49 })(i)
50 }
51
52 #[test_case(&hex!("30 00"), Ok(&[]) ; "empty seq")]
53 #[test_case(&hex!("30 0a 02 03 01 00 01 02 03 01 00 00"), Ok(&[0x10001, 0x10000]) ; "seq ok")]
54 #[test_case(&hex!("30 07 02 03 01 00 01 02 03 01"), Err(Err::Error(BerError::NomError(ErrorKind::Eof))) ; "incomplete")]
55 #[test_case(&hex!("31 0a 02 03 01 00 01 02 03 01 00 00"), Err(Err::Error(BerError::InvalidTag)) ; "invalid tag")]
56 #[test_case(&hex!("30 80 02 03 01 00 01 00 00"), Ok(&[0x10001]) ; "indefinite seq ok")]
57 #[test_case(&hex!("30 80"), Err(Err::Incomplete(Needed::new(1))) ; "indefinite incomplete")]
tc_ber_seq_of(i: &[u8], out: Result<&[u32], Err<BerError>>)58 fn tc_ber_seq_of(i: &[u8], out: Result<&[u32], Err<BerError>>) {
59 fn parser(i: &[u8]) -> BerResult {
60 parse_ber_sequence_of(parse_ber_integer)(i)
61 }
62 let res = parser(i);
63 match out {
64 Ok(l) => {
65 let (rem, res) = res.expect("could not parse sequence of");
66 assert!(rem.is_empty());
67 if let BerObjectContent::Sequence(res) = res.content {
68 pretty_assertions::assert_eq!(res.len(), l.len());
69 for (a, b) in res.iter().zip(l.iter()) {
70 pretty_assertions::assert_eq!(a.as_u32().unwrap(), *b);
71 }
72 } else {
73 panic!("wrong type for parsed object");
74 }
75 }
76 Err(e) => {
77 pretty_assertions::assert_eq!(res, Err(e));
78 }
79 }
80 }
81
82 #[test_case(&hex!("30 0a 02 03 01 00 01 02 03 01 00 00"), Ok(&[0x10001, 0x10000]) ; "seq ok")]
83 #[test_case(&hex!("30 07 02 03 01 00 01 02 01"), Err(Err::Incomplete(Needed::new(1))) ; "incomplete")]
84 #[test_case(&hex!("31 0a 02 03 01 00 01 02 03 01 00 00"), Err(Err::Error(BerError::InvalidTag)) ; "invalid tag")]
85 #[test_case(&hex!("30 80 02 03 01 00 01 02 03 01 00 00 00 00"), Ok(&[0x10001, 0x10000]) ; "indefinite seq")]
tc_ber_seq_defined(i: &[u8], out: Result<&[u32], Err<BerError>>)86 fn tc_ber_seq_defined(i: &[u8], out: Result<&[u32], Err<BerError>>) {
87 fn parser(i: &[u8]) -> BerResult<BerObject> {
88 parse_ber_sequence_defined(map(
89 tuple((parse_ber_integer, parse_ber_integer)),
90 |(a, b)| vec![a, b],
91 ))(i)
92 }
93 let res = parser(i);
94 match out {
95 Ok(l) => {
96 let (rem, res) = res.expect("could not parse sequence");
97 assert!(rem.is_empty());
98 if let BerObjectContent::Sequence(res) = res.content {
99 pretty_assertions::assert_eq!(res.len(), l.len());
100 for (a, b) in res.iter().zip(l.iter()) {
101 pretty_assertions::assert_eq!(a.as_u32().unwrap(), *b);
102 }
103 } else {
104 panic!("wrong type for parsed object");
105 }
106 }
107 Err(e) => {
108 pretty_assertions::assert_eq!(res, Err(e));
109 }
110 }
111 }
112
113 #[test_case(&hex!("31 00"), Ok(&[]) ; "empty set")]
114 #[test_case(&hex!("31 0a 02 03 01 00 01 02 03 01 00 00"), Ok(&[0x10001, 0x10000]) ; "set ok")]
115 #[test_case(&hex!("31 07 02 03 01 00 01 02 03 01"), Err(Err::Error(BerError::NomError(ErrorKind::Eof))) ; "incomplete")]
116 #[test_case(&hex!("30 0a 02 03 01 00 01 02 03 01 00 00"), Err(Err::Error(BerError::InvalidTag)) ; "invalid tag")]
117 #[test_case(&hex!("31 80 02 03 01 00 01 00 00"), Ok(&[0x10001]) ; "indefinite set ok")]
118 #[test_case(&hex!("31 80"), Err(Err::Incomplete(Needed::new(1))) ; "indefinite incomplete")]
tc_ber_set_of(i: &[u8], out: Result<&[u32], Err<BerError>>)119 fn tc_ber_set_of(i: &[u8], out: Result<&[u32], Err<BerError>>) {
120 fn parser(i: &[u8]) -> BerResult {
121 parse_ber_set_of(parse_ber_integer)(i)
122 }
123 let res = parser(i);
124 match out {
125 Ok(l) => {
126 let (rem, res) = res.expect("could not parse set of");
127 assert!(rem.is_empty());
128 if let BerObjectContent::Set(res) = res.content {
129 pretty_assertions::assert_eq!(res.len(), l.len());
130 for (a, b) in res.iter().zip(l.iter()) {
131 pretty_assertions::assert_eq!(a.as_u32().unwrap(), *b);
132 }
133 } else {
134 panic!("wrong type for parsed object");
135 }
136 }
137 Err(e) => {
138 pretty_assertions::assert_eq!(res, Err(e));
139 }
140 }
141 }
142
143 #[test_case(&hex!("31 0a 02 03 01 00 01 02 03 01 00 00"), Ok(&[0x10001, 0x10000]) ; "set ok")]
144 #[test_case(&hex!("31 07 02 03 01 00 01 02 01"), Err(Err::Incomplete(Needed::new(1))) ; "incomplete")]
145 #[test_case(&hex!("30 0a 02 03 01 00 01 02 03 01 00 00"), Err(Err::Error(BerError::InvalidTag)) ; "invalid tag")]
146 #[test_case(&hex!("31 80 02 03 01 00 01 02 03 01 00 00 00 00"), Ok(&[0x10001, 0x10000]) ; "indefinite set")]
tc_ber_set_defined(i: &[u8], out: Result<&[u32], Err<BerError>>)147 fn tc_ber_set_defined(i: &[u8], out: Result<&[u32], Err<BerError>>) {
148 fn parser(i: &[u8]) -> BerResult<BerObject> {
149 parse_ber_set_defined(map(
150 tuple((parse_ber_integer, parse_ber_integer)),
151 |(a, b)| vec![a, b],
152 ))(i)
153 }
154 let res = parser(i);
155 match out {
156 Ok(l) => {
157 let (rem, res) = res.expect("could not parse set");
158 assert!(rem.is_empty());
159 if let BerObjectContent::Set(res) = res.content {
160 pretty_assertions::assert_eq!(res.len(), l.len());
161 for (a, b) in res.iter().zip(l.iter()) {
162 pretty_assertions::assert_eq!(a.as_u32().unwrap(), *b);
163 }
164 } else {
165 panic!("wrong type for parsed object");
166 }
167 }
168 Err(e) => {
169 pretty_assertions::assert_eq!(res, Err(e));
170 }
171 }
172 }
173 #[test]
empty_seq()174 fn empty_seq() {
175 let data = &hex!("30 00");
176 let (_, res) = parse_ber_sequence(data).expect("parsing empty sequence failed");
177 assert!(res.as_sequence().unwrap().is_empty());
178 }
179
180 #[test]
struct01()181 fn struct01() {
182 let bytes = [
183 0x30, 0x0a, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x03, 0x01, 0x00, 0x00,
184 ];
185 let empty = &b""[..];
186 let expected = MyStruct {
187 a: BerObject::from_int_slice(b"\x01\x00\x01"),
188 b: BerObject::from_int_slice(b"\x01\x00\x00"),
189 };
190 let res = parse_struct01(&bytes);
191 assert_eq!(res, Ok((empty, expected)));
192 }
193
194 #[test]
struct02()195 fn struct02() {
196 let empty = &b""[..];
197 let bytes = [
198 0x30, 0x45, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x46, 0x52,
199 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0a, 0x53, 0x6f, 0x6d, 0x65,
200 0x2d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x31, 0x21, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x04, 0x0a,
201 0x16, 0x18, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x20, 0x57, 0x69, 0x64, 0x67,
202 0x69, 0x74, 0x73, 0x20, 0x50, 0x74, 0x79, 0x20, 0x4c, 0x74, 0x64,
203 ];
204 #[derive(Debug, PartialEq)]
205 struct Attr<'a> {
206 oid: Oid<'a>,
207 val: BerObject<'a>,
208 }
209 #[derive(Debug, PartialEq)]
210 struct Rdn<'a> {
211 a: Attr<'a>,
212 }
213 #[derive(Debug, PartialEq)]
214 struct Name<'a> {
215 l: Vec<Rdn<'a>>,
216 }
217 let expected = Name {
218 l: vec![
219 Rdn {
220 a: Attr {
221 oid: Oid::from(&[2, 5, 4, 6]).unwrap(), // countryName
222 val: BerObject::from_obj(BerObjectContent::PrintableString("FR")),
223 },
224 },
225 Rdn {
226 a: Attr {
227 oid: Oid::from(&[2, 5, 4, 8]).unwrap(), // stateOrProvinceName
228 val: BerObject::from_obj(BerObjectContent::UTF8String("Some-State")),
229 },
230 },
231 Rdn {
232 a: Attr {
233 oid: Oid::from(&[2, 5, 4, 10]).unwrap(), // organizationName
234 val: BerObject::from_obj(BerObjectContent::IA5String(
235 "Internet Widgits Pty Ltd",
236 )),
237 },
238 },
239 ],
240 };
241 fn parse_directory_string(i: &[u8]) -> BerResult {
242 alt((
243 parse_ber_utf8string,
244 parse_ber_printablestring,
245 parse_ber_ia5string,
246 ))(i)
247 }
248 fn parse_attr_type_and_value(i: &[u8]) -> BerResult<Attr> {
249 fn clone_oid(x: BerObject) -> Result<Oid, BerError> {
250 x.as_oid().map(|o| o.clone())
251 }
252 parse_der_sequence_defined_g(|i: &[u8], _| {
253 let (i, o) = map_res(parse_ber_oid, clone_oid)(i)?;
254 let (i, s) = parse_directory_string(i)?;
255 Ok((i, Attr { oid: o, val: s }))
256 })(i)
257 }
258 fn parse_rdn(i: &[u8]) -> BerResult<Rdn> {
259 parse_der_set_defined_g(|i: &[u8], _| {
260 let (i, a) = parse_attr_type_and_value(i)?;
261 Ok((i, Rdn { a }))
262 })(i)
263 }
264 fn parse_name(i: &[u8]) -> BerResult<Name> {
265 parse_der_sequence_defined_g(|i: &[u8], _| {
266 let (i, l) = many0(complete(parse_rdn))(i)?;
267 Ok((i, Name { l }))
268 })(i)
269 }
270 let parsed = parse_name(&bytes).unwrap();
271 assert_eq!(parsed, (empty, expected));
272 //
273 assert_eq!(parsed.1.l[0].a.val.as_str(), Ok("FR"));
274 assert_eq!(parsed.1.l[1].a.val.as_str(), Ok("Some-State"));
275 assert_eq!(parsed.1.l[2].a.val.as_str(), Ok("Internet Widgits Pty Ltd"));
276 }
277
278 #[test]
struct_with_garbage()279 fn struct_with_garbage() {
280 let bytes = [
281 0x30, 0x0c, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x03, 0x01, 0x00, 0x00, 0xff, 0xff,
282 ];
283 let empty = &b""[..];
284 let expected = MyStruct {
285 a: BerObject::from_int_slice(b"\x01\x00\x01"),
286 b: BerObject::from_int_slice(b"\x01\x00\x00"),
287 };
288 assert_eq!(parse_struct01(&bytes), Ok((empty, expected)));
289 assert_eq!(
290 parse_struct01_complete(&bytes),
291 Err(Err::Error(error_position!(&bytes[12..], ErrorKind::Eof)))
292 );
293 }
294
295 #[test]
struct_verify_tag()296 fn struct_verify_tag() {
297 let bytes = [
298 0x30, 0x0a, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x03, 0x01, 0x00, 0x00,
299 ];
300 let empty = &b""[..];
301 let expected = MyStruct {
302 a: BerObject::from_int_slice(b"\x01\x00\x01"),
303 b: BerObject::from_int_slice(b"\x01\x00\x00"),
304 };
305 let res = parse_struct04(&bytes, BerTag::Sequence);
306 assert_eq!(res, Ok((empty, expected)));
307 let res = parse_struct04(&bytes, BerTag::Set);
308 assert_eq!(res, Err(Err::Error(BerError::InvalidTag)));
309 }
310
311 #[test_case(&hex!("a2 05 02 03 01 00 01"), Ok(0x10001) ; "tag ok")]
312 #[test_case(&hex!("a2 80 02 03 01 00 01 00 00"), Ok(0x10001) ; "indefinite tag ok")]
313 #[test_case(&hex!("a3 05 02 03 01 00 01"), Err(BerError::InvalidTag) ; "invalid tag")]
314 #[test_case(&hex!("22 05 02 03 01 00 01"), Err(BerError::InvalidClass) ; "invalid class")]
315 #[test_case(&hex!("82 05 02 03 01 00 01"), Err(BerError::ConstructExpected) ; "construct expected")]
tc_ber_tagged_explicit_g(i: &[u8], out: Result<u32, BerError>)316 fn tc_ber_tagged_explicit_g(i: &[u8], out: Result<u32, BerError>) {
317 fn parse_int_explicit(i: &[u8]) -> BerResult<u32> {
318 parse_ber_tagged_explicit_g(2, move |content, _hdr| {
319 let (rem, obj) = parse_ber_integer(content)?;
320 let value = obj.as_u32()?;
321 Ok((rem, value))
322 })(i)
323 }
324 let res = parse_int_explicit(i);
325 match out {
326 Ok(expected) => {
327 pretty_assertions::assert_eq!(res, Ok((&b""[..], expected)));
328 }
329 Err(e) => {
330 pretty_assertions::assert_eq!(res, Err(Err::Error(e)));
331 }
332 }
333 }
334
335 #[test]
tagged_explicit()336 fn tagged_explicit() {
337 fn parse_int_explicit(i: &[u8]) -> BerResult<u32> {
338 map_res(
339 parse_der_tagged_explicit(2, parse_der_integer),
340 |x: BerObject| x.as_tagged()?.2.as_u32(),
341 )(i)
342 }
343 let bytes = &[0xa2, 0x05, 0x02, 0x03, 0x01, 0x00, 0x01];
344 // EXPLICIT tagged value parsing
345 let (rem, val) = parse_int_explicit(bytes).expect("Could not parse explicit int");
346 assert!(rem.is_empty());
347 assert_eq!(val, 0x10001);
348 // wrong tag
349 assert_eq!(
350 parse_der_tagged_explicit(3, parse_der_integer)(bytes as &[u8]),
351 Err(Err::Error(BerError::InvalidTag))
352 );
353 // wrong type
354 assert_eq!(
355 parse_der_tagged_explicit(2, parse_der_bool)(bytes as &[u8]),
356 Err(Err::Error(BerError::InvalidTag))
357 );
358 }
359
360 #[test_case(&hex!("82 03 01 00 01"), Ok(0x10001) ; "tag ok")]
361 #[test_case(&hex!("83 03 01 00 01"), Err(BerError::InvalidTag) ; "invalid tag")]
tc_ber_tagged_implicit_g(i: &[u8], out: Result<u32, BerError>)362 fn tc_ber_tagged_implicit_g(i: &[u8], out: Result<u32, BerError>) {
363 fn parse_int_implicit(i: &[u8]) -> BerResult<u32> {
364 parse_ber_tagged_implicit_g(2, |content, hdr, depth| {
365 let (rem, obj) = parse_ber_content(BerTag::Integer)(content, &hdr, depth)?;
366 let value = obj.as_u32()?;
367 Ok((rem, value))
368 })(i)
369 }
370 let res = parse_int_implicit(i);
371 match out {
372 Ok(expected) => {
373 pretty_assertions::assert_eq!(res, Ok((&b""[..], expected)));
374 }
375 Err(e) => {
376 pretty_assertions::assert_eq!(res, Err(Err::Error(e)));
377 }
378 }
379 }
380
381 #[test]
tagged_implicit()382 fn tagged_implicit() {
383 fn parse_int_implicit(i: &[u8]) -> BerResult<u32> {
384 map_res(
385 parse_der_tagged_implicit(2, parse_der_content(DerTag::Integer)),
386 |x: BerObject| x.as_u32(),
387 )(i)
388 }
389 let bytes = &[0x82, 0x03, 0x01, 0x00, 0x01];
390 // IMPLICIT tagged value parsing
391 let (rem, val) = parse_int_implicit(bytes).expect("could not parse implicit int");
392 assert!(rem.is_empty());
393 assert_eq!(val, 0x10001);
394 // wrong tag
395 assert_eq!(
396 parse_der_tagged_implicit(3, parse_der_content(DerTag::Integer))(bytes as &[u8]),
397 Err(Err::Error(BerError::InvalidTag))
398 );
399 }
400
401 #[test]
application()402 fn application() {
403 #[derive(Debug, PartialEq)]
404 struct SimpleStruct {
405 a: u32,
406 }
407 fn parse_app01(i: &[u8]) -> BerResult<SimpleStruct> {
408 parse_der_container(|i, hdr| {
409 if hdr.class != BerClass::Application {
410 return Err(Err::Error(BerError::InvalidClass));
411 }
412 if hdr.tag != BerTag(2) {
413 return Err(Err::Error(BerError::InvalidTag));
414 }
415 let (i, a) = map_res(parse_ber_integer, |x: BerObject| x.as_u32())(i)?;
416 Ok((i, SimpleStruct { a }))
417 })(i)
418 }
419 let bytes = &[0x62, 0x05, 0x02, 0x03, 0x01, 0x00, 0x01];
420 let (rem, app) = parse_app01(bytes).expect("could not parse application");
421 assert!(rem.is_empty());
422 assert_eq!(app, SimpleStruct { a: 0x10001 });
423 }
424
425 #[test]
426 #[ignore = "not yet implemented"]
ber_constructed_string()427 fn ber_constructed_string() {
428 // this encoding is equivalent to "04 05 01 AB 23 7F CA"
429 let data = &hex!(
430 "
431 24 80
432 04 02 01 ab
433 04 02 23 7f
434 04 01 ca
435 00 00"
436 );
437 let _ = parse_ber_octetstring(data).expect("parsing failed");
438 }
439