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 <openssl/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 #if OPENSSL_API_COMPAT < 0x10200000L
174 /***** LONG ******************************************************************/
177 /* If decoding is expected to succeed, set this to 1, otherwise 0 */
178 ASN1_BOOLEAN success;
183 ASN1_SEQUENCE(ASN1_LONG_DATA) = {
184 ASN1_SIMPLE(ASN1_LONG_DATA, success, ASN1_FBOOLEAN),
185 ASN1_SIMPLE(ASN1_LONG_DATA, test_long, LONG),
186 ASN1_EXP_OPT(ASN1_LONG_DATA, test_zlong, ZLONG, 0)
187 } static_ASN1_SEQUENCE_END(ASN1_LONG_DATA)
189 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_LONG_DATA)
190 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_LONG_DATA)
192 static ASN1_LONG_DATA long_expected_32bit[] = {
193 /* The following should fail on the second because it's the default */
194 { 0xff, 0, 1 }, { 0, 0, 0 }, /* t_zero */
195 { 0, 0, 0 }, { 0xff, 1, 0x7fffffff }, /* t_longundef */
196 CUSTOM_EXPECTED_SUCCESS(1, 1), /* t_one */
197 CUSTOM_EXPECTED_FAILURE, /* t_9bytes_1 */
198 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_1 */
199 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_2 */
200 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_3_pad */
201 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_4_neg */
202 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_5_negpad */
203 CUSTOM_EXPECTED_FAILURE, /* t_5bytes_1 */
204 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_1 (too large positive) */
205 CUSTOM_EXPECTED_SUCCESS(INT32_MAX - 1, INT32_MAX -1), /* t_4bytes_2 */
206 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_3_pad (illegal padding) */
207 CUSTOM_EXPECTED_SUCCESS(INT32_MIN, INT32_MIN), /* t_4bytes_4_neg */
208 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_5_negpad (illegal padding) */
210 static ASN1_LONG_DATA long_encdec_data_32bit[] = {
211 ENCDEC_ARRAY(LONG_MAX - 1, LONG_MAX, LONG_MIN, LONG_MIN),
212 /* Check that default numbers fail */
213 { 0, ASN1_LONG_UNDEF, 1 }, { 0, 1, 0 }
216 static TEST_PACKAGE long_test_package_32bit = {
217 "LONG", sizeof(long) != 4,
219 sizeof(long_expected_32bit), sizeof(long_expected_32bit[0]),
220 long_encdec_data_32bit,
221 sizeof(long_encdec_data_32bit), sizeof(long_encdec_data_32bit[0]),
222 (i2d_fn *)i2d_ASN1_LONG_DATA, (d2i_fn *)d2i_ASN1_LONG_DATA,
223 (ifree_fn *)ASN1_LONG_DATA_free
226 static ASN1_LONG_DATA long_expected_64bit[] = {
227 /* The following should fail on the second because it's the default */
228 { 0xff, 0, 1 }, { 0, 0, 0 }, /* t_zero */
229 { 0, 0, 0 }, { 0xff, 1, 0x7fffffff }, /* t_longundef */
230 CUSTOM_EXPECTED_SUCCESS(1, 1), /* t_one */
231 CUSTOM_EXPECTED_FAILURE, /* t_9bytes_1 */
232 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_1 */
233 CUSTOM_EXPECTED_SUCCESS(LONG_MAX, LONG_MAX), /* t_8bytes_2 */
234 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_3_pad (illegal padding) */
235 CUSTOM_EXPECTED_SUCCESS(LONG_MIN, LONG_MIN), /* t_8bytes_4_neg */
236 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_5_negpad (illegal padding) */
237 CUSTOM_EXPECTED_SUCCESS((long)0x1ffffffff, (long)0x1ffffffff), /* t_5bytes_1 */
238 CUSTOM_EXPECTED_SUCCESS((long)0x80000000, (long)0x80000000), /* t_4bytes_1 */
239 CUSTOM_EXPECTED_SUCCESS(INT32_MAX - 1, INT32_MAX -1), /* t_4bytes_2 */
240 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_3_pad (illegal padding) */
241 CUSTOM_EXPECTED_SUCCESS(INT32_MIN, INT32_MIN), /* t_4bytes_4_neg */
242 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_5_negpad (illegal padding) */
244 static ASN1_LONG_DATA long_encdec_data_64bit[] = {
245 ENCDEC_ARRAY(LONG_MAX, LONG_MAX, LONG_MIN, LONG_MIN),
246 /* Check that default numbers fail */
247 { 0, ASN1_LONG_UNDEF, 1 }, { 0, 1, 0 }
250 static TEST_PACKAGE long_test_package_64bit = {
251 "LONG", sizeof(long) != 8,
253 sizeof(long_expected_64bit), sizeof(long_expected_64bit[0]),
254 long_encdec_data_64bit,
255 sizeof(long_encdec_data_64bit), sizeof(long_encdec_data_64bit[0]),
256 (i2d_fn *)i2d_ASN1_LONG_DATA, (d2i_fn *)d2i_ASN1_LONG_DATA,
257 (ifree_fn *)ASN1_LONG_DATA_free
261 /***** INT32 *****************************************************************/
264 ASN1_BOOLEAN success;
269 ASN1_SEQUENCE(ASN1_INT32_DATA) = {
270 ASN1_SIMPLE(ASN1_INT32_DATA, success, ASN1_FBOOLEAN),
271 ASN1_SIMPLE(ASN1_INT32_DATA, test_int32, INT32),
272 ASN1_EXP_OPT(ASN1_INT32_DATA, test_zint32, ZINT32, 0)
273 } static_ASN1_SEQUENCE_END(ASN1_INT32_DATA)
275 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_INT32_DATA)
276 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_INT32_DATA)
278 static ASN1_INT32_DATA int32_expected[] = {
279 CUSTOM_EXPECTED_SUCCESS(0, 0), /* t_zero */
280 CUSTOM_EXPECTED_SUCCESS(ASN1_LONG_UNDEF, ASN1_LONG_UNDEF), /* t_zero */
281 CUSTOM_EXPECTED_SUCCESS(1, 1), /* t_one */
282 CUSTOM_EXPECTED_FAILURE, /* t_9bytes_1 */
283 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_1 */
284 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_2 */
285 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_3_pad */
286 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_4_neg */
287 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_5_negpad */
288 CUSTOM_EXPECTED_FAILURE, /* t_5bytes_1 */
289 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_1 (too large positive) */
290 CUSTOM_EXPECTED_SUCCESS(INT32_MAX - 1, INT32_MAX -1), /* t_4bytes_2 */
291 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_3_pad (illegal padding) */
292 CUSTOM_EXPECTED_SUCCESS(INT32_MIN, INT32_MIN), /* t_4bytes_4_neg */
293 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_5_negpad (illegal padding) */
295 static ASN1_INT32_DATA int32_encdec_data[] = {
296 ENCDEC_ARRAY(INT32_MAX, INT32_MAX, INT32_MIN, INT32_MIN),
299 static TEST_PACKAGE int32_test_package = {
301 int32_expected, sizeof(int32_expected), sizeof(int32_expected[0]),
302 int32_encdec_data, sizeof(int32_encdec_data), sizeof(int32_encdec_data[0]),
303 (i2d_fn *)i2d_ASN1_INT32_DATA, (d2i_fn *)d2i_ASN1_INT32_DATA,
304 (ifree_fn *)ASN1_INT32_DATA_free
307 /***** UINT32 ****************************************************************/
310 ASN1_BOOLEAN success;
311 uint32_t test_uint32;
312 uint32_t test_zuint32;
315 ASN1_SEQUENCE(ASN1_UINT32_DATA) = {
316 ASN1_SIMPLE(ASN1_UINT32_DATA, success, ASN1_FBOOLEAN),
317 ASN1_SIMPLE(ASN1_UINT32_DATA, test_uint32, UINT32),
318 ASN1_EXP_OPT(ASN1_UINT32_DATA, test_zuint32, ZUINT32, 0)
319 } static_ASN1_SEQUENCE_END(ASN1_UINT32_DATA)
321 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_UINT32_DATA)
322 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_UINT32_DATA)
324 static ASN1_UINT32_DATA uint32_expected[] = {
325 CUSTOM_EXPECTED_SUCCESS(0, 0), /* t_zero */
326 CUSTOM_EXPECTED_SUCCESS(ASN1_LONG_UNDEF, ASN1_LONG_UNDEF), /* t_zero */
327 CUSTOM_EXPECTED_SUCCESS(1, 1), /* t_one */
328 CUSTOM_EXPECTED_FAILURE, /* t_9bytes_1 */
329 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_1 */
330 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_2 */
331 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_3_pad */
332 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_4_neg */
333 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_5_negpad */
334 CUSTOM_EXPECTED_FAILURE, /* t_5bytes_1 */
335 CUSTOM_EXPECTED_SUCCESS(0x80000000, 0x80000000), /* t_4bytes_1 */
336 CUSTOM_EXPECTED_SUCCESS(INT32_MAX - 1, INT32_MAX -1), /* t_4bytes_2 */
337 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_3_pad (illegal padding) */
338 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_4_neg (illegal negative value) */
339 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_5_negpad (illegal padding) */
341 static ASN1_UINT32_DATA uint32_encdec_data[] = {
342 ENCDEC_ARRAY(UINT32_MAX, UINT32_MAX, 0, 0),
345 static TEST_PACKAGE uint32_test_package = {
347 uint32_expected, sizeof(uint32_expected), sizeof(uint32_expected[0]),
348 uint32_encdec_data, sizeof(uint32_encdec_data), sizeof(uint32_encdec_data[0]),
349 (i2d_fn *)i2d_ASN1_UINT32_DATA, (d2i_fn *)d2i_ASN1_UINT32_DATA,
350 (ifree_fn *)ASN1_UINT32_DATA_free
353 /***** INT64 *****************************************************************/
356 ASN1_BOOLEAN success;
361 ASN1_SEQUENCE(ASN1_INT64_DATA) = {
362 ASN1_SIMPLE(ASN1_INT64_DATA, success, ASN1_FBOOLEAN),
363 ASN1_SIMPLE(ASN1_INT64_DATA, test_int64, INT64),
364 ASN1_EXP_OPT(ASN1_INT64_DATA, test_zint64, ZINT64, 0)
365 } static_ASN1_SEQUENCE_END(ASN1_INT64_DATA)
367 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_INT64_DATA)
368 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_INT64_DATA)
370 static ASN1_INT64_DATA int64_expected[] = {
371 CUSTOM_EXPECTED_SUCCESS(0, 0), /* t_zero */
372 CUSTOM_EXPECTED_SUCCESS(ASN1_LONG_UNDEF, ASN1_LONG_UNDEF), /* t_zero */
373 CUSTOM_EXPECTED_SUCCESS(1, 1), /* t_one */
374 CUSTOM_EXPECTED_FAILURE, /* t_9bytes_1 */
375 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_1 (too large positive) */
376 CUSTOM_EXPECTED_SUCCESS(INT64_MAX, INT64_MAX), /* t_8bytes_2 */
377 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_3_pad (illegal padding) */
378 CUSTOM_EXPECTED_SUCCESS(INT64_MIN, INT64_MIN), /* t_8bytes_4_neg */
379 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_5_negpad (illegal padding) */
380 CUSTOM_EXPECTED_SUCCESS(0x1ffffffff, 0x1ffffffff), /* t_5bytes_1 */
381 CUSTOM_EXPECTED_SUCCESS(0x80000000, 0x80000000), /* t_4bytes_1 */
382 CUSTOM_EXPECTED_SUCCESS(INT32_MAX - 1, INT32_MAX -1), /* t_4bytes_2 */
383 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_3_pad (illegal padding) */
384 CUSTOM_EXPECTED_SUCCESS(INT32_MIN, INT32_MIN), /* t_4bytes_4_neg */
385 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_5_negpad (illegal padding) */
387 static ASN1_INT64_DATA int64_encdec_data[] = {
388 ENCDEC_ARRAY(INT64_MAX, INT64_MAX, INT64_MIN, INT64_MIN),
389 ENCDEC_ARRAY(INT32_MAX, INT32_MAX, INT32_MIN, INT32_MIN),
392 static TEST_PACKAGE int64_test_package = {
394 int64_expected, sizeof(int64_expected), sizeof(int64_expected[0]),
395 int64_encdec_data, sizeof(int64_encdec_data), sizeof(int64_encdec_data[0]),
396 (i2d_fn *)i2d_ASN1_INT64_DATA, (d2i_fn *)d2i_ASN1_INT64_DATA,
397 (ifree_fn *)ASN1_INT64_DATA_free
400 /***** UINT64 ****************************************************************/
403 ASN1_BOOLEAN success;
404 uint64_t test_uint64;
405 uint64_t test_zuint64;
408 ASN1_SEQUENCE(ASN1_UINT64_DATA) = {
409 ASN1_SIMPLE(ASN1_UINT64_DATA, success, ASN1_FBOOLEAN),
410 ASN1_SIMPLE(ASN1_UINT64_DATA, test_uint64, UINT64),
411 ASN1_EXP_OPT(ASN1_UINT64_DATA, test_zuint64, ZUINT64, 0)
412 } static_ASN1_SEQUENCE_END(ASN1_UINT64_DATA)
414 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_UINT64_DATA)
415 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_UINT64_DATA)
417 static ASN1_UINT64_DATA uint64_expected[] = {
418 CUSTOM_EXPECTED_SUCCESS(0, 0), /* t_zero */
419 CUSTOM_EXPECTED_SUCCESS(ASN1_LONG_UNDEF, ASN1_LONG_UNDEF), /* t_zero */
420 CUSTOM_EXPECTED_SUCCESS(1, 1), /* t_one */
421 CUSTOM_EXPECTED_FAILURE, /* t_9bytes_1 */
422 CUSTOM_EXPECTED_SUCCESS((uint64_t)INT64_MAX+1, (uint64_t)INT64_MAX+1),
424 CUSTOM_EXPECTED_SUCCESS(INT64_MAX, INT64_MAX), /* t_8bytes_2 */
425 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_3_pad */
426 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_4_neg */
427 CUSTOM_EXPECTED_FAILURE, /* t_8bytes_5_negpad */
428 CUSTOM_EXPECTED_SUCCESS(0x1ffffffff, 0x1ffffffff), /* t_5bytes_1 */
429 CUSTOM_EXPECTED_SUCCESS(0x80000000, 0x80000000), /* t_4bytes_1 */
430 CUSTOM_EXPECTED_SUCCESS(INT32_MAX - 1, INT32_MAX -1), /* t_4bytes_2 */
431 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_3_pad (illegal padding) */
432 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_4_neg (illegal negative value) */
433 CUSTOM_EXPECTED_FAILURE, /* t_4bytes_5_negpad (illegal padding) */
435 static ASN1_UINT64_DATA uint64_encdec_data[] = {
436 ENCDEC_ARRAY(UINT64_MAX, UINT64_MAX, 0, 0),
439 static TEST_PACKAGE uint64_test_package = {
441 uint64_expected, sizeof(uint64_expected), sizeof(uint64_expected[0]),
442 uint64_encdec_data, sizeof(uint64_encdec_data), sizeof(uint64_encdec_data[0]),
443 (i2d_fn *)i2d_ASN1_UINT64_DATA, (d2i_fn *)d2i_ASN1_UINT64_DATA,
444 (ifree_fn *)ASN1_UINT64_DATA_free
447 /***** General testing functions *********************************************/
450 /* Template structure to map onto any test data structure */
452 ASN1_BOOLEAN success;
453 unsigned char bytes[1]; /* In reality, there's more */
457 * do_decode returns a tristate:
460 * 0 decoded structure wasn't what was expected (failure)
461 * 1 decoded structure was what was expected (success)
463 static int do_decode(unsigned char *bytes, long nbytes,
464 const EXPECTED *expected, size_t expected_size,
465 const TEST_PACKAGE *package)
467 EXPECTED *enctst = NULL;
468 const unsigned char *start;
472 enctst = package->d2i(NULL, &bytes, nbytes);
473 if (enctst == NULL) {
474 if (expected->success == 0) {
481 if (start + nbytes == bytes
482 && memcmp(enctst, expected, expected_size) == 0)
488 package->ifree(enctst);
492 /* Do an encode/decode round trip */
493 static int do_enc_dec(EXPECTED *bytes, long nbytes,
494 const TEST_PACKAGE *package)
496 unsigned char *data = NULL;
501 len = package->i2d(p, &data);
505 ret = do_decode(data, len, bytes, nbytes, package);
510 static size_t der_encode_length(size_t len, unsigned char **pp)
514 OPENSSL_assert(len < 0x8000);
526 *(*pp)++ = lenbytes - 1;
528 *(*pp)++ = 0x80 | len;
530 *(*pp)++ = 0x80 | (len >> 8);
531 *(*pp)++ = len & 0xff;
538 /* Attempt to decode a custom encoding of the test structure */
539 static int do_decode_custom(const TEST_CUSTOM_DATA *custom_data,
540 const EXPECTED *expected, size_t expected_size,
541 const TEST_PACKAGE *package)
543 size_t firstbytes, secondbytes, secondbytesinner, seqbytes;
544 const unsigned char t_true[] = { V_ASN1_BOOLEAN, 0x01, 0xff };
545 unsigned char *encoding, *p = NULL;
549 * The first item is just an INTEGER tag, INTEGER length and INTEGER content
552 1 + der_encode_length(custom_data->nbytes1, NULL)
553 + custom_data->nbytes1;
556 * The second item is an explicit tag, content length, INTEGER tag,
557 * INTEGER length, INTEGER bytes
560 1 + der_encode_length(custom_data->nbytes2, NULL)
561 + custom_data->nbytes2;
563 1 + der_encode_length(secondbytesinner, NULL) + secondbytesinner;
566 * The whole sequence is the sequence tag, content length, BOOLEAN true
567 * (copied from t_true), the first (firstbytes) and second (secondbytes)
571 1 + der_encode_length(sizeof(t_true) + firstbytes + secondbytes, NULL)
572 + sizeof(t_true) + firstbytes + secondbytes;
574 encoding = p = OPENSSL_malloc(seqbytes);
575 if (encoding == NULL)
580 der_encode_length(sizeof(t_true) + firstbytes + secondbytes, &p);
582 /* ASN1_BOOLEAN TRUE */
583 memcpy(p, t_true, sizeof(t_true)); /* Marks decoding success */
586 /* First INTEGER item (non-optional) */
587 *p++ = V_ASN1_INTEGER;
588 der_encode_length(custom_data->nbytes1, &p);
589 memcpy(p, custom_data->bytes1, custom_data->nbytes1);
590 p += custom_data->nbytes1;
592 /* Second INTEGER item (optional) */
593 /* Start with the explicit optional tag */
595 der_encode_length(secondbytesinner, &p);
596 *p++ = V_ASN1_INTEGER;
597 der_encode_length(custom_data->nbytes2, &p);
598 memcpy(p, custom_data->bytes2, custom_data->nbytes2);
599 p += custom_data->nbytes2;
601 OPENSSL_assert(seqbytes == (size_t)(p - encoding));
603 ret = do_decode(encoding, seqbytes, expected, expected_size, package);
604 OPENSSL_free(encoding);
610 static int test_intern(const TEST_PACKAGE *package)
619 /* Do decode_custom checks */
620 nelems = package->encode_expectations_size
621 / package->encode_expectations_elem_size;
622 OPENSSL_assert(nelems ==
623 sizeof(test_custom_data) / sizeof(test_custom_data[0]));
624 for (i = 0; i < nelems; i++) {
625 size_t pos = i * package->encode_expectations_elem_size;
626 switch (do_decode_custom(&test_custom_data[i],
627 (EXPECTED *)&((unsigned char *)package
628 ->encode_expectations)[pos],
629 package->encode_expectations_elem_size,
632 fprintf(stderr, "Failed custom decode round trip %u of %s\n",
634 ERR_print_errors_fp(stderr);
639 fprintf(stderr, "Custom decode round trip %u of %s mismatch\n",
646 OPENSSL_die("do_enc_dec() return unknown value",
651 /* Do enc_dec checks */
652 nelems = package->encdec_data_size / package->encdec_data_elem_size;
653 for (i = 0; i < nelems; i++) {
654 size_t pos = i * package->encdec_data_elem_size;
655 switch (do_enc_dec((EXPECTED *)&((unsigned char *)package
657 package->encdec_data_elem_size,
660 fprintf(stderr, "Failed encode/decode round trip %u of %s\n",
662 ERR_print_errors_fp(stderr);
667 fprintf(stderr, "Encode/decode round trip %u of %s mismatch\n",
674 OPENSSL_die("do_enc_dec() return unknown value",
682 #if OPENSSL_API_COMPAT < 0x10200000L
683 static int test_long_32bit(void)
685 return test_intern(&long_test_package_32bit);
688 static int test_long_64bit(void)
690 return test_intern(&long_test_package_64bit);
694 static int test_int32(void)
696 return test_intern(&int32_test_package);
699 static int test_uint32(void)
701 return test_intern(&uint32_test_package);
704 static int test_int64(void)
706 return test_intern(&int64_test_package);
709 static int test_uint64(void)
711 return test_intern(&uint64_test_package);
714 void register_tests(void)
716 #if OPENSSL_API_COMPAT < 0x10200000L
717 ADD_TEST(test_long_32bit);
718 ADD_TEST(test_long_64bit);
720 ADD_TEST(test_int32);
721 ADD_TEST(test_uint32);
722 ADD_TEST(test_int64);
723 ADD_TEST(test_uint64);