2 * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the OpenSSL license (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
13 #include "internal/asn1t.h"
14 #include "internal/numbers.h"
15 #include "test_main.h"
19 # pragma GCC diagnostic ignored "-Wunused-function"
20 # pragma GCC diagnostic ignored "-Wformat"
23 # pragma clang diagnostic ignored "-Wunused-function"
24 # pragma clang diagnostic ignored "-Wformat"
27 /***** Custom test data ******************************************************/
30 * We conduct tests with these arrays for every type we try out.
31 * You will find the expected results together with the test structures
32 * for each type, further down.
35 static unsigned char t_zero
[] = {
38 static unsigned char t_one
[] = {
41 static unsigned char t_longundef
[] = {
42 0x7f, 0xff, 0xff, 0xff
44 static unsigned char t_9bytes_1
[] = {
45 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
47 static unsigned char t_8bytes_1
[] = {
48 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
50 static unsigned char t_8bytes_2
[] = {
51 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
53 static unsigned char t_8bytes_3_pad
[] = {
54 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
56 static unsigned char t_8bytes_4_neg
[] = {
57 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
59 static unsigned char t_8bytes_5_negpad
[] = {
60 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
64 static unsigned char t_5bytes_1
[] = {
65 0x01, 0xff, 0xff, 0xff, 0xff
67 static unsigned char t_4bytes_1
[] = {
68 0x00, 0x80, 0x00, 0x00, 0x00
70 /* We make the last byte 0xfe to avoid a clash with ASN1_LONG_UNDEF */
71 static unsigned char t_4bytes_2
[] = {
72 0x7f, 0xff, 0xff, 0xfe
74 static unsigned char t_4bytes_3_pad
[] = {
75 0x00, 0x7f, 0xff, 0xff, 0xfe
77 static unsigned char t_4bytes_4_neg
[] = {
78 0x80, 0x00, 0x00, 0x00
80 static unsigned char t_4bytes_5_negpad
[] = {
81 0xff, 0x80, 0x00, 0x00, 0x00
85 unsigned char *bytes1
;
87 unsigned char *bytes2
;
90 #define CUSTOM_DATA(v) \
91 { v, sizeof(v), t_one, sizeof(t_one) }, \
92 { t_one, sizeof(t_one), v, sizeof(v) }
94 static TEST_CUSTOM_DATA test_custom_data
[] = {
96 CUSTOM_DATA(t_longundef
),
98 CUSTOM_DATA(t_9bytes_1
),
99 CUSTOM_DATA(t_8bytes_1
),
100 CUSTOM_DATA(t_8bytes_2
),
101 CUSTOM_DATA(t_8bytes_3_pad
),
102 CUSTOM_DATA(t_8bytes_4_neg
),
103 CUSTOM_DATA(t_8bytes_5_negpad
),
104 CUSTOM_DATA(t_5bytes_1
),
105 CUSTOM_DATA(t_4bytes_1
),
106 CUSTOM_DATA(t_4bytes_2
),
107 CUSTOM_DATA(t_4bytes_3_pad
),
108 CUSTOM_DATA(t_4bytes_4_neg
),
109 CUSTOM_DATA(t_4bytes_5_negpad
),
113 /***** Type specific test data ***********************************************/
116 * First, a few utility things that all type specific data can use, or in some
121 * For easy creation of arrays of expected data. These macros correspond to
122 * the uses of CUSTOM_DATA above.
124 #define CUSTOM_EXPECTED_SUCCESS(num, znum) \
127 #define CUSTOM_EXPECTED_FAILURE \
132 * A structure to collect all test information in. There MUST be one instance
133 * of this for each test
135 typedef int i2d_fn(void **a
, unsigned char **pp
);
136 typedef void *d2i_fn(void **a
, unsigned char **pp
, long length
);
137 typedef void ifree_fn(void *a
);
140 int skip
; /* 1 if this package should be skipped */
142 /* An array of structures to compare decoded custom data with */
143 void *encode_expectations
;
144 size_t encode_expectations_size
;
145 size_t encode_expectations_elem_size
;
148 * An array of structures that are encoded into a DER blob, which is
149 * then decoded, and result gets compared with the original.
152 size_t encdec_data_size
;
153 size_t encdec_data_elem_size
;
155 /* The i2d function to use with this type */
157 /* The d2i function to use with this type */
159 /* Function to free a decoded structure */
163 /* To facilitate the creation of an encdec_data array */
164 #define ENCDEC_DATA(num, znum) \
165 { 0xff, num, 1 }, { 0xff, 1, znum }
166 #define ENCDEC_ARRAY(max, zmax, min, zmin) \
167 ENCDEC_DATA(max,zmax), \
168 ENCDEC_DATA(min,zmin), \
170 ENCDEC_DATA(-1, -1), \
171 ENCDEC_DATA(0, ASN1_LONG_UNDEF)
173 /***** LONG ******************************************************************/
176 /* If decoding is expected to succeed, set this to 1, otherwise 0 */
177 ASN1_BOOLEAN success
;
182 ASN1_SEQUENCE(ASN1_LONG_DATA
) = {
183 ASN1_SIMPLE(ASN1_LONG_DATA
, success
, ASN1_FBOOLEAN
),
184 ASN1_SIMPLE(ASN1_LONG_DATA
, test_long
, LONG
),
185 ASN1_EXP_OPT(ASN1_LONG_DATA
, test_zlong
, ZLONG
, 0)
186 } static_ASN1_SEQUENCE_END(ASN1_LONG_DATA
)
188 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_LONG_DATA
)
189 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_LONG_DATA
)
191 static ASN1_LONG_DATA long_expected_32bit
[] = {
192 /* The following should fail on the second because it's the default */
193 { 0xff, 0, 1 }, { 0, 0, 0 }, /* t_zero */
194 { 0, 0, 0 }, { 0xff, 1, 0x7fffffff }, /* t_longundef */
195 CUSTOM_EXPECTED_SUCCESS(1, 1), /* t_one */
196 CUSTOM_EXPECTED_FAILURE
, /* t_9bytes_1 */
197 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_1 */
198 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_2 */
199 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_3_pad */
200 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_4_neg */
201 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_5_negpad */
202 CUSTOM_EXPECTED_FAILURE
, /* t_5bytes_1 */
203 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_1 (too large positive) */
204 CUSTOM_EXPECTED_SUCCESS(INT32_MAX
- 1, INT32_MAX
-1), /* t_4bytes_2 */
205 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_3_pad (illegal padding) */
206 CUSTOM_EXPECTED_SUCCESS(INT32_MIN
, INT32_MIN
), /* t_4bytes_4_neg */
207 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_5_negpad (illegal padding) */
209 static ASN1_LONG_DATA long_encdec_data_32bit
[] = {
210 ENCDEC_ARRAY(LONG_MAX
- 1, LONG_MAX
, LONG_MIN
, LONG_MIN
),
211 /* Check that default numbers fail */
212 { 0, ASN1_LONG_UNDEF
, 1 }, { 0, 1, 0 }
215 static TEST_PACKAGE long_test_package_32bit
= {
216 "LONG", sizeof(long) != 4,
218 sizeof(long_expected_32bit
), sizeof(long_expected_32bit
[0]),
219 long_encdec_data_32bit
,
220 sizeof(long_encdec_data_32bit
), sizeof(long_encdec_data_32bit
[0]),
221 (i2d_fn
*)i2d_ASN1_LONG_DATA
, (d2i_fn
*)d2i_ASN1_LONG_DATA
,
222 (ifree_fn
*)ASN1_LONG_DATA_free
225 static ASN1_LONG_DATA long_expected_64bit
[] = {
226 /* The following should fail on the second because it's the default */
227 { 0xff, 0, 1 }, { 0, 0, 0 }, /* t_zero */
228 { 0, 0, 0 }, { 0xff, 1, 0x7fffffff }, /* t_longundef */
229 CUSTOM_EXPECTED_SUCCESS(1, 1), /* t_one */
230 CUSTOM_EXPECTED_FAILURE
, /* t_9bytes_1 */
231 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_1 */
232 CUSTOM_EXPECTED_SUCCESS(LONG_MAX
, LONG_MAX
), /* t_8bytes_2 */
233 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_3_pad (illegal padding) */
234 CUSTOM_EXPECTED_SUCCESS(LONG_MIN
, LONG_MIN
), /* t_8bytes_4_neg */
235 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_5_negpad (illegal padding) */
236 CUSTOM_EXPECTED_SUCCESS((long)0x1ffffffff, (long)0x1ffffffff), /* t_5bytes_1 */
237 CUSTOM_EXPECTED_SUCCESS((long)0x80000000, (long)0x80000000), /* t_4bytes_1 */
238 CUSTOM_EXPECTED_SUCCESS(INT32_MAX
- 1, INT32_MAX
-1), /* t_4bytes_2 */
239 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_3_pad (illegal padding) */
240 CUSTOM_EXPECTED_SUCCESS(INT32_MIN
, INT32_MIN
), /* t_4bytes_4_neg */
241 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_5_negpad (illegal padding) */
243 static ASN1_LONG_DATA long_encdec_data_64bit
[] = {
244 ENCDEC_ARRAY(LONG_MAX
, LONG_MAX
, LONG_MIN
, LONG_MIN
),
245 /* Check that default numbers fail */
246 { 0, ASN1_LONG_UNDEF
, 1 }, { 0, 1, 0 }
249 static TEST_PACKAGE long_test_package_64bit
= {
250 "LONG", sizeof(long) != 8,
252 sizeof(long_expected_64bit
), sizeof(long_expected_64bit
[0]),
253 long_encdec_data_64bit
,
254 sizeof(long_encdec_data_64bit
), sizeof(long_encdec_data_64bit
[0]),
255 (i2d_fn
*)i2d_ASN1_LONG_DATA
, (d2i_fn
*)d2i_ASN1_LONG_DATA
,
256 (ifree_fn
*)ASN1_LONG_DATA_free
259 /***** INT32 *****************************************************************/
262 ASN1_BOOLEAN success
;
267 ASN1_SEQUENCE(ASN1_INT32_DATA
) = {
268 ASN1_SIMPLE(ASN1_INT32_DATA
, success
, ASN1_FBOOLEAN
),
269 ASN1_SIMPLE(ASN1_INT32_DATA
, test_int32
, INT32
),
270 ASN1_EXP_OPT(ASN1_INT32_DATA
, test_zint32
, ZINT32
, 0)
271 } static_ASN1_SEQUENCE_END(ASN1_INT32_DATA
)
273 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_INT32_DATA
)
274 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_INT32_DATA
)
276 static ASN1_INT32_DATA int32_expected
[] = {
277 CUSTOM_EXPECTED_SUCCESS(0, 0), /* t_zero */
278 CUSTOM_EXPECTED_SUCCESS(ASN1_LONG_UNDEF
, ASN1_LONG_UNDEF
), /* t_zero */
279 CUSTOM_EXPECTED_SUCCESS(1, 1), /* t_one */
280 CUSTOM_EXPECTED_FAILURE
, /* t_9bytes_1 */
281 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_1 */
282 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_2 */
283 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_3_pad */
284 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_4_neg */
285 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_5_negpad */
286 CUSTOM_EXPECTED_FAILURE
, /* t_5bytes_1 */
287 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_1 (too large positive) */
288 CUSTOM_EXPECTED_SUCCESS(INT32_MAX
- 1, INT32_MAX
-1), /* t_4bytes_2 */
289 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_3_pad (illegal padding) */
290 CUSTOM_EXPECTED_SUCCESS(INT32_MIN
, INT32_MIN
), /* t_4bytes_4_neg */
291 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_5_negpad (illegal padding) */
293 static ASN1_INT32_DATA int32_encdec_data
[] = {
294 ENCDEC_ARRAY(INT32_MAX
, INT32_MAX
, INT32_MIN
, INT32_MIN
),
297 static TEST_PACKAGE int32_test_package
= {
299 int32_expected
, sizeof(int32_expected
), sizeof(int32_expected
[0]),
300 int32_encdec_data
, sizeof(int32_encdec_data
), sizeof(int32_encdec_data
[0]),
301 (i2d_fn
*)i2d_ASN1_INT32_DATA
, (d2i_fn
*)d2i_ASN1_INT32_DATA
,
302 (ifree_fn
*)ASN1_INT32_DATA_free
305 /***** UINT32 ****************************************************************/
308 ASN1_BOOLEAN success
;
309 uint32_t test_uint32
;
310 uint32_t test_zuint32
;
313 ASN1_SEQUENCE(ASN1_UINT32_DATA
) = {
314 ASN1_SIMPLE(ASN1_UINT32_DATA
, success
, ASN1_FBOOLEAN
),
315 ASN1_SIMPLE(ASN1_UINT32_DATA
, test_uint32
, UINT32
),
316 ASN1_EXP_OPT(ASN1_UINT32_DATA
, test_zuint32
, ZUINT32
, 0)
317 } static_ASN1_SEQUENCE_END(ASN1_UINT32_DATA
)
319 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_UINT32_DATA
)
320 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_UINT32_DATA
)
322 static ASN1_UINT32_DATA uint32_expected
[] = {
323 CUSTOM_EXPECTED_SUCCESS(0, 0), /* t_zero */
324 CUSTOM_EXPECTED_SUCCESS(ASN1_LONG_UNDEF
, ASN1_LONG_UNDEF
), /* t_zero */
325 CUSTOM_EXPECTED_SUCCESS(1, 1), /* t_one */
326 CUSTOM_EXPECTED_FAILURE
, /* t_9bytes_1 */
327 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_1 */
328 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_2 */
329 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_3_pad */
330 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_4_neg */
331 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_5_negpad */
332 CUSTOM_EXPECTED_FAILURE
, /* t_5bytes_1 */
333 CUSTOM_EXPECTED_SUCCESS(0x80000000, 0x80000000), /* t_4bytes_1 */
334 CUSTOM_EXPECTED_SUCCESS(INT32_MAX
- 1, INT32_MAX
-1), /* t_4bytes_2 */
335 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_3_pad (illegal padding) */
336 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_4_neg (illegal negative value) */
337 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_5_negpad (illegal padding) */
339 static ASN1_UINT32_DATA uint32_encdec_data
[] = {
340 ENCDEC_ARRAY(UINT32_MAX
, UINT32_MAX
, 0, 0),
343 static TEST_PACKAGE uint32_test_package
= {
345 uint32_expected
, sizeof(uint32_expected
), sizeof(uint32_expected
[0]),
346 uint32_encdec_data
, sizeof(uint32_encdec_data
), sizeof(uint32_encdec_data
[0]),
347 (i2d_fn
*)i2d_ASN1_UINT32_DATA
, (d2i_fn
*)d2i_ASN1_UINT32_DATA
,
348 (ifree_fn
*)ASN1_UINT32_DATA_free
351 /***** INT64 *****************************************************************/
354 ASN1_BOOLEAN success
;
359 ASN1_SEQUENCE(ASN1_INT64_DATA
) = {
360 ASN1_SIMPLE(ASN1_INT64_DATA
, success
, ASN1_FBOOLEAN
),
361 ASN1_SIMPLE(ASN1_INT64_DATA
, test_int64
, INT64
),
362 ASN1_EXP_OPT(ASN1_INT64_DATA
, test_zint64
, ZINT64
, 0)
363 } static_ASN1_SEQUENCE_END(ASN1_INT64_DATA
)
365 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_INT64_DATA
)
366 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_INT64_DATA
)
368 static ASN1_INT64_DATA int64_expected
[] = {
369 CUSTOM_EXPECTED_SUCCESS(0, 0), /* t_zero */
370 CUSTOM_EXPECTED_SUCCESS(ASN1_LONG_UNDEF
, ASN1_LONG_UNDEF
), /* t_zero */
371 CUSTOM_EXPECTED_SUCCESS(1, 1), /* t_one */
372 CUSTOM_EXPECTED_FAILURE
, /* t_9bytes_1 */
373 CUSTOM_EXPECTED_SUCCESS(INT64_MIN
, INT64_MIN
), /* t_8bytes_1 */
374 CUSTOM_EXPECTED_SUCCESS(INT64_MAX
, INT64_MAX
), /* t_8bytes_2 */
375 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_3_pad (illegal padding) */
376 CUSTOM_EXPECTED_SUCCESS(INT64_MIN
, INT64_MIN
), /* t_8bytes_4_neg */
377 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_5_negpad (illegal padding) */
378 CUSTOM_EXPECTED_SUCCESS(0x1ffffffff, 0x1ffffffff), /* t_5bytes_1 */
379 CUSTOM_EXPECTED_SUCCESS(0x80000000, 0x80000000), /* t_4bytes_1 */
380 CUSTOM_EXPECTED_SUCCESS(INT32_MAX
- 1, INT32_MAX
-1), /* t_4bytes_2 */
381 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_3_pad (illegal padding) */
382 CUSTOM_EXPECTED_SUCCESS(0x80000000, 0x80000000), /* t_4bytes_4_neg */
383 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_5_negpad (illegal padding) */
385 static ASN1_INT64_DATA int64_encdec_data
[] = {
386 ENCDEC_ARRAY(INT64_MAX
, INT64_MAX
, INT64_MIN
, INT64_MIN
),
387 ENCDEC_ARRAY(INT32_MAX
, INT32_MAX
, INT32_MIN
, INT32_MIN
),
390 static TEST_PACKAGE int64_test_package
= {
392 int64_expected
, sizeof(int64_expected
), sizeof(int64_expected
[0]),
393 int64_encdec_data
, sizeof(int64_encdec_data
), sizeof(int64_encdec_data
[0]),
394 (i2d_fn
*)i2d_ASN1_INT64_DATA
, (d2i_fn
*)d2i_ASN1_INT64_DATA
,
395 (ifree_fn
*)ASN1_INT64_DATA_free
398 /***** UINT64 ****************************************************************/
401 ASN1_BOOLEAN success
;
402 uint64_t test_uint64
;
403 uint64_t test_zuint64
;
406 ASN1_SEQUENCE(ASN1_UINT64_DATA
) = {
407 ASN1_SIMPLE(ASN1_UINT64_DATA
, success
, ASN1_FBOOLEAN
),
408 ASN1_SIMPLE(ASN1_UINT64_DATA
, test_uint64
, UINT64
),
409 ASN1_EXP_OPT(ASN1_UINT64_DATA
, test_zuint64
, ZUINT64
, 0)
410 } static_ASN1_SEQUENCE_END(ASN1_UINT64_DATA
)
412 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_UINT64_DATA
)
413 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_UINT64_DATA
)
415 static ASN1_UINT64_DATA uint64_expected
[] = {
416 CUSTOM_EXPECTED_SUCCESS(0, 0), /* t_zero */
417 CUSTOM_EXPECTED_SUCCESS(ASN1_LONG_UNDEF
, ASN1_LONG_UNDEF
), /* t_zero */
418 CUSTOM_EXPECTED_SUCCESS(1, 1), /* t_one */
419 CUSTOM_EXPECTED_FAILURE
, /* t_9bytes_1 */
420 CUSTOM_EXPECTED_SUCCESS(INT64_MIN
, INT64_MIN
), /* t_8bytes_1 */
421 CUSTOM_EXPECTED_SUCCESS(INT64_MAX
, INT64_MAX
), /* t_8bytes_2 */
422 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_3_pad */
423 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_4_neg */
424 CUSTOM_EXPECTED_FAILURE
, /* t_8bytes_5_negpad */
425 CUSTOM_EXPECTED_SUCCESS(0x1ffffffff, 0x1ffffffff), /* t_5bytes_1 */
426 CUSTOM_EXPECTED_SUCCESS(0x80000000, 0x80000000), /* t_4bytes_1 */
427 CUSTOM_EXPECTED_SUCCESS(INT32_MAX
- 1, INT32_MAX
-1), /* t_4bytes_2 */
428 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_3_pad (illegal padding) */
429 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_4_neg (illegal negative value) */
430 CUSTOM_EXPECTED_FAILURE
, /* t_4bytes_5_negpad (illegal padding) */
432 static ASN1_UINT64_DATA uint64_encdec_data
[] = {
433 ENCDEC_ARRAY(UINT64_MAX
, UINT64_MAX
, 0, 0),
436 static TEST_PACKAGE uint64_test_package
= {
438 uint64_expected
, sizeof(uint64_expected
), sizeof(uint64_expected
[0]),
439 uint64_encdec_data
, sizeof(uint64_encdec_data
), sizeof(uint64_encdec_data
[0]),
440 (i2d_fn
*)i2d_ASN1_UINT64_DATA
, (d2i_fn
*)d2i_ASN1_UINT64_DATA
,
441 (ifree_fn
*)ASN1_UINT64_DATA_free
444 /***** General testing functions *********************************************/
447 /* Template structure to map onto any test data structure */
449 ASN1_BOOLEAN success
;
450 unsigned char bytes
[1]; /* In reality, there's more */
454 * do_decode returns a tristate:
457 * 0 decoded structure wasn't what was expected (failure)
458 * 1 decoded structure was what was expected (success)
460 static int do_decode(unsigned char *bytes
, long nbytes
,
461 const EXPECTED
*expected
, size_t expected_size
,
462 const TEST_PACKAGE
*package
)
464 EXPECTED
*enctst
= NULL
;
465 const unsigned char *start
;
469 enctst
= package
->d2i(NULL
, &bytes
, nbytes
);
470 if (enctst
== NULL
) {
471 if (expected
->success
== 0) {
478 if (start
+ nbytes
== bytes
479 && memcmp(enctst
, expected
, expected_size
) == 0)
485 package
->ifree(enctst
);
489 /* Do an encode/decode round trip */
490 static int do_enc_dec(EXPECTED
*bytes
, long nbytes
,
491 const TEST_PACKAGE
*package
)
493 unsigned char *data
= NULL
;
498 len
= package
->i2d(p
, &data
);
502 ret
= do_decode(data
, len
, bytes
, nbytes
, package
);
507 static size_t der_encode_length(size_t len
, unsigned char **pp
)
511 OPENSSL_assert(len
< 0x8000);
523 *(*pp
)++ = lenbytes
- 1;
525 *(*pp
)++ = 0x80 | len
;
527 *(*pp
)++ = 0x80 | (len
>> 8);
528 *(*pp
)++ = len
& 0xff;
535 /* Attempt to decode a custom encoding of the test structure */
536 static int do_decode_custom(const TEST_CUSTOM_DATA
*custom_data
,
537 const EXPECTED
*expected
, size_t expected_size
,
538 const TEST_PACKAGE
*package
)
540 size_t firstbytes
, secondbytes
, secondbytesinner
, seqbytes
;
541 const unsigned char t_true
[] = { V_ASN1_BOOLEAN
, 0x01, 0xff };
542 unsigned char *encoding
, *p
= NULL
;
546 * The first item is just an INTEGER tag, INTEGER length and INTEGER content
549 1 + der_encode_length(custom_data
->nbytes1
, NULL
)
550 + custom_data
->nbytes1
;
553 * The second item is an explicit tag, content length, INTEGER tag,
554 * INTEGER length, INTEGER bytes
557 1 + der_encode_length(custom_data
->nbytes2
, NULL
)
558 + custom_data
->nbytes2
;
560 1 + der_encode_length(secondbytesinner
, NULL
) + secondbytesinner
;
563 * The whole sequence is the sequence tag, content length, BOOLEAN true
564 * (copied from t_true), the first (firstbytes) and second (secondbytes)
568 1 + der_encode_length(sizeof(t_true
) + firstbytes
+ secondbytes
, NULL
)
569 + sizeof(t_true
) + firstbytes
+ secondbytes
;
571 encoding
= p
= OPENSSL_malloc(seqbytes
);
572 if (encoding
== NULL
)
577 der_encode_length(sizeof(t_true
) + firstbytes
+ secondbytes
, &p
);
579 /* ASN1_BOOLEAN TRUE */
580 memcpy(p
, t_true
, sizeof(t_true
)); /* Marks decoding success */
583 /* First INTEGER item (non-optional) */
584 *p
++ = V_ASN1_INTEGER
;
585 der_encode_length(custom_data
->nbytes1
, &p
);
586 memcpy(p
, custom_data
->bytes1
, custom_data
->nbytes1
);
587 p
+= custom_data
->nbytes1
;
589 /* Second INTEGER item (optional) */
590 /* Start with the explicit optional tag */
592 der_encode_length(secondbytesinner
, &p
);
593 *p
++ = V_ASN1_INTEGER
;
594 der_encode_length(custom_data
->nbytes2
, &p
);
595 memcpy(p
, custom_data
->bytes2
, custom_data
->nbytes2
);
596 p
+= custom_data
->nbytes2
;
598 OPENSSL_assert(seqbytes
== (size_t)(p
- encoding
));
600 ret
= do_decode(encoding
, seqbytes
, expected
, expected_size
, package
);
601 OPENSSL_free(encoding
);
607 static int test_intern(const TEST_PACKAGE
*package
)
616 /* Do decode_custom checks */
617 nelems
= package
->encode_expectations_size
618 / package
->encode_expectations_elem_size
;
619 OPENSSL_assert(nelems
==
620 sizeof(test_custom_data
) / sizeof(test_custom_data
[0]));
621 for (i
= 0; i
< nelems
; i
++) {
622 size_t pos
= i
* package
->encode_expectations_elem_size
;
623 switch (do_decode_custom(&test_custom_data
[i
],
624 (EXPECTED
*)&((unsigned char *)package
625 ->encode_expectations
)[pos
],
626 package
->encode_expectations_elem_size
,
629 fprintf(stderr
, "Failed custom decode round trip %u of %s\n",
631 ERR_print_errors_fp(stderr
);
636 fprintf(stderr
, "Custom decode round trip %u of %s mismatch\n",
643 OPENSSL_die("do_enc_dec() return unknown value",
648 /* Do enc_dec checks */
649 nelems
= package
->encdec_data_size
/ package
->encdec_data_elem_size
;
650 for (i
= 0; i
< nelems
; i
++) {
651 size_t pos
= i
* package
->encdec_data_elem_size
;
652 switch (do_enc_dec((EXPECTED
*)&((unsigned char *)package
654 package
->encdec_data_elem_size
,
657 fprintf(stderr
, "Failed encode/decode round trip %u of %s\n",
659 ERR_print_errors_fp(stderr
);
664 fprintf(stderr
, "Encode/decode round trip %u of %s mismatch\n",
671 OPENSSL_die("do_enc_dec() return unknown value",
679 static int test_long_32bit(void)
681 return test_intern(&long_test_package_32bit
);
684 static int test_long_64bit(void)
686 return test_intern(&long_test_package_64bit
);
689 static int test_int32(void)
691 return test_intern(&int32_test_package
);
694 static int test_uint32(void)
696 return test_intern(&uint32_test_package
);
699 static int test_int64(void)
701 return test_intern(&int64_test_package
);
704 static int test_uint64(void)
706 return test_intern(&uint64_test_package
);
709 void register_tests(void)
711 ADD_TEST(test_long_32bit
);
712 ADD_TEST(test_long_64bit
);
713 ADD_TEST(test_int32
);
714 ADD_TEST(test_uint32
);
715 ADD_TEST(test_int64
);
716 ADD_TEST(test_uint64
);