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_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) */
 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((uint64_t)INT64_MAX+1, (uint64_t)INT64_MAX+1),
 423                                  /* t_8bytes_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) */
 434 };
 435 static ASN1_UINT64_DATA uint64_encdec_data[] = {
 436     ENCDEC_ARRAY(UINT64_MAX, UINT64_MAX, 0, 0),
 437 };
 438
 439 static TEST_PACKAGE uint64_test_package = {
 440     "UINT64", 0,
 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
 445 };
 446
 447 /***** General testing functions *********************************************/
 448
 449
 450 /* Template structure to map onto any test data structure */
 451 typedef struct {
 452     ASN1_BOOLEAN success;
 453     unsigned char bytes[1];       /* In reality, there's more */
 454 } EXPECTED;
 455
 456 /*
 457  * do_decode returns a tristate:
 458  *
 459  *      -1      Couldn't decode
 460  *      0       decoded structure wasn't what was expected (failure)
 461  *      1       decoded structure was what was expected (success)
 462  */
 463 static int do_decode(unsigned char *bytes, long nbytes,
 464                      const EXPECTED *expected, size_t expected_size,
 465                      const TEST_PACKAGE *package)
 466 {
 467     EXPECTED *enctst = NULL;
 468     const unsigned char *start;
 469     int ret = 0;
 470
 471     start = bytes;
 472     enctst = package->d2i(NULL, &bytes, nbytes);
 473     if (enctst == NULL) {
 474         if (expected->success == 0) {
 475             ret = 1;
 476             ERR_clear_error();
 477         } else {
 478             ret = -1;
 479         }
 480     } else {
 481         if (start + nbytes == bytes
 482             && memcmp(enctst, expected, expected_size) == 0)
 483             ret = 1;
 484         else
 485             ret = 0;
 486     }
 487
 488     package->ifree(enctst);
 489     return ret;
 490 }
 491
 492 /* Do an encode/decode round trip */
 493 static int do_enc_dec(EXPECTED *bytes, long nbytes,
 494                       const TEST_PACKAGE *package)
 495 {
 496     unsigned char *data = NULL;
 497     int len;
 498     int ret = 0;
 499     void *p = bytes;
 500
 501     len = package->i2d(p, &data);
 502     if (len < 0)
 503         return -1;
 504
 505     ret = do_decode(data, len, bytes, nbytes, package);
 506     OPENSSL_free(data);
 507     return ret;
 508 }
 509
 510 static size_t der_encode_length(size_t len, unsigned char **pp)
 511 {
 512     size_t lenbytes;
 513
 514     OPENSSL_assert(len < 0x8000);
 515     if (len > 255)
 516         lenbytes = 3;
 517     else if (len > 127)
 518         lenbytes = 2;
 519     else
 520         lenbytes = 1;
 521
 522     if (pp != NULL) {
 523         if (lenbytes == 1) {
 524             *(*pp)++ = len;
 525         } else {
 526             *(*pp)++ = lenbytes - 1;
 527             if (lenbytes == 2) {
 528                 *(*pp)++ = 0x80 | len;
 529             } else {
 530                 *(*pp)++ = 0x80 | (len >> 8);
 531                 *(*pp)++ = len & 0xff;
 532             }
 533         }
 534     }
 535     return lenbytes;
 536 }
 537
 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)
 542 {
 543     size_t firstbytes, secondbytes, secondbytesinner, seqbytes;
 544     const unsigned char t_true[] = { V_ASN1_BOOLEAN, 0x01, 0xff };
 545     unsigned char *encoding, *p = NULL;
 546     int ret;
 547
 548     /*
 549      * The first item is just an INTEGER tag, INTEGER length and INTEGER content
 550      */
 551     firstbytes =
 552         1 + der_encode_length(custom_data->nbytes1, NULL)
 553         + custom_data->nbytes1;
 554
 555     /*
 556      * The second item is an explicit tag, content length, INTEGER tag,
 557      * INTEGER length, INTEGER bytes
 558      */
 559     secondbytesinner =
 560         1 + der_encode_length(custom_data->nbytes2, NULL)
 561         + custom_data->nbytes2;
 562     secondbytes =
 563         1 + der_encode_length(secondbytesinner, NULL) + secondbytesinner;
 564
 565     /*
 566      * The whole sequence is the sequence tag, content length, BOOLEAN true
 567      * (copied from t_true), the first (firstbytes) and second (secondbytes)
 568      * items
 569      */
 570     seqbytes =
 571         1 + der_encode_length(sizeof(t_true) + firstbytes + secondbytes, NULL)
 572         + sizeof(t_true) + firstbytes + secondbytes;
 573
 574     encoding = p = OPENSSL_malloc(seqbytes);
 575     if (encoding == NULL)
 576         return -1;
 577
 578     /* Sequence tag */
 579     *p++ = 0x30;
 580     der_encode_length(sizeof(t_true) + firstbytes + secondbytes, &p);
 581
 582     /* ASN1_BOOLEAN TRUE */
 583     memcpy(p, t_true, sizeof(t_true)); /* Marks decoding success */
 584     p += sizeof(t_true);
 585
 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;
 591
 592     /* Second INTEGER item (optional) */
 593     /* Start with the explicit optional tag */
 594     *p++ = 0xa0;
 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;
 600
 601     OPENSSL_assert(seqbytes == (size_t)(p - encoding));
 602
 603     ret = do_decode(encoding, seqbytes, expected, expected_size, package);
 604     OPENSSL_free(encoding);
 605
 606     return ret;
 607 }
 608
 609
 610 static int test_intern(const TEST_PACKAGE *package)
 611 {
 612     unsigned int i;
 613     size_t nelems;
 614     int fail = 0;
 615
 616     if (package->skip)
 617         return 1;
 618
 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,
 630                                  package)) {
 631         case -1:
 632             fprintf(stderr, "Failed custom decode round trip %u of %s\n",
 633                     i, package->name);
 634             ERR_print_errors_fp(stderr);
 635             fail++;
 636             ERR_clear_error();
 637             break;
 638         case 0:
 639             fprintf(stderr, "Custom decode round trip %u of %s mismatch\n",
 640                     i, package->name);
 641             fail++;
 642             break;
 643         case 1:
 644             break;
 645         default:
 646             OPENSSL_die("do_enc_dec() return unknown value",
 647                         __FILE__, __LINE__);
 648         }
 649     }
 650
 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
 656                                          ->encdec_data)[pos],
 657                            package->encdec_data_elem_size,
 658                            package)) {
 659         case -1:
 660             fprintf(stderr, "Failed encode/decode round trip %u of %s\n",
 661                     i, package->name);
 662             ERR_print_errors_fp(stderr);
 663             ERR_clear_error();
 664             fail++;
 665             break;
 666         case 0:
 667             fprintf(stderr, "Encode/decode round trip %u of %s mismatch\n",
 668                     i, package->name);
 669             fail++;
 670             break;
 671         case 1:
 672             break;
 673         default:
 674             OPENSSL_die("do_enc_dec() return unknown value",
 675                         __FILE__, __LINE__);
 676         }
 677     }
 678
 679     return fail == 0;
 680 }
 681
 682 #if OPENSSL_API_COMPAT < 0x10200000L
 683 static int test_long_32bit(void)
 684 {
 685     return test_intern(&long_test_package_32bit);
 686 }
 687
 688 static int test_long_64bit(void)
 689 {
 690     return test_intern(&long_test_package_64bit);
 691 }
 692 #endif
 693
 694 static int test_int32(void)
 695 {
 696     return test_intern(&int32_test_package);
 697 }
 698
 699 static int test_uint32(void)
 700 {
 701     return test_intern(&uint32_test_package);
 702 }
 703
 704 static int test_int64(void)
 705 {
 706     return test_intern(&int64_test_package);
 707 }
 708
 709 static int test_uint64(void)
 710 {
 711     return test_intern(&uint64_test_package);
 712 }
 713
 714 void register_tests(void)
 715 {
 716 #if OPENSSL_API_COMPAT < 0x10200000L
 717     ADD_TEST(test_long_32bit);
 718     ADD_TEST(test_long_64bit);
 719 #endif
 720     ADD_TEST(test_int32);
 721     ADD_TEST(test_uint32);
 722     ADD_TEST(test_int64);
 723     ADD_TEST(test_uint64);
 724 }