1 // Copyright 2016 Masaki Hara
2 //
3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
4 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
5 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
6 // option. This file may not be copied, modified, or distributed
7 // except according to those terms.
8 
9 use alloc::vec;
10 
11 #[cfg(feature = "num-bigint")]
12 use num_bigint::{BigUint, BigInt};
13 
14 use super::super::Tag;
15 use super::*;
16 
17 #[test]
test_der_write_bool()18 fn test_der_write_bool() {
19     let tests : &[(bool, &[u8])] = &[
20         (false, &[1, 1, 0]),
21         (true, &[1, 1, 255]),
22     ];
23     for &(value, edata) in tests {
24         let data = construct_der(|writer| {
25             writer.write_bool(value)
26         });
27         assert_eq!(data, edata);
28     }
29 }
30 
31 #[test]
test_der_write_i64()32 fn test_der_write_i64() {
33     let tests : &[(i64, &[u8])] = &[
34         (-9223372036854775808, &[2, 8, 128, 0, 0, 0, 0, 0, 0, 0]),
35         (-65537, &[2, 3, 254, 255, 255]),
36         (-65536, &[2, 3, 255, 0, 0]),
37         (-32769, &[2, 3, 255, 127, 255]),
38         (-32768, &[2, 2, 128, 0]),
39         (-129, &[2, 2, 255, 127]),
40         (-128, &[2, 1, 128]),
41         (-1, &[2, 1, 255]),
42         (0, &[2, 1, 0]),
43         (1, &[2, 1, 1]),
44         (127, &[2, 1, 127]),
45         (128, &[2, 2, 0, 128]),
46         (32767, &[2, 2, 127, 255]),
47         (32768, &[2, 3, 0, 128, 0]),
48         (65535, &[2, 3, 0, 255, 255]),
49         (65536, &[2, 3, 1, 0, 0]),
50         (9223372036854775807, &[2, 8, 127, 255, 255, 255, 255, 255, 255, 255]),
51     ];
52     for &(value, edata) in tests {
53         let data = construct_der(|writer| {
54             writer.write_i64(value)
55         });
56         assert_eq!(data, edata);
57     }
58 }
59 
60 #[test]
test_der_write_u64()61 fn test_der_write_u64() {
62     let tests : &[(u64, &[u8])] = &[
63         (0, &[2, 1, 0]),
64         (1, &[2, 1, 1]),
65         (127, &[2, 1, 127]),
66         (128, &[2, 2, 0, 128]),
67         (32767, &[2, 2, 127, 255]),
68         (32768, &[2, 3, 0, 128, 0]),
69         (65535, &[2, 3, 0, 255, 255]),
70         (65536, &[2, 3, 1, 0, 0]),
71         (9223372036854775807, &[2, 8, 127, 255, 255, 255, 255, 255, 255, 255]),
72         (18446744073709551615,
73             &[2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255]),
74     ];
75     for &(value, edata) in tests {
76         let data = construct_der(|writer| {
77             writer.write_u64(value)
78         });
79         assert_eq!(data, edata);
80     }
81 }
82 
83 #[test]
test_der_write_i32()84 fn test_der_write_i32() {
85     let tests : &[(i32, &[u8])] = &[
86         (-2147483648, &[2, 4, 128, 0, 0, 0]),
87         (-65537, &[2, 3, 254, 255, 255]),
88         (-65536, &[2, 3, 255, 0, 0]),
89         (-32769, &[2, 3, 255, 127, 255]),
90         (-32768, &[2, 2, 128, 0]),
91         (-129, &[2, 2, 255, 127]),
92         (-128, &[2, 1, 128]),
93         (-1, &[2, 1, 255]),
94         (0, &[2, 1, 0]),
95         (1, &[2, 1, 1]),
96         (127, &[2, 1, 127]),
97         (128, &[2, 2, 0, 128]),
98         (32767, &[2, 2, 127, 255]),
99         (32768, &[2, 3, 0, 128, 0]),
100         (65535, &[2, 3, 0, 255, 255]),
101         (65536, &[2, 3, 1, 0, 0]),
102         (2147483647, &[2, 4, 127, 255, 255, 255]),
103     ];
104     for &(value, edata) in tests {
105         let data = construct_der(|writer| {
106             writer.write_i32(value)
107         });
108         assert_eq!(data, edata);
109     }
110 }
111 
112 #[test]
test_der_write_u32()113 fn test_der_write_u32() {
114     let tests : &[(u32, &[u8])] = &[
115         (0, &[2, 1, 0]),
116         (1, &[2, 1, 1]),
117         (127, &[2, 1, 127]),
118         (128, &[2, 2, 0, 128]),
119         (32767, &[2, 2, 127, 255]),
120         (32768, &[2, 3, 0, 128, 0]),
121         (65535, &[2, 3, 0, 255, 255]),
122         (65536, &[2, 3, 1, 0, 0]),
123         (2147483647, &[2, 4, 127, 255, 255, 255]),
124         (4294967295, &[2, 5, 0, 255, 255, 255, 255]),
125     ];
126     for &(value, edata) in tests {
127         let data = construct_der(|writer| {
128             writer.write_u32(value)
129         });
130         assert_eq!(data, edata);
131     }
132 }
133 
134 #[test]
test_der_write_i16()135 fn test_der_write_i16() {
136     let tests : &[(i16, &[u8])] = &[
137         (-32768, &[2, 2, 128, 0]),
138         (-129, &[2, 2, 255, 127]),
139         (-128, &[2, 1, 128]),
140         (-1, &[2, 1, 255]),
141         (0, &[2, 1, 0]),
142         (1, &[2, 1, 1]),
143         (127, &[2, 1, 127]),
144         (128, &[2, 2, 0, 128]),
145         (32767, &[2, 2, 127, 255]),
146     ];
147     for &(value, edata) in tests {
148         let data = construct_der(|writer| {
149             writer.write_i16(value)
150         });
151         assert_eq!(data, edata);
152     }
153 }
154 
155 #[test]
test_der_write_u16()156 fn test_der_write_u16() {
157     let tests : &[(u16, &[u8])] = &[
158         (0, &[2, 1, 0]),
159         (1, &[2, 1, 1]),
160         (127, &[2, 1, 127]),
161         (128, &[2, 2, 0, 128]),
162         (32767, &[2, 2, 127, 255]),
163         (32768, &[2, 3, 0, 128, 0]),
164         (65535, &[2, 3, 0, 255, 255]),
165     ];
166     for &(value, edata) in tests {
167         let data = construct_der(|writer| {
168             writer.write_u16(value)
169         });
170         assert_eq!(data, edata);
171     }
172 }
173 
174 #[test]
test_der_write_i8()175 fn test_der_write_i8() {
176     let tests : &[(i8, &[u8])] = &[
177         (-128, &[2, 1, 128]),
178         (-1, &[2, 1, 255]),
179         (0, &[2, 1, 0]),
180         (1, &[2, 1, 1]),
181         (127, &[2, 1, 127]),
182     ];
183     for &(value, edata) in tests {
184         let data = construct_der(|writer| {
185             writer.write_i8(value)
186         });
187         assert_eq!(data, edata);
188     }
189 }
190 
191 #[test]
test_der_write_u8()192 fn test_der_write_u8() {
193     let tests : &[(u8, &[u8])] = &[
194         (0, &[2, 1, 0]),
195         (1, &[2, 1, 1]),
196         (127, &[2, 1, 127]),
197         (128, &[2, 2, 0, 128]),
198         (255, &[2, 2, 0, 255]),
199     ];
200     for &(value, edata) in tests {
201         let data = construct_der(|writer| {
202             writer.write_u8(value)
203         });
204         assert_eq!(data, edata);
205     }
206 }
207 
208 #[cfg(feature = "num-bigint")]
209 #[test]
test_der_write_bigint()210 fn test_der_write_bigint() {
211     use num_traits::FromPrimitive;
212     let tests : &[(i64, &[u8])] = &[
213         (-9223372036854775808, &[2, 8, 128, 0, 0, 0, 0, 0, 0, 0]),
214         (-65537, &[2, 3, 254, 255, 255]),
215         (-65536, &[2, 3, 255, 0, 0]),
216         (-32769, &[2, 3, 255, 127, 255]),
217         (-32768, &[2, 2, 128, 0]),
218         (-129, &[2, 2, 255, 127]),
219         (-128, &[2, 1, 128]),
220         (-1, &[2, 1, 255]),
221         (0, &[2, 1, 0]),
222         (1, &[2, 1, 1]),
223         (127, &[2, 1, 127]),
224         (128, &[2, 2, 0, 128]),
225         (32767, &[2, 2, 127, 255]),
226         (32768, &[2, 3, 0, 128, 0]),
227         (65535, &[2, 3, 0, 255, 255]),
228         (65536, &[2, 3, 1, 0, 0]),
229         (9223372036854775807, &[2, 8, 127, 255, 255, 255, 255, 255, 255, 255]),
230     ];
231     for &(value, edata) in tests {
232         let data = construct_der(|writer| {
233             writer.write_bigint(&BigInt::from_i64(value).unwrap())
234         });
235         assert_eq!(data, edata);
236     }
237 
238     let tests : &[(BigInt, &[u8])] = &[
239         (BigInt::parse_bytes(
240             b"1234567890123456789012345678901234567890", 10).unwrap(),
241             &[2, 17, 3, 160, 201, 32, 117, 192, 219,
242             243, 184, 172, 188, 95, 150, 206, 63, 10, 210]),
243         (BigInt::parse_bytes(
244             b"-1234567890123456789012345678901234567890", 10).unwrap(),
245             &[2, 17, 252, 95, 54, 223, 138, 63, 36,
246             12, 71, 83, 67, 160, 105, 49, 192, 245, 46]),
247     ];
248     for &(ref value, edata) in tests {
249         let data = construct_der(|writer| {
250             writer.write_bigint(value)
251         });
252         assert_eq!(data, edata);
253     }
254 }
255 
256 #[cfg(feature = "num-bigint")]
257 #[test]
test_der_write_biguint()258 fn test_der_write_biguint() {
259     use num_traits::FromPrimitive;
260     let tests : &[(u64, &[u8])] = &[
261         (0, &[2, 1, 0]),
262         (1, &[2, 1, 1]),
263         (127, &[2, 1, 127]),
264         (128, &[2, 2, 0, 128]),
265         (32767, &[2, 2, 127, 255]),
266         (32768, &[2, 3, 0, 128, 0]),
267         (65535, &[2, 3, 0, 255, 255]),
268         (65536, &[2, 3, 1, 0, 0]),
269         (9223372036854775807, &[2, 8, 127, 255, 255, 255, 255, 255, 255, 255]),
270         (18446744073709551615,
271             &[2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255]),
272     ];
273     for &(value, edata) in tests {
274         let data = construct_der(|writer| {
275             writer.write_biguint(&BigUint::from_u64(value).unwrap())
276         });
277         assert_eq!(data, edata);
278     }
279 
280     let tests : &[(BigUint, &[u8])] = &[
281         (BigUint::parse_bytes(
282             b"1234567890123456789012345678901234567890", 10).unwrap(),
283             &[2, 17, 3, 160, 201, 32, 117, 192, 219,
284             243, 184, 172, 188, 95, 150, 206, 63, 10, 210]),
285     ];
286     for &(ref value, edata) in tests {
287         let data = construct_der(|writer| {
288             writer.write_biguint(value)
289         });
290         assert_eq!(data, edata);
291     }
292 }
293 
294 #[test]
test_der_write_bytes()295 fn test_der_write_bytes() {
296     let tests : &[(&[u8], &[u8])] = &[
297         (&[1, 0, 100, 255], &[4, 4, 1, 0, 100, 255]),
298         (&[], &[4, 0]),
299         (&[4, 4, 4, 4], &[4, 4, 4, 4, 4, 4]),
300     ];
301     for &(value, edata) in tests {
302         let data = construct_der(|writer| {
303             writer.write_bytes(value)
304         });
305         assert_eq!(data, edata);
306     }
307 }
308 
309 #[test]
test_der_write_null()310 fn test_der_write_null() {
311     let data = construct_der(|writer| {
312         writer.write_null()
313     });
314     assert_eq!(data, vec![5, 0]);
315 }
316 
317 #[test]
test_der_write_sequence_small()318 fn test_der_write_sequence_small() {
319     let data = construct_der(|writer| {
320         writer.write_sequence(|_| {})
321     });
322     assert_eq!(data, vec![48, 0]);
323 
324     let data = construct_der(|writer| {
325         writer.write_sequence(|writer| {
326             writer.next().write_bytes(&vec![91; 20]);
327         })
328     });
329     assert_eq!(data, vec![
330         48, 22, 4, 20, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
331         91, 91, 91, 91, 91, 91]);
332 
333     let data = construct_der(|writer| {
334         writer.write_sequence(|writer| {
335             writer.next().write_bytes(&vec![91; 200]);
336         })
337     });
338     assert_eq!(data[0..9].to_vec(),
339         vec![48, 129, 203, 4, 129, 200, 91, 91, 91]);
340     assert_eq!(data.len(), 206);
341 
342     let data = construct_der(|writer| {
343         writer.write_sequence(|writer| {
344             writer.next().write_bytes(&vec![91; 2000]);
345         })
346     });
347     assert_eq!(data[0..11].to_vec(),
348         vec![48, 130, 7, 212, 4, 130, 7, 208, 91, 91, 91]);
349     assert_eq!(data.len(), 2008);
350 }
351 
352 #[test]
test_der_write_sequence_medium()353 fn test_der_write_sequence_medium() {
354     let data = construct_der(|writer| {
355         writer.write_sequence(|writer| {
356             writer.next().write_bytes(&vec![91; 200000]);
357         })
358     });
359     assert_eq!(data[0..13].to_vec(),
360         vec![48, 131, 3, 13, 69, 4, 131, 3, 13, 64, 91, 91, 91]);
361     assert_eq!(data.len(), 200010);
362 }
363 
364 #[test]
365 #[ignore]
test_der_write_sequence_large()366 fn test_der_write_sequence_large() {
367     let data = construct_der(|writer| {
368         writer.write_sequence(|writer| {
369             writer.next().write_bytes(&vec![91; 20000000]);
370         })
371     });
372     assert_eq!(data[0..15].to_vec(),
373         vec![48, 132, 1, 49, 45, 6, 4, 132, 1, 49, 45, 0, 91, 91, 91]);
374     assert_eq!(data.len(), 20000012);
375 }
376 
377 #[test]
test_der_write_set()378 fn test_der_write_set() {
379     let data = construct_der(|writer| {
380         writer.write_set(|writer| {
381             writer.next().write_tagged_implicit(Tag::context(28), |writer| {
382                 writer.write_i64(456789)
383             });
384             writer.next().write_tagged(Tag::context(345678), |writer| {
385                 writer.write_bytes(b"Foo")
386             });
387             writer.next().write_tagged(Tag::context(27), |writer| {
388                 writer.write_i64(456790)
389             });
390             writer.next().write_tagged(Tag::context(345677), |writer| {
391                 writer.write_bytes(b"Bar")
392             });
393         })
394     });
395     assert_eq!(data, vec![
396         49, 32, 187, 5, 2, 3, 6, 248, 86, 156, 3, 6, 248, 85, 191, 149, 140,
397         77, 5, 4, 3, 66, 97, 114, 191, 149, 140, 78, 5, 4, 3, 70, 111, 111]);
398 }
399 
400 #[test]
test_der_write_set_of()401 fn test_der_write_set_of() {
402     let tests : &[(&[i64], &[u8])] = &[
403         (&[-129, -128, 127, 128], &[
404             49, 14, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127]),
405         (&[-128, 127, 128], &[
406             49, 10, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128]),
407         (&[-129, -128, 127, 128, 32768], &[
408             49, 19, 2, 1, 127, 2, 1, 128, 2, 2, 0, 128, 2, 2, 255, 127,
409             2, 3, 0, 128, 0]),
410     ];
411     for &(value, edata) in tests {
412         let data = construct_der(|writer| {
413             writer.write_set_of(|writer| {
414                 for &x in value {
415                     writer.next().write_i64(x);
416                 }
417             })
418         });
419         assert_eq!(data, edata);
420     }
421 }
422 
423 #[test]
test_der_write_tagged()424 fn test_der_write_tagged() {
425     let data = construct_der(|writer| {
426         writer.write_tagged(Tag::context(3), |writer| {
427             writer.write_i64(10)
428         })
429     });
430     assert_eq!(data, vec![163, 3, 2, 1, 10]);
431 }
432 
433 #[test]
test_der_write_tagged_implicit()434 fn test_der_write_tagged_implicit() {
435     let data = construct_der(|writer| {
436         writer.write_tagged_implicit(Tag::context(3), |writer| {
437             writer.write_i64(10)
438         })
439     });
440     assert_eq!(data, vec![131, 1, 10]);
441 }
442