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