luna - wolfssl/tests/api/test_ossl

   1/* test_ossl_asn1.c
   2 *
   3 * Copyright (C) 2006-2026 wolfSSL Inc.
   4 *
   5 * This file is part of wolfSSL.
   6 *
   7 * wolfSSL is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * wolfSSL is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  20 */
  21
  22#include <tests/unit.h>
  23
  24#ifdef NO_INLINE
  25    #include <wolfssl/wolfcrypt/misc.h>
  26#else
  27    #define WOLFSSL_MISC_INCLUDED
  28    #include <wolfcrypt/src/misc.c>
  29#endif
  30
  31#include <wolfssl/openssl/asn1.h>
  32#include <wolfssl/openssl/x509v3.h>
  33#include <wolfssl/internal.h>
  34#include <wolfssl/wolfcrypt/types.h>
  35#include <tests/api/api.h>
  36#include <tests/api/test_ossl_asn1.h>
  37
  38/*******************************************************************************
  39 * ASN.1 OpenSSL compatibility API Testing
  40 ******************************************************************************/
  41
  42int test_wolfSSL_ASN1_BIT_STRING(void)
  43{
  44    EXPECT_DECLS;
  45#if !defined(NO_CERTS) && defined(OPENSSL_ALL)
  46    ASN1_BIT_STRING* str = NULL;
  47    ASN1_BIT_STRING* str2 = NULL;
  48    unsigned char* der = NULL;
  49
  50    ExpectNotNull(str = ASN1_BIT_STRING_new());
  51    /* Empty data testing. */
  52    ExpectIntEQ(ASN1_BIT_STRING_get_bit(str, 1), 0);
  53    ASN1_BIT_STRING_free(str);
  54    str = NULL;
  55
  56    ExpectNotNull(str = ASN1_BIT_STRING_new());
  57
  58    /* Invalid parameter testing. */
  59    ExpectIntEQ(ASN1_BIT_STRING_set_bit(NULL, 42, 1), 0);
  60    ExpectIntEQ(ASN1_BIT_STRING_set_bit(str, -1, 1), 0);
  61    ExpectIntEQ(ASN1_BIT_STRING_set_bit(str, 42, 2), 0);
  62    ExpectIntEQ(ASN1_BIT_STRING_set_bit(str, 42, -1), 0);
  63
  64    /* No bit string - bit is always 0. */
  65    ExpectIntEQ(ASN1_BIT_STRING_get_bit(NULL, 42), 0);
  66    ExpectIntEQ(ASN1_BIT_STRING_get_bit(NULL, -1), 0);
  67    ExpectIntEQ(ASN1_BIT_STRING_get_bit(str, -1), 0);
  68    ExpectIntEQ(ASN1_BIT_STRING_get_bit(str, 0), 0);
  69
  70    ExpectIntEQ(ASN1_BIT_STRING_set_bit(str, 42, 1), 1);
  71    ExpectIntEQ(ASN1_BIT_STRING_get_bit(str, 42), 1);
  72    ExpectIntEQ(ASN1_BIT_STRING_get_bit(str, 41), 0);
  73    ExpectIntEQ(ASN1_BIT_STRING_get_bit(str, -1), 0);
  74    ExpectIntEQ(ASN1_BIT_STRING_set_bit(str, 84, 1), 1);
  75    ExpectIntEQ(ASN1_BIT_STRING_get_bit(str, 84), 1);
  76    ExpectIntEQ(ASN1_BIT_STRING_get_bit(str, 83), 0);
  77    ExpectIntEQ(ASN1_BIT_STRING_set_bit(str, 91, 0), 1);
  78    ExpectIntEQ(ASN1_BIT_STRING_get_bit(str, 91), 0);
  79    ExpectIntEQ(ASN1_BIT_STRING_set_bit(str, 89, 0), 1);
  80    ExpectIntEQ(ASN1_BIT_STRING_get_bit(str, 89), 0);
  81    ExpectIntEQ(ASN1_BIT_STRING_set_bit(str, 42, 0), 1);
  82    ExpectIntEQ(ASN1_BIT_STRING_get_bit(str, 42), 0);
  83
  84    ExpectIntEQ(i2d_ASN1_BIT_STRING(str, NULL), 14);
  85    ExpectIntEQ(i2d_ASN1_BIT_STRING(str, &der), 14);
  86#ifdef WOLFSSL_ASN_TEMPLATE
  87    {
  88        const unsigned char* tmp = der;
  89        ExpectNotNull(d2i_ASN1_BIT_STRING(&str2, &tmp, 14));
  90    }
  91#endif
  92
  93    ASN1_BIT_STRING_free(str);
  94    ASN1_BIT_STRING_free(str2);
  95    ASN1_BIT_STRING_free(NULL);
  96    XFREE(der, NULL, DYNAMIC_TYPE_ASN1);
  97#endif
  98    return EXPECT_RESULT();
  99}
 100
 101int test_wolfSSL_ASN1_INTEGER(void)
 102{
 103    EXPECT_DECLS;
 104#if defined(OPENSSL_EXTRA) && !defined(NO_ASN)
 105    ASN1_INTEGER* a = NULL;
 106    ASN1_INTEGER* dup = NULL;
 107    const unsigned char invalidLenDer[] = {
 108        0x02, 0x20, 0x00
 109    };
 110    const unsigned char longDer[] = {
 111        0x02, 0x20,
 112            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 113            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 114            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 115            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
 116    };
 117    const unsigned char* p;
 118
 119    /* Invalid parameter testing. */
 120    ASN1_INTEGER_free(NULL);
 121    ExpectNull(wolfSSL_ASN1_INTEGER_dup(NULL));
 122
 123    ExpectNotNull(a = ASN1_INTEGER_new());
 124    ExpectNotNull(dup = wolfSSL_ASN1_INTEGER_dup(a));
 125    ASN1_INTEGER_free(dup);
 126    dup = NULL;
 127    ASN1_INTEGER_free(a);
 128    a = NULL;
 129
 130    p = invalidLenDer;
 131    ExpectNull(d2i_ASN1_INTEGER(NULL, &p, sizeof(invalidLenDer)));
 132
 133    p = longDer;
 134    ExpectNotNull(a = d2i_ASN1_INTEGER(NULL, &p, sizeof(longDer)));
 135    ExpectPtrNE(p, longDer);
 136    ExpectNotNull(dup = wolfSSL_ASN1_INTEGER_dup(a));
 137    ASN1_INTEGER_free(dup);
 138    ASN1_INTEGER_free(a);
 139#endif
 140    return EXPECT_RESULT();
 141}
 142
 143int test_wolfSSL_ASN1_INTEGER_cmp(void)
 144{
 145    EXPECT_DECLS;
 146#if defined(OPENSSL_EXTRA) && !defined(NO_ASN)
 147    ASN1_INTEGER* a = NULL;
 148    ASN1_INTEGER* b = NULL;
 149
 150    ExpectNotNull(a = ASN1_INTEGER_new());
 151    ExpectNotNull(b = ASN1_INTEGER_new());
 152    ExpectIntEQ(ASN1_INTEGER_set(a, 1), 1);
 153    ExpectIntEQ(ASN1_INTEGER_set(b, 1), 1);
 154
 155    /* Invalid parameter testing. */
 156    ExpectIntEQ(wolfSSL_ASN1_INTEGER_cmp(NULL, NULL), -1);
 157    ExpectIntEQ(wolfSSL_ASN1_INTEGER_cmp(a, NULL), -1);
 158    ExpectIntEQ(wolfSSL_ASN1_INTEGER_cmp(NULL, b), -1);
 159
 160    ExpectIntEQ(wolfSSL_ASN1_INTEGER_cmp(a, b), 0);
 161    ExpectIntEQ(ASN1_INTEGER_set(b, -1), 1);
 162    ExpectIntGT(wolfSSL_ASN1_INTEGER_cmp(a, b), 0);
 163    ExpectIntEQ(ASN1_INTEGER_set(a, -2), 1);
 164    ExpectIntLT(wolfSSL_ASN1_INTEGER_cmp(a, b), 0);
 165    ExpectIntEQ(ASN1_INTEGER_set(b, 1), 1);
 166    ExpectIntLT(wolfSSL_ASN1_INTEGER_cmp(a, b), 0);
 167    ExpectIntEQ(ASN1_INTEGER_set(a, 0x01), 1);
 168    ExpectIntEQ(ASN1_INTEGER_set(b, 0x1000), 1);
 169    ExpectIntLT(wolfSSL_ASN1_INTEGER_cmp(a, b), 0);
 170    ExpectIntGT(wolfSSL_ASN1_INTEGER_cmp(b, a), 0);
 171
 172    ASN1_INTEGER_free(b);
 173    ASN1_INTEGER_free(a);
 174#endif
 175    return EXPECT_RESULT();
 176}
 177
 178int test_wolfSSL_ASN1_INTEGER_BN(void)
 179{
 180    EXPECT_DECLS;
 181#if defined(OPENSSL_EXTRA) && !defined(NO_ASN)
 182    ASN1_INTEGER* ai = NULL;
 183    ASN1_INTEGER* ai2 = NULL;
 184    BIGNUM* bn = NULL;
 185    BIGNUM* bn2 = NULL;
 186
 187    ExpectNotNull(ai = ASN1_INTEGER_new());
 188    ExpectNotNull(bn2 = BN_new());
 189
 190    /* Invalid parameter testing. */
 191    ExpectNull(bn = ASN1_INTEGER_to_BN(NULL, NULL));
 192    ExpectNull(ai2 = BN_to_ASN1_INTEGER(NULL, NULL));
 193
 194    /* at the moment hard setting since no set function */
 195    if (ai != NULL) {
 196        ai->data[0] = 0xff; /* No DER encoding. */
 197        ai->length = 1;
 198    }
 199#if defined(WOLFSSL_QT) || defined(WOLFSSL_HAPROXY)
 200    ExpectNotNull(bn = ASN1_INTEGER_to_BN(ai, NULL));
 201#else
 202    ExpectNull(bn = ASN1_INTEGER_to_BN(ai, NULL));
 203#endif
 204    BN_free(bn);
 205    bn = NULL;
 206
 207    if (ai != NULL) {
 208        ai->data[0] = 0x02; /* tag for ASN_INTEGER */
 209        ai->data[1] = 0x04; /* bad length of integer */
 210        ai->data[2] = 0x03;
 211        ai->length = 3;
 212    }
 213#if defined(WOLFSSL_QT) || defined(WOLFSSL_HAPROXY)
 214    /* Interpreted as a number 0x020403. */
 215    ExpectNotNull(bn = ASN1_INTEGER_to_BN(ai, NULL));
 216#else
 217    ExpectNull(bn = ASN1_INTEGER_to_BN(ai, NULL));
 218#endif
 219    BN_free(bn);
 220    bn = NULL;
 221
 222    if (ai != NULL) {
 223        ai->data[0] = 0x02; /* tag for ASN_INTEGER */
 224        ai->data[1] = 0x01; /* length of integer */
 225        ai->data[2] = 0x03;
 226        ai->length = 3;
 227    }
 228    ExpectNotNull(bn = ASN1_INTEGER_to_BN(ai, NULL));
 229    ExpectNotNull(ai2 = BN_to_ASN1_INTEGER(bn, NULL));
 230    ExpectIntEQ(ASN1_INTEGER_cmp(ai, ai2), 0);
 231    ExpectNotNull(bn2 = ASN1_INTEGER_to_BN(ai2, bn2));
 232    ExpectIntEQ(BN_cmp(bn, bn2), 0);
 233
 234    if (ai != NULL) {
 235        ai->data[0] = 0x02; /* tag for ASN_INTEGER */
 236        ai->data[1] = 0x02; /* length of integer */
 237        ai->data[2] = 0x00; /* padding byte to ensure positive */
 238        ai->data[3] = 0xff;
 239        ai->length = 4;
 240    }
 241    ExpectNotNull(bn = ASN1_INTEGER_to_BN(ai, bn));
 242    ExpectNotNull(ai2 = BN_to_ASN1_INTEGER(bn, ai2));
 243    ExpectIntEQ(ASN1_INTEGER_cmp(ai, ai2), 0);
 244    ExpectNotNull(bn2 = ASN1_INTEGER_to_BN(ai2, bn2));
 245    ExpectIntEQ(BN_cmp(bn, bn2), 0);
 246
 247    if (ai != NULL) {
 248        ai->data[0] = 0x02; /* tag for ASN_INTEGER */
 249        ai->data[1] = 0x01; /* length of integer */
 250        ai->data[2] = 0x00;
 251        ai->length = 3;
 252    }
 253    ExpectNotNull(bn = ASN1_INTEGER_to_BN(ai, bn));
 254    ExpectNotNull(ai2 = BN_to_ASN1_INTEGER(bn, ai2));
 255    ExpectIntEQ(ASN1_INTEGER_cmp(ai, ai2), 0);
 256    ExpectNotNull(bn2 = ASN1_INTEGER_to_BN(ai2, bn2));
 257    ExpectIntEQ(BN_cmp(bn, bn2), 0);
 258
 259    if (ai != NULL) {
 260        ai->data[0] = 0x02; /* tag for ASN_INTEGER */
 261        ai->data[1] = 0x01; /* length of integer */
 262        ai->data[2] = 0x01;
 263        ai->length = 3;
 264        ai->negative = 1;
 265    }
 266    ExpectNotNull(bn = ASN1_INTEGER_to_BN(ai, bn));
 267    ExpectNotNull(ai2 = BN_to_ASN1_INTEGER(bn, ai2));
 268    ExpectIntEQ(ASN1_INTEGER_cmp(ai, ai2), 0);
 269    ExpectNotNull(bn2 = ASN1_INTEGER_to_BN(ai2, bn2));
 270    ExpectIntEQ(BN_cmp(bn, bn2), 0);
 271
 272    BN_free(bn2);
 273    BN_free(bn);
 274    ASN1_INTEGER_free(ai2);
 275    ASN1_INTEGER_free(ai);
 276#endif
 277    return EXPECT_RESULT();
 278}
 279
 280int test_wolfSSL_ASN1_INTEGER_get_set(void)
 281{
 282    EXPECT_DECLS;
 283#if defined(OPENSSL_EXTRA) && !defined(NO_ASN)
 284    ASN1_INTEGER *a = NULL;
 285    long val;
 286
 287    ExpectNotNull(a = ASN1_INTEGER_new());
 288    /* Invalid parameter testing. */
 289    ExpectIntEQ(ASN1_INTEGER_get(NULL), 0);
 290#if defined(WOLFSSL_QT) || defined(WOLFSSL_HAPROXY)
 291    ExpectIntEQ(ASN1_INTEGER_get(a), 0);
 292#else
 293    ExpectIntEQ(ASN1_INTEGER_get(a), -1);
 294#endif
 295    ASN1_INTEGER_free(a);
 296    a = NULL;
 297
 298    ExpectNotNull(a = ASN1_INTEGER_new());
 299    val = 0;
 300    ExpectIntEQ(ASN1_INTEGER_set(NULL, val), 0);
 301    ASN1_INTEGER_free(a);
 302    a = NULL;
 303
 304    /* 0 */
 305    ExpectNotNull(a = ASN1_INTEGER_new());
 306    val = 0;
 307    ExpectIntEQ(ASN1_INTEGER_set(a, val), 1);
 308    ExpectTrue(ASN1_INTEGER_get(a) == val);
 309    ASN1_INTEGER_free(a);
 310    a = NULL;
 311
 312    /* 40 */
 313    ExpectNotNull(a = ASN1_INTEGER_new());
 314    val = 40;
 315    ExpectIntEQ(ASN1_INTEGER_set(a, val), 1);
 316    ExpectTrue(ASN1_INTEGER_get(a) == val);
 317    ASN1_INTEGER_free(a);
 318    a = NULL;
 319
 320    /* -40 */
 321    ExpectNotNull(a = ASN1_INTEGER_new());
 322    val = -40;
 323    ExpectIntEQ(ASN1_INTEGER_set(a, val), 1);
 324    ExpectTrue(ASN1_INTEGER_get(a) == val);
 325    ASN1_INTEGER_free(a);
 326    a = NULL;
 327
 328    /* 128 */
 329    ExpectNotNull(a = ASN1_INTEGER_new());
 330    val = 128;
 331    ExpectIntEQ(ASN1_INTEGER_set(a, val), 1);
 332    ExpectTrue(ASN1_INTEGER_get(a) == val);
 333    ASN1_INTEGER_free(a);
 334    a = NULL;
 335
 336    /* -128 */
 337    ExpectNotNull(a = ASN1_INTEGER_new());
 338    val = -128;
 339    ExpectIntEQ(ASN1_INTEGER_set(a, val), 1);
 340    ExpectTrue(ASN1_INTEGER_get(a) == val);
 341    ASN1_INTEGER_free(a);
 342    a = NULL;
 343
 344    /* 200 */
 345    ExpectNotNull(a = ASN1_INTEGER_new());
 346    val = 200;
 347    ExpectIntEQ(ASN1_INTEGER_set(a, val), 1);
 348    ExpectTrue(ASN1_INTEGER_get(a) == val);
 349    ASN1_INTEGER_free(a);
 350    a = NULL;
 351
 352    /* int max (2147483647) */
 353    ExpectNotNull(a = ASN1_INTEGER_new());
 354    val = 2147483647;
 355    ExpectIntEQ(ASN1_INTEGER_set(a, val), 1);
 356    ExpectTrue(ASN1_INTEGER_get(a) == val);
 357    ASN1_INTEGER_free(a);
 358    a = NULL;
 359
 360    /* int min (-2147483648) */
 361    ExpectNotNull(a = ASN1_INTEGER_new());
 362    val = -2147483647 - 1;
 363    ExpectIntEQ(ASN1_INTEGER_set(a, val), 1);
 364    ExpectTrue(ASN1_INTEGER_get(a) == val);
 365    ASN1_INTEGER_free(a);
 366    a = NULL;
 367
 368    /* long max positive */
 369    ExpectNotNull(a = ASN1_INTEGER_new());
 370    val = (long)(((unsigned long)-1) >> 1);
 371    ExpectIntEQ(ASN1_INTEGER_set(a, val), 1);
 372    ExpectTrue(ASN1_INTEGER_get(a) == val);
 373    ASN1_INTEGER_free(a);
 374#endif
 375    return EXPECT_RESULT();
 376}
 377
 378#if defined(OPENSSL_EXTRA)
 379typedef struct ASN1IntTestVector {
 380    const byte* der;
 381    const size_t derSz;
 382    const long value;
 383} ASN1IntTestVector;
 384#endif
 385int test_wolfSSL_d2i_ASN1_INTEGER(void)
 386{
 387    EXPECT_DECLS;
 388#if defined(OPENSSL_EXTRA)
 389    size_t i;
 390    WOLFSSL_ASN1_INTEGER* a = NULL;
 391    WOLFSSL_ASN1_INTEGER* b = NULL;
 392    WOLFSSL_ASN1_INTEGER* c = NULL;
 393    const byte* p = NULL;
 394    byte* p2 = NULL;
 395    byte* reEncoded = NULL;
 396    int reEncodedSz = 0;
 397
 398    static const byte zeroDer[] = {
 399        0x02, 0x01, 0x00
 400    };
 401    static const byte oneDer[] = {
 402        0x02, 0x01, 0x01
 403    };
 404    static const byte negativeDer[] = {
 405        0x02, 0x03, 0xC1, 0x16, 0x0D
 406    };
 407    static const byte positiveDer[] = {
 408        0x02, 0x03, 0x01, 0x00, 0x01
 409    };
 410    static const byte primeDer[] = {
 411        0x02, 0x82, 0x01, 0x01, 0x00, 0xc0, 0x95, 0x08, 0xe1, 0x57, 0x41,
 412        0xf2, 0x71, 0x6d, 0xb7, 0xd2, 0x45, 0x41, 0x27, 0x01, 0x65, 0xc6,
 413        0x45, 0xae, 0xf2, 0xbc, 0x24, 0x30, 0xb8, 0x95, 0xce, 0x2f, 0x4e,
 414        0xd6, 0xf6, 0x1c, 0x88, 0xbc, 0x7c, 0x9f, 0xfb, 0xa8, 0x67, 0x7f,
 415        0xfe, 0x5c, 0x9c, 0x51, 0x75, 0xf7, 0x8a, 0xca, 0x07, 0xe7, 0x35,
 416        0x2f, 0x8f, 0xe1, 0xbd, 0x7b, 0xc0, 0x2f, 0x7c, 0xab, 0x64, 0xa8,
 417        0x17, 0xfc, 0xca, 0x5d, 0x7b, 0xba, 0xe0, 0x21, 0xe5, 0x72, 0x2e,
 418        0x6f, 0x2e, 0x86, 0xd8, 0x95, 0x73, 0xda, 0xac, 0x1b, 0x53, 0xb9,
 419        0x5f, 0x3f, 0xd7, 0x19, 0x0d, 0x25, 0x4f, 0xe1, 0x63, 0x63, 0x51,
 420        0x8b, 0x0b, 0x64, 0x3f, 0xad, 0x43, 0xb8, 0xa5, 0x1c, 0x5c, 0x34,
 421        0xb3, 0xae, 0x00, 0xa0, 0x63, 0xc5, 0xf6, 0x7f, 0x0b, 0x59, 0x68,
 422        0x78, 0x73, 0xa6, 0x8c, 0x18, 0xa9, 0x02, 0x6d, 0xaf, 0xc3, 0x19,
 423        0x01, 0x2e, 0xb8, 0x10, 0xe3, 0xc6, 0xcc, 0x40, 0xb4, 0x69, 0xa3,
 424        0x46, 0x33, 0x69, 0x87, 0x6e, 0xc4, 0xbb, 0x17, 0xa6, 0xf3, 0xe8,
 425        0xdd, 0xad, 0x73, 0xbc, 0x7b, 0x2f, 0x21, 0xb5, 0xfd, 0x66, 0x51,
 426        0x0c, 0xbd, 0x54, 0xb3, 0xe1, 0x6d, 0x5f, 0x1c, 0xbc, 0x23, 0x73,
 427        0xd1, 0x09, 0x03, 0x89, 0x14, 0xd2, 0x10, 0xb9, 0x64, 0xc3, 0x2a,
 428        0xd0, 0xa1, 0x96, 0x4a, 0xbc, 0xe1, 0xd4, 0x1a, 0x5b, 0xc7, 0xa0,
 429        0xc0, 0xc1, 0x63, 0x78, 0x0f, 0x44, 0x37, 0x30, 0x32, 0x96, 0x80,
 430        0x32, 0x23, 0x95, 0xa1, 0x77, 0xba, 0x13, 0xd2, 0x97, 0x73, 0xe2,
 431        0x5d, 0x25, 0xc9, 0x6a, 0x0d, 0xc3, 0x39, 0x60, 0xa4, 0xb4, 0xb0,
 432        0x69, 0x42, 0x42, 0x09, 0xe9, 0xd8, 0x08, 0xbc, 0x33, 0x20, 0xb3,
 433        0x58, 0x22, 0xa7, 0xaa, 0xeb, 0xc4, 0xe1, 0xe6, 0x61, 0x83, 0xc5,
 434        0xd2, 0x96, 0xdf, 0xd9, 0xd0, 0x4f, 0xad, 0xd7
 435    };
 436    static const byte garbageDer[] = {0xDE, 0xAD, 0xBE, 0xEF};
 437
 438    static const ASN1IntTestVector testVectors[] = {
 439        {zeroDer, sizeof(zeroDer), 0},
 440        {oneDer, sizeof(oneDer), 1},
 441        {negativeDer, sizeof(negativeDer), -4123123},
 442        {positiveDer, sizeof(positiveDer), 65537},
 443        {primeDer, sizeof(primeDer), 0}
 444    };
 445    static const size_t NUM_TEST_VECTORS =
 446        sizeof(testVectors)/sizeof(testVectors[0]);
 447
 448    /* Check d2i error conditions */
 449    /* NULL pointer to input. */
 450    ExpectNull((a = wolfSSL_d2i_ASN1_INTEGER(&b, NULL, 1)));
 451    ExpectNull(b);
 452    /* NULL input. */
 453    ExpectNull((a = wolfSSL_d2i_ASN1_INTEGER(&b, &p, 1)));
 454    ExpectNull(b);
 455    /* 0 length. */
 456    p = testVectors[0].der;
 457    ExpectNull((a = wolfSSL_d2i_ASN1_INTEGER(&b, &p, 0)));
 458    ExpectNull(b);
 459    /* Negative length. */
 460    p = testVectors[0].der;
 461    ExpectNull((a = wolfSSL_d2i_ASN1_INTEGER(&b, &p, -1)));
 462    ExpectNull(b);
 463    /* Garbage DER input. */
 464    p = garbageDer;
 465    ExpectNull((a = wolfSSL_d2i_ASN1_INTEGER(&b, &p, sizeof(garbageDer))));
 466    ExpectNull(b);
 467
 468    /* Check i2d error conditions */
 469    /* NULL input. */
 470    ExpectIntLT(wolfSSL_i2d_ASN1_INTEGER(NULL, &p2), 0);
 471    /* 0 length input data buffer (a->length == 0). */
 472    ExpectNotNull((a = wolfSSL_ASN1_INTEGER_new()));
 473    ExpectIntLT(wolfSSL_i2d_ASN1_INTEGER(a, &p2), 0);
 474    if (a != NULL)
 475        a->data = NULL;
 476    /* NULL input data buffer. */
 477    ExpectIntLT(wolfSSL_i2d_ASN1_INTEGER(a, &p2), 0);
 478    if (a != NULL) {
 479        /* Reset a->data. */
 480        a->isDynamic = 0;
 481        a->data = a->intData;
 482    }
 483    /* Reset p2 to NULL. */
 484    XFREE(p2, NULL, DYNAMIC_TYPE_ASN1);
 485
 486    /* Set a to valid value. */
 487    ExpectIntEQ(wolfSSL_ASN1_INTEGER_set(a, 1), WOLFSSL_SUCCESS);
 488    /* NULL output buffer. */
 489    ExpectIntEQ(wolfSSL_i2d_ASN1_INTEGER(a, NULL), 3);
 490    wolfSSL_ASN1_INTEGER_free(a);
 491    a = NULL;
 492
 493    for (i = 0; i < NUM_TEST_VECTORS; ++i) {
 494        p = testVectors[i].der;
 495        ExpectNotNull(a = wolfSSL_d2i_ASN1_INTEGER(&b, &p,
 496            testVectors[i].derSz));
 497        ExpectIntEQ(wolfSSL_ASN1_INTEGER_cmp(a, b), 0);
 498
 499        if (testVectors[i].derSz <= sizeof(long)) {
 500            ExpectNotNull(c = wolfSSL_ASN1_INTEGER_new());
 501            ExpectIntEQ(wolfSSL_ASN1_INTEGER_set(c, testVectors[i].value), 1);
 502            ExpectIntEQ(wolfSSL_ASN1_INTEGER_cmp(a, c), 0);
 503            wolfSSL_ASN1_INTEGER_free(c);
 504            c = NULL;
 505        }
 506
 507        /* Convert to DER without a pre-allocated output buffer. */
 508        ExpectIntGT((reEncodedSz = wolfSSL_i2d_ASN1_INTEGER(a, &reEncoded)), 0);
 509        ExpectIntEQ(reEncodedSz, testVectors[i].derSz);
 510        ExpectIntEQ(XMEMCMP(reEncoded, testVectors[i].der, reEncodedSz), 0);
 511
 512        /* Convert to DER with a pre-allocated output buffer. In this case, the
 513         * output buffer pointer should be incremented just past the end of the
 514         * encoded data. */
 515        p2 = reEncoded;
 516        ExpectIntGT((reEncodedSz = wolfSSL_i2d_ASN1_INTEGER(a, &p2)), 0);
 517        ExpectIntEQ(reEncodedSz, testVectors[i].derSz);
 518        ExpectPtrEq(reEncoded, p2 - reEncodedSz);
 519        ExpectIntEQ(XMEMCMP(reEncoded, testVectors[i].der, reEncodedSz), 0);
 520
 521        XFREE(reEncoded, NULL, DYNAMIC_TYPE_ASN1);
 522        reEncoded = NULL;
 523        wolfSSL_ASN1_INTEGER_free(a);
 524        a = NULL;
 525    }
 526#endif /* OPENSSL_EXTRA */
 527    return EXPECT_RESULT();
 528}
 529
 530int test_wolfSSL_a2i_ASN1_INTEGER(void)
 531{
 532    EXPECT_DECLS;
 533#if defined(OPENSSL_EXTRA) && !defined(NO_BIO)
 534    BIO* bio = NULL;
 535    BIO* out = NULL;
 536    BIO* fixed = NULL;
 537    ASN1_INTEGER* ai = NULL;
 538    char buf[] = "123456\n12345\n1123456789123456\\\n78901234567890 \r\n\n";
 539    char tmp[1024];
 540    int  tmpSz;
 541
 542    const char expected1[] = "123456";
 543    const char expected2[] = "112345678912345678901234567890";
 544    char longStr[] = "123456781234567812345678123456781234567812345678\n"
 545        "123456781234567812345678123456781234567812345678\\\n12345678\n";
 546
 547    ExpectNotNull(out = BIO_new(BIO_s_mem()));
 548    ExpectNotNull(ai = ASN1_INTEGER_new());
 549
 550    ExpectNotNull(bio = BIO_new_mem_buf(buf, -1));
 551
 552    /* Invalid parameter testing. */
 553    ExpectIntEQ(a2i_ASN1_INTEGER(NULL, NULL, NULL, -1), 0);
 554    ExpectIntEQ(a2i_ASN1_INTEGER(bio, NULL, NULL, -1), 0);
 555    ExpectIntEQ(a2i_ASN1_INTEGER(NULL, ai, NULL, -1), 0);
 556    ExpectIntEQ(a2i_ASN1_INTEGER(NULL, NULL, tmp, -1), 0);
 557    ExpectIntEQ(a2i_ASN1_INTEGER(NULL, NULL, NULL, sizeof(tmp)), 0);
 558    ExpectIntEQ(a2i_ASN1_INTEGER(NULL, ai, tmp, sizeof(tmp)), 0);
 559    ExpectIntEQ(a2i_ASN1_INTEGER(bio, NULL, tmp, sizeof(tmp)), 0);
 560    ExpectIntEQ(a2i_ASN1_INTEGER(bio, ai, NULL, sizeof(tmp)), 0);
 561    ExpectIntEQ(a2i_ASN1_INTEGER(bio, ai, tmp, -1), 0);
 562    ExpectIntEQ(i2a_ASN1_INTEGER(NULL, NULL), 0);
 563    ExpectIntEQ(i2a_ASN1_INTEGER(bio, NULL), 0);
 564    ExpectIntEQ(i2a_ASN1_INTEGER(NULL, ai), 0);
 565
 566    /* No data to read from BIO. */
 567    ExpectIntEQ(a2i_ASN1_INTEGER(out, ai, tmp, sizeof(tmp)), 0);
 568
 569    /* read first line */
 570    ExpectIntEQ(a2i_ASN1_INTEGER(bio, ai, tmp, sizeof(tmp)), 1);
 571    ExpectIntEQ(i2a_ASN1_INTEGER(out, ai), 6);
 572    XMEMSET(tmp, 0, sizeof(tmp));
 573    tmpSz = BIO_read(out, tmp, sizeof(tmp));
 574    ExpectIntEQ(tmpSz, 6);
 575    ExpectIntEQ(XMEMCMP(tmp, expected1, tmpSz), 0);
 576
 577    /* fail on second line (not % 2) */
 578    ExpectIntEQ(a2i_ASN1_INTEGER(bio, ai, tmp, sizeof(tmp)), 0);
 579
 580    /* read 3rd long line */
 581    ExpectIntEQ(a2i_ASN1_INTEGER(bio, ai, tmp, sizeof(tmp)), 1);
 582    ExpectIntEQ(i2a_ASN1_INTEGER(out, ai), 30);
 583    XMEMSET(tmp, 0, sizeof(tmp));
 584    tmpSz = BIO_read(out, tmp, sizeof(tmp));
 585    ExpectIntEQ(tmpSz, 30);
 586    ExpectIntEQ(XMEMCMP(tmp, expected2, tmpSz), 0);
 587
 588    /* fail on empty line */
 589    ExpectIntEQ(a2i_ASN1_INTEGER(bio, ai, tmp, sizeof(tmp)), 0);
 590
 591    BIO_free(bio);
 592    bio = NULL;
 593
 594    /* Make long integer, requiring dynamic memory, even longer. */
 595    ExpectNotNull(bio = BIO_new_mem_buf(longStr, -1));
 596    ExpectIntEQ(a2i_ASN1_INTEGER(bio, ai, tmp, sizeof(tmp)), 1);
 597    ExpectIntEQ(i2a_ASN1_INTEGER(out, ai), 48);
 598    XMEMSET(tmp, 0, sizeof(tmp));
 599    tmpSz = BIO_read(out, tmp, sizeof(tmp));
 600    ExpectIntEQ(tmpSz, 48);
 601    ExpectIntEQ(a2i_ASN1_INTEGER(bio, ai, tmp, sizeof(tmp)), 1);
 602    ExpectIntEQ(i2a_ASN1_INTEGER(out, ai), 56);
 603    XMEMSET(tmp, 0, sizeof(tmp));
 604    tmpSz = BIO_read(out, tmp, sizeof(tmp));
 605    ExpectIntEQ(tmpSz, 56);
 606    ExpectIntEQ(wolfSSL_ASN1_INTEGER_set(ai, 1), 1);
 607    BIO_free(bio);
 608    BIO_free(out);
 609
 610    ExpectNotNull(fixed = BIO_new(wolfSSL_BIO_s_fixed_mem()));
 611    ExpectIntEQ(BIO_set_write_buf_size(fixed, 1), 1);
 612    /* Ensure there is 0 bytes available to write into. */
 613    ExpectIntEQ(BIO_write(fixed, tmp, 1), 1);
 614    ExpectIntEQ(i2a_ASN1_INTEGER(fixed, ai), 0);
 615    ExpectIntEQ(BIO_set_write_buf_size(fixed, 1), 1);
 616    ExpectIntEQ(i2a_ASN1_INTEGER(fixed, ai), 0);
 617    BIO_free(fixed);
 618
 619    ASN1_INTEGER_free(ai);
 620#endif
 621    return EXPECT_RESULT();
 622}
 623
 624int test_wolfSSL_i2c_ASN1_INTEGER(void)
 625{
 626    EXPECT_DECLS;
 627#if defined(OPENSSL_EXTRA) && !defined(NO_ASN)
 628    ASN1_INTEGER *a = NULL;
 629    unsigned char *pp = NULL,*tpp = NULL;
 630    int ret = 0;
 631
 632    ExpectNotNull(a = wolfSSL_ASN1_INTEGER_new());
 633
 634    /* Invalid parameter testing. */
 635    /* Set pp to an invalid value. */
 636    pp = NULL;
 637    ExpectIntEQ(i2c_ASN1_INTEGER(NULL, &pp), 0);
 638    ExpectIntEQ(i2c_ASN1_INTEGER(a, &pp), 0);
 639    ExpectIntEQ(i2c_ASN1_INTEGER(NULL, NULL), 0);
 640
 641    /* 40 */
 642    if (a != NULL) {
 643        a->intData[0] = ASN_INTEGER;
 644        a->intData[1] = 1;
 645        a->intData[2] = 40;
 646    }
 647    ExpectIntEQ(ret = i2c_ASN1_INTEGER(a, NULL), 1);
 648    ExpectNotNull(pp = (unsigned char*)XMALLOC(ret + 1, NULL,
 649                DYNAMIC_TYPE_TMP_BUFFER));
 650    tpp = pp;
 651    if (tpp != NULL) {
 652        ExpectNotNull(XMEMSET(tpp, 0, ret + 1));
 653        ExpectIntEQ(i2c_ASN1_INTEGER(a, &tpp), 1);
 654        tpp--;
 655        ExpectIntEQ(*tpp, 40);
 656    }
 657    XFREE(pp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 658    pp = NULL;
 659
 660    /* 128 */
 661    if (a != NULL) {
 662        a->intData[0] = ASN_INTEGER;
 663        a->intData[1] = 1;
 664        a->intData[2] = 128;
 665    }
 666    ExpectIntEQ(ret = i2c_ASN1_INTEGER(a, NULL), 2);
 667    ExpectNotNull(pp = (unsigned char*)XMALLOC(ret + 1, NULL,
 668                DYNAMIC_TYPE_TMP_BUFFER));
 669    tpp = pp;
 670    if (tpp != NULL) {
 671        ExpectNotNull(XMEMSET(tpp, 0, ret + 1));
 672        ExpectIntEQ(i2c_ASN1_INTEGER(a, &tpp), 2);
 673        tpp--;
 674        ExpectIntEQ(*(tpp--), 128);
 675        ExpectIntEQ(*tpp, 0);
 676    }
 677    XFREE(pp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 678    pp = NULL;
 679
 680    /* -40 */
 681    if (a != NULL) {
 682        a->intData[0] = ASN_INTEGER;
 683        a->intData[1] = 1;
 684        a->intData[2] = 40;
 685        a->negative = 1;
 686    }
 687    ExpectIntEQ(ret = i2c_ASN1_INTEGER(a, NULL), 1);
 688    ExpectNotNull(pp = (unsigned char*)XMALLOC(ret + 1, NULL,
 689                DYNAMIC_TYPE_TMP_BUFFER));
 690    tpp = pp;
 691    if (tpp != NULL) {
 692        ExpectNotNull(XMEMSET(tpp, 0, ret + 1));
 693        ExpectIntEQ(i2c_ASN1_INTEGER(a, &tpp), 1);
 694        tpp--;
 695        ExpectIntEQ(*tpp, 216);
 696    }
 697    XFREE(pp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 698    pp = NULL;
 699
 700    /* -128 */
 701    if (a != NULL) {
 702        a->intData[0] = ASN_INTEGER;
 703        a->intData[1] = 1;
 704        a->intData[2] = 128;
 705        a->negative = 1;
 706    }
 707    ExpectIntEQ(ret = i2c_ASN1_INTEGER(a, NULL), 1);
 708    ExpectNotNull(pp = (unsigned char*)XMALLOC(ret + 1, NULL,
 709                DYNAMIC_TYPE_TMP_BUFFER));
 710    tpp = pp;
 711    if (tpp != NULL) {
 712        ExpectNotNull(XMEMSET(tpp, 0, ret + 1));
 713        ExpectIntEQ(i2c_ASN1_INTEGER(a, &tpp), 1);
 714        tpp--;
 715        ExpectIntEQ(*tpp, 128);
 716    }
 717    XFREE(pp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 718    pp = NULL;
 719
 720    /* -200 */
 721    if (a != NULL) {
 722        a->intData[0] = ASN_INTEGER;
 723        a->intData[1] = 1;
 724        a->intData[2] = 200;
 725        a->negative = 1;
 726    }
 727    ExpectIntEQ(ret = i2c_ASN1_INTEGER(a, NULL), 2);
 728    ExpectNotNull(pp = (unsigned char*)XMALLOC(ret + 1, NULL,
 729            DYNAMIC_TYPE_TMP_BUFFER));
 730    tpp = pp;
 731    if (tpp != NULL) {
 732        ExpectNotNull(XMEMSET(tpp, 0, ret + 1));
 733        ExpectIntEQ(i2c_ASN1_INTEGER(a, &tpp), 2);
 734        tpp--;
 735        ExpectIntEQ(*(tpp--), 56);
 736        ExpectIntEQ(*tpp, 255);
 737    }
 738    XFREE(pp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 739    pp = NULL;
 740
 741    /* Empty */
 742    if (a != NULL) {
 743        a->intData[0] = ASN_INTEGER;
 744        a->intData[1] = 0;
 745        a->negative = 0;
 746    }
 747    ExpectIntEQ(ret = i2c_ASN1_INTEGER(a, NULL), 1);
 748    ExpectNotNull(pp = (unsigned char*)XMALLOC(ret + 1, NULL,
 749                DYNAMIC_TYPE_TMP_BUFFER));
 750    tpp = pp;
 751    if (tpp != NULL) {
 752        ExpectNotNull(XMEMSET(tpp, 0, ret + 1));
 753        ExpectIntEQ(i2c_ASN1_INTEGER(a, &tpp), 1);
 754        tpp--;
 755        ExpectIntEQ(*tpp, 0);
 756    }
 757    XFREE(pp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 758    pp = NULL;
 759
 760    /* 0 */
 761    if (a != NULL) {
 762        a->intData[0] = ASN_INTEGER;
 763        a->intData[1] = 1;
 764        a->intData[2] = 0;
 765        a->negative = 1;
 766    }
 767    ExpectIntEQ(ret = i2c_ASN1_INTEGER(a, NULL), 1);
 768    ExpectNotNull(pp = (unsigned char*)XMALLOC(ret + 1, NULL,
 769                DYNAMIC_TYPE_TMP_BUFFER));
 770    if (tpp != NULL) {
 771        tpp = pp;
 772        ExpectNotNull(XMEMSET(tpp, 0, ret + 1));
 773        ExpectIntEQ(i2c_ASN1_INTEGER(a, &tpp), 1);
 774        tpp--;
 775        ExpectIntEQ(*tpp, 0);
 776    }
 777    XFREE(pp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 778    pp = NULL;
 779
 780    /* 0x100 */
 781    if (a != NULL) {
 782        a->intData[0] = ASN_INTEGER;
 783        a->intData[1] = 2;
 784        a->intData[2] = 0x01;
 785        a->intData[3] = 0x00;
 786        a->negative = 0;
 787    }
 788    ExpectIntEQ(ret = i2c_ASN1_INTEGER(a, NULL), 2);
 789    ExpectNotNull(pp = (unsigned char*)XMALLOC(ret + 1, NULL,
 790                DYNAMIC_TYPE_TMP_BUFFER));
 791    if (tpp != NULL) {
 792        tpp = pp;
 793        ExpectNotNull(XMEMSET(tpp, 0, ret + 1));
 794        ExpectIntEQ(i2c_ASN1_INTEGER(a, &tpp), 2);
 795        tpp -= 2;
 796        ExpectIntEQ(tpp[0], 0x01);
 797        ExpectIntEQ(tpp[1], 0x00);
 798    }
 799    XFREE(pp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 800    pp = NULL;
 801
 802    /* -0x8000 => 0x8000 */
 803    if (a != NULL) {
 804        a->intData[0] = ASN_INTEGER;
 805        a->intData[1] = 2;
 806        a->intData[2] = 0x80;
 807        a->intData[3] = 0x00;
 808        a->negative = 1;
 809    }
 810    ExpectIntEQ(ret = i2c_ASN1_INTEGER(a, NULL), 2);
 811    ExpectNotNull(pp = (unsigned char*)XMALLOC(ret + 1, NULL,
 812                DYNAMIC_TYPE_TMP_BUFFER));
 813    tpp = pp;
 814    if (tpp != NULL) {
 815        ExpectNotNull(XMEMSET(tpp, 0, ret + 1));
 816        ExpectIntEQ(i2c_ASN1_INTEGER(a, &tpp), 2);
 817        tpp -= 2;
 818        ExpectIntEQ(tpp[0], 0x80);
 819        ExpectIntEQ(tpp[1], 0x00);
 820    }
 821    XFREE(pp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 822    pp = NULL;
 823
 824    /* -0x8001 => 0xFF7FFF */
 825    if (a != NULL) {
 826        a->intData[0] = ASN_INTEGER;
 827        a->intData[1] = 2;
 828        a->intData[2] = 0x80;
 829        a->intData[3] = 0x01;
 830        a->negative = 1;
 831    }
 832    ExpectIntEQ(ret = i2c_ASN1_INTEGER(a, NULL), 3);
 833    ExpectNotNull(pp = (unsigned char*)XMALLOC(ret + 1, NULL,
 834                DYNAMIC_TYPE_TMP_BUFFER));
 835    tpp = pp;
 836    if (tpp != NULL) {
 837        ExpectNotNull(XMEMSET(tpp, 0, ret + 1));
 838        ExpectIntEQ(i2c_ASN1_INTEGER(a, &tpp), 3);
 839        tpp -= 3;
 840        ExpectIntEQ(tpp[0], 0xFF);
 841        ExpectIntEQ(tpp[1], 0x7F);
 842        ExpectIntEQ(tpp[2], 0xFF);
 843    }
 844    XFREE(pp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 845
 846    wolfSSL_ASN1_INTEGER_free(a);
 847#endif /* OPENSSL_EXTRA && !NO_ASN */
 848    return EXPECT_RESULT();
 849}
 850
 851int test_wolfSSL_ASN1_OBJECT(void)
 852{
 853    EXPECT_DECLS;
 854#if defined(OPENSSL_EXTRA)
 855    ASN1_OBJECT* a = NULL;
 856    ASN1_OBJECT s;
 857    const unsigned char der[] = { 0x06, 0x01, 0x00 };
 858
 859    /* Invalid parameter testing. */
 860    ASN1_OBJECT_free(NULL);
 861    ExpectNull(wolfSSL_ASN1_OBJECT_dup(NULL));
 862
 863    /* Test that a static ASN1_OBJECT can be freed. */
 864    XMEMSET(&s, 0, sizeof(ASN1_OBJECT));
 865    ASN1_OBJECT_free(&s);
 866    ExpectNotNull(a = wolfSSL_ASN1_OBJECT_dup(&s));
 867    ASN1_OBJECT_free(a);
 868    a = NULL;
 869    s.obj = der;
 870    s.objSz = sizeof(der);
 871    ExpectNotNull(a = wolfSSL_ASN1_OBJECT_dup(&s));
 872    ASN1_OBJECT_free(a);
 873    a = NULL;
 874    ASN1_OBJECT_free(&s);
 875
 876    /* Test dup copies pathlen when set */
 877    XMEMSET(&s, 0, sizeof(ASN1_OBJECT));
 878    s.type = NID_basic_constraints;
 879    s.ca = 1;
 880    s.pathlen = wolfSSL_ASN1_INTEGER_new();
 881    ExpectNotNull(s.pathlen);
 882    if (s.pathlen != NULL) {
 883        s.pathlen->length = 5;
 884    }
 885    ExpectNotNull(a = wolfSSL_ASN1_OBJECT_dup(&s));
 886    if (a != NULL) {
 887        ExpectIntEQ(a->ca, 1);
 888        ExpectNotNull(a->pathlen);
 889        if (a->pathlen != NULL) {
 890            ExpectIntEQ(a->pathlen->length, 5);
 891        }
 892    }
 893    ASN1_OBJECT_free(a);
 894    a = NULL;
 895
 896    /* Test dup with NULL pathlen leaves it NULL */
 897    wolfSSL_ASN1_INTEGER_free(s.pathlen);
 898    s.pathlen = NULL;
 899    ExpectNotNull(a = wolfSSL_ASN1_OBJECT_dup(&s));
 900    if (a != NULL) {
 901        ExpectNull(a->pathlen);
 902    }
 903    ASN1_OBJECT_free(a);
 904    ASN1_OBJECT_free(&s);
 905#endif /* OPENSSL_EXTRA */
 906    return EXPECT_RESULT();
 907}
 908
 909int test_wolfSSL_ASN1_get_object(void)
 910{
 911    EXPECT_DECLS;
 912#if defined(OPENSSL_EXTRA) && defined(HAVE_ECC) && defined(USE_CERT_BUFFERS_256)
 913    const unsigned char* derBuf = cliecc_cert_der_256;
 914    const unsigned char* nullPtr = NULL;
 915    const unsigned char objDerInvalidLen[] = { 0x30, 0x81 };
 916    const unsigned char objDerBadLen[] = { 0x30, 0x04 };
 917    const unsigned char objDerNotObj[] = { 0x02, 0x01, 0x00 };
 918    const unsigned char objDerNoData[] = { 0x06, 0x00 };
 919    const unsigned char* p;
 920    unsigned char objDer[10];
 921    unsigned char* der;
 922    unsigned char* derPtr;
 923    int len = sizeof_cliecc_cert_der_256;
 924    long asnLen = 0;
 925    int tag = 0;
 926    int cls = 0;
 927    ASN1_OBJECT* a = NULL;
 928    ASN1_OBJECT s;
 929
 930    XMEMSET(&s, 0, sizeof(ASN1_OBJECT));
 931
 932    /* Invalid encoding at length. */
 933    p = objDerInvalidLen;
 934    ExpectIntEQ(ASN1_get_object(&p, &asnLen, &tag, &cls, sizeof(objDerBadLen)),
 935        0x80);
 936    p = objDerBadLen;
 937    /* Error = 0x80, Constructed = 0x20 */
 938    ExpectIntEQ(ASN1_get_object(&p, &asnLen, &tag, &cls, sizeof(objDerBadLen)),
 939        0x80 | 0x20);
 940
 941    /* Read a couple TLV triplets and make sure they match the expected values
 942     */
 943
 944    /* SEQUENCE */
 945    ExpectIntEQ(ASN1_get_object(&derBuf, &asnLen, &tag, &cls, len) & 0x80, 0);
 946    ExpectIntEQ(asnLen, 861);
 947    ExpectIntEQ(tag, 0x10);
 948    ExpectIntEQ(cls, 0);
 949
 950    /* SEQUENCE */
 951    ExpectIntEQ(ASN1_get_object(&derBuf, &asnLen, &tag, &cls,
 952            len - (derBuf - cliecc_cert_der_256)) & 0x80, 0);
 953    ExpectIntEQ(asnLen, 772);
 954    ExpectIntEQ(tag, 0x10);
 955    ExpectIntEQ(cls, 0);
 956
 957    /* [0] */
 958    ExpectIntEQ(ASN1_get_object(&derBuf, &asnLen, &tag, &cls,
 959            len - (derBuf - cliecc_cert_der_256)) & 0x80, 0);
 960    ExpectIntEQ(asnLen, 3);
 961    ExpectIntEQ(tag, 0);
 962    ExpectIntEQ(cls, 0x80);
 963
 964    /* INTEGER */
 965    ExpectIntEQ(ASN1_get_object(&derBuf, &asnLen, &tag, &cls,
 966            len - (derBuf - cliecc_cert_der_256)) & 0x80, 0);
 967    ExpectIntEQ(asnLen, 1);
 968    ExpectIntEQ(tag, 0x2);
 969    ExpectIntEQ(cls, 0);
 970    derBuf += asnLen;
 971
 972    /* INTEGER */
 973    ExpectIntEQ(ASN1_get_object(&derBuf, &asnLen, &tag, &cls,
 974            len - (derBuf - cliecc_cert_der_256)) & 0x80, 0);
 975    ExpectIntEQ(asnLen, 20);
 976    ExpectIntEQ(tag, 0x2);
 977    ExpectIntEQ(cls, 0);
 978    derBuf += asnLen;
 979
 980    /* SEQUENCE */
 981    ExpectIntEQ(ASN1_get_object(&derBuf, &asnLen, &tag, &cls,
 982            len - (derBuf - cliecc_cert_der_256)) & 0x80, 0);
 983    ExpectIntEQ(asnLen, 10);
 984    ExpectIntEQ(tag, 0x10);
 985    ExpectIntEQ(cls, 0);
 986
 987    /* Found OBJECT_ID. */
 988
 989    /* Invalid parameter testing. */
 990    ExpectIntEQ(ASN1_get_object(NULL, NULL, NULL, NULL, 0), 0x80);
 991    ExpectIntEQ(ASN1_get_object(&nullPtr, NULL, NULL, NULL, 0), 0x80);
 992    ExpectIntEQ(ASN1_get_object(NULL, &asnLen, &tag, &cls, len), 0x80);
 993    ExpectIntEQ(ASN1_get_object(&nullPtr, &asnLen, &tag, &cls, len), 0x80);
 994    ExpectIntEQ(ASN1_get_object(&derBuf, NULL, &tag, &cls, len), 0x80);
 995    ExpectIntEQ(ASN1_get_object(&derBuf, &asnLen, NULL, &cls, len), 0x80);
 996    ExpectIntEQ(ASN1_get_object(&derBuf, &asnLen, &tag, NULL, len), 0x80);
 997    ExpectIntEQ(ASN1_get_object(&derBuf, &asnLen, &tag, &cls, 0), 0x80);
 998    ExpectIntEQ(ASN1_get_object(&derBuf, &asnLen, &tag, &cls, -1), 0x80);
 999    ExpectNull(d2i_ASN1_OBJECT(NULL, NULL, -1));
1000    ExpectNull(d2i_ASN1_OBJECT(NULL, &nullPtr, -1));
1001    ExpectNull(d2i_ASN1_OBJECT(NULL, &derBuf, -1));
1002    ExpectNull(d2i_ASN1_OBJECT(NULL, NULL, 0));
1003    ExpectNull(d2i_ASN1_OBJECT(&a, NULL, len));
1004    ExpectNull(d2i_ASN1_OBJECT(&a, &nullPtr, len));
1005    ExpectNull(d2i_ASN1_OBJECT(&a, &derBuf, -1));
1006    ExpectNull(c2i_ASN1_OBJECT(NULL, NULL, -1));
1007    ExpectNull(c2i_ASN1_OBJECT(NULL, &nullPtr, -1));
1008    ExpectNull(c2i_ASN1_OBJECT(NULL, &derBuf, -1));
1009    ExpectNull(c2i_ASN1_OBJECT(NULL, NULL, 1));
1010    ExpectNull(c2i_ASN1_OBJECT(NULL, &nullPtr, 1));
1011
1012    /* Invalid encoding at length. */
1013    p = objDerInvalidLen;
1014    ExpectNull(d2i_ASN1_OBJECT(&a, &p, sizeof(objDerInvalidLen)));
1015    p = objDerBadLen;
1016    ExpectNull(d2i_ASN1_OBJECT(&a, &p, sizeof(objDerBadLen)));
1017    p = objDerNotObj;
1018    ExpectNull(d2i_ASN1_OBJECT(&a, &p, sizeof(objDerNotObj)));
1019    p = objDerNoData;
1020    ExpectNull(d2i_ASN1_OBJECT(&a, &p, sizeof(objDerNoData)));
1021
1022    /* Create an ASN OBJECT from content */
1023    p = derBuf + 2;
1024    ExpectNotNull(a = c2i_ASN1_OBJECT(NULL, &p, 8));
1025    ASN1_OBJECT_free(a);
1026    a = NULL;
1027    /* Create an ASN OBJECT from DER */
1028    ExpectNotNull(d2i_ASN1_OBJECT(&a, &derBuf, len));
1029
1030    /* Invalid parameter testing. */
1031    ExpectIntEQ(i2d_ASN1_OBJECT(NULL, NULL), 0);
1032    ExpectIntEQ(i2d_ASN1_OBJECT(&s, NULL), 0);
1033
1034    ExpectIntEQ(i2d_ASN1_OBJECT(a, NULL), 10);
1035    der = NULL;
1036    ExpectIntEQ(i2d_ASN1_OBJECT(a, &der), 10);
1037    derPtr = objDer;
1038    ExpectIntEQ(i2d_ASN1_OBJECT(a, &derPtr), 10);
1039    ExpectPtrNE(derPtr, objDer);
1040    ExpectIntEQ(XMEMCMP(der, objDer, 10), 0);
1041    XFREE(der, NULL, DYNAMIC_TYPE_OPENSSL);
1042
1043    ASN1_OBJECT_free(a);
1044#endif /* OPENSSL_EXTRA && HAVE_ECC && USE_CERT_BUFFERS_256 */
1045    return EXPECT_RESULT();
1046}
1047
1048int test_wolfSSL_i2a_ASN1_OBJECT(void)
1049{
1050    EXPECT_DECLS;
1051#if defined(OPENSSL_EXTRA) && !defined(NO_ASN) && !defined(NO_BIO)
1052    ASN1_OBJECT* obj = NULL;
1053    ASN1_OBJECT* a = NULL;
1054    BIO *bio = NULL;
1055    const unsigned char notObjDer[] = { 0x04, 0x01, 0xff };
1056    const unsigned char* p;
1057
1058    ExpectNotNull(obj = OBJ_nid2obj(NID_sha256));
1059    ExpectTrue((bio = BIO_new(BIO_s_mem())) != NULL);
1060
1061    ExpectIntGT(wolfSSL_i2a_ASN1_OBJECT(bio, obj), 0);
1062    ExpectIntGT(wolfSSL_i2a_ASN1_OBJECT(bio, NULL), 0);
1063
1064    ExpectIntEQ(wolfSSL_i2a_ASN1_OBJECT(NULL, obj), 0);
1065
1066    /* No DER encoding in ASN1_OBJECT. */
1067    ExpectNotNull(a = wolfSSL_ASN1_OBJECT_new());
1068    ExpectIntEQ(wolfSSL_i2a_ASN1_OBJECT(bio, a), 0);
1069    ASN1_OBJECT_free(a);
1070    a = NULL;
1071    /* DER encoding */
1072    p = notObjDer;
1073    ExpectNotNull(a = c2i_ASN1_OBJECT(NULL, &p, 3));
1074    ExpectIntEQ(wolfSSL_i2a_ASN1_OBJECT(bio, a), 5);
1075    ASN1_OBJECT_free(a);
1076
1077    BIO_free(bio);
1078    ASN1_OBJECT_free(obj);
1079#endif
1080    return EXPECT_RESULT();
1081}
1082
1083int test_wolfSSL_i2t_ASN1_OBJECT(void)
1084{
1085    EXPECT_DECLS;
1086#if defined(OPENSSL_EXTRA) && \
1087    defined(WOLFSSL_CERT_EXT) && defined(WOLFSSL_CERT_GEN)
1088    char buf[50] = {0};
1089    ASN1_OBJECT* obj;
1090    const char* oid = "2.5.29.19";
1091    const char* ln  = "X509v3 Basic Constraints";
1092
1093    obj = NULL;
1094    ExpectIntEQ(i2t_ASN1_OBJECT(NULL, sizeof(buf), obj), 0);
1095    ExpectIntEQ(i2t_ASN1_OBJECT(buf, sizeof(buf), NULL), 0);
1096    ExpectIntEQ(i2t_ASN1_OBJECT(buf, 0, NULL), 0);
1097
1098    ExpectNotNull(obj = OBJ_txt2obj(oid, 0));
1099    XMEMSET(buf, 0, sizeof(buf));
1100    ExpectIntEQ(i2t_ASN1_OBJECT(buf, sizeof(buf), obj), XSTRLEN(ln));
1101    ExpectIntEQ(XSTRNCMP(buf, ln, XSTRLEN(ln)), 0);
1102    ASN1_OBJECT_free(obj);
1103#endif /* OPENSSL_EXTRA && WOLFSSL_CERT_EXT && WOLFSSL_CERT_GEN */
1104    return EXPECT_RESULT();
1105}
1106
1107int test_wolfSSL_sk_ASN1_OBJECT(void)
1108{
1109    EXPECT_DECLS;
1110#if !defined(NO_ASN) && (defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL))
1111    WOLFSSL_STACK* sk = NULL;
1112    WOLFSSL_ASN1_OBJECT* obj;
1113
1114    ExpectNotNull(obj = wolfSSL_ASN1_OBJECT_new());
1115
1116    ExpectNotNull(sk = wolfSSL_sk_new_asn1_obj());
1117    wolfSSL_sk_ASN1_OBJECT_free(sk);
1118    sk = NULL;
1119
1120    ExpectNotNull(sk = wolfSSL_sk_new_asn1_obj());
1121    ExpectIntEQ(wolfSSL_sk_ASN1_OBJECT_push(NULL, NULL), -1);
1122    ExpectIntEQ(wolfSSL_sk_ASN1_OBJECT_push(sk, NULL), 0);
1123    ExpectIntEQ(wolfSSL_sk_ASN1_OBJECT_push(NULL, obj), -1);
1124    ExpectIntEQ(wolfSSL_sk_ASN1_OBJECT_push(sk, obj), 1);
1125    wolfSSL_sk_ASN1_OBJECT_pop_free(sk, NULL);
1126    sk = NULL;
1127    /* obj freed in pop_free call. */
1128
1129    ExpectNotNull(obj = wolfSSL_ASN1_OBJECT_new());
1130    ExpectNotNull(sk = wolfSSL_sk_new_asn1_obj());
1131    ExpectIntEQ(wolfSSL_sk_ASN1_OBJECT_push(sk, obj), 1);
1132    ExpectPtrEq(obj, wolfSSL_sk_ASN1_OBJECT_pop(sk));
1133    wolfSSL_sk_ASN1_OBJECT_free(sk);
1134    wolfSSL_ASN1_OBJECT_free(obj);
1135#endif /* !NO_ASN && (OPENSSL_EXTRA || WOLFSSL_WPAS_SMALL) */
1136    return EXPECT_RESULT();
1137}
1138
1139int test_wolfSSL_ASN1_STRING(void)
1140{
1141    EXPECT_DECLS;
1142#if defined(OPENSSL_EXTRA)
1143    ASN1_STRING* str = NULL;
1144    ASN1_STRING* c = NULL;
1145    const char data[]  = "hello wolfSSL";
1146    const char data2[] = "Same len data";
1147    const char longData[] =
1148        "This string must be longer than CTC_NAME_SIZE that is defined as 64.";
1149
1150    ExpectNotNull(str = ASN1_STRING_type_new(V_ASN1_OCTET_STRING));
1151    ASN1_STRING_free(str);
1152    str = NULL;
1153
1154    ExpectNotNull(str = ASN1_STRING_type_new(V_ASN1_OCTET_STRING));
1155    ExpectIntEQ(ASN1_STRING_type(str), V_ASN1_OCTET_STRING);
1156    ExpectIntEQ(ASN1_STRING_type(NULL), 0);
1157    /* Check setting to NULL works. */
1158    ExpectIntEQ(ASN1_STRING_set(str, NULL, 0), 1);
1159    ExpectIntEQ(ASN1_STRING_set(str, (const void*)data, sizeof(data)), 1);
1160    ExpectIntEQ(ASN1_STRING_set(str, (const void*)data, -1), 1);
1161    ExpectIntEQ(ASN1_STRING_set(str, NULL, -1), 0);
1162    ExpectIntEQ(ASN1_STRING_set(NULL, NULL, 0), 0);
1163
1164    ExpectIntEQ(wolfSSL_ASN1_STRING_copy(NULL, NULL), 0);
1165    ExpectIntEQ(wolfSSL_ASN1_STRING_copy(str, NULL), 0);
1166    ExpectIntEQ(wolfSSL_ASN1_STRING_copy(NULL, str), 0);
1167    ExpectNull(wolfSSL_ASN1_STRING_dup(NULL));
1168
1169    ExpectNotNull(c = wolfSSL_ASN1_STRING_dup(str));
1170    ExpectIntEQ(ASN1_STRING_cmp(NULL, NULL), -1);
1171    ExpectIntEQ(ASN1_STRING_cmp(str, NULL), -1);
1172    ExpectIntEQ(ASN1_STRING_cmp(NULL, c), -1);
1173    ExpectIntEQ(ASN1_STRING_cmp(str, c), 0);
1174    ExpectIntEQ(ASN1_STRING_set(c, (const void*)data2, -1), 1);
1175    ExpectIntGT(ASN1_STRING_cmp(str, c), 0);
1176    ExpectIntEQ(ASN1_STRING_set(str, (const void*)longData, -1), 1);
1177    ExpectIntEQ(wolfSSL_ASN1_STRING_copy(c, str), 1);
1178    ExpectIntEQ(ASN1_STRING_cmp(str, c), 0);
1179    /* Check setting back to smaller size frees dynamic data. */
1180    ExpectIntEQ(ASN1_STRING_set(str, (const void*)data, -1), 1);
1181    ExpectIntLT(ASN1_STRING_cmp(str, c), 0);
1182    ExpectIntGT(ASN1_STRING_cmp(c, str), 0);
1183
1184    ExpectNull(ASN1_STRING_get0_data(NULL));
1185    ExpectNotNull(ASN1_STRING_get0_data(str));
1186    ExpectNull(ASN1_STRING_data(NULL));
1187    ExpectNotNull(ASN1_STRING_data(str));
1188    ExpectIntEQ(ASN1_STRING_length(NULL), 0);
1189    ExpectIntGT(ASN1_STRING_length(str), 0);
1190
1191    ASN1_STRING_free(c);
1192    ASN1_STRING_free(str);
1193    ASN1_STRING_free(NULL);
1194
1195#ifndef NO_WOLFSSL_STUB
1196    ExpectNull(d2i_DISPLAYTEXT(NULL, NULL, 0));
1197#endif
1198#endif
1199    return EXPECT_RESULT();
1200}
1201
1202int test_wolfSSL_ASN1_STRING_to_UTF8(void)
1203{
1204    EXPECT_DECLS;
1205#if defined(OPENSSL_ALL) && !defined(NO_ASN) && !defined(NO_RSA) && \
1206    !defined(NO_FILESYSTEM)
1207    WOLFSSL_X509* x509 = NULL;
1208    WOLFSSL_X509_NAME* subject = NULL;
1209    WOLFSSL_X509_NAME_ENTRY* e = NULL;
1210    WOLFSSL_ASN1_STRING* a = NULL;
1211    FILE* file = XBADFILE;
1212    int idx = 0;
1213    char targetOutput[16] = "www.wolfssl.com";
1214    unsigned char* actual_output = NULL;
1215    int len = 0;
1216
1217    ExpectNotNull(file = fopen("./certs/server-cert.pem", "rb"));
1218    ExpectNotNull(x509 = wolfSSL_PEM_read_X509(file, NULL, NULL, NULL));
1219    if (file != XBADFILE)
1220        fclose(file);
1221
1222    /* wolfSSL_ASN1_STRING_to_UTF8(): NID_commonName */
1223    ExpectNotNull(subject = wolfSSL_X509_get_subject_name(x509));
1224    ExpectIntEQ((idx = wolfSSL_X509_NAME_get_index_by_NID(subject,
1225                    NID_commonName, -1)), 5);
1226    ExpectNotNull(e = wolfSSL_X509_NAME_get_entry(subject, idx));
1227    ExpectNotNull(a = wolfSSL_X509_NAME_ENTRY_get_data(e));
1228    ExpectIntEQ((len = wolfSSL_ASN1_STRING_to_UTF8(&actual_output, a)), 15);
1229    ExpectIntEQ(strncmp((const char*)actual_output, targetOutput, (size_t)len),
1230                0);
1231    a = NULL;
1232
1233    /* wolfSSL_ASN1_STRING_to_UTF8(NULL, valid) */
1234    ExpectIntEQ((len = wolfSSL_ASN1_STRING_to_UTF8(NULL, a)), -1);
1235
1236    /* wolfSSL_ASN1_STRING_to_UTF8(valid, NULL) */
1237    ExpectIntEQ((len = wolfSSL_ASN1_STRING_to_UTF8(&actual_output, NULL)), -1);
1238
1239    /* wolfSSL_ASN1_STRING_to_UTF8(NULL, NULL) */
1240    ExpectIntEQ((len = wolfSSL_ASN1_STRING_to_UTF8(NULL, NULL)), -1);
1241
1242    wolfSSL_X509_free(x509);
1243    XFREE(actual_output, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1244
1245    ExpectNotNull(a = ASN1_STRING_new());
1246    ExpectIntEQ(wolfSSL_ASN1_STRING_to_UTF8(&actual_output, a), -1);
1247    ASN1_STRING_free(a);
1248#endif
1249    return EXPECT_RESULT();
1250}
1251
1252int test_wolfSSL_i2s_ASN1_STRING(void)
1253{
1254    EXPECT_DECLS;
1255#if defined(OPENSSL_EXTRA) && !defined(NO_ASN)
1256    WOLFSSL_ASN1_STRING* str = NULL;
1257    const char* data = "test_wolfSSL_i2s_ASN1_STRING";
1258    char* ret = NULL;
1259
1260    ExpectNotNull(str = ASN1_STRING_new());
1261
1262    ExpectNull(ret = wolfSSL_i2s_ASN1_STRING(NULL, NULL));
1263    XFREE(ret, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1264    ret = NULL;
1265    /* No data. */
1266    ExpectNull(ret = wolfSSL_i2s_ASN1_STRING(NULL, str));
1267    XFREE(ret, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1268    ret = NULL;
1269
1270    ExpectIntEQ(ASN1_STRING_set(str, data, 0), 1);
1271    ExpectNotNull(ret = wolfSSL_i2s_ASN1_STRING(NULL, str));
1272    XFREE(ret, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1273    ret = NULL;
1274
1275    ExpectIntEQ(ASN1_STRING_set(str, data, -1), 1);
1276    /* No type. */
1277    ExpectNotNull(ret = wolfSSL_i2s_ASN1_STRING(NULL, str));
1278    XFREE(ret, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1279
1280    ASN1_STRING_free(str);
1281#endif
1282    return EXPECT_RESULT();
1283}
1284
1285int test_wolfSSL_ASN1_STRING_canon(void)
1286{
1287    EXPECT_DECLS;
1288#if defined(WOLFSSL_TEST_STATIC_BUILD)
1289#if !defined(NO_CERTS) && (defined(OPENSSL_ALL) || defined(OPENSSL_EXTRA) || \
1290    defined(OPENSSL_EXTRA_X509_SMALL))
1291    WOLFSSL_ASN1_STRING* orig = NULL;
1292    WOLFSSL_ASN1_STRING* canon = NULL;
1293    const char* data = "test_wolfSSL_ASN1_STRING_canon";
1294    const char* whitespaceOnly = "\t\r\n";
1295    const char* modData = "  \x01\f\t\x02\r\n\v\xff\nTt \n";
1296    const char* canonData = "\x01 \x02 \xff tt";
1297    const char longData[] =
1298        "This string must be longer than CTC_NAME_SIZE that is defined as 64.";
1299
1300    ExpectNotNull(orig = ASN1_STRING_new());
1301    ExpectNotNull(canon = ASN1_STRING_new());
1302
1303    /* Invalid parameter testing. */
1304    ExpectIntEQ(wolfSSL_ASN1_STRING_canon(NULL, NULL),
1305        WC_NO_ERR_TRACE(BAD_FUNC_ARG));
1306    ExpectIntEQ(wolfSSL_ASN1_STRING_canon(canon, NULL),
1307        WC_NO_ERR_TRACE(BAD_FUNC_ARG));
1308    ExpectIntEQ(wolfSSL_ASN1_STRING_canon(NULL, orig),
1309        WC_NO_ERR_TRACE(BAD_FUNC_ARG));
1310
1311    ExpectIntEQ(wolfSSL_ASN1_STRING_canon(canon, orig), 1);
1312    ExpectIntEQ(ASN1_STRING_cmp(orig, canon), 0);
1313
1314    ExpectIntEQ(ASN1_STRING_set(orig, longData, (int)XSTRLEN(data)), 1);
1315    ExpectIntEQ(wolfSSL_ASN1_STRING_canon(canon, orig), 1);
1316    ExpectIntEQ(ASN1_STRING_cmp(orig, canon), 0);
1317
1318    ExpectIntEQ(ASN1_STRING_set(orig, data, (int)XSTRLEN(data)), 1);
1319    ExpectIntEQ(wolfSSL_ASN1_STRING_canon(canon, orig), 1);
1320    ExpectIntEQ(ASN1_STRING_cmp(orig, canon), 0);
1321
1322    ASN1_STRING_free(orig);
1323    orig = NULL;
1324
1325    ExpectNotNull(orig = ASN1_STRING_type_new(MBSTRING_UTF8));
1326    ExpectIntEQ(ASN1_STRING_set(orig, modData, 15), 1);
1327    ExpectIntEQ(wolfSSL_ASN1_STRING_canon(canon, orig), 1);
1328    ExpectIntEQ(ASN1_STRING_set(orig, canonData, 8), 1);
1329    ExpectIntEQ(ASN1_STRING_cmp(orig, canon), 0);
1330    ASN1_STRING_free(orig);
1331    orig = NULL;
1332
1333    ExpectNotNull(orig = ASN1_STRING_type_new(V_ASN1_PRINTABLESTRING));
1334    ExpectIntEQ(ASN1_STRING_set(orig, whitespaceOnly, 3), 1);
1335    ExpectIntEQ(wolfSSL_ASN1_STRING_canon(canon, orig), 1);
1336    ASN1_STRING_free(orig);
1337    orig = NULL;
1338    ExpectNotNull(orig = ASN1_STRING_type_new(MBSTRING_UTF8));
1339    ExpectIntEQ(ASN1_STRING_cmp(orig, canon), 0);
1340
1341    ASN1_STRING_free(orig);
1342    ASN1_STRING_free(canon);
1343#endif
1344#endif
1345    return EXPECT_RESULT();
1346}
1347
1348int test_wolfSSL_ASN1_STRING_print(void)
1349{
1350    EXPECT_DECLS;
1351#if defined(OPENSSL_ALL) && !defined(NO_ASN) && !defined(NO_CERTS) && \
1352    !defined(NO_BIO)
1353    ASN1_STRING* asnStr = NULL;
1354    const char HELLO_DATA[]= \
1355                      {'H','e','l','l','o',' ','w','o','l','f','S','S','L','!'};
1356    #define MAX_UNPRINTABLE_CHAR 32
1357    #define MAX_BUF 255
1358    unsigned char unprintableData[MAX_UNPRINTABLE_CHAR + sizeof(HELLO_DATA)];
1359    unsigned char expected[sizeof(unprintableData)+1];
1360    unsigned char rbuf[MAX_BUF];
1361    BIO *bio = NULL;
1362    int p_len;
1363    int i;
1364
1365    /* setup */
1366
1367    for (i = 0; i < (int)sizeof(HELLO_DATA); i++) {
1368        unprintableData[i]  = (unsigned char)HELLO_DATA[i];
1369        expected[i]         = (unsigned char)HELLO_DATA[i];
1370    }
1371
1372    for (i = 0; i < (int)MAX_UNPRINTABLE_CHAR; i++) {
1373        unprintableData[sizeof(HELLO_DATA)+i] = i;
1374
1375        if (i == (int)'\n' || i == (int)'\r')
1376            expected[sizeof(HELLO_DATA)+i] = i;
1377        else
1378            expected[sizeof(HELLO_DATA)+i] = '.';
1379    }
1380
1381    unprintableData[sizeof(unprintableData)-1] = '\0';
1382    expected[sizeof(expected)-1] = '\0';
1383
1384    XMEMSET(rbuf, 0, MAX_BUF);
1385    ExpectNotNull(bio = BIO_new(BIO_s_mem()));
1386    ExpectIntEQ(BIO_set_write_buf_size(bio, MAX_BUF), 0);
1387
1388    ExpectNotNull(asnStr = ASN1_STRING_type_new(V_ASN1_OCTET_STRING));
1389    ExpectIntEQ(ASN1_STRING_set(asnStr,(const void*)unprintableData,
1390            (int)sizeof(unprintableData)), 1);
1391    /* test */
1392    ExpectIntEQ(wolfSSL_ASN1_STRING_print(NULL, NULL), 0);
1393    ExpectIntEQ(wolfSSL_ASN1_STRING_print(bio, NULL), 0);
1394    ExpectIntEQ(wolfSSL_ASN1_STRING_print(NULL, asnStr), 0);
1395    ExpectIntEQ(p_len = wolfSSL_ASN1_STRING_print(bio, asnStr), 46);
1396    ExpectIntEQ(BIO_read(bio, (void*)rbuf, 46), 46);
1397
1398    ExpectStrEQ((char*)rbuf, (const char*)expected);
1399
1400    BIO_free(bio);
1401    bio = NULL;
1402
1403    ExpectNotNull(bio = BIO_new(wolfSSL_BIO_s_fixed_mem()));
1404    ExpectIntEQ(BIO_set_write_buf_size(bio, 1), 1);
1405    /* Ensure there is 0 bytes available to write into. */
1406    ExpectIntEQ(BIO_write(bio, rbuf, 1), 1);
1407    ExpectIntEQ(wolfSSL_ASN1_STRING_print(bio, asnStr), 0);
1408    ExpectIntEQ(BIO_set_write_buf_size(bio, 1), 1);
1409    ExpectIntEQ(wolfSSL_ASN1_STRING_print(bio, asnStr), 0);
1410    ExpectIntEQ(BIO_set_write_buf_size(bio, 45), 1);
1411    ExpectIntEQ(wolfSSL_ASN1_STRING_print(bio, asnStr), 0);
1412    BIO_free(bio);
1413
1414    ASN1_STRING_free(asnStr);
1415#endif /* OPENSSL_EXTRA && !NO_ASN && !NO_CERTS && !NO_BIO */
1416    return EXPECT_RESULT();
1417}
1418
1419int test_wolfSSL_ASN1_STRING_print_ex(void)
1420{
1421    EXPECT_DECLS;
1422#if defined(OPENSSL_EXTRA) && !defined(NO_ASN) && !defined(NO_BIO)
1423    ASN1_STRING* asn_str = NULL;
1424    const char data[] = "Hello wolfSSL!";
1425    ASN1_STRING* esc_str = NULL;
1426    const char esc_data[] = "a+;<>";
1427    ASN1_STRING* neg_int = NULL;
1428    const char neg_int_data[] = "\xff";
1429    ASN1_STRING* neg_enum = NULL;
1430    const char neg_enum_data[] = "\xff";
1431    BIO *bio = NULL;
1432    BIO *fixed = NULL;
1433    unsigned long flags;
1434    int p_len;
1435    unsigned char rbuf[255];
1436
1437    /* setup */
1438    XMEMSET(rbuf, 0, 255);
1439    ExpectNotNull(bio = BIO_new(BIO_s_mem()));
1440    ExpectIntEQ(BIO_set_write_buf_size(bio, 255), 0);
1441    ExpectNotNull(fixed = BIO_new(wolfSSL_BIO_s_fixed_mem()));
1442
1443    ExpectNotNull(asn_str = ASN1_STRING_type_new(V_ASN1_OCTET_STRING));
1444    ExpectIntEQ(ASN1_STRING_set(asn_str, (const void*)data, sizeof(data)), 1);
1445    ExpectNotNull(esc_str = ASN1_STRING_type_new(V_ASN1_OCTET_STRING));
1446    ExpectIntEQ(ASN1_STRING_set(esc_str, (const void*)esc_data,
1447        sizeof(esc_data)), 1);
1448    ExpectNotNull(neg_int = ASN1_STRING_type_new(V_ASN1_NEG_INTEGER));
1449    ExpectIntEQ(ASN1_STRING_set(neg_int, (const void*)neg_int_data,
1450        sizeof(neg_int_data) - 1), 1);
1451    ExpectNotNull(neg_enum = ASN1_STRING_type_new(V_ASN1_NEG_ENUMERATED));
1452    ExpectIntEQ(ASN1_STRING_set(neg_enum, (const void*)neg_enum_data,
1453        sizeof(neg_enum_data) - 1), 1);
1454
1455    /* Invalid parameter testing. */
1456    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(NULL, NULL, 0), 0);
1457    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(bio, NULL, 0), 0);
1458    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(NULL, asn_str, 0), 0);
1459
1460    /* no flags */
1461    XMEMSET(rbuf, 0, 255);
1462    flags = 0;
1463    ExpectIntEQ(p_len = wolfSSL_ASN1_STRING_print_ex(bio, asn_str, flags), 15);
1464    ExpectIntEQ(BIO_read(bio, (void*)rbuf, 15), 15);
1465    ExpectStrEQ((char*)rbuf, "Hello wolfSSL!");
1466    ExpectIntEQ(BIO_set_write_buf_size(fixed, 1), 1);
1467    /* Ensure there is 0 bytes available to write into. */
1468    ExpectIntEQ(BIO_write(fixed, rbuf, 1), 1);
1469    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, asn_str, flags), 0);
1470    ExpectIntEQ(BIO_set_write_buf_size(fixed, 1), 1);
1471    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, asn_str, flags), 0);
1472    ExpectIntEQ(BIO_set_write_buf_size(fixed, 14), 1);
1473    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, asn_str, flags), 0);
1474
1475    /* RFC2253 Escape */
1476    XMEMSET(rbuf, 0, 255);
1477    flags = ASN1_STRFLGS_ESC_2253;
1478    ExpectIntEQ(p_len = wolfSSL_ASN1_STRING_print_ex(bio, esc_str, flags), 9);
1479    ExpectIntEQ(BIO_read(bio, (void*)rbuf, 9), 9);
1480    ExpectStrEQ((char*)rbuf, "a\\+\\;\\<\\>");
1481    ExpectIntEQ(BIO_set_write_buf_size(fixed, 1), 1);
1482    /* Ensure there is 0 bytes available to write into. */
1483    ExpectIntEQ(BIO_write(fixed, rbuf, 1), 1);
1484    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, esc_str, flags), 0);
1485    ExpectIntEQ(BIO_set_write_buf_size(fixed, 1), 1);
1486    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, esc_str, flags), 0);
1487    ExpectIntEQ(BIO_set_write_buf_size(fixed, 8), 1);
1488    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, esc_str, flags), 0);
1489
1490    /* Show type */
1491    XMEMSET(rbuf, 0, 255);
1492    flags = ASN1_STRFLGS_SHOW_TYPE;
1493    ExpectIntEQ(p_len = wolfSSL_ASN1_STRING_print_ex(bio, asn_str, flags), 28);
1494    ExpectIntEQ(BIO_read(bio, (void*)rbuf, 28), 28);
1495    ExpectStrEQ((char*)rbuf, "OCTET STRING:Hello wolfSSL!");
1496    ExpectIntEQ(BIO_set_write_buf_size(fixed, 1), 1);
1497    /* Ensure there is 0 bytes available to write into. */
1498    ExpectIntEQ(BIO_write(fixed, rbuf, 1), 1);
1499    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, asn_str, flags), 0);
1500    ExpectIntEQ(BIO_set_write_buf_size(fixed, 1), 1);
1501    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, asn_str, flags), 0);
1502    ExpectIntEQ(BIO_set_write_buf_size(fixed, 12), 1);
1503    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, asn_str, flags), 0);
1504    ExpectIntEQ(BIO_set_write_buf_size(fixed, 27), 1);
1505    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, asn_str, flags), 0);
1506
1507    /* Dump All */
1508    XMEMSET(rbuf, 0, 255);
1509    flags = ASN1_STRFLGS_DUMP_ALL;
1510    ExpectIntEQ(p_len = wolfSSL_ASN1_STRING_print_ex(bio, asn_str, flags), 31);
1511    ExpectIntEQ(BIO_read(bio, (void*)rbuf, 31), 31);
1512    ExpectStrEQ((char*)rbuf, "#48656C6C6F20776F6C6653534C2100");
1513    ExpectIntEQ(BIO_set_write_buf_size(fixed, 1), 1);
1514    /* Ensure there is 0 bytes available to write into. */
1515    ExpectIntEQ(BIO_write(fixed, rbuf, 1), 1);
1516    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, asn_str, flags), 0);
1517    ExpectIntEQ(BIO_set_write_buf_size(fixed, 1), 1);
1518    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, asn_str, flags), 0);
1519    ExpectIntEQ(BIO_set_write_buf_size(fixed, 30), 1);
1520    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, asn_str, flags), 0);
1521
1522    /* Dump Der */
1523    XMEMSET(rbuf, 0, 255);
1524    flags = ASN1_STRFLGS_DUMP_ALL | ASN1_STRFLGS_DUMP_DER;
1525    ExpectIntEQ(p_len = wolfSSL_ASN1_STRING_print_ex(bio, asn_str, flags), 35);
1526    ExpectIntEQ(BIO_read(bio, (void*)rbuf, 35), 35);
1527    ExpectStrEQ((char*)rbuf, "#040F48656C6C6F20776F6C6653534C2100");
1528    ExpectIntEQ(BIO_set_write_buf_size(fixed, 1), 1);
1529    /* Ensure there is 0 bytes available to write into. */
1530    ExpectIntEQ(BIO_write(fixed, rbuf, 1), 1);
1531    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, asn_str, flags), 0);
1532    ExpectIntEQ(BIO_set_write_buf_size(fixed, 1), 1);
1533    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, asn_str, flags), 0);
1534    ExpectIntEQ(BIO_set_write_buf_size(fixed, 2), 1);
1535    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, asn_str, flags), 0);
1536    ExpectIntEQ(BIO_set_write_buf_size(fixed, 30), 1);
1537    ExpectIntEQ(wolfSSL_ASN1_STRING_print_ex(fixed, asn_str, flags), 0);
1538
1539    /* Dump All + Show type */
1540    XMEMSET(rbuf, 0, 255);
1541    flags = ASN1_STRFLGS_DUMP_ALL | ASN1_STRFLGS_SHOW_TYPE;
1542    ExpectIntEQ(p_len = wolfSSL_ASN1_STRING_print_ex(bio, asn_str, flags), 44);
1543    ExpectIntEQ(BIO_read(bio, (void*)rbuf, 44), 44);
1544    ExpectStrEQ((char*)rbuf, "OCTET STRING:#48656C6C6F20776F6C6653534C2100");
1545
1546    /* Dump All + Show type - Negative Integer. */
1547    XMEMSET(rbuf, 0, 255);
1548    flags = ASN1_STRFLGS_DUMP_ALL | ASN1_STRFLGS_SHOW_TYPE;
1549    ExpectIntEQ(p_len = wolfSSL_ASN1_STRING_print_ex(bio, neg_int, flags), 11);
1550    ExpectIntEQ(BIO_read(bio, (void*)rbuf, 11), 11);
1551    ExpectStrEQ((char*)rbuf, "INTEGER:#FF");
1552
1553    /* Dump All + Show type - Negative Enumerated. */
1554    XMEMSET(rbuf, 0, 255);
1555    flags = ASN1_STRFLGS_DUMP_ALL | ASN1_STRFLGS_SHOW_TYPE;
1556    ExpectIntEQ(p_len = wolfSSL_ASN1_STRING_print_ex(bio, neg_enum, flags), 14);
1557    ExpectIntEQ(BIO_read(bio, (void*)rbuf, 14), 14);
1558    ExpectStrEQ((char*)rbuf, "ENUMERATED:#FF");
1559
1560    BIO_free(fixed);
1561    BIO_free(bio);
1562    ASN1_STRING_free(asn_str);
1563    ASN1_STRING_free(esc_str);
1564    ASN1_STRING_free(neg_int);
1565    ASN1_STRING_free(neg_enum);
1566
1567    ExpectStrEQ(wolfSSL_ASN1_tag2str(-1), "(unknown)");
1568    ExpectStrEQ(wolfSSL_ASN1_tag2str(31), "(unknown)");
1569#endif
1570    return EXPECT_RESULT();
1571}
1572
1573int test_wolfSSL_ASN1_UNIVERSALSTRING_to_string(void)
1574{
1575    EXPECT_DECLS;
1576#if defined(OPENSSL_ALL) && !defined(NO_ASN)
1577    ASN1_STRING* asn1str_test = NULL;
1578    ASN1_STRING* asn1str_answer = NULL;
1579    /* Each character is encoded using 4 bytes */
1580    char input[] = {
1581            0, 0, 0, 'T',
1582            0, 0, 0, 'e',
1583            0, 0, 0, 's',
1584            0, 0, 0, 't',
1585    };
1586    char output[] = "Test";
1587    char badInput[] = {
1588            1, 0, 0, 'T',
1589            0, 1, 0, 'e',
1590            0, 0, 1, 's',
1591    };
1592
1593    ExpectIntEQ(ASN1_UNIVERSALSTRING_to_string(NULL), 0);
1594    /* Test wrong type. */
1595    ExpectNotNull(asn1str_test = ASN1_STRING_type_new(V_ASN1_OCTET_STRING));
1596    ExpectIntEQ(ASN1_UNIVERSALSTRING_to_string(asn1str_test), 0);
1597    ASN1_STRING_free(asn1str_test);
1598    asn1str_test = NULL;
1599
1600    ExpectNotNull(asn1str_test = ASN1_STRING_type_new(V_ASN1_UNIVERSALSTRING));
1601
1602    /* Test bad length. */
1603    ExpectIntEQ(ASN1_STRING_set(asn1str_test, input, sizeof(input) - 1), 1);
1604    ExpectIntEQ(ASN1_UNIVERSALSTRING_to_string(asn1str_test), 0);
1605    /* Test bad input. */
1606    ExpectIntEQ(ASN1_STRING_set(asn1str_test, badInput + 0, 4), 1);
1607    ExpectIntEQ(ASN1_UNIVERSALSTRING_to_string(asn1str_test), 0);
1608    ExpectIntEQ(ASN1_STRING_set(asn1str_test, badInput + 4, 4), 1);
1609    ExpectIntEQ(ASN1_UNIVERSALSTRING_to_string(asn1str_test), 0);
1610    ExpectIntEQ(ASN1_STRING_set(asn1str_test, badInput + 8, 4), 1);
1611    ExpectIntEQ(ASN1_UNIVERSALSTRING_to_string(asn1str_test), 0);
1612
1613    ExpectIntEQ(ASN1_STRING_set(asn1str_test, input, sizeof(input)), 1);
1614    ExpectIntEQ(ASN1_UNIVERSALSTRING_to_string(asn1str_test), 1);
1615
1616    ExpectNotNull(
1617        asn1str_answer = ASN1_STRING_type_new(V_ASN1_PRINTABLESTRING));
1618    ExpectIntEQ(ASN1_STRING_set(asn1str_answer, output, sizeof(output)-1), 1);
1619
1620    ExpectIntEQ(ASN1_STRING_cmp(asn1str_test, asn1str_answer), 0);
1621
1622    ASN1_STRING_free(asn1str_test);
1623    ASN1_STRING_free(asn1str_answer);
1624#endif /* OPENSSL_ALL && !NO_ASN */
1625    return EXPECT_RESULT();
1626}
1627
1628int test_wolfSSL_ASN1_GENERALIZEDTIME_free(void)
1629{
1630    EXPECT_DECLS;
1631#if defined(OPENSSL_EXTRA) && !defined(NO_ASN_TIME)
1632    WOLFSSL_ASN1_GENERALIZEDTIME* asn1_gtime = NULL;
1633
1634    ExpectNotNull(asn1_gtime = ASN1_GENERALIZEDTIME_new());
1635    if (asn1_gtime != NULL)
1636        XMEMCPY(asn1_gtime->data, "20180504123500Z", ASN_GENERALIZED_TIME_SIZE);
1637    ASN1_GENERALIZEDTIME_free(asn1_gtime);
1638#endif /* OPENSSL_EXTRA && !NO_ASN_TIME */
1639    return EXPECT_RESULT();
1640}
1641
1642int test_wolfSSL_ASN1_GENERALIZEDTIME_print(void)
1643{
1644    EXPECT_DECLS;
1645#if defined(OPENSSL_EXTRA) && !defined(NO_ASN_TIME) && !defined(NO_BIO)
1646    WOLFSSL_ASN1_GENERALIZEDTIME* gtime = NULL;
1647    BIO* bio = NULL;
1648    unsigned char buf[24];
1649    int i;
1650
1651    ExpectNotNull(bio = BIO_new(BIO_s_mem()));
1652    BIO_set_write_buf_size(bio, 24);
1653
1654    ExpectNotNull(gtime = ASN1_GENERALIZEDTIME_new());
1655    /* Type not set. */
1656    ExpectIntEQ(wolfSSL_ASN1_GENERALIZEDTIME_print(bio, gtime), 0);
1657    ExpectIntEQ(wolfSSL_ASN1_TIME_set_string(gtime, "20180504123500Z"), 1);
1658
1659    /* Invalid parameters testing. */
1660    ExpectIntEQ(wolfSSL_ASN1_GENERALIZEDTIME_print(NULL, NULL),
1661        WC_NO_ERR_TRACE(BAD_FUNC_ARG));
1662    ExpectIntEQ(wolfSSL_ASN1_GENERALIZEDTIME_print(bio, NULL),
1663        WC_NO_ERR_TRACE(BAD_FUNC_ARG));
1664    ExpectIntEQ(wolfSSL_ASN1_GENERALIZEDTIME_print(NULL, gtime),
1665        WC_NO_ERR_TRACE(BAD_FUNC_ARG));
1666
1667    ExpectIntEQ(wolfSSL_ASN1_GENERALIZEDTIME_print(bio, gtime), 1);
1668    ExpectIntEQ(BIO_read(bio, buf, sizeof(buf)), 20);
1669    ExpectIntEQ(XMEMCMP(buf, "May 04 12:35:00 2018", 20), 0);
1670
1671    BIO_free(bio);
1672    bio = NULL;
1673
1674    ExpectNotNull(bio = BIO_new(wolfSSL_BIO_s_fixed_mem()));
1675    ExpectIntEQ(BIO_set_write_buf_size(bio, 1), 1);
1676    /* Ensure there is 0 bytes available to write into. */
1677    ExpectIntEQ(BIO_write(bio, buf, 1), 1);
1678    ExpectIntEQ(wolfSSL_ASN1_GENERALIZEDTIME_print(bio, gtime), 0);
1679    for (i = 1; i < 20; i++) {
1680        ExpectIntEQ(BIO_set_write_buf_size(bio, i), 1);
1681        ExpectIntEQ(wolfSSL_ASN1_GENERALIZEDTIME_print(bio, gtime), 0);
1682    }
1683    BIO_free(bio);
1684
1685    wolfSSL_ASN1_GENERALIZEDTIME_free(gtime);
1686#endif /* OPENSSL_EXTRA && !NO_ASN_TIME && !NO_BIO */
1687    return EXPECT_RESULT();
1688}
1689
1690int test_wolfSSL_ASN1_TIME(void)
1691{
1692    EXPECT_DECLS;
1693#if defined(OPENSSL_EXTRA) && !defined(NO_ASN_TIME)
1694    WOLFSSL_ASN1_TIME* asn_time = NULL;
1695    unsigned char *data = NULL;
1696
1697    ExpectNotNull(asn_time = ASN1_TIME_new());
1698
1699#ifndef NO_WOLFSSL_STUB
1700    ExpectNotNull(ASN1_TIME_set(asn_time, 1));
1701#endif
1702    ExpectIntEQ(ASN1_TIME_set_string(NULL, NULL), 0);
1703    ExpectIntEQ(ASN1_TIME_set_string(asn_time, NULL), 0);
1704    ExpectIntEQ(ASN1_TIME_set_string(NULL,
1705        "String longer than CTC_DATA_SIZE that is 32 bytes"), 0);
1706    ExpectIntEQ(ASN1_TIME_set_string(NULL, "101219181011Z"), 1);
1707    ExpectIntEQ(ASN1_TIME_set_string(asn_time, "101219181011Z"), 1);
1708
1709    ExpectIntEQ(wolfSSL_ASN1_TIME_get_length(NULL), 0);
1710    ExpectIntEQ(wolfSSL_ASN1_TIME_get_length(asn_time), ASN_UTC_TIME_SIZE - 1);
1711    ExpectNull(wolfSSL_ASN1_TIME_get_data(NULL));
1712    ExpectNotNull(data = wolfSSL_ASN1_TIME_get_data(asn_time));
1713    ExpectIntEQ(XMEMCMP(data, "101219181011Z", 14), 0);
1714
1715    ExpectIntEQ(ASN1_TIME_check(NULL), 0);
1716    ExpectIntEQ(ASN1_TIME_check(asn_time), 1);
1717
1718    ExpectIntEQ(ASN1_TIME_set_string_X509(asn_time, "101219181011Z"), 1);
1719    ExpectIntEQ(ASN1_TIME_set_string_X509(asn_time, "101219181011Za"), 0);
1720
1721    ASN1_TIME_free(asn_time);
1722    ASN1_TIME_free(NULL);
1723#endif
1724    return EXPECT_RESULT();
1725}
1726
1727int test_wolfSSL_ASN1_TIME_to_string(void)
1728{
1729    EXPECT_DECLS;
1730#ifndef NO_ASN_TIME
1731#if defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(WOLFSSL_NGINX) || \
1732    defined(WOLFSSL_HAPROXY) || defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)
1733    WOLFSSL_ASN1_TIME* t = NULL;
1734    char buf[ASN_GENERALIZED_TIME_SIZE];
1735
1736    ExpectNotNull((t = ASN1_TIME_new()));
1737    ExpectIntEQ(ASN1_TIME_set_string(t, "030222211515Z"), 1);
1738
1739    /* Invalid parameter testing. */
1740    ExpectNull(ASN1_TIME_to_string(NULL, NULL, 4));
1741    ExpectNull(ASN1_TIME_to_string(t, NULL, 4));
1742    ExpectNull(ASN1_TIME_to_string(NULL, buf, 4));
1743    ExpectNull(ASN1_TIME_to_string(NULL, NULL, 5));
1744    ExpectNull(ASN1_TIME_to_string(NULL, buf, 5));
1745    ExpectNull(ASN1_TIME_to_string(t, NULL, 5));
1746    ExpectNull(ASN1_TIME_to_string(t, buf, 4));
1747    /* Buffer needs to be longer than minimum of 5 characters. */
1748    ExpectNull(ASN1_TIME_to_string(t, buf, 5));
1749
1750    ASN1_TIME_free(t);
1751#endif
1752#endif /* NO_ASN_TIME */
1753    return EXPECT_RESULT();
1754}
1755
1756int test_wolfSSL_ASN1_TIME_diff_compare(void)
1757{
1758    EXPECT_DECLS;
1759#if defined(OPENSSL_EXTRA) && !defined(NO_ASN_TIME)
1760    ASN1_TIME* fromTime = NULL;
1761    ASN1_TIME* closeToTime = NULL;
1762    ASN1_TIME* toTime = NULL;
1763    ASN1_TIME* invalidTime = NULL;
1764    int daysDiff = 0;
1765    int secsDiff = 0;
1766
1767    ExpectNotNull((fromTime = ASN1_TIME_new()));
1768    /* Feb 22, 2003, 21:15:15 */
1769    ExpectIntEQ(ASN1_TIME_set_string(fromTime, "030222211515Z"), 1);
1770    ExpectNotNull((closeToTime = ASN1_TIME_new()));
1771    /* Feb 22, 2003, 21:16:15 */
1772    ExpectIntEQ(ASN1_TIME_set_string(closeToTime, "030222211615Z"), 1);
1773    ExpectNotNull((toTime = ASN1_TIME_new()));
1774    /* Dec 19, 2010, 18:10:11 */
1775    ExpectIntEQ(ASN1_TIME_set_string(toTime, "101219181011Z"), 1);
1776    ExpectNotNull((invalidTime = ASN1_TIME_new()));
1777    /* Dec 19, 2010, 18:10:11 but 'U' instead of 'Z' which is invalid. */
1778    ExpectIntEQ(ASN1_TIME_set_string(invalidTime, "102519181011U"), 1);
1779
1780    ExpectIntEQ(ASN1_TIME_diff(&daysDiff, &secsDiff, fromTime, invalidTime), 0);
1781    ExpectIntEQ(ASN1_TIME_diff(&daysDiff, &secsDiff, invalidTime, toTime), 0);
1782
1783    ExpectIntEQ(ASN1_TIME_diff(&daysDiff, &secsDiff, fromTime, toTime), 1);
1784
1785    /* Test when secsDiff or daysDiff is NULL. */
1786    ExpectIntEQ(ASN1_TIME_diff(NULL, &secsDiff, fromTime, toTime), 1);
1787    ExpectIntEQ(ASN1_TIME_diff(&daysDiff, NULL, fromTime, toTime), 1);
1788    ExpectIntEQ(ASN1_TIME_diff(NULL, NULL, fromTime, toTime), 1);
1789
1790    /* If both times are NULL, difference is 0. */
1791    ExpectIntEQ(ASN1_TIME_diff(&daysDiff, &secsDiff, NULL, NULL), 1);
1792    ExpectIntEQ(daysDiff, 0);
1793    ExpectIntEQ(secsDiff, 0);
1794
1795    /* If one time is NULL, it defaults to the current time. */
1796    ExpectIntEQ(ASN1_TIME_diff(&daysDiff, &secsDiff, NULL, toTime), 1);
1797    ExpectIntEQ(ASN1_TIME_diff(&daysDiff, &secsDiff, fromTime, NULL), 1);
1798
1799    /* Normal operation. Both times non-NULL. */
1800    ExpectIntEQ(ASN1_TIME_diff(&daysDiff, &secsDiff, fromTime, toTime), 1);
1801    ExpectIntEQ(daysDiff, 2856);
1802    ExpectIntEQ(secsDiff, 75296);
1803    /* Swapping the times should return negative values. */
1804    ExpectIntEQ(ASN1_TIME_diff(&daysDiff, &secsDiff, toTime, fromTime), 1);
1805    ExpectIntEQ(daysDiff, -2856);
1806    ExpectIntEQ(secsDiff, -75296);
1807
1808    /* Compare with invalid time string. */
1809    ExpectIntEQ(ASN1_TIME_compare(fromTime, invalidTime), -2);
1810    ExpectIntEQ(ASN1_TIME_compare(invalidTime, toTime), -2);
1811    /* Compare with days difference of 0. */
1812    ExpectIntEQ(ASN1_TIME_compare(fromTime, closeToTime), -1);
1813    ExpectIntEQ(ASN1_TIME_compare(closeToTime, fromTime), 1);
1814    /* Days and seconds differences not 0. */
1815    ExpectIntEQ(ASN1_TIME_compare(fromTime, toTime), -1);
1816    ExpectIntEQ(ASN1_TIME_compare(toTime, fromTime), 1);
1817    /* Same time. */
1818    ExpectIntEQ(ASN1_TIME_compare(fromTime, fromTime), 0);
1819
1820    /* Compare regression test: No seconds difference, just difference in days.
1821     */
1822    ASN1_TIME_set_string(fromTime, "19700101000000Z");
1823    ASN1_TIME_set_string(toTime, "19800101000000Z");
1824    ExpectIntEQ(ASN1_TIME_compare(fromTime, toTime), -1);
1825    ExpectIntEQ(ASN1_TIME_compare(toTime, fromTime), 1);
1826    ExpectIntEQ(ASN1_TIME_compare(fromTime, fromTime), 0);
1827
1828    /* Edge case with Unix epoch. */
1829    ExpectNotNull(ASN1_TIME_set_string(fromTime, "19700101000000Z"));
1830    ExpectNotNull(ASN1_TIME_set_string(toTime, "19800101000000Z"));
1831    ExpectIntEQ(ASN1_TIME_diff(&daysDiff, &secsDiff, fromTime, toTime), 1);
1832    ExpectIntEQ(daysDiff, 3652);
1833    ExpectIntEQ(secsDiff, 0);
1834
1835    /* Edge case with year > 2038 (year 2038 problem). */
1836    ExpectNotNull(ASN1_TIME_set_string(toTime, "99991231235959Z"));
1837    ExpectIntEQ(ASN1_TIME_diff(&daysDiff, &secsDiff, fromTime, toTime), 1);
1838    ExpectIntEQ(daysDiff, 2932896);
1839    ExpectIntEQ(secsDiff, 86399);
1840
1841    ASN1_TIME_free(fromTime);
1842    ASN1_TIME_free(closeToTime);
1843    ASN1_TIME_free(toTime);
1844    ASN1_TIME_free(invalidTime);
1845#endif
1846    return EXPECT_RESULT();
1847}
1848
1849int test_wolfSSL_ASN1_TIME_adj(void)
1850{
1851    EXPECT_DECLS;
1852#if defined(OPENSSL_EXTRA) && !defined(NO_ASN_TIME) && \
1853    !defined(USER_TIME) && !defined(TIME_OVERRIDES)
1854    const int year = 365*24*60*60;
1855    const int day  = 24*60*60;
1856    const int hour = 60*60;
1857    const int mini = 60;
1858    const byte asn_utc_time = ASN_UTC_TIME;
1859#if !defined(TIME_T_NOT_64BIT) && !defined(NO_64BIT)
1860    const byte asn_gen_time = ASN_GENERALIZED_TIME;
1861#endif
1862    WOLFSSL_ASN1_TIME* asn_time = NULL;
1863    WOLFSSL_ASN1_TIME* s = NULL;
1864    int offset_day;
1865    long offset_sec;
1866    char date_str[CTC_DATE_SIZE + 1];
1867    time_t t;
1868
1869    ExpectNotNull(s = wolfSSL_ASN1_TIME_new());
1870    /* UTC notation test */
1871    /* 2000/2/15 20:30:00 */
1872    t = (time_t)30 * year + 45 * day + 20 * hour + 30 * mini + 7 * day;
1873    offset_day = 7;
1874    offset_sec = 45 * mini;
1875    /* offset_sec = -45 * min;*/
1876    ExpectNotNull(asn_time =
1877            wolfSSL_ASN1_TIME_adj(s, t, offset_day, offset_sec));
1878    if (asn_time != NULL) {
1879        ExpectTrue(asn_time->type == asn_utc_time);
1880        ExpectNotNull(XSTRNCPY(date_str, (const char*)&asn_time->data,
1881            CTC_DATE_SIZE));
1882        date_str[CTC_DATE_SIZE] = '\0';
1883        ExpectIntEQ(0, XMEMCMP(date_str, "000222211500Z", 13));
1884        if (asn_time != s) {
1885            XFREE(asn_time, NULL, DYNAMIC_TYPE_OPENSSL);
1886        }
1887        asn_time = NULL;
1888    }
1889
1890    /* negative offset */
1891    offset_sec = -45 * mini;
1892    asn_time = wolfSSL_ASN1_TIME_adj(s, t, offset_day, offset_sec);
1893    ExpectNotNull(asn_time);
1894    if (asn_time != NULL) {
1895        ExpectTrue(asn_time->type == asn_utc_time);
1896        ExpectNotNull(XSTRNCPY(date_str, (const char*)&asn_time->data,
1897            CTC_DATE_SIZE));
1898        date_str[CTC_DATE_SIZE] = '\0';
1899        ExpectIntEQ(0, XMEMCMP(date_str, "000222194500Z", 13));
1900        if (asn_time != s) {
1901            XFREE(asn_time, NULL, DYNAMIC_TYPE_OPENSSL);
1902        }
1903        asn_time = NULL;
1904    }
1905
1906    XFREE(s, NULL, DYNAMIC_TYPE_OPENSSL);
1907    s = NULL;
1908    XMEMSET(date_str, 0, sizeof(date_str));
1909
1910    /* Generalized time will overflow time_t if not long */
1911#if !defined(TIME_T_NOT_64BIT) && !defined(NO_64BIT)
1912    s = (WOLFSSL_ASN1_TIME*)XMALLOC(sizeof(WOLFSSL_ASN1_TIME), NULL,
1913                                    DYNAMIC_TYPE_OPENSSL);
1914    /* GeneralizedTime notation test */
1915    /* 2055/03/01 09:00:00 */
1916    t = (time_t)85 * year + 59 * day + 9 * hour + 21 * day;
1917        offset_day = 12;
1918        offset_sec = 10 * mini;
1919    ExpectNotNull(asn_time = wolfSSL_ASN1_TIME_adj(s, t, offset_day,
1920        offset_sec));
1921    if (asn_time != NULL) {
1922        ExpectTrue(asn_time->type == asn_gen_time);
1923        ExpectNotNull(XSTRNCPY(date_str, (const char*)&asn_time->data,
1924            CTC_DATE_SIZE));
1925        date_str[CTC_DATE_SIZE] = '\0';
1926        ExpectIntEQ(0, XMEMCMP(date_str, "20550313091000Z", 15));
1927        if (asn_time != s) {
1928            XFREE(asn_time, NULL, DYNAMIC_TYPE_OPENSSL);
1929        }
1930        asn_time = NULL;
1931    }
1932
1933    XFREE(s, NULL, DYNAMIC_TYPE_OPENSSL);
1934    s = NULL;
1935    XMEMSET(date_str, 0, sizeof(date_str));
1936#endif /* !TIME_T_NOT_64BIT && !NO_64BIT */
1937
1938    /* if WOLFSSL_ASN1_TIME struct is not allocated */
1939    s = NULL;
1940
1941    t = (time_t)30 * year + 45 * day + 20 * hour + 30 * mini + 15 + 7 * day;
1942    offset_day = 7;
1943    offset_sec = 45 * mini;
1944    ExpectNotNull(asn_time = wolfSSL_ASN1_TIME_adj(s, t, offset_day,
1945        offset_sec));
1946    if (asn_time != NULL) {
1947        ExpectTrue(asn_time->type == asn_utc_time);
1948        ExpectNotNull(XSTRNCPY(date_str, (const char*)&asn_time->data,
1949            CTC_DATE_SIZE));
1950        date_str[CTC_DATE_SIZE] = '\0';
1951        ExpectIntEQ(0, XMEMCMP(date_str, "000222211515Z", 13));
1952        XFREE(asn_time, NULL, DYNAMIC_TYPE_OPENSSL);
1953        asn_time = NULL;
1954    }
1955    ExpectNotNull(asn_time = wolfSSL_ASN1_TIME_adj(NULL, t, offset_day,
1956        offset_sec));
1957    if (asn_time != NULL) {
1958        ExpectTrue(asn_time->type == asn_utc_time);
1959        ExpectNotNull(XSTRNCPY(date_str, (const char*)&asn_time->data,
1960            CTC_DATE_SIZE));
1961        date_str[CTC_DATE_SIZE] = '\0';
1962        ExpectIntEQ(0, XMEMCMP(date_str, "000222211515Z", 13));
1963        XFREE(asn_time, NULL, DYNAMIC_TYPE_OPENSSL);
1964        asn_time = NULL;
1965    }
1966#endif
1967    return EXPECT_RESULT();
1968}
1969
1970int test_wolfSSL_ASN1_TIME_to_tm(void)
1971{
1972    EXPECT_DECLS;
1973#if (defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(WOLFSSL_NGINX) || \
1974      defined(WOLFSSL_HAPROXY) || defined(OPENSSL_EXTRA) || \
1975      defined(OPENSSL_ALL)) && !defined(NO_ASN_TIME)
1976    ASN1_TIME asnTime;
1977    struct tm tm;
1978    time_t testTime = 1683926567; /* Fri May 12 09:22:47 PM UTC 2023 */
1979
1980    XMEMSET(&tm, 0, sizeof(struct tm));
1981
1982    XMEMSET(&asnTime, 0, sizeof(ASN1_TIME));
1983    ExpectIntEQ(ASN1_TIME_set_string(&asnTime, "000222211515Z"), 1);
1984    ExpectIntEQ(ASN1_TIME_to_tm(&asnTime, NULL), 1);
1985    ExpectIntEQ(ASN1_TIME_to_tm(&asnTime, &tm), 1);
1986
1987    ExpectIntEQ(tm.tm_sec, 15);
1988    ExpectIntEQ(tm.tm_min, 15);
1989    ExpectIntEQ(tm.tm_hour, 21);
1990    ExpectIntEQ(tm.tm_mday, 22);
1991    ExpectIntEQ(tm.tm_mon, 1);
1992    ExpectIntEQ(tm.tm_year, 100);
1993    ExpectIntEQ(tm.tm_isdst, 0);
1994#ifdef XMKTIME
1995    ExpectIntEQ(tm.tm_wday, 2);
1996    ExpectIntEQ(tm.tm_yday, 52);
1997#endif
1998
1999    ExpectIntEQ(ASN1_TIME_set_string(&asnTime, "500222211515Z"), 1);
2000    ExpectIntEQ(ASN1_TIME_to_tm(&asnTime, &tm), 1);
2001    ExpectIntEQ(tm.tm_year, 50);
2002
2003    /* Get current time. */
2004    ExpectIntEQ(ASN1_TIME_to_tm(NULL, NULL), 0);
2005    ExpectIntEQ(ASN1_TIME_to_tm(NULL, &tm), 1);
2006
2007    XMEMSET(&asnTime, 0, sizeof(ASN1_TIME));
2008    /* 0 length. */
2009    ExpectIntEQ(ASN1_TIME_to_tm(&asnTime, &tm), 0);
2010    /* No type. */
2011    asnTime.length = 1;
2012    ExpectIntEQ(ASN1_TIME_to_tm(&asnTime, &tm), 0);
2013    /* Not UTCTIME length. */
2014    asnTime.type = V_ASN1_UTCTIME;
2015    ExpectIntEQ(ASN1_TIME_to_tm(&asnTime, &tm), 0);
2016    /* Not GENERALIZEDTIME length. */
2017    asnTime.type = V_ASN1_GENERALIZEDTIME;
2018    ExpectIntEQ(ASN1_TIME_to_tm(&asnTime, &tm), 0);
2019
2020    /* Not Zulu timezone. */
2021    ExpectIntEQ(ASN1_TIME_set_string(&asnTime, "000222211515U"), 1);
2022    ExpectIntEQ(ASN1_TIME_to_tm(&asnTime, &tm), 0);
2023    ExpectIntEQ(ASN1_TIME_set_string(&asnTime, "20000222211515U"), 1);
2024    ExpectIntEQ(ASN1_TIME_to_tm(&asnTime, &tm), 0);
2025
2026#ifdef XMKTIME
2027    ExpectNotNull(ASN1_TIME_adj(&asnTime, testTime, 0, 0));
2028    ExpectIntEQ(ASN1_TIME_to_tm(&asnTime, &tm), 1);
2029    ExpectIntEQ(tm.tm_sec, 47);
2030    ExpectIntEQ(tm.tm_min, 22);
2031    ExpectIntEQ(tm.tm_hour, 21);
2032    ExpectIntEQ(tm.tm_mday, 12);
2033    ExpectIntEQ(tm.tm_mon, 4);
2034    ExpectIntEQ(tm.tm_year, 123);
2035    ExpectIntEQ(tm.tm_wday, 5);
2036    ExpectIntEQ(tm.tm_yday, 131);
2037    /* Confirm that when used with a tm struct from ASN1_TIME_adj, all other
2038       fields are zeroed out as expected. */
2039    ExpectIntEQ(tm.tm_isdst, 0);
2040#endif
2041#endif
2042    return EXPECT_RESULT();
2043}
2044
2045int test_wolfSSL_ASN1_TIME_to_generalizedtime(void)
2046{
2047    EXPECT_DECLS;
2048#if defined(OPENSSL_EXTRA) && !defined(NO_ASN_TIME)
2049    WOLFSSL_ASN1_TIME *t = NULL;
2050    WOLFSSL_ASN1_TIME *out = NULL;
2051    WOLFSSL_ASN1_TIME *gtime = NULL;
2052    int tlen = 0;
2053    unsigned char *data = NULL;
2054
2055    ExpectNotNull(t = wolfSSL_ASN1_TIME_new());
2056    ExpectNull(wolfSSL_ASN1_TIME_to_generalizedtime(NULL, &out));
2057    /* type not set. */
2058    ExpectNull(wolfSSL_ASN1_TIME_to_generalizedtime(t, &out));
2059    XFREE(t, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2060    t = NULL;
2061
2062    /* UTC Time test */
2063    ExpectNotNull(t = wolfSSL_ASN1_TIME_new());
2064    if (t != NULL) {
2065        XMEMSET(t->data, 0, ASN_GENERALIZED_TIME_SIZE);
2066        t->type = ASN_UTC_TIME;
2067        t->length = ASN_UTC_TIME_SIZE;
2068        XMEMCPY(t->data, "050727123456Z", ASN_UTC_TIME_SIZE);
2069    }
2070
2071    ExpectIntEQ(tlen = wolfSSL_ASN1_TIME_get_length(t), ASN_UTC_TIME_SIZE);
2072    ExpectStrEQ((char*)(data = wolfSSL_ASN1_TIME_get_data(t)), "050727123456Z");
2073
2074    out = NULL;
2075    ExpectNotNull(gtime = wolfSSL_ASN1_TIME_to_generalizedtime(t, &out));
2076    wolfSSL_ASN1_TIME_free(gtime);
2077    gtime = NULL;
2078    ExpectNotNull(out = wolfSSL_ASN1_TIME_new());
2079    ExpectNotNull(gtime = wolfSSL_ASN1_TIME_to_generalizedtime(t, &out));
2080    ExpectPtrEq(gtime, out);
2081    ExpectIntEQ(gtime->type, ASN_GENERALIZED_TIME);
2082    ExpectIntEQ(gtime->length, ASN_GENERALIZED_TIME_SIZE);
2083    ExpectStrEQ((char*)gtime->data, "20050727123456Z");
2084
2085    /* Generalized Time test */
2086    ExpectNotNull(XMEMSET(t, 0, ASN_GENERALIZED_TIME_SIZE));
2087    ExpectNotNull(XMEMSET(out, 0, ASN_GENERALIZED_TIME_SIZE));
2088    ExpectNotNull(XMEMSET(data, 0, ASN_GENERALIZED_TIME_SIZE));
2089    if (t != NULL) {
2090        t->type = ASN_GENERALIZED_TIME;
2091        t->length = ASN_GENERALIZED_TIME_SIZE;
2092        XMEMCPY(t->data, "20050727123456Z", ASN_GENERALIZED_TIME_SIZE);
2093    }
2094
2095    ExpectIntEQ(tlen = wolfSSL_ASN1_TIME_get_length(t),
2096        ASN_GENERALIZED_TIME_SIZE);
2097    ExpectStrEQ((char*)(data = wolfSSL_ASN1_TIME_get_data(t)),
2098        "20050727123456Z");
2099    ExpectNotNull(gtime = wolfSSL_ASN1_TIME_to_generalizedtime(t, &out));
2100    ExpectIntEQ(gtime->type, ASN_GENERALIZED_TIME);
2101    ExpectIntEQ(gtime->length, ASN_GENERALIZED_TIME_SIZE);
2102    ExpectStrEQ((char*)gtime->data, "20050727123456Z");
2103
2104    /* UTC Time to Generalized Time 1900's test */
2105    ExpectNotNull(XMEMSET(t, 0, ASN_GENERALIZED_TIME_SIZE));
2106    ExpectNotNull(XMEMSET(out, 0, ASN_GENERALIZED_TIME_SIZE));
2107    ExpectNotNull(XMEMSET(data, 0, ASN_GENERALIZED_TIME_SIZE));
2108    if (t != NULL) {
2109        t->type = ASN_UTC_TIME;
2110        t->length = ASN_UTC_TIME_SIZE;
2111        XMEMCPY(t->data, "500727123456Z", ASN_UTC_TIME_SIZE);
2112    }
2113
2114    ExpectNotNull(gtime = wolfSSL_ASN1_TIME_to_generalizedtime(t, &out));
2115    ExpectIntEQ(gtime->type, ASN_GENERALIZED_TIME);
2116    ExpectIntEQ(gtime->length, ASN_GENERALIZED_TIME_SIZE);
2117    ExpectStrEQ((char*)gtime->data, "19500727123456Z");
2118    XFREE(out, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2119
2120    /* Null parameter test */
2121    ExpectNotNull(XMEMSET(t, 0, ASN_GENERALIZED_TIME_SIZE));
2122    gtime = NULL;
2123    out = NULL;
2124    if (t != NULL) {
2125        t->type = ASN_UTC_TIME;
2126        t->length = ASN_UTC_TIME_SIZE;
2127        XMEMCPY(t->data, "050727123456Z", ASN_UTC_TIME_SIZE);
2128    }
2129    ExpectNotNull(gtime = wolfSSL_ASN1_TIME_to_generalizedtime(t, NULL));
2130    ExpectIntEQ(gtime->type, ASN_GENERALIZED_TIME);
2131    ExpectIntEQ(gtime->length, ASN_GENERALIZED_TIME_SIZE);
2132    ExpectStrEQ((char*)gtime->data, "20050727123456Z");
2133
2134    XFREE(gtime, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2135    XFREE(t, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2136#endif
2137    return EXPECT_RESULT();
2138}
2139
2140int test_wolfSSL_ASN1_TIME_print(void)
2141{
2142    EXPECT_DECLS;
2143#if !defined(NO_CERTS) && !defined(NO_RSA) && !defined(NO_BIO) && \
2144    (defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(WOLFSSL_NGINX) || \
2145     defined(WOLFSSL_HAPROXY) || defined(OPENSSL_EXTRA) || \
2146     defined(OPENSSL_ALL)) && defined(USE_CERT_BUFFERS_2048) && \
2147    !defined(NO_ASN_TIME)
2148    BIO*  bio = NULL;
2149    BIO*  fixed = NULL;
2150    X509*  x509 = NULL;
2151    const unsigned char* der = client_cert_der_2048;
2152    ASN1_TIME* notAfter = NULL;
2153    ASN1_TIME* notBefore = NULL;
2154    unsigned char buf[25];
2155
2156    ExpectNotNull(bio = BIO_new(BIO_s_mem()));
2157    ExpectNotNull(fixed = BIO_new(wolfSSL_BIO_s_fixed_mem()));
2158    ExpectNotNull(x509 = wolfSSL_X509_load_certificate_buffer(der,
2159                sizeof_client_cert_der_2048, WOLFSSL_FILETYPE_ASN1));
2160    ExpectNotNull(notBefore = X509_get_notBefore(x509));
2161
2162    ExpectIntEQ(ASN1_TIME_print(NULL, NULL), 0);
2163    ExpectIntEQ(ASN1_TIME_print(bio, NULL), 0);
2164    ExpectIntEQ(ASN1_TIME_print(NULL, notBefore), 0);
2165
2166    ExpectIntEQ(ASN1_TIME_print(bio, notBefore), 1);
2167    ExpectIntEQ(BIO_read(bio, buf, sizeof(buf)), 24);
2168    ExpectIntEQ(XMEMCMP(buf, "Nov 13 20:41:10 2025 GMT", sizeof(buf) - 1), 0);
2169
2170    /* Test BIO_write fails. */
2171    ExpectIntEQ(BIO_set_write_buf_size(fixed, 1), 1);
2172    /* Ensure there is 0 bytes available to write into. */
2173    ExpectIntEQ(BIO_write(fixed, buf, 1), 1);
2174    ExpectIntEQ(ASN1_TIME_print(fixed, notBefore), 0);
2175    ExpectIntEQ(BIO_set_write_buf_size(fixed, 1), 1);
2176    ExpectIntEQ(ASN1_TIME_print(fixed, notBefore), 0);
2177    ExpectIntEQ(BIO_set_write_buf_size(fixed, 23), 1);
2178    ExpectIntEQ(ASN1_TIME_print(fixed, notBefore), 0);
2179
2180    /* create a bad time and test results */
2181    ExpectNotNull(notAfter = X509_get_notAfter(x509));
2182    ExpectIntEQ(ASN1_TIME_check(notAfter), 1);
2183    if (EXPECT_SUCCESS()) {
2184        notAfter->data[8] = 0;
2185        notAfter->data[3] = 0;
2186    }
2187    ExpectIntNE(ASN1_TIME_print(bio, notAfter), 1);
2188    ExpectIntEQ(BIO_read(bio, buf, sizeof(buf)), 14);
2189    ExpectIntEQ(XMEMCMP(buf, "Bad time value", 14), 0);
2190    ExpectIntEQ(ASN1_TIME_check(notAfter), 0);
2191
2192    BIO_free(bio);
2193    BIO_free(fixed);
2194    X509_free(x509);
2195#endif
2196    return EXPECT_RESULT();
2197}
2198
2199int test_wolfSSL_ASN1_UTCTIME_print(void)
2200{
2201    EXPECT_DECLS;
2202#if defined(OPENSSL_EXTRA) && !defined(NO_ASN_TIME) && !defined(NO_BIO)
2203    BIO*  bio = NULL;
2204    ASN1_UTCTIME* utc = NULL;
2205    unsigned char buf[25];
2206    const char* validDate   = "190424111501Z";   /* UTC =   YYMMDDHHMMSSZ */
2207    const char* invalidDate = "190424111501X";   /* UTC =   YYMMDDHHMMSSZ */
2208    const char* genDate     = "20190424111501Z"; /* GEN = YYYYMMDDHHMMSSZ */
2209
2210    /* Valid date */
2211    ExpectNotNull(bio = BIO_new(BIO_s_mem()));
2212    ExpectNotNull(utc = (ASN1_UTCTIME*)XMALLOC(sizeof(ASN1_UTCTIME), NULL,
2213                                                           DYNAMIC_TYPE_ASN1));
2214    if (utc != NULL) {
2215        utc->type = ASN_UTC_TIME;
2216        utc->length = ASN_UTC_TIME_SIZE;
2217        XMEMCPY(utc->data, (byte*)validDate, ASN_UTC_TIME_SIZE);
2218    }
2219
2220    ExpectIntEQ(ASN1_UTCTIME_print(NULL, NULL), 0);
2221    ExpectIntEQ(ASN1_UTCTIME_print(bio, NULL), 0);
2222    ExpectIntEQ(ASN1_UTCTIME_print(NULL, utc), 0);
2223
2224    ExpectIntEQ(ASN1_UTCTIME_print(bio, utc), 1);
2225    ExpectIntEQ(BIO_read(bio, buf, sizeof(buf)), 24);
2226    ExpectIntEQ(XMEMCMP(buf, "Apr 24 11:15:01 2019 GMT", sizeof(buf)-1), 0);
2227
2228    XMEMSET(buf, 0, sizeof(buf));
2229    BIO_free(bio);
2230    bio = NULL;
2231
2232    /* Invalid format */
2233    ExpectNotNull(bio = BIO_new(BIO_s_mem()));
2234    if (utc != NULL) {
2235        utc->type = ASN_UTC_TIME;
2236        utc->length = ASN_UTC_TIME_SIZE;
2237        XMEMCPY(utc->data, (byte*)invalidDate, ASN_UTC_TIME_SIZE);
2238    }
2239    ExpectIntEQ(ASN1_UTCTIME_print(bio, utc), 0);
2240    ExpectIntEQ(BIO_read(bio, buf, sizeof(buf)), 14);
2241    ExpectIntEQ(XMEMCMP(buf, "Bad time value", 14), 0);
2242
2243    /* Invalid type */
2244    if (utc != NULL) {
2245        utc->type = ASN_GENERALIZED_TIME;
2246        utc->length = ASN_GENERALIZED_TIME_SIZE;
2247        XMEMCPY(utc->data, (byte*)genDate, ASN_GENERALIZED_TIME_SIZE);
2248    }
2249    ExpectIntEQ(ASN1_UTCTIME_print(bio, utc), 0);
2250
2251    XFREE(utc, NULL, DYNAMIC_TYPE_ASN1);
2252    BIO_free(bio);
2253#endif /* OPENSSL_EXTRA && !NO_ASN_TIME && !NO_BIO */
2254    return EXPECT_RESULT();
2255}
2256
2257int test_wolfSSL_ASN1_TYPE(void)
2258{
2259    EXPECT_DECLS;
2260#if defined(OPENSSL_ALL) || defined(WOLFSSL_APACHE_HTTPD) || \
2261    defined(WOLFSSL_HAPROXY) || defined(WOLFSSL_WPAS)
2262    WOLFSSL_ASN1_TYPE* t = NULL;
2263    WOLFSSL_ASN1_OBJECT* obj = NULL;
2264#ifndef NO_ASN_TIME
2265    WOLFSSL_ASN1_TIME* time = NULL;
2266#endif
2267    WOLFSSL_ASN1_STRING* str = NULL;
2268    unsigned char data[] = { 0x00 };
2269
2270    ASN1_TYPE_set(NULL, V_ASN1_NULL, NULL);
2271
2272    ExpectNotNull(t = wolfSSL_ASN1_TYPE_new());
2273    ASN1_TYPE_set(t, V_ASN1_EOC, NULL);
2274    wolfSSL_ASN1_TYPE_free(t);
2275    t = NULL;
2276
2277    ExpectNotNull(t = wolfSSL_ASN1_TYPE_new());
2278    ASN1_TYPE_set(t, V_ASN1_NULL, NULL);
2279    ASN1_TYPE_set(t, V_ASN1_NULL, data);
2280    wolfSSL_ASN1_TYPE_free(t);
2281    t = NULL;
2282
2283    ExpectNotNull(t = wolfSSL_ASN1_TYPE_new());
2284    ExpectNotNull(obj = wolfSSL_ASN1_OBJECT_new());
2285    ASN1_TYPE_set(t, V_ASN1_OBJECT, obj);
2286    wolfSSL_ASN1_TYPE_free(t);
2287    t = NULL;
2288
2289#ifndef NO_ASN_TIME
2290    ExpectNotNull(t = wolfSSL_ASN1_TYPE_new());
2291    ExpectNotNull(time = wolfSSL_ASN1_TIME_new());
2292    ASN1_TYPE_set(t, V_ASN1_UTCTIME, time);
2293    wolfSSL_ASN1_TYPE_free(t);
2294    t = NULL;
2295
2296    ExpectNotNull(t = wolfSSL_ASN1_TYPE_new());
2297    ExpectNotNull(time = wolfSSL_ASN1_TIME_new());
2298    ASN1_TYPE_set(t, V_ASN1_GENERALIZEDTIME, time);
2299    wolfSSL_ASN1_TYPE_free(t);
2300    t = NULL;
2301#endif
2302
2303    ExpectNotNull(t = wolfSSL_ASN1_TYPE_new());
2304    ExpectNotNull(str = wolfSSL_ASN1_STRING_new());
2305    ASN1_TYPE_set(t, V_ASN1_UTF8STRING, str);
2306    wolfSSL_ASN1_TYPE_free(t);
2307    t = NULL;
2308
2309    ExpectNotNull(t = wolfSSL_ASN1_TYPE_new());
2310    ExpectNotNull(str = wolfSSL_ASN1_STRING_new());
2311    ASN1_TYPE_set(t, V_ASN1_PRINTABLESTRING, str);
2312    wolfSSL_ASN1_TYPE_free(t);
2313    t = NULL;
2314
2315    ExpectNotNull(t = wolfSSL_ASN1_TYPE_new());
2316    ExpectNotNull(str = wolfSSL_ASN1_STRING_new());
2317    ASN1_TYPE_set(t, V_ASN1_T61STRING, str);
2318    wolfSSL_ASN1_TYPE_free(t);
2319    t = NULL;
2320
2321    ExpectNotNull(t = wolfSSL_ASN1_TYPE_new());
2322    ExpectNotNull(str = wolfSSL_ASN1_STRING_new());
2323    ASN1_TYPE_set(t, V_ASN1_IA5STRING, str);
2324    wolfSSL_ASN1_TYPE_free(t);
2325    t = NULL;
2326
2327    ExpectNotNull(t = wolfSSL_ASN1_TYPE_new());
2328    ExpectNotNull(str = wolfSSL_ASN1_STRING_new());
2329    ASN1_TYPE_set(t, V_ASN1_UNIVERSALSTRING, str);
2330    wolfSSL_ASN1_TYPE_free(t);
2331    t = NULL;
2332
2333    ExpectNotNull(t = wolfSSL_ASN1_TYPE_new());
2334    ExpectNotNull(str = wolfSSL_ASN1_STRING_new());
2335    ASN1_TYPE_set(t, V_ASN1_SEQUENCE, str);
2336    wolfSSL_ASN1_TYPE_free(t);
2337    t = NULL;
2338#endif
2339    return EXPECT_RESULT();
2340}
2341
2342/* Testing code used in old dpp.c in hostap */
2343#if defined(OPENSSL_ALL) && defined(HAVE_ECC) && defined(USE_CERT_BUFFERS_256)
2344typedef struct {
2345    /* AlgorithmIdentifier ecPublicKey with optional parameters present
2346     * as an OID identifying the curve */
2347    X509_ALGOR *alg;
2348    /* Compressed format public key per ANSI X9.63 */
2349    ASN1_BIT_STRING *pub_key;
2350} DPP_BOOTSTRAPPING_KEY;
2351
2352ASN1_SEQUENCE(DPP_BOOTSTRAPPING_KEY) = {
2353    ASN1_SIMPLE(DPP_BOOTSTRAPPING_KEY, alg, X509_ALGOR),
2354    ASN1_SIMPLE(DPP_BOOTSTRAPPING_KEY, pub_key, ASN1_BIT_STRING)
2355} ASN1_SEQUENCE_END(DPP_BOOTSTRAPPING_KEY)
2356
2357IMPLEMENT_ASN1_FUNCTIONS(DPP_BOOTSTRAPPING_KEY)
2358
2359typedef struct {
2360    int type;
2361    union {
2362        ASN1_BIT_STRING *str1;
2363        ASN1_BIT_STRING *str2;
2364        ASN1_BIT_STRING *str3;
2365    } d;
2366} ASN1_CHOICE_TEST;
2367
2368ASN1_CHOICE(ASN1_CHOICE_TEST) = {
2369    ASN1_IMP(ASN1_CHOICE_TEST, d.str1, ASN1_BIT_STRING, 1),
2370    ASN1_IMP(ASN1_CHOICE_TEST, d.str2, ASN1_BIT_STRING, 2),
2371    ASN1_IMP(ASN1_CHOICE_TEST, d.str3, ASN1_BIT_STRING, 3)
2372} ASN1_CHOICE_END(ASN1_CHOICE_TEST)
2373
2374IMPLEMENT_ASN1_FUNCTIONS(ASN1_CHOICE_TEST)
2375
2376/* Test nested objects */
2377typedef struct {
2378    DPP_BOOTSTRAPPING_KEY* key;
2379    ASN1_INTEGER* asnNum;
2380    ASN1_INTEGER* expNum;
2381    STACK_OF(ASN1_GENERALSTRING) *strList;
2382    ASN1_CHOICE_TEST* str;
2383} TEST_ASN1_NEST1;
2384
2385ASN1_SEQUENCE(TEST_ASN1_NEST1) = {
2386    ASN1_SIMPLE(TEST_ASN1_NEST1, key, DPP_BOOTSTRAPPING_KEY),
2387    ASN1_SIMPLE(TEST_ASN1_NEST1, asnNum, ASN1_INTEGER),
2388    ASN1_EXP(TEST_ASN1_NEST1, expNum, ASN1_INTEGER, 0),
2389    ASN1_EXP_SEQUENCE_OF(TEST_ASN1_NEST1, strList, ASN1_GENERALSTRING, 1),
2390    ASN1_SIMPLE(TEST_ASN1_NEST1, str, ASN1_CHOICE_TEST)
2391} ASN1_SEQUENCE_END(TEST_ASN1_NEST1)
2392
2393IMPLEMENT_ASN1_FUNCTIONS(TEST_ASN1_NEST1)
2394
2395typedef struct {
2396    ASN1_INTEGER* num;
2397    DPP_BOOTSTRAPPING_KEY* key;
2398    TEST_ASN1_NEST1* asn1_obj;
2399} TEST_ASN1_NEST2;
2400
2401ASN1_SEQUENCE(TEST_ASN1_NEST2) = {
2402    ASN1_SIMPLE(TEST_ASN1_NEST2, num, ASN1_INTEGER),
2403    ASN1_SIMPLE(TEST_ASN1_NEST2, key, DPP_BOOTSTRAPPING_KEY),
2404    ASN1_SIMPLE(TEST_ASN1_NEST2, asn1_obj, TEST_ASN1_NEST1)
2405} ASN1_SEQUENCE_END(TEST_ASN1_NEST2)
2406
2407IMPLEMENT_ASN1_FUNCTIONS(TEST_ASN1_NEST2)
2408/* End nested objects */
2409
2410typedef struct {
2411    ASN1_INTEGER *integer;
2412} TEST_ASN1;
2413
2414ASN1_SEQUENCE(TEST_ASN1) = {
2415    ASN1_SIMPLE(TEST_ASN1, integer, ASN1_INTEGER),
2416} ASN1_SEQUENCE_END(TEST_ASN1)
2417
2418IMPLEMENT_ASN1_FUNCTIONS(TEST_ASN1)
2419
2420typedef STACK_OF(ASN1_INTEGER) TEST_ASN1_ITEM;
2421
2422ASN1_ITEM_TEMPLATE(TEST_ASN1_ITEM) =
2423        ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, MemName, ASN1_INTEGER)
2424ASN1_ITEM_TEMPLATE_END(TEST_ASN1_ITEM)
2425
2426IMPLEMENT_ASN1_FUNCTIONS(TEST_ASN1_ITEM)
2427#endif
2428
2429int test_wolfSSL_IMPLEMENT_ASN1_FUNCTIONS(void)
2430{
2431    EXPECT_DECLS;
2432    /* Testing code used in dpp.c in hostap */
2433#if defined(OPENSSL_ALL) && defined(HAVE_ECC) && defined(USE_CERT_BUFFERS_256)
2434#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
2435    EC_KEY *eckey = NULL;
2436    EVP_PKEY *key = NULL;
2437    size_t len = 0;
2438    unsigned char *der = NULL;
2439    unsigned char *der2 = NULL;
2440    const unsigned char *tmp = NULL;
2441    DPP_BOOTSTRAPPING_KEY *bootstrap = NULL, *bootstrap2 = NULL;
2442    const unsigned char *in = ecc_clikey_der_256;
2443    WOLFSSL_ASN1_OBJECT* ec_obj = NULL;
2444    WOLFSSL_ASN1_OBJECT* group_obj = NULL;
2445    const EC_GROUP *group = NULL;
2446    const EC_POINT *point = NULL;
2447    int nid;
2448    TEST_ASN1 *test_asn1 = NULL;
2449    TEST_ASN1 *test_asn1_2 = NULL;
2450
2451    const unsigned char badObjDer[] = { 0x06, 0x00 };
2452    const unsigned char goodObjDer[] = {
2453        0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01
2454    };
2455    WOLFSSL_ASN1_ITEM emptyTemplate;
2456
2457    XMEMSET(&emptyTemplate, 0, sizeof(WOLFSSL_ASN1_ITEM));
2458
2459    ExpectNotNull(bootstrap = DPP_BOOTSTRAPPING_KEY_new());
2460
2461    der = NULL;
2462    ExpectIntEQ(i2d_DPP_BOOTSTRAPPING_KEY(NULL, &der), -1);
2463    ExpectIntEQ(wolfSSL_ASN1_item_i2d(bootstrap, &der, NULL), -1);
2464    ExpectIntEQ(i2d_DPP_BOOTSTRAPPING_KEY(bootstrap, &der), -1);
2465
2466    ExpectNotNull(key = d2i_PrivateKey(EVP_PKEY_EC, NULL, &in,
2467                                       (long)sizeof_ecc_clikey_der_256));
2468    ExpectNotNull(eckey = EVP_PKEY_get1_EC_KEY(key));
2469    ExpectNotNull(group = EC_KEY_get0_group(eckey));
2470    ExpectNotNull(point = EC_KEY_get0_public_key(eckey));
2471    nid = EC_GROUP_get_curve_name(group);
2472
2473    ec_obj = OBJ_nid2obj(EVP_PKEY_EC);
2474    group_obj = OBJ_nid2obj(nid);
2475    if ((ec_obj != NULL) && (group_obj != NULL)) {
2476        ExpectIntEQ(X509_ALGOR_set0(NULL, ec_obj, V_ASN1_OBJECT,
2477            group_obj), 0);
2478        ExpectIntEQ(X509_ALGOR_set0(bootstrap->alg, NULL, V_ASN1_OBJECT,
2479            NULL), 1);
2480        ExpectIntEQ(X509_ALGOR_set0(bootstrap->alg, ec_obj, V_ASN1_OBJECT,
2481            group_obj), 1);
2482        if (EXPECT_SUCCESS()) {
2483            ec_obj = NULL;
2484            group_obj = NULL;
2485        }
2486    }
2487    wolfSSL_ASN1_OBJECT_free(group_obj);
2488    wolfSSL_ASN1_OBJECT_free(ec_obj);
2489    ExpectIntEQ(EC_POINT_point2oct(group, point, 0, NULL, 0, NULL), 0);
2490#ifdef HAVE_COMP_KEY
2491    ExpectIntGT((len = EC_POINT_point2oct(
2492                                   group, point, POINT_CONVERSION_COMPRESSED,
2493                                   NULL, 0, NULL)), 0);
2494#else
2495    ExpectIntGT((len = EC_POINT_point2oct(
2496                                   group, point, POINT_CONVERSION_UNCOMPRESSED,
2497                                   NULL, 0, NULL)), 0);
2498#endif
2499    ExpectNotNull(der = (unsigned char*)XMALLOC(len, NULL, DYNAMIC_TYPE_ASN1));
2500#ifdef HAVE_COMP_KEY
2501    ExpectIntEQ(EC_POINT_point2oct(group, point, POINT_CONVERSION_COMPRESSED,
2502                                   der, len-1, NULL), 0);
2503    ExpectIntEQ(EC_POINT_point2oct(group, point, POINT_CONVERSION_COMPRESSED,
2504                                   der, len, NULL), len);
2505#else
2506    ExpectIntEQ(EC_POINT_point2oct(group, point, POINT_CONVERSION_UNCOMPRESSED,
2507                                   der, len-1, NULL), 0);
2508    ExpectIntEQ(EC_POINT_point2oct(group, point, POINT_CONVERSION_UNCOMPRESSED,
2509                                   der, len, NULL), len);
2510#endif
2511    if (EXPECT_SUCCESS()) {
2512        bootstrap->pub_key->data = der;
2513        bootstrap->pub_key->length = (int)len;
2514        /* Not actually used */
2515        bootstrap->pub_key->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);
2516        bootstrap->pub_key->flags |= ASN1_STRING_FLAG_BITS_LEFT;
2517    }
2518
2519    ExpectIntEQ(i2d_DPP_BOOTSTRAPPING_KEY(bootstrap, NULL), 16+len);
2520    der = NULL;
2521    ExpectIntEQ(i2d_DPP_BOOTSTRAPPING_KEY(bootstrap, &der), 16+len);
2522    der2 = NULL;
2523#ifdef WOLFSSL_ASN_TEMPLATE
2524    tmp = der;
2525    ExpectNotNull(d2i_DPP_BOOTSTRAPPING_KEY(&bootstrap2, &tmp, 16+len));
2526    ExpectIntEQ(i2d_DPP_BOOTSTRAPPING_KEY(bootstrap2, &der2), 16+len);
2527    ExpectBufEQ(der, der2, 49);
2528#endif
2529
2530    XFREE(der, NULL, DYNAMIC_TYPE_ASN1);
2531    XFREE(der2, NULL, DYNAMIC_TYPE_ASN1);
2532    EVP_PKEY_free(key);
2533    EC_KEY_free(eckey);
2534    DPP_BOOTSTRAPPING_KEY_free(bootstrap);
2535    DPP_BOOTSTRAPPING_KEY_free(bootstrap2);
2536    bootstrap = NULL;
2537    DPP_BOOTSTRAPPING_KEY_free(NULL);
2538
2539    /* Create bootstrap key with bad OBJECT_ID DER data, parameter that is
2540     * a NULL and an empty BIT_STRING. */
2541    ExpectNotNull(bootstrap = DPP_BOOTSTRAPPING_KEY_new());
2542    ExpectNotNull(bootstrap->alg->algorithm = wolfSSL_ASN1_OBJECT_new());
2543    if (EXPECT_SUCCESS()) {
2544        bootstrap->alg->algorithm->obj = badObjDer;
2545        bootstrap->alg->algorithm->objSz = (unsigned int)sizeof(badObjDer);
2546    }
2547    ExpectNotNull(bootstrap->alg->parameter = wolfSSL_ASN1_TYPE_new());
2548    if (EXPECT_SUCCESS()) {
2549        bootstrap->alg->parameter->type = V_ASN1_NULL;
2550        bootstrap->alg->parameter->value.ptr = NULL;
2551        bootstrap->pub_key->data = NULL;
2552        bootstrap->pub_key->length = 0;
2553        /* Not actually used */
2554        bootstrap->pub_key->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);
2555        bootstrap->pub_key->flags |= ASN1_STRING_FLAG_BITS_LEFT;
2556    }
2557    /* Encode with bad OBJECT_ID. */
2558    der = NULL;
2559    ExpectIntEQ(i2d_DPP_BOOTSTRAPPING_KEY(bootstrap, &der), -1);
2560
2561    /* Fix OBJECT_ID and encode with empty BIT_STRING. */
2562    if (EXPECT_SUCCESS()) {
2563        bootstrap->alg->algorithm->obj = goodObjDer;
2564        bootstrap->alg->algorithm->objSz = (unsigned int)sizeof(goodObjDer);
2565        bootstrap->alg->algorithm->grp = 2;
2566    }
2567    der = NULL;
2568    ExpectIntEQ(i2d_DPP_BOOTSTRAPPING_KEY(bootstrap, &der), 16);
2569    ExpectIntEQ(wolfSSL_ASN1_item_i2d(bootstrap, &der, &emptyTemplate), -1);
2570    XFREE(der, NULL, DYNAMIC_TYPE_ASN1);
2571    DPP_BOOTSTRAPPING_KEY_free(bootstrap);
2572
2573    /* Test integer */
2574    ExpectNotNull(test_asn1 = TEST_ASN1_new());
2575    der = NULL;
2576    ExpectIntEQ(ASN1_INTEGER_set(test_asn1->integer, 100), 1);
2577    ExpectIntEQ(i2d_TEST_ASN1(test_asn1, &der), 5);
2578    tmp = der;
2579    ExpectNotNull(d2i_TEST_ASN1(&test_asn1_2, &tmp, 5));
2580    der2 = NULL;
2581    ExpectIntEQ(i2d_TEST_ASN1(test_asn1_2, &der2), 5);
2582    ExpectBufEQ(der, der2, 5);
2583    XFREE(der, NULL, DYNAMIC_TYPE_ASN1);
2584    XFREE(der2, NULL, DYNAMIC_TYPE_ASN1);
2585    TEST_ASN1_free(test_asn1);
2586    TEST_ASN1_free(test_asn1_2);
2587
2588    /* Test integer cases. */
2589    ExpectNull(wolfSSL_ASN1_item_new(NULL));
2590    TEST_ASN1_free(NULL);
2591
2592    /* Test nested asn1 objects */
2593    {
2594        TEST_ASN1_NEST2 *nested_asn1 = NULL;
2595        TEST_ASN1_NEST2 *nested_asn1_2 = NULL;
2596        int i;
2597
2598        ExpectNotNull(nested_asn1 = TEST_ASN1_NEST2_new());
2599        /* Populate nested_asn1 with some random data */
2600        /* nested_asn1->num */
2601        ExpectIntEQ(ASN1_INTEGER_set(nested_asn1->num, 30003), 1);
2602        /* nested_asn1->key */
2603        ec_obj = OBJ_nid2obj(EVP_PKEY_EC);
2604        group_obj = OBJ_nid2obj(NID_secp256k1);
2605        ExpectIntEQ(X509_ALGOR_set0(nested_asn1->key->alg, ec_obj,
2606                V_ASN1_OBJECT, group_obj), 1);
2607        if (EXPECT_SUCCESS()) {
2608            ec_obj = NULL;
2609            group_obj = NULL;
2610        }
2611        else {
2612            wolfSSL_ASN1_OBJECT_free(ec_obj);
2613            wolfSSL_ASN1_OBJECT_free(group_obj);
2614        }
2615        ExpectIntEQ(ASN1_BIT_STRING_set_bit(nested_asn1->key->pub_key, 50, 1),
2616                1);
2617        /* nested_asn1->asn1_obj->key */
2618        ec_obj = OBJ_nid2obj(EVP_PKEY_EC);
2619        group_obj = OBJ_nid2obj(NID_secp256k1);
2620        ExpectIntEQ(X509_ALGOR_set0(nested_asn1->asn1_obj->key->alg, ec_obj,
2621                V_ASN1_OBJECT, group_obj), 1);
2622        if (EXPECT_SUCCESS()) {
2623            ec_obj = NULL;
2624            group_obj = NULL;
2625        }
2626        else {
2627            wolfSSL_ASN1_OBJECT_free(ec_obj);
2628            wolfSSL_ASN1_OBJECT_free(group_obj);
2629        }
2630        ExpectIntEQ(ASN1_BIT_STRING_set_bit(nested_asn1->asn1_obj->key->pub_key,
2631                500, 1), 1);
2632        /* nested_asn1->asn1_obj->asnNum */
2633        ExpectIntEQ(ASN1_INTEGER_set(nested_asn1->asn1_obj->asnNum, 666666), 1);
2634        /* nested_asn1->asn1_obj->expNum */
2635        ExpectIntEQ(ASN1_INTEGER_set(nested_asn1->asn1_obj->expNum, 22222), 1);
2636        /* nested_asn1->asn1_obj->strList */
2637        for (i = 10; i >= 0; i--) {
2638            ASN1_GENERALSTRING* genStr = NULL;
2639            char fmtStr[20];
2640
2641            ExpectIntGT(snprintf(fmtStr, sizeof(fmtStr), "Bonjour #%d", i), 0);
2642            ExpectNotNull(genStr = ASN1_GENERALSTRING_new());
2643            ExpectIntEQ(ASN1_GENERALSTRING_set(genStr, fmtStr, -1), 1);
2644            ExpectIntGT(
2645                    sk_ASN1_GENERALSTRING_push(nested_asn1->asn1_obj->strList,
2646                            genStr), 0);
2647            if (EXPECT_FAIL()) {
2648                ASN1_GENERALSTRING_free(genStr);
2649            }
2650        }
2651        /* nested_asn1->asn1_obj->str */
2652        ExpectNotNull(nested_asn1->asn1_obj->str->d.str2
2653                = ASN1_BIT_STRING_new());
2654        ExpectIntEQ(ASN1_BIT_STRING_set_bit(nested_asn1->asn1_obj->str->d.str2,
2655                150, 1), 1);
2656        if (nested_asn1 != NULL) {
2657            nested_asn1->asn1_obj->str->type = 2;
2658        }
2659
2660        der = NULL;
2661        ExpectIntEQ(i2d_TEST_ASN1_NEST2(nested_asn1, &der), 285);
2662#ifdef WOLFSSL_ASN_TEMPLATE
2663        tmp = der;
2664        ExpectNotNull(d2i_TEST_ASN1_NEST2(&nested_asn1_2, &tmp, 285));
2665        der2 = NULL;
2666        ExpectIntEQ(i2d_TEST_ASN1_NEST2(nested_asn1_2, &der2), 285);
2667        ExpectBufEQ(der, der2, 285);
2668        XFREE(der2, NULL, DYNAMIC_TYPE_ASN1);
2669#endif
2670        XFREE(der, NULL, DYNAMIC_TYPE_ASN1);
2671
2672        TEST_ASN1_NEST2_free(nested_asn1);
2673        TEST_ASN1_NEST2_free(nested_asn1_2);
2674    }
2675
2676    /* Test ASN1_ITEM_TEMPLATE */
2677    {
2678        TEST_ASN1_ITEM* asn1_item = NULL;
2679        TEST_ASN1_ITEM* asn1_item2 = NULL;
2680        int i;
2681
2682        ExpectNotNull(asn1_item = TEST_ASN1_ITEM_new());
2683        for (i = 0; i < 11; i++) {
2684            ASN1_INTEGER* asn1_num = NULL;
2685
2686            ExpectNotNull(asn1_num = ASN1_INTEGER_new());
2687            ExpectIntEQ(ASN1_INTEGER_set(asn1_num, i), 1);
2688            ExpectIntGT(wolfSSL_sk_insert(asn1_item, asn1_num, -1), 0);
2689            if (EXPECT_FAIL()) {
2690                ASN1_INTEGER_free(asn1_num);
2691            }
2692        }
2693
2694        der = NULL;
2695        ExpectIntEQ(i2d_TEST_ASN1_ITEM(asn1_item, &der), 35);
2696        tmp = der;
2697        ExpectNotNull(d2i_TEST_ASN1_ITEM(&asn1_item2, &tmp, 35));
2698        der2 = NULL;
2699        ExpectIntEQ(i2d_TEST_ASN1_ITEM(asn1_item2, &der2), 35);
2700        ExpectBufEQ(der, der2, 35);
2701        XFREE(der, NULL, DYNAMIC_TYPE_ASN1);
2702        XFREE(der2, NULL, DYNAMIC_TYPE_ASN1);
2703
2704        TEST_ASN1_ITEM_free(asn1_item);
2705        TEST_ASN1_ITEM_free(asn1_item2);
2706    }
2707
2708#endif /* !HAVE_FIPS || HAVE_FIPS_VERSION > 2 */
2709#endif /* OPENSSL_ALL && HAVE_ECC && USE_CERT_BUFFERS_256 */
2710    return EXPECT_RESULT();
2711}
2712
2713int test_wolfSSL_i2d_ASN1_TYPE(void)
2714{
2715    EXPECT_DECLS;
2716#if defined(OPENSSL_EXTRA)
2717    /* Taken from one of sssd's certs othernames */
2718    unsigned char str_bin[] = {
2719        0x04, 0x10, 0xa4, 0x9b, 0xc8, 0xf4, 0x85, 0x8e, 0x89, 0x4d, 0x85, 0x8d,
2720        0x27, 0xbd, 0x63, 0xaa, 0x93, 0x93
2721    };
2722    ASN1_TYPE* asn1type = NULL;
2723    unsigned char* der = NULL;
2724
2725    /* Create ASN1_TYPE manually as we don't have a d2i version yet */
2726    {
2727        ASN1_STRING* str = NULL;
2728        ExpectNotNull(str = ASN1_STRING_type_new(V_ASN1_SEQUENCE));
2729        ExpectIntEQ(ASN1_STRING_set(str, str_bin, sizeof(str_bin)), 1);
2730        ExpectNotNull(asn1type = ASN1_TYPE_new());
2731        if (asn1type != NULL) {
2732            ASN1_TYPE_set(asn1type, V_ASN1_SEQUENCE, str);
2733        }
2734        else {
2735            ASN1_STRING_free(str);
2736        }
2737    }
2738
2739    ExpectIntEQ(i2d_ASN1_TYPE(asn1type, NULL), sizeof(str_bin));
2740    ExpectIntEQ(i2d_ASN1_TYPE(asn1type, &der), sizeof(str_bin));
2741    ExpectBufEQ(der, str_bin, sizeof(str_bin));
2742
2743    ASN1_TYPE_free(asn1type);
2744    XFREE(der, NULL, DYNAMIC_TYPE_ASN1);
2745#endif
2746    return EXPECT_RESULT();
2747}
2748
2749int test_wolfSSL_i2d_ASN1_SEQUENCE(void)
2750{
2751    EXPECT_DECLS;
2752#if defined(OPENSSL_EXTRA)
2753    /* Taken from one of sssd's certs othernames */
2754    unsigned char str_bin[] = {
2755      0x04, 0x10, 0xa4, 0x9b, 0xc8, 0xf4, 0x85, 0x8e, 0x89, 0x4d, 0x85, 0x8d,
2756      0x27, 0xbd, 0x63, 0xaa, 0x93, 0x93
2757    };
2758    ASN1_STRING* str = NULL;
2759    unsigned char* der = NULL;
2760
2761    ExpectNotNull(str = ASN1_STRING_type_new(V_ASN1_SEQUENCE));
2762    ExpectIntEQ(ASN1_STRING_set(str, str_bin, sizeof(str_bin)), 1);
2763    ExpectIntEQ(i2d_ASN1_SEQUENCE(str, NULL), sizeof(str_bin));
2764    ExpectIntEQ(i2d_ASN1_SEQUENCE(str, &der), sizeof(str_bin));
2765
2766    ASN1_STRING_free(str);
2767    XFREE(der, NULL, DYNAMIC_TYPE_ASN1);
2768#endif
2769    return EXPECT_RESULT();
2770}
2771
2772int test_ASN1_strings(void)
2773{
2774    EXPECT_DECLS;
2775#if defined(OPENSSL_EXTRA)
2776    char text[] = "\0\0test string";
2777    unsigned char* der = NULL;
2778    ASN1_STRING* str = NULL;
2779
2780    /* Set the length byte */
2781    text[1] = XSTRLEN(text + 2);
2782
2783    /* GENERALSTRING */
2784    {
2785        const unsigned char* p = (const unsigned char*)text;
2786        text[0] = ASN_GENERALSTRING;
2787        ExpectNotNull(d2i_ASN1_GENERALSTRING(&str, &p, sizeof(text)));
2788        ExpectIntEQ(i2d_ASN1_GENERALSTRING(str, &der), 13);
2789        ASN1_STRING_free(str);
2790        str = NULL;
2791        XFREE(der, NULL, DYNAMIC_TYPE_ASN1);
2792        der = NULL;
2793    }
2794
2795    /* OCTET_STRING */
2796    {
2797        const unsigned char* p = (const unsigned char*)text;
2798        text[0] = ASN_OCTET_STRING;
2799        ExpectNotNull(d2i_ASN1_OCTET_STRING(&str, &p, sizeof(text)));
2800        ExpectIntEQ(i2d_ASN1_OCTET_STRING(str, &der), 13);
2801        ASN1_STRING_free(str);
2802        str = NULL;
2803        XFREE(der, NULL, DYNAMIC_TYPE_ASN1);
2804        der = NULL;
2805    }
2806
2807    /* UTF8STRING */
2808    {
2809        const unsigned char* p = (const unsigned char*)text;
2810        text[0] = ASN_UTF8STRING;
2811        ExpectNotNull(d2i_ASN1_UTF8STRING(&str, &p, sizeof(text)));
2812        ExpectIntEQ(i2d_ASN1_UTF8STRING(str, &der), 13);
2813        ASN1_STRING_free(str);
2814        str = NULL;
2815        XFREE(der, NULL, DYNAMIC_TYPE_ASN1);
2816        der = NULL;
2817    }
2818
2819#endif
2820    return EXPECT_RESULT();
2821}
2822