Act on deprecation of LONG and ZLONG, step 1
[openssl.git] / test / asn1_encode_test.c
1 /*
2  * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
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
8  */
9
10 #include <stdio.h>
11 #include <string.h>
12
13 #include <openssl/asn1t.h>
14 #include "internal/numbers.h"
15 #include "test_main.h"
16 #include "testutil.h"
17
18 #ifdef __GNUC__
19 # pragma GCC diagnostic ignored "-Wunused-function"
20 # pragma GCC diagnostic ignored "-Wformat"
21 #endif
22 #ifdef __clang__
23 # pragma clang diagnostic ignored "-Wunused-function"
24 # pragma clang diagnostic ignored "-Wformat"
25 #endif
26
27 /***** Custom test data ******************************************************/
28
29 /*
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.
33  */
34
35 static unsigned char t_zero[] = {
36     0x00
37 };
38 static unsigned char t_one[] = {
39     0x01
40 };
41 static unsigned char t_longundef[] = {
42     0x7f, 0xff, 0xff, 0xff
43 };
44 static unsigned char t_9bytes_1[] = {
45     0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
46 };
47 static unsigned char t_8bytes_1[] = {
48     0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
49 };
50 static unsigned char t_8bytes_2[] = {
51     0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
52 };
53 static unsigned char t_8bytes_3_pad[] = {
54     0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
55 };
56 static unsigned char t_8bytes_4_neg[] = {
57     0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
58 };
59 static unsigned char t_8bytes_5_negpad[] = {
60     0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
61 };
62
63 /* 32-bit long */
64 static unsigned char t_5bytes_1[] = {
65     0x01, 0xff, 0xff, 0xff, 0xff
66 };
67 static unsigned char t_4bytes_1[] = {
68     0x00, 0x80, 0x00, 0x00, 0x00
69 };
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
73 };
74 static unsigned char t_4bytes_3_pad[] = {
75     0x00, 0x7f, 0xff, 0xff, 0xfe
76 };
77 static unsigned char t_4bytes_4_neg[] = {
78     0x80, 0x00, 0x00, 0x00
79 };
80 static unsigned char t_4bytes_5_negpad[] = {
81     0xff, 0x80, 0x00, 0x00, 0x00
82 };
83
84 typedef struct {
85     unsigned char *bytes1;
86     size_t nbytes1;
87     unsigned char *bytes2;
88     size_t nbytes2;
89 } TEST_CUSTOM_DATA;
90 #define CUSTOM_DATA(v)                          \
91     { v, sizeof(v), t_one, sizeof(t_one) },     \
92     { t_one, sizeof(t_one), v, sizeof(v) }
93
94 static TEST_CUSTOM_DATA test_custom_data[] = {
95     CUSTOM_DATA(t_zero),
96     CUSTOM_DATA(t_longundef),
97     CUSTOM_DATA(t_one),
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),
110 };
111
112
113 /***** Type specific test data ***********************************************/
114
115 /*
116  * First, a few utility things that all type specific data can use, or in some
117  * cases, MUST use.
118  */
119
120 /*
121  * For easy creation of arrays of expected data.  These macros correspond to
122  * the uses of CUSTOM_DATA above.
123  */
124 #define CUSTOM_EXPECTED_SUCCESS(num, znum)      \
125     { 0xff, num, 1 },                           \
126     { 0xff, 1, znum }
127 #define CUSTOM_EXPECTED_FAILURE                 \
128     { 0, 0, 0 },                                \
129     { 0, 0, 0 }
130
131 /*
132  * A structure to collect all test information in.  There MUST be one instance
133  * of this for each test
134  */
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);
138 typedef struct {
139     char *name;
140     int skip;                    /* 1 if this package should be skipped */
141
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;
146
147     /*
148      * An array of structures that are encoded into a DER blob, which is
149      * then decoded, and result gets compared with the original.
150      */
151     void *encdec_data;
152     size_t encdec_data_size;
153     size_t encdec_data_elem_size;
154
155     /* The i2d function to use with this type */
156     i2d_fn *i2d;
157     /* The d2i function to use with this type */
158     d2i_fn *d2i;
159     /* Function to free a decoded structure */
160     ifree_fn *ifree;
161 } TEST_PACKAGE;
162
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),                      \
169     ENCDEC_DATA(1, 1),                          \
170     ENCDEC_DATA(-1, -1),                        \
171     ENCDEC_DATA(0, ASN1_LONG_UNDEF)
172
173 #if OPENSSL_API_COMPAT < 0x10200000L
174 /***** LONG ******************************************************************/
175
176 typedef struct {
177     /* If decoding is expected to succeed, set this to 1, otherwise 0 */
178     ASN1_BOOLEAN success;
179     long test_long;
180     long test_zlong;
181 } ASN1_LONG_DATA;
182
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)
188
189 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_LONG_DATA)
190 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_LONG_DATA)
191
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) */
209 };
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 }
214 };
215
216 static TEST_PACKAGE long_test_package_32bit = {
217     "LONG", sizeof(long) != 4,
218     long_expected_32bit,
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
224 };
225
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) */
243 };
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 }
248 };
249
250 static TEST_PACKAGE long_test_package_64bit = {
251     "LONG", sizeof(long) != 8,
252     long_expected_64bit,
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
258 };
259 #endif
260
261 /***** INT32 *****************************************************************/
262
263 typedef struct {
264     ASN1_BOOLEAN success;
265     int32_t test_int32;
266     int32_t test_zint32;
267 } ASN1_INT32_DATA;
268
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)
274
275 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_INT32_DATA)
276 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_INT32_DATA)
277
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) */
294 };
295 static ASN1_INT32_DATA int32_encdec_data[] = {
296     ENCDEC_ARRAY(INT32_MAX, INT32_MAX, INT32_MIN, INT32_MIN),
297 };
298
299 static TEST_PACKAGE int32_test_package = {
300     "INT32", 0,
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
305 };
306
307 /***** UINT32 ****************************************************************/
308
309 typedef struct {
310     ASN1_BOOLEAN success;
311     uint32_t test_uint32;
312     uint32_t test_zuint32;
313 } ASN1_UINT32_DATA;
314
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)
320
321 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_UINT32_DATA)
322 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_UINT32_DATA)
323
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) */
340 };
341 static ASN1_UINT32_DATA uint32_encdec_data[] = {
342     ENCDEC_ARRAY(UINT32_MAX, UINT32_MAX, 0, 0),
343 };
344
345 static TEST_PACKAGE uint32_test_package = {
346     "UINT32", 0,
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
351 };
352
353 /***** INT64 *****************************************************************/
354
355 typedef struct {
356     ASN1_BOOLEAN success;
357     int64_t test_int64;
358     int64_t test_zint64;
359 } ASN1_INT64_DATA;
360
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)
366
367 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_INT64_DATA)
368 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_INT64_DATA)
369
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_SUCCESS(INT64_MIN, INT64_MIN), /* t_8bytes_1 */
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(0x80000000, 0x80000000), /* t_4bytes_4_neg */
385     CUSTOM_EXPECTED_FAILURE,     /* t_4bytes_5_negpad (illegal padding) */
386 };
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),
390 };
391
392 static TEST_PACKAGE int64_test_package = {
393     "INT64", 0,
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
398 };
399
400 /***** UINT64 ****************************************************************/
401
402 typedef struct {
403     ASN1_BOOLEAN success;
404     uint64_t test_uint64;
405     uint64_t test_zuint64;
406 } ASN1_UINT64_DATA;
407
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)
413
414 IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(ASN1_UINT64_DATA)
415 IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(ASN1_UINT64_DATA)
416
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(INT64_MIN, INT64_MIN), /* t_8bytes_1 */
423     CUSTOM_EXPECTED_SUCCESS(INT64_MAX, INT64_MAX), /* t_8bytes_2 */
424     CUSTOM_EXPECTED_FAILURE,     /* t_8bytes_3_pad */
425     CUSTOM_EXPECTED_FAILURE,     /* t_8bytes_4_neg */
426     CUSTOM_EXPECTED_FAILURE,     /* t_8bytes_5_negpad */
427     CUSTOM_EXPECTED_SUCCESS(0x1ffffffff, 0x1ffffffff), /* t_5bytes_1 */
428     CUSTOM_EXPECTED_SUCCESS(0x80000000, 0x80000000), /* t_4bytes_1 */
429     CUSTOM_EXPECTED_SUCCESS(INT32_MAX - 1, INT32_MAX -1), /* t_4bytes_2 */
430     CUSTOM_EXPECTED_FAILURE,     /* t_4bytes_3_pad (illegal padding) */
431     CUSTOM_EXPECTED_FAILURE,     /* t_4bytes_4_neg (illegal negative value) */
432     CUSTOM_EXPECTED_FAILURE,     /* t_4bytes_5_negpad (illegal padding) */
433 };
434 static ASN1_UINT64_DATA uint64_encdec_data[] = {
435     ENCDEC_ARRAY(UINT64_MAX, UINT64_MAX, 0, 0),
436 };
437
438 static TEST_PACKAGE uint64_test_package = {
439     "UINT64", 0,
440     uint64_expected, sizeof(uint64_expected), sizeof(uint64_expected[0]),
441     uint64_encdec_data, sizeof(uint64_encdec_data), sizeof(uint64_encdec_data[0]),
442     (i2d_fn *)i2d_ASN1_UINT64_DATA, (d2i_fn *)d2i_ASN1_UINT64_DATA,
443     (ifree_fn *)ASN1_UINT64_DATA_free
444 };
445
446 /***** General testing functions *********************************************/
447
448
449 /* Template structure to map onto any test data structure */
450 typedef struct {
451     ASN1_BOOLEAN success;
452     unsigned char bytes[1];       /* In reality, there's more */
453 } EXPECTED;
454
455 /*
456  * do_decode returns a tristate:
457  *
458  *      -1      Couldn't decode
459  *      0       decoded structure wasn't what was expected (failure)
460  *      1       decoded structure was what was expected (success)
461  */
462 static int do_decode(unsigned char *bytes, long nbytes,
463                      const EXPECTED *expected, size_t expected_size,
464                      const TEST_PACKAGE *package)
465 {
466     EXPECTED *enctst = NULL;
467     const unsigned char *start;
468     int ret = 0;
469
470     start = bytes;
471     enctst = package->d2i(NULL, &bytes, nbytes);
472     if (enctst == NULL) {
473         if (expected->success == 0) {
474             ret = 1;
475             ERR_clear_error();
476         } else {
477             ret = -1;
478         }
479     } else {
480         if (start + nbytes == bytes
481             && memcmp(enctst, expected, expected_size) == 0)
482             ret = 1;
483         else
484             ret = 0;
485     }
486
487     package->ifree(enctst);
488     return ret;
489 }
490
491 /* Do an encode/decode round trip */
492 static int do_enc_dec(EXPECTED *bytes, long nbytes,
493                       const TEST_PACKAGE *package)
494 {
495     unsigned char *data = NULL;
496     int len;
497     int ret = 0;
498     void *p = bytes;
499
500     len = package->i2d(p, &data);
501     if (len < 0)
502         return -1;
503
504     ret = do_decode(data, len, bytes, nbytes, package);
505     OPENSSL_free(data);
506     return ret;
507 }
508
509 static size_t der_encode_length(size_t len, unsigned char **pp)
510 {
511     size_t lenbytes;
512
513     OPENSSL_assert(len < 0x8000);
514     if (len > 255)
515         lenbytes = 3;
516     else if (len > 127)
517         lenbytes = 2;
518     else
519         lenbytes = 1;
520
521     if (pp != NULL) {
522         if (lenbytes == 1) {
523             *(*pp)++ = len;
524         } else {
525             *(*pp)++ = lenbytes - 1;
526             if (lenbytes == 2) {
527                 *(*pp)++ = 0x80 | len;
528             } else {
529                 *(*pp)++ = 0x80 | (len >> 8);
530                 *(*pp)++ = len & 0xff;
531             }
532         }
533     }
534     return lenbytes;
535 }
536
537 /* Attempt to decode a custom encoding of the test structure */
538 static int do_decode_custom(const TEST_CUSTOM_DATA *custom_data,
539                             const EXPECTED *expected, size_t expected_size,
540                             const TEST_PACKAGE *package)
541 {
542     size_t firstbytes, secondbytes, secondbytesinner, seqbytes;
543     const unsigned char t_true[] = { V_ASN1_BOOLEAN, 0x01, 0xff };
544     unsigned char *encoding, *p = NULL;
545     int ret;
546
547     /*
548      * The first item is just an INTEGER tag, INTEGER length and INTEGER content
549      */
550     firstbytes =
551         1 + der_encode_length(custom_data->nbytes1, NULL)
552         + custom_data->nbytes1;
553
554     /*
555      * The second item is an explicit tag, content length, INTEGER tag,
556      * INTEGER length, INTEGER bytes
557      */
558     secondbytesinner =
559         1 + der_encode_length(custom_data->nbytes2, NULL)
560         + custom_data->nbytes2;
561     secondbytes =
562         1 + der_encode_length(secondbytesinner, NULL) + secondbytesinner;
563
564     /*
565      * The whole sequence is the sequence tag, content length, BOOLEAN true
566      * (copied from t_true), the first (firstbytes) and second (secondbytes)
567      * items
568      */
569     seqbytes =
570         1 + der_encode_length(sizeof(t_true) + firstbytes + secondbytes, NULL)
571         + sizeof(t_true) + firstbytes + secondbytes;
572
573     encoding = p = OPENSSL_malloc(seqbytes);
574     if (encoding == NULL)
575         return -1;
576
577     /* Sequence tag */
578     *p++ = 0x30;
579     der_encode_length(sizeof(t_true) + firstbytes + secondbytes, &p);
580
581     /* ASN1_BOOLEAN TRUE */
582     memcpy(p, t_true, sizeof(t_true)); /* Marks decoding success */
583     p += sizeof(t_true);
584
585     /* First INTEGER item (non-optional) */
586     *p++ = V_ASN1_INTEGER;
587     der_encode_length(custom_data->nbytes1, &p);
588     memcpy(p, custom_data->bytes1, custom_data->nbytes1);
589     p += custom_data->nbytes1;
590
591     /* Second INTEGER item (optional) */
592     /* Start with the explicit optional tag */
593     *p++ = 0xa0;
594     der_encode_length(secondbytesinner, &p);
595     *p++ = V_ASN1_INTEGER;
596     der_encode_length(custom_data->nbytes2, &p);
597     memcpy(p, custom_data->bytes2, custom_data->nbytes2);
598     p += custom_data->nbytes2;
599
600     OPENSSL_assert(seqbytes == (size_t)(p - encoding));
601
602     ret = do_decode(encoding, seqbytes, expected, expected_size, package);
603     OPENSSL_free(encoding);
604
605     return ret;
606 }
607
608
609 static int test_intern(const TEST_PACKAGE *package)
610 {
611     unsigned int i;
612     size_t nelems;
613     int fail = 0;
614
615     if (package->skip)
616         return 1;
617
618     /* Do decode_custom checks */
619     nelems = package->encode_expectations_size
620         / package->encode_expectations_elem_size;
621     OPENSSL_assert(nelems ==
622                    sizeof(test_custom_data) / sizeof(test_custom_data[0]));
623     for (i = 0; i < nelems; i++) {
624         size_t pos = i * package->encode_expectations_elem_size;
625         switch (do_decode_custom(&test_custom_data[i],
626                                  (EXPECTED *)&((unsigned char *)package
627                                                ->encode_expectations)[pos],
628                                  package->encode_expectations_elem_size,
629                                  package)) {
630         case -1:
631             fprintf(stderr, "Failed custom decode round trip %u of %s\n",
632                     i, package->name);
633             ERR_print_errors_fp(stderr);
634             fail++;
635             ERR_clear_error();
636             break;
637         case 0:
638             fprintf(stderr, "Custom decode round trip %u of %s mismatch\n",
639                     i, package->name);
640             fail++;
641             break;
642         case 1:
643             break;
644         default:
645             OPENSSL_die("do_enc_dec() return unknown value",
646                         __FILE__, __LINE__);
647         }
648     }
649
650     /* Do enc_dec checks */
651     nelems = package->encdec_data_size / package->encdec_data_elem_size;
652     for (i = 0; i < nelems; i++) {
653         size_t pos = i * package->encdec_data_elem_size;
654         switch (do_enc_dec((EXPECTED *)&((unsigned char *)package
655                                          ->encdec_data)[pos],
656                            package->encdec_data_elem_size,
657                            package)) {
658         case -1:
659             fprintf(stderr, "Failed encode/decode round trip %u of %s\n",
660                     i, package->name);
661             ERR_print_errors_fp(stderr);
662             ERR_clear_error();
663             fail++;
664             break;
665         case 0:
666             fprintf(stderr, "Encode/decode round trip %u of %s mismatch\n",
667                     i, package->name);
668             fail++;
669             break;
670         case 1:
671             break;
672         default:
673             OPENSSL_die("do_enc_dec() return unknown value",
674                         __FILE__, __LINE__);
675         }
676     }
677
678     return fail == 0;
679 }
680
681 #if OPENSSL_API_COMPAT < 0x10200000L
682 static int test_long_32bit(void)
683 {
684     return test_intern(&long_test_package_32bit);
685 }
686
687 static int test_long_64bit(void)
688 {
689     return test_intern(&long_test_package_64bit);
690 }
691 #endif
692
693 static int test_int32(void)
694 {
695     return test_intern(&int32_test_package);
696 }
697
698 static int test_uint32(void)
699 {
700     return test_intern(&uint32_test_package);
701 }
702
703 static int test_int64(void)
704 {
705     return test_intern(&int64_test_package);
706 }
707
708 static int test_uint64(void)
709 {
710     return test_intern(&uint64_test_package);
711 }
712
713 void register_tests(void)
714 {
715 #if OPENSSL_API_COMPAT < 0x10200000L
716     ADD_TEST(test_long_32bit);
717     ADD_TEST(test_long_64bit);
718 #endif
719     ADD_TEST(test_int32);
720     ADD_TEST(test_uint32);
721     ADD_TEST(test_int64);
722     ADD_TEST(test_uint64);
723 }