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