1 #![allow(deprecated)]
2
3 use der_parser::ber::*;
4 use der_parser::der::*;
5 use der_parser::error::*;
6 use der_parser::oid::*;
7 use der_parser::*;
8 use hex_literal::hex;
9 use nom::branch::alt;
10 use nom::combinator::map;
11 use nom::error::ErrorKind;
12 use nom::sequence::tuple;
13 use nom::Err;
14 use pretty_assertions::assert_eq;
15 use test_case::test_case;
16
17 #[test]
test_der_bool()18 fn test_der_bool() {
19 let empty = &b""[..];
20 let b_true = DerObject::from_obj(BerObjectContent::Boolean(true));
21 let b_false = DerObject::from_obj(BerObjectContent::Boolean(false));
22 assert_eq!(parse_der_bool(&[0x01, 0x01, 0x00]), Ok((empty, b_false)));
23 assert_eq!(parse_der_bool(&[0x01, 0x01, 0xff]), Ok((empty, b_true)));
24 assert_eq!(
25 parse_der_bool(&[0x01, 0x01, 0x7f]),
26 Err(Err::Error(BerError::DerConstraintFailed))
27 );
28 }
29
30 #[test]
test_der_int()31 fn test_der_int() {
32 let empty = &b""[..];
33 let bytes = hex!("02 03 01 00 01");
34 let expected = DerObject::from_obj(BerObjectContent::Integer(b"\x01\x00\x01"));
35 assert_eq!(parse_der_integer(&bytes), Ok((empty, expected)));
36 let res = parse_der_u64(&bytes);
37 assert_eq!(res.expect("integer").1, 0x10001);
38 // wrong tag
39 let bytes = hex!("04 03 41 41 41");
40 let res = parse_der_integer(&bytes);
41 assert!(res.is_err());
42 let res = parse_der_u64(&bytes);
43 assert!(res.is_err());
44 // very long integer
45 let bytes = hex!("02 0b 40 41 02 03 04 05 06 07 08 09 0a");
46 let res = parse_der_integer(&bytes);
47 assert!(res.is_ok());
48 let res = parse_der_u64(&bytes);
49 assert!(res.is_err());
50 }
51
52 #[test]
test_der_bitstring_primitive()53 fn test_der_bitstring_primitive() {
54 let empty = &b""[..];
55 //
56 // correct DER encoding
57 //
58 let bytes = &[0x03, 0x04, 0x06, 0x6e, 0x5d, 0xc0];
59 let expected = DerObject::from_obj(BerObjectContent::BitString(
60 6,
61 BitStringObject { data: &bytes[3..] },
62 ));
63 assert_eq!(parse_der_bitstring(bytes), Ok((empty, expected)));
64 //
65 // correct encoding, but wrong padding bits (not all set to 0)
66 //
67 let bytes = &[0x03, 0x04, 0x06, 0x6e, 0x5d, 0xe0];
68 assert_eq!(
69 parse_der_bitstring(bytes),
70 Err(Err::Error(BerError::DerConstraintFailed))
71 );
72 //
73 // long form of length (invalid, < 127)
74 //
75 let bytes = &[0x03, 0x81, 0x04, 0x06, 0x6e, 0x5d, 0xc0];
76 assert_eq!(
77 parse_der_bitstring(bytes),
78 Err(Err::Error(BerError::DerConstraintFailed))
79 );
80 }
81
82 #[test]
test_der_bitstring_constructed()83 fn test_der_bitstring_constructed() {
84 let bytes = &hex!("23 81 0c 03 03 00 0a 3b 03 05 04 5f 29 1c d0");
85 assert_eq!(
86 parse_der_bitstring(bytes),
87 Err(Err::Error(BerError::DerConstraintFailed))
88 );
89 }
90
91 #[test]
test_der_indefinite_length()92 fn test_der_indefinite_length() {
93 let bytes = &hex!("23 80 03 03 00 0a 3b 03 05 04 5f 29 1c d0 00 00");
94 assert_eq!(
95 parse_der_bitstring(bytes),
96 Err(Err::Error(BerError::DerConstraintFailed))
97 );
98 }
99
100 #[test]
test_der_octetstring_primitive()101 fn test_der_octetstring_primitive() {
102 let empty = &b""[..];
103 let bytes = [0x04, 0x05, 0x41, 0x41, 0x41, 0x41, 0x41];
104 let expected = DerObject::from_obj(BerObjectContent::OctetString(b"AAAAA"));
105 assert_eq!(parse_der_octetstring(&bytes), Ok((empty, expected)));
106 }
107
108 #[test]
test_der_null()109 fn test_der_null() {
110 let empty = &b""[..];
111 let expected = DerObject::from_obj(BerObjectContent::Null);
112 assert_eq!(parse_der_null(&[0x05, 0x00]), Ok((empty, expected)));
113 }
114
115 #[test]
test_der_oid()116 fn test_der_oid() {
117 let empty = &b""[..];
118 let bytes = [
119 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05,
120 ];
121 let expected = DerObject::from_obj(BerObjectContent::OID(
122 Oid::from(&[1, 2, 840, 113_549, 1, 1, 5]).unwrap(),
123 ));
124 assert_eq!(parse_der_oid(&bytes), Ok((empty, expected)));
125 }
126
127 #[test]
test_der_enum()128 fn test_der_enum() {
129 let empty = &b""[..];
130 let expected = DerObject::from_obj(BerObjectContent::Enum(2));
131 assert_eq!(parse_der_enum(&[0x0a, 0x01, 0x02]), Ok((empty, expected)));
132 }
133
134 #[test]
test_der_utf8string()135 fn test_der_utf8string() {
136 let empty = &b""[..];
137 let bytes = [
138 0x0c, 0x0a, 0x53, 0x6f, 0x6d, 0x65, 0x2d, 0x53, 0x74, 0x61, 0x74, 0x65,
139 ];
140 let expected = DerObject::from_obj(BerObjectContent::UTF8String("Some-State"));
141 assert_eq!(parse_der_utf8string(&bytes), Ok((empty, expected)));
142 }
143
144 #[test]
test_der_relativeoid()145 fn test_der_relativeoid() {
146 let empty = &b""[..];
147 let bytes = [0x0d, 0x04, 0xc2, 0x7b, 0x03, 0x02];
148 let expected = DerObject::from_obj(BerObjectContent::RelativeOID(
149 Oid::from_relative(&[8571, 3, 2]).unwrap(),
150 ));
151 assert_eq!(parse_der_relative_oid(&bytes), Ok((empty, expected)));
152 }
153
154 #[test]
test_der_seq()155 fn test_der_seq() {
156 let empty = &b""[..];
157 let bytes = [0x30, 0x05, 0x02, 0x03, 0x01, 0x00, 0x01];
158 let expected = DerObject::from_seq(vec![DerObject::from_int_slice(b"\x01\x00\x01")]);
159 assert_eq!(parse_der_sequence(&bytes), Ok((empty, expected)));
160 }
161
162 #[test]
test_der_set()163 fn test_der_set() {
164 let empty = &b""[..];
165 let bytes = [0x31, 0x05, 0x02, 0x03, 0x01, 0x00, 0x01];
166 let expected = DerObject::from_set(vec![DerObject::from_int_slice(b"\x01\x00\x01")]);
167 assert_eq!(parse_der_set(&bytes), Ok((empty, expected)));
168 }
169
170 #[test]
test_der_seq_defined()171 fn test_der_seq_defined() {
172 let empty = &b""[..];
173 let bytes = [
174 0x30, 0x0a, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x03, 0x01, 0x00, 0x00,
175 ];
176 let expected = DerObject::from_seq(vec![
177 DerObject::from_int_slice(b"\x01\x00\x01"),
178 DerObject::from_int_slice(b"\x01\x00\x00"),
179 ]);
180 fn parser(i: &[u8]) -> DerResult {
181 parse_der_sequence_defined(
182 // the nom `tuple` combinator returns a tuple, so we have to map it
183 // to a list
184 map(tuple((parse_der_integer, parse_der_integer)), |(a, b)| {
185 vec![a, b]
186 }),
187 )(i)
188 }
189 assert_eq!(parser(&bytes), Ok((empty, expected)));
190 }
191
192 #[test]
test_der_set_defined()193 fn test_der_set_defined() {
194 let empty = &b""[..];
195 let bytes = [
196 0x31, 0x0a, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x03, 0x01, 0x00, 0x00,
197 ];
198 let expected = DerObject::from_set(vec![
199 DerObject::from_int_slice(b"\x01\x00\x01"),
200 DerObject::from_int_slice(b"\x01\x00\x00"),
201 ]);
202 fn parser(i: &[u8]) -> DerResult {
203 parse_der_set_defined(
204 // the nom `tuple` combinator returns a tuple, so we have to map it
205 // to a list
206 map(tuple((parse_der_integer, parse_der_integer)), |(a, b)| {
207 vec![a, b]
208 }),
209 )(i)
210 }
211 assert_eq!(parser(&bytes), Ok((empty, expected)));
212 }
213
214 #[test]
test_der_seq_of()215 fn test_der_seq_of() {
216 let empty = &b""[..];
217 let bytes = [
218 0x30, 0x0a, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x03, 0x01, 0x00, 0x00,
219 ];
220 let expected = DerObject::from_seq(vec![
221 DerObject::from_int_slice(b"\x01\x00\x01"),
222 DerObject::from_int_slice(b"\x01\x00\x00"),
223 ]);
224 fn parser(i: &[u8]) -> DerResult {
225 parse_der_sequence_of(parse_der_integer)(i)
226 }
227 assert_eq!(parser(&bytes), Ok((empty, expected.clone())));
228 //
229 fn parser2(i: &[u8]) -> BerResult {
230 parse_ber_sequence_of(parse_der_integer)(i)
231 }
232 assert_eq!(parser2(&bytes), Ok((empty, expected)));
233 }
234
235 // extra bytes are simply ignored
236 #[test]
test_der_seq_of_incomplete()237 fn test_der_seq_of_incomplete() {
238 let bytes = [0x30, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01, 0x00, 0x00];
239 fn parser(i: &[u8]) -> DerResult {
240 parse_der_sequence_of(parse_der_integer)(i)
241 }
242 assert_eq!(parser(&bytes), Err(Err::Failure(BerError::InvalidTag)));
243 //
244 fn parser2(i: &[u8]) -> BerResult<Vec<BerObject>> {
245 parse_ber_sequence_of_v(parse_der_integer)(i)
246 }
247 // eprintln!("trailing data");
248 assert_eq!(parser2(&bytes), Err(Err::Failure(BerError::InvalidTag)));
249 let h = &hex!("30 06 02 03 01 00 01 02");
250 // eprintln!("remaining 02 at end (incomplete)");
251 assert_eq!(
252 parser2(h),
253 Err(Err::Error(BerError::NomError(ErrorKind::Eof)))
254 );
255 }
256
257 #[test]
test_der_set_of()258 fn test_der_set_of() {
259 let empty = &b""[..];
260 let bytes = [
261 0x31, 0x0a, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x03, 0x01, 0x00, 0x00,
262 ];
263 let expected = DerObject::from_set(vec![
264 DerObject::from_int_slice(b"\x01\x00\x01"),
265 DerObject::from_int_slice(b"\x01\x00\x00"),
266 ]);
267 fn parser(i: &[u8]) -> DerResult {
268 parse_der_set_of(parse_der_integer)(i)
269 }
270 assert_eq!(parser(&bytes), Ok((empty, expected)));
271 }
272
273 #[test]
test_der_utctime()274 fn test_der_utctime() {
275 let bytes = hex!("17 0D 30 32 31 32 31 33 31 34 32 39 32 33 5A FF");
276 let expected = DerObject::from_obj(BerObjectContent::UTCTime(
277 std::str::from_utf8(&bytes[2..(2 + 0x0d)]).unwrap(),
278 ));
279 assert_eq!(parse_der_utctime(&bytes), Ok((&[0xff][..], expected)));
280 let bytes = hex!("17 0c 30 32 31 32 31 33 31 34 32 39 32 33");
281 parse_der_utctime(&bytes).err().expect("expected error");
282 }
283
284 #[test]
test_der_generalizedtime()285 fn test_der_generalizedtime() {
286 let empty = &b""[..];
287 let bytes = [
288 0x18, 0x0D, 0x30, 0x32, 0x31, 0x32, 0x31, 0x33, 0x31, 0x34, 0x32, 0x39, 0x32, 0x33, 0x5A,
289 ];
290 let expected = DerObject::from_obj(BerObjectContent::GeneralizedTime(
291 std::str::from_utf8(&bytes[2..]).unwrap(),
292 ));
293 assert_eq!(parse_der_generalizedtime(&bytes), Ok((empty, expected)));
294 }
295
296 #[test]
test_der_generalstring()297 fn test_der_generalstring() {
298 let empty = &b""[..];
299 let bytes = [0x1b, 0x04, 0x63, 0x69, 0x66, 0x73];
300 let expected = DerObject::from_obj(BerObjectContent::GeneralString(b"cifs"));
301 assert_eq!(parse_der_generalstring(&bytes), Ok((empty, expected)));
302 }
303
304 #[test]
test_der_contextspecific()305 fn test_der_contextspecific() {
306 let bytes = [0xa0, 0x03, 0x02, 0x01, 0x02];
307 let empty = &b""[..];
308 let expected = DerObject {
309 header: BerObjectHeader::new(BerClass::ContextSpecific, 1, BerTag(0), 3)
310 .with_raw_tag(Some(&[0xa0])),
311 content: BerObjectContent::Unknown(BerClass::ContextSpecific, BerTag(0), &bytes[2..]),
312 };
313 assert_eq!(parse_der(&bytes), Ok((empty, expected)));
314 }
315
316 #[test]
test_der_explicit_optional()317 fn test_der_explicit_optional() {
318 let empty = &b""[..];
319 let bytes = [0xa0, 0x03, 0x02, 0x01, 0x02];
320 let header = BerObjectHeader::new(BerClass::ContextSpecific, 1, BerTag(0), 3)
321 .with_raw_tag(Some(&[0xa0]));
322 let expected = DerObject {
323 header: header.clone(),
324 content: BerObjectContent::Optional(Some(Box::new(BerObject::from_header_and_content(
325 header,
326 BerObjectContent::Tagged(
327 BerClass::ContextSpecific,
328 BerTag(0),
329 Box::new(DerObject::from_int_slice(b"\x02")),
330 ),
331 )))),
332 };
333 assert_eq!(
334 parse_der_explicit_optional(&bytes, BerTag(0), parse_der_integer),
335 Ok((empty, expected))
336 );
337 let expected2 = DerObject::from_obj(BerObjectContent::Optional(None));
338 assert_eq!(
339 parse_der_explicit_optional(&bytes, BerTag(1), parse_der_integer),
340 Ok((&bytes[..], expected2))
341 );
342 }
343
344 #[test]
test_der_implicit()345 fn test_der_implicit() {
346 let empty = &b""[..];
347 let bytes = [0x81, 0x04, 0x70, 0x61, 0x73, 0x73];
348 let expected = DerObject {
349 header: BerObjectHeader::new(BerClass::ContextSpecific, 0, BerTag(1), 4)
350 .with_raw_tag(Some(&[0x81])),
351 content: BerObjectContent::IA5String("pass"),
352 };
353 fn der_read_ia5string_content<'a>(
354 i: &'a [u8],
355 hdr: &BerObjectHeader,
356 depth: usize,
357 ) -> BerResult<'a, BerObjectContent<'a>> {
358 ber_read_element_content_as(i, DerTag::Ia5String, hdr.len, hdr.is_constructed(), depth)
359 }
360 assert_eq!(
361 parse_der_implicit(&bytes, BerTag(1), der_read_ia5string_content),
362 Ok((empty, expected))
363 );
364 assert_eq!(
365 parse_der_implicit(&bytes, BerTag(2), der_read_ia5string_content),
366 Err(Err::Error(BerError::InvalidTag))
367 );
368 }
369
370 #[test]
test_der_implicit_long_tag()371 fn test_der_implicit_long_tag() {
372 let empty = &b""[..];
373 let bytes = [0x5f, 0x52, 0x04, 0x70, 0x61, 0x73, 0x73];
374 let expected = DerObject {
375 header: BerObjectHeader::new(BerClass::Application, 0, BerTag(0x52), 4)
376 .with_raw_tag(Some(&[0x5f, 0x52])),
377 content: BerObjectContent::IA5String("pass"),
378 };
379 fn der_read_ia5string_content<'a>(
380 i: &'a [u8],
381 hdr: &BerObjectHeader,
382 depth: usize,
383 ) -> BerResult<'a, BerObjectContent<'a>> {
384 ber_read_element_content_as(i, DerTag::Ia5String, hdr.len, hdr.is_constructed(), depth)
385 }
386 assert_eq!(
387 parse_der_implicit(&bytes, BerTag(0x52), der_read_ia5string_content),
388 Ok((empty, expected))
389 );
390 assert_eq!(
391 parse_der_implicit(&bytes, BerTag(2), der_read_ia5string_content),
392 Err(Err::Error(BerError::InvalidTag))
393 );
394 }
395
396 #[test]
test_der_optional()397 fn test_der_optional() {
398 let empty = &b""[..];
399 let bytes1 = [
400 0x30, 0x0a, 0x0a, 0x03, 0x00, 0x00, 0x01, 0x02, 0x03, 0x01, 0x00, 0x01,
401 ];
402 let bytes2 = [0x30, 0x05, 0x02, 0x03, 0x01, 0x00, 0x01];
403 let expected1 = DerObject::from_seq(vec![
404 DerObject::from_obj(BerObjectContent::Optional(Some(Box::new(
405 DerObject::from_obj(BerObjectContent::Enum(1)),
406 )))),
407 DerObject::from_int_slice(b"\x01\x00\x01"),
408 ]);
409 let expected2 = DerObject::from_seq(vec![
410 DerObject::from_obj(BerObjectContent::Optional(None)),
411 DerObject::from_int_slice(b"\x01\x00\x01"),
412 ]);
413 fn parse_optional_enum(i: &[u8]) -> DerResult {
414 parse_ber_optional(parse_der_enum)(i)
415 }
416 fn parser(i: &[u8]) -> DerResult {
417 parse_der_sequence_defined(
418 // the nom `tuple` combinator returns a tuple, so we have to map it
419 // to a list
420 map(tuple((parse_optional_enum, parse_der_integer)), |(a, b)| {
421 vec![a, b]
422 }),
423 )(i)
424 }
425 assert_eq!(parser(&bytes1), Ok((empty, expected1)));
426 assert_eq!(parser(&bytes2), Ok((empty, expected2)));
427 }
428
429 #[test]
test_der_seq_dn()430 fn test_der_seq_dn() {
431 let empty = &b""[..];
432 let bytes = [
433 0x30, 0x45, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x46, 0x52,
434 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0a, 0x53, 0x6f, 0x6d, 0x65,
435 0x2d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x31, 0x21, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x04, 0x0a,
436 0x0c, 0x18, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x20, 0x57, 0x69, 0x64, 0x67,
437 0x69, 0x74, 0x73, 0x20, 0x50, 0x74, 0x79, 0x20, 0x4c, 0x74, 0x64,
438 ];
439 let expected = DerObject::from_seq(vec![
440 DerObject::from_set(vec![DerObject::from_seq(vec![
441 DerObject::from_obj(BerObjectContent::OID(Oid::from(&[2, 5, 4, 6]).unwrap())), // countryName
442 DerObject::from_obj(BerObjectContent::PrintableString("FR")),
443 ])]),
444 DerObject::from_set(vec![DerObject::from_seq(vec![
445 DerObject::from_obj(BerObjectContent::OID(Oid::from(&[2, 5, 4, 8]).unwrap())), // stateOrProvinceName
446 DerObject::from_obj(BerObjectContent::UTF8String("Some-State")),
447 ])]),
448 DerObject::from_set(vec![DerObject::from_seq(vec![
449 DerObject::from_obj(BerObjectContent::OID(Oid::from(&[2, 5, 4, 10]).unwrap())), // organizationName
450 DerObject::from_obj(BerObjectContent::UTF8String("Internet Widgits Pty Ltd")),
451 ])]),
452 ]);
453 assert_eq!(parse_der(&bytes), Ok((empty, expected)));
454 }
455
456 #[test]
test_der_seq_dn_defined()457 fn test_der_seq_dn_defined() {
458 let empty = &b""[..];
459 let bytes = [
460 0x30, 0x45, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x46, 0x52,
461 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0a, 0x53, 0x6f, 0x6d, 0x65,
462 0x2d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x31, 0x21, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x04, 0x0a,
463 0x0c, 0x18, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x20, 0x57, 0x69, 0x64, 0x67,
464 0x69, 0x74, 0x73, 0x20, 0x50, 0x74, 0x79, 0x20, 0x4c, 0x74, 0x64,
465 ];
466 let expected = DerObject::from_seq(vec![
467 DerObject::from_set(vec![DerObject::from_seq(vec![
468 DerObject::from_obj(BerObjectContent::OID(Oid::from(&[2, 5, 4, 6]).unwrap())), // countryName
469 DerObject::from_obj(BerObjectContent::PrintableString("FR")),
470 ])]),
471 DerObject::from_set(vec![DerObject::from_seq(vec![
472 DerObject::from_obj(BerObjectContent::OID(Oid::from(&[2, 5, 4, 8]).unwrap())), // stateOrProvinceName
473 DerObject::from_obj(BerObjectContent::UTF8String("Some-State")),
474 ])]),
475 DerObject::from_set(vec![DerObject::from_seq(vec![
476 DerObject::from_obj(BerObjectContent::OID(Oid::from(&[2, 5, 4, 10]).unwrap())), // organizationName
477 DerObject::from_obj(BerObjectContent::UTF8String("Internet Widgits Pty Ltd")),
478 ])]),
479 ]);
480 #[inline]
481 fn parse_directory_string(i: &[u8]) -> DerResult {
482 alt((
483 parse_der_utf8string,
484 parse_der_printablestring,
485 parse_der_ia5string,
486 ))(i)
487 }
488 #[inline]
489 fn parse_attr_type_and_value(i: &[u8]) -> DerResult {
490 parse_der_sequence_defined(
491 // the nom `tuple` combinator returns a tuple, so we have to map it
492 // to a list
493 map(tuple((parse_der_oid, parse_directory_string)), |(a, b)| {
494 vec![a, b]
495 }),
496 )(i)
497 }
498 #[inline]
499 fn parse_rdn(i: &[u8]) -> DerResult {
500 parse_der_set_of(parse_attr_type_and_value)(i)
501 }
502 #[inline]
503 fn parse_name(i: &[u8]) -> DerResult {
504 parse_der_sequence_of(parse_rdn)(i)
505 }
506 assert_eq!(parse_name(&bytes), Ok((empty, expected)));
507 }
508
509 #[test_case(&hex!("02 01 01"), Ok(1) ; "u32-1")]
510 #[test_case(&hex!("02 01 ff"), Err(BerError::IntegerNegative) ; "negative integer")]
511 #[test_case(&hex!("02 02 00 ff"), Ok(255) ; "u32-255")]
512 #[test_case(&hex!("02 02 01 23"), Ok(0x123) ; "u32-0x123")]
513 #[test_case(&hex!("02 04 01 23 45 67"), Ok(0x0123_4567) ; "u32-long-ok")]
514 #[test_case(&hex!("02 04 ff ff ff ff"), Err(BerError::IntegerNegative) ; "u32-long2-neg")]
515 #[test_case(&hex!("02 06 00 00 01 23 45 67"), Err(BerError::DerConstraintFailed) ; "u32-long-leading-zeros")]
516 #[test_case(&hex!("02 05 01 23 45 67 01"), Err(BerError::IntegerTooLarge) ; "u32 too large")]
517 #[test_case(&hex!("02 09 01 23 45 67 01 23 45 67 ab"), Err(BerError::IntegerTooLarge) ; "u32 too large 2")]
518 #[test_case(&hex!("03 03 01 00 01"), Err(BerError::InvalidTag) ; "invalid tag")]
tc_der_u32(i: &[u8], out: Result<u32, BerError>)519 fn tc_der_u32(i: &[u8], out: Result<u32, BerError>) {
520 let res = parse_der_u32(i);
521 match out {
522 Ok(expected) => {
523 pretty_assertions::assert_eq!(res, Ok((&b""[..], expected)));
524 }
525 Err(e) => {
526 pretty_assertions::assert_eq!(res, Err(Err::Error(e)));
527 }
528 }
529 }
530
531 #[test_case(&hex!("02 01 01"), Ok(1) ; "i32-1")]
532 #[test_case(&hex!("02 01 ff"), Ok(-1) ; "i32-neg1")]
533 #[test_case(&hex!("02 01 80"), Ok(-128) ; "i32-neg128")]
534 #[test_case(&hex!("02 02 ff 7f"), Ok(-129) ; "i32-neg129")]
535 #[test_case(&hex!("02 02 00 ff"), Ok(255) ; "i32-255")]
tc_der_i32(i: &[u8], out: Result<i32, BerError>)536 fn tc_der_i32(i: &[u8], out: Result<i32, BerError>) {
537 let res = parse_der_i32(i);
538 match out {
539 Ok(expected) => {
540 pretty_assertions::assert_eq!(res, Ok((&b""[..], expected)));
541 }
542 Err(e) => {
543 pretty_assertions::assert_eq!(res, Err(Err::Error(e)));
544 }
545 }
546 }
547
548 #[test_case(&hex!("02 01 01"), Ok(1) ; "u64-1")]
549 #[test_case(&hex!("02 02 00 ff"), Ok(255) ; "u64-255")]
550 #[test_case(&hex!("02 02 01 23"), Ok(0x123) ; "u64-0x123")]
551 #[test_case(&hex!("02 08 01 23 45 67 01 23 45 67"), Ok(0x0123_4567_0123_4567) ; "u64-long-ok")]
552 #[test_case(&hex!("02 09 00 ff ff ff ff ff ff ff ff"), Ok(0xffff_ffff_ffff_ffff) ; "u64-long2-ok")]
553 #[test_case(&hex!("02 09 01 23 45 67 01 23 45 67 ab"), Err(BerError::IntegerTooLarge) ; "u64 too large")]
554 #[test_case(&hex!("03 03 01 00 01"), Err(BerError::InvalidTag) ; "invalid tag")]
tc_der_u64(i: &[u8], out: Result<u64, BerError>)555 fn tc_der_u64(i: &[u8], out: Result<u64, BerError>) {
556 let res = parse_der_u64(i);
557 match out {
558 Ok(expected) => {
559 pretty_assertions::assert_eq!(res, Ok((&b""[..], expected)));
560 }
561 Err(e) => {
562 pretty_assertions::assert_eq!(res, Err(Err::Error(e)));
563 }
564 }
565 }
566
567 #[test_case(&hex!("02 01 01"), Ok(&[1]) ; "slice 1")]
568 #[test_case(&hex!("02 01 ff"), Ok(&[255]) ; "slice 2")]
569 #[test_case(&hex!("02 09 01 23 45 67 01 23 45 67 ab"), Ok(&hex!("01 23 45 67 01 23 45 67 ab")) ; "slice 3")]
570 #[test_case(&hex!("22 80 02 01 01 00 00"), Err(BerError::DerConstraintFailed) ; "constructed slice")]
571 #[test_case(&hex!("03 03 01 00 01"), Err(BerError::InvalidTag) ; "invalid tag")]
tc_der_slice(i: &[u8], out: Result<&[u8], BerError>)572 fn tc_der_slice(i: &[u8], out: Result<&[u8], BerError>) {
573 let res = parse_der_slice(i, 2);
574 match out {
575 Ok(expected) => {
576 pretty_assertions::assert_eq!(res, Ok((&b""[..], expected)));
577 }
578 Err(e) => {
579 pretty_assertions::assert_eq!(res, Err(Err::Error(e)));
580 }
581 }
582 }
583