1 use der_parser::der::*;
2 use der_parser::error::*;
3 use hex_literal::hex;
4 use nom::combinator::map;
5 use nom::error::ErrorKind;
6 use nom::sequence::tuple;
7 use nom::{Err, Needed};
8 use test_case::test_case;
9
10 #[test_case(&hex!("a2 05 02 03 01 00 01"), Ok(0x10001) ; "tag ok")]
11 #[test_case(&hex!("a2 80 02 03 01 00 01 00 00"), Err(BerError::DerConstraintFailed) ; "indefinite tag ok")]
12 #[test_case(&hex!("a3 05 02 03 01 00 01"), Err(BerError::InvalidTag) ; "invalid tag")]
13 #[test_case(&hex!("22 05 02 03 01 00 01"), Err(BerError::InvalidClass) ; "invalid class")]
14 #[test_case(&hex!("82 05 02 03 01 00 01"), Err(BerError::ConstructExpected) ; "construct expected")]
tc_der_tagged_explicit_g(i: &[u8], out: Result<u32, BerError>)15 fn tc_der_tagged_explicit_g(i: &[u8], out: Result<u32, BerError>) {
16 fn parse_int_explicit(i: &[u8]) -> BerResult<u32> {
17 parse_der_tagged_explicit_g(2, move |content, _hdr| {
18 let (rem, obj) = parse_der_integer(content)?;
19 let value = obj.as_u32()?;
20 Ok((rem, value))
21 })(i)
22 }
23 let res = parse_int_explicit(i);
24 match out {
25 Ok(expected) => {
26 pretty_assertions::assert_eq!(res, Ok((&b""[..], expected)));
27 }
28 Err(e) => {
29 pretty_assertions::assert_eq!(res, Err(Err::Error(e)));
30 }
31 }
32 }
33
34 #[test_case(&hex!("82 03 01 00 01"), Ok(0x10001) ; "tag ok")]
35 #[test_case(&hex!("83 03 01 00 01"), Err(BerError::InvalidTag) ; "invalid tag")]
tc_der_tagged_implicit_g(i: &[u8], out: Result<u32, BerError>)36 fn tc_der_tagged_implicit_g(i: &[u8], out: Result<u32, BerError>) {
37 fn parse_int_implicit(i: &[u8]) -> BerResult<u32> {
38 parse_der_tagged_implicit_g(2, |content, hdr, depth| {
39 let (rem, obj) = parse_der_content(DerTag::Integer)(content, &hdr, depth)?;
40 let value = obj.as_u32()?;
41 Ok((rem, value))
42 })(i)
43 }
44 let res = parse_int_implicit(i);
45 match out {
46 Ok(expected) => {
47 pretty_assertions::assert_eq!(res, Ok((&b""[..], expected)));
48 }
49 Err(e) => {
50 pretty_assertions::assert_eq!(res, Err(Err::Error(e)));
51 }
52 }
53 }
54
55 #[test_case(&hex!("30 00"), Ok(&[]) ; "empty seq")]
56 #[test_case(&hex!("30 0a 02 03 01 00 01 02 03 01 00 00"), Ok(&[0x10001, 0x10000]) ; "seq ok")]
57 #[test_case(&hex!("30 07 02 03 01 00 01 02 03 01"), Err(BerError::NomError(ErrorKind::Eof)) ; "incomplete")]
58 #[test_case(&hex!("31 0a 02 03 01 00 01 02 03 01 00 00"), Err(BerError::InvalidTag) ; "invalid tag")]
59 #[test_case(&hex!("30 80 02 03 01 00 01 00 00"), Err(BerError::DerConstraintFailed) ; "indefinite seq ok")]
tc_der_seq_of(i: &[u8], out: Result<&[u32], BerError>)60 fn tc_der_seq_of(i: &[u8], out: Result<&[u32], BerError>) {
61 fn parser(i: &[u8]) -> BerResult {
62 parse_der_sequence_of(parse_der_integer)(i)
63 }
64 let res = parser(i);
65 match out {
66 Ok(l) => {
67 let (rem, res) = res.expect("could not parse sequence of");
68 assert!(rem.is_empty());
69 if let DerObjectContent::Sequence(res) = res.content {
70 pretty_assertions::assert_eq!(res.len(), l.len());
71 for (a, b) in res.iter().zip(l.iter()) {
72 pretty_assertions::assert_eq!(a.as_u32().unwrap(), *b);
73 }
74 } else {
75 panic!("wrong type for parsed object");
76 }
77 }
78 Err(e) => {
79 pretty_assertions::assert_eq!(res, Err(Err::Error(e)));
80 }
81 }
82 }
83
84 #[test_case(&hex!("30 0a 02 03 01 00 01 02 03 01 00 00"), Ok(&[0x10001, 0x10000]) ; "seq ok")]
85 #[test_case(&hex!("30 07 02 03 01 00 01 02 01"), Err(Err::Incomplete(Needed::new(1))) ; "incomplete")]
86 #[test_case(&hex!("31 0a 02 03 01 00 01 02 03 01 00 00"), Err(Err::Error(BerError::InvalidTag)) ; "invalid tag")]
87 #[test_case(&hex!("30 80 02 03 01 00 01 00 00"), Err(Err::Error(BerError::DerConstraintFailed)) ; "indefinite seq ok")]
tc_der_seq_defined(i: &[u8], out: Result<&[u32], Err<BerError>>)88 fn tc_der_seq_defined(i: &[u8], out: Result<&[u32], Err<BerError>>) {
89 fn parser(i: &[u8]) -> BerResult<DerObject> {
90 parse_der_sequence_defined(map(
91 tuple((parse_der_integer, parse_der_integer)),
92 |(a, b)| vec![a, b],
93 ))(i)
94 }
95 let res = parser(i);
96 match out {
97 Ok(l) => {
98 let (rem, res) = res.expect("could not parse sequence");
99 assert!(rem.is_empty());
100 if let DerObjectContent::Sequence(res) = res.content {
101 pretty_assertions::assert_eq!(res.len(), l.len());
102 for (a, b) in res.iter().zip(l.iter()) {
103 pretty_assertions::assert_eq!(a.as_u32().unwrap(), *b);
104 }
105 } else {
106 panic!("wrong type for parsed object");
107 }
108 }
109 Err(e) => {
110 pretty_assertions::assert_eq!(res, Err(e));
111 }
112 }
113 }
114
115 #[test_case(&hex!("31 00"), Ok(&[]) ; "empty set")]
116 #[test_case(&hex!("31 0a 02 03 01 00 01 02 03 01 00 00"), Ok(&[0x10001, 0x10000]) ; "set ok")]
117 #[test_case(&hex!("31 07 02 03 01 00 01 02 03 01"), Err(BerError::NomError(ErrorKind::Eof)) ; "incomplete")]
118 #[test_case(&hex!("30 0a 02 03 01 00 01 02 03 01 00 00"), Err(BerError::InvalidTag) ; "invalid tag")]
119 #[test_case(&hex!("31 80 02 03 01 00 01 00 00"), Err(BerError::DerConstraintFailed) ; "indefinite set ok")]
tc_der_set_of(i: &[u8], out: Result<&[u32], BerError>)120 fn tc_der_set_of(i: &[u8], out: Result<&[u32], BerError>) {
121 fn parser(i: &[u8]) -> BerResult {
122 parse_der_set_of(parse_der_integer)(i)
123 }
124 let res = parser(i);
125 match out {
126 Ok(l) => {
127 let (rem, res) = res.expect("could not parse set of");
128 assert!(rem.is_empty());
129 if let DerObjectContent::Set(res) = res.content {
130 pretty_assertions::assert_eq!(res.len(), l.len());
131 for (a, b) in res.iter().zip(l.iter()) {
132 pretty_assertions::assert_eq!(a.as_u32().unwrap(), *b);
133 }
134 } else {
135 panic!("wrong type for parsed object");
136 }
137 }
138 Err(e) => {
139 pretty_assertions::assert_eq!(res, Err(Err::Error(e)));
140 }
141 }
142 }
143
144 #[test_case(&hex!("31 0a 02 03 01 00 01 02 03 01 00 00"), Ok(&[0x10001, 0x10000]) ; "set ok")]
145 #[test_case(&hex!("31 07 02 03 01 00 01 02 01"), Err(Err::Incomplete(Needed::new(1))) ; "incomplete")]
146 #[test_case(&hex!("30 0a 02 03 01 00 01 02 03 01 00 00"), Err(Err::Error(BerError::InvalidTag)) ; "invalid tag")]
147 #[test_case(&hex!("31 80 02 03 01 00 01 00 00"), Err(Err::Error(BerError::DerConstraintFailed)) ; "indefinite set ok")]
tc_der_set_defined(i: &[u8], out: Result<&[u32], Err<BerError>>)148 fn tc_der_set_defined(i: &[u8], out: Result<&[u32], Err<BerError>>) {
149 fn parser(i: &[u8]) -> BerResult<DerObject> {
150 parse_der_set_defined(map(
151 tuple((parse_der_integer, parse_der_integer)),
152 |(a, b)| vec![a, b],
153 ))(i)
154 }
155 let res = parser(i);
156 match out {
157 Ok(l) => {
158 let (rem, res) = res.expect("could not parse set");
159 assert!(rem.is_empty());
160 if let DerObjectContent::Set(res) = res.content {
161 pretty_assertions::assert_eq!(res.len(), l.len());
162 for (a, b) in res.iter().zip(l.iter()) {
163 pretty_assertions::assert_eq!(a.as_u32().unwrap(), *b);
164 }
165 } else {
166 panic!("wrong type for parsed object");
167 }
168 }
169 Err(e) => {
170 pretty_assertions::assert_eq!(res, Err(e));
171 }
172 }
173 }
174