luna - wolfssl/tests/api/test_ossl_x509

   1/* test_ossl_x509_str.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/ssl.h>
  32#ifdef OPENSSL_EXTRA
  33    #include <wolfssl/openssl/x509_vfy.h>
  34    #include <wolfssl/openssl/pem.h>
  35#endif
  36#include <tests/api/api.h>
  37#include <tests/api/test_ossl_x509_str.h>
  38
  39#if defined(OPENSSL_ALL) && !defined(NO_RSA) && !defined(NO_FILESYSTEM) && \
  40    !defined(NO_ASN_TIME)
  41static int last_errcodes[10];
  42static int last_errdepths[10];
  43static int err_index = 0;
  44
  45static int X509CallbackCount(int ok, X509_STORE_CTX *ctx)
  46{
  47    if (!ok) {
  48        if (err_index < 10) {
  49            last_errcodes[err_index]  = X509_STORE_CTX_get_error(ctx);
  50            last_errdepths[err_index] = X509_STORE_CTX_get_error_depth(ctx);
  51            err_index++;
  52        } else {
  53            /* Should not happen in test */
  54            WOLFSSL_MSG("Error index overflow in X509CallbackCount");
  55            err_index = 0;
  56        }
  57    }
  58    /* Always return OK to allow verification to continue.*/
  59    return 1;
  60}
  61#endif
  62
  63int test_wolfSSL_X509_STORE_CTX_set_time(void)
  64{
  65    EXPECT_DECLS;
  66#if defined(OPENSSL_EXTRA)
  67    WOLFSSL_X509_STORE_CTX* ctx = NULL;
  68    time_t c_time;
  69
  70    ExpectNotNull(ctx = wolfSSL_X509_STORE_CTX_new());
  71    c_time = 365*24*60*60;
  72    wolfSSL_X509_STORE_CTX_set_time(ctx, 0, c_time);
  73    ExpectTrue((ctx->param->flags & WOLFSSL_USE_CHECK_TIME) ==
  74        WOLFSSL_USE_CHECK_TIME);
  75    ExpectTrue(ctx->param->check_time == c_time);
  76    wolfSSL_X509_STORE_CTX_free(ctx);
  77#endif /* OPENSSL_EXTRA */
  78    return EXPECT_RESULT();
  79}
  80
  81int test_wolfSSL_X509_STORE_check_time(void)
  82{
  83    EXPECT_DECLS;
  84#if defined(OPENSSL_EXTRA) && !defined(NO_FILESYSTEM) && \
  85        !defined(NO_ASN_TIME) && !defined(NO_RSA)
  86    WOLFSSL_X509_STORE* store = NULL;
  87    WOLFSSL_X509_STORE_CTX* ctx = NULL;
  88    WOLFSSL_X509* ca = NULL;
  89    WOLFSSL_X509* cert = NULL;
  90    int ret;
  91    time_t check_time;
  92    const char* srvCertFile = "./certs/server-cert.pem";
  93    const char* expiredCertFile = "./certs/test/expired/expired-cert.pem";
  94
  95    /* Set check_time to May 26, 2000 - should fail "not yet valid" check */
  96    ExpectNotNull(store = wolfSSL_X509_STORE_new());
  97    if (store != NULL) {
  98        /* Load CA certificate - should validate with current time by default */
  99        ExpectNotNull(ca = wolfSSL_X509_load_certificate_file(caCertFile,
 100                            SSL_FILETYPE_PEM));
 101        ExpectIntEQ(wolfSSL_X509_STORE_add_cert(store, ca), WOLFSSL_SUCCESS);
 102
 103        /* Set check_time to May 26, 2000 (timestamp: 959320800) */
 104        check_time = (time_t)959320800; /* May 26, 2000 00:00:00 UTC */
 105        store->param->check_time = check_time;
 106        wolfSSL_X509_VERIFY_PARAM_set_flags(store->param,
 107            WOLFSSL_USE_CHECK_TIME);
 108        ExpectTrue(store->param->check_time == check_time);
 109        ExpectNotNull(cert = wolfSSL_X509_load_certificate_file(srvCertFile,
 110                        SSL_FILETYPE_PEM));
 111        ExpectNotNull(ctx = wolfSSL_X509_STORE_CTX_new());
 112        ExpectIntEQ(wolfSSL_X509_STORE_CTX_init(ctx, store, cert, NULL),
 113                    WOLFSSL_SUCCESS);
 114
 115        /* Verify that check_time was copied to context */
 116        ExpectTrue((ctx->param->flags & WOLFSSL_USE_CHECK_TIME) ==
 117            WOLFSSL_USE_CHECK_TIME);
 118        ExpectTrue(ctx->param->check_time == check_time);
 119
 120        /* Verify certificate using the custom check_time - should fail because
 121        * certificate is not yet valid (use before check fails) */
 122        ret = wolfSSL_X509_verify_cert(ctx);
 123        ExpectIntNE(ret, WOLFSSL_SUCCESS);
 124        ExpectIntEQ(wolfSSL_X509_STORE_CTX_get_error(ctx),
 125                    WOLFSSL_X509_V_ERR_CERT_NOT_YET_VALID);
 126        wolfSSL_X509_STORE_CTX_free(ctx);
 127        ctx = NULL;
 128    }
 129    wolfSSL_X509_STORE_free(store);
 130    store = NULL;
 131    wolfSSL_X509_free(cert);
 132    cert = NULL;
 133    wolfSSL_X509_free(ca);
 134    ca = NULL;
 135
 136    /* Verify without setting check_time - should work with current time */
 137    ExpectNotNull(store = wolfSSL_X509_STORE_new());
 138    if (store != NULL) {
 139        ExpectNotNull(ca = wolfSSL_X509_load_certificate_file(caCertFile,
 140                            SSL_FILETYPE_PEM));
 141        ExpectIntEQ(wolfSSL_X509_STORE_add_cert(store, ca), WOLFSSL_SUCCESS);
 142        ExpectNotNull(cert = wolfSSL_X509_load_certificate_file(srvCertFile,
 143                        SSL_FILETYPE_PEM));
 144        ExpectNotNull(ctx = wolfSSL_X509_STORE_CTX_new());
 145        ExpectIntEQ(wolfSSL_X509_STORE_CTX_init(ctx, store, cert, NULL),
 146                    WOLFSSL_SUCCESS);
 147        ret = wolfSSL_X509_verify_cert(ctx);
 148        ExpectIntEQ(ret, WOLFSSL_SUCCESS);
 149        wolfSSL_X509_STORE_CTX_free(ctx);
 150        ctx = NULL;
 151    }
 152    wolfSSL_X509_STORE_free(store);
 153    store = NULL;
 154    wolfSSL_X509_free(cert);
 155    cert = NULL;
 156    wolfSSL_X509_free(ca);
 157    ca = NULL;
 158
 159    /* Test WOLFSSL_NO_CHECK_TIME flag with expired certificate */
 160    ExpectNotNull(store = wolfSSL_X509_STORE_new());
 161    if (store != NULL) {
 162        /* Set NO_CHECK_TIME flag to skip time validation */
 163        wolfSSL_X509_VERIFY_PARAM_set_flags(store->param,
 164            WOLFSSL_NO_CHECK_TIME);
 165        ExpectTrue((store->param->flags & WOLFSSL_NO_CHECK_TIME) ==
 166            WOLFSSL_NO_CHECK_TIME);
 167
 168        /* Load expired certificate (self-signed) */
 169        ExpectNotNull(cert = wolfSSL_X509_load_certificate_file(expiredCertFile,
 170                        SSL_FILETYPE_PEM));
 171        /* Add expired certificate as trusted CA (self-signed) */
 172        ExpectIntEQ(wolfSSL_X509_STORE_add_cert(store, cert), WOLFSSL_SUCCESS);
 173
 174        ExpectNotNull(ctx = wolfSSL_X509_STORE_CTX_new());
 175        ExpectIntEQ(wolfSSL_X509_STORE_CTX_init(ctx, store, cert, NULL),
 176                    WOLFSSL_SUCCESS);
 177        /* Verify expired certificate with NO_CHECK_TIME - should succeed
 178        * because time validation is skipped */
 179        ret = wolfSSL_X509_verify_cert(ctx);
 180        ExpectIntEQ(ret, WOLFSSL_SUCCESS);
 181    }
 182    wolfSSL_X509_STORE_CTX_free(ctx);
 183    ctx = NULL;
 184    wolfSSL_X509_STORE_free(store);
 185    store = NULL;
 186    wolfSSL_X509_free(cert);
 187    cert = NULL;
 188
 189#if defined(OPENSSL_ALL) && !defined(NO_RSA) && !defined(NO_FILESYSTEM)
 190
 191    err_index = 0;
 192
 193    ExpectNotNull(store = X509_STORE_new());
 194    ExpectNotNull(ctx = X509_STORE_CTX_new());
 195    ExpectNotNull(ca = wolfSSL_X509_load_certificate_file(caCertFile,
 196                        SSL_FILETYPE_PEM));
 197    ExpectIntEQ(wolfSSL_X509_STORE_add_cert(store, ca), WOLFSSL_SUCCESS);
 198
 199    X509_STORE_set_verify_cb(store, X509CallbackCount);
 200
 201    ExpectNotNull(cert = wolfSSL_X509_load_certificate_file(expiredCertFile,
 202                        SSL_FILETYPE_PEM));
 203
 204    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, cert, NULL), WOLFSSL_SUCCESS);
 205    ExpectIntEQ(X509_verify_cert(ctx), WOLFSSL_SUCCESS);
 206    /* while verifying the certificate, it should have two errors */
 207    ExpectIntEQ(err_index, 2);
 208    /* self-signed */
 209    ExpectIntEQ(last_errcodes[err_index - 2],
 210                WOLFSSL_X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT);
 211    /* expired */
 212    ExpectIntEQ(last_errcodes[err_index - 1],
 213                WOLFSSL_X509_V_ERR_CERT_HAS_EXPIRED);
 214
 215    X509_STORE_CTX_free(ctx);
 216    ctx = NULL;
 217    X509_STORE_free(store);
 218    store = NULL;
 219    X509_free(cert);
 220    cert = NULL;
 221    X509_free(ca);
 222    ca = NULL;
 223
 224    err_index = 0;
 225
 226    ExpectNotNull(store = X509_STORE_new());
 227    /* Set NO_CHECK_TIME flag to skip time validation */
 228    ExpectIntEQ(X509_VERIFY_PARAM_set_flags(store->param,
 229                        WOLFSSL_NO_CHECK_TIME), WOLFSSL_SUCCESS);
 230    ExpectTrue((store->param->flags & WOLFSSL_NO_CHECK_TIME) ==
 231        WOLFSSL_NO_CHECK_TIME);
 232    ExpectNotNull(ctx = X509_STORE_CTX_new());
 233    ExpectNotNull(ca = wolfSSL_X509_load_certificate_file(caCertFile,
 234                        SSL_FILETYPE_PEM));
 235    ExpectIntEQ(wolfSSL_X509_STORE_add_cert(store, ca), WOLFSSL_SUCCESS);
 236
 237    X509_STORE_set_verify_cb(store, X509CallbackCount);
 238
 239    ExpectNotNull(cert = wolfSSL_X509_load_certificate_file(expiredCertFile,
 240                        SSL_FILETYPE_PEM));
 241
 242    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, cert, NULL), WOLFSSL_SUCCESS);
 243    ExpectIntEQ(X509_verify_cert(ctx), WOLFSSL_SUCCESS);
 244    /* while verifying the certificate, it should have an error */
 245    ExpectIntEQ(err_index, 1);
 246    /* self-signed */
 247    ExpectIntEQ(last_errcodes[err_index - 1],
 248                WOLFSSL_X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT);
 249    /* no expired because of no_check_time */
 250    X509_STORE_CTX_free(ctx);
 251    ctx = NULL;
 252    X509_STORE_free(store);
 253    store = NULL;
 254    X509_free(cert);
 255    cert = NULL;
 256    X509_free(ca);
 257    ca = NULL;
 258#endif
 259#endif /* OPENSSL_EXTRA && !NO_FILESYSTEM && !NO_ASN_TIME && !NO_RSA */
 260    return EXPECT_RESULT();
 261}
 262
 263int test_wolfSSL_X509_STORE_CTX_get0_store(void)
 264{
 265    EXPECT_DECLS;
 266#if defined(OPENSSL_EXTRA)
 267    X509_STORE* store = NULL;
 268    X509_STORE_CTX* ctx = NULL;
 269    X509_STORE_CTX* ctx_no_init = NULL;
 270
 271    ExpectNotNull((store = X509_STORE_new()));
 272    ExpectNotNull(ctx = X509_STORE_CTX_new());
 273    ExpectNotNull(ctx_no_init = X509_STORE_CTX_new());
 274    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, NULL, NULL), SSL_SUCCESS);
 275
 276    ExpectNull(X509_STORE_CTX_get0_store(NULL));
 277    /* should return NULL if ctx has not bee initialized */
 278    ExpectNull(X509_STORE_CTX_get0_store(ctx_no_init));
 279    ExpectNotNull(X509_STORE_CTX_get0_store(ctx));
 280
 281    wolfSSL_X509_STORE_CTX_free(ctx);
 282    wolfSSL_X509_STORE_CTX_free(ctx_no_init);
 283    X509_STORE_free(store);
 284#endif /* OPENSSL_EXTRA */
 285    return EXPECT_RESULT();
 286}
 287
 288#if defined(OPENSSL_EXTRA) && !defined(NO_CERTS) && \
 289       !defined(NO_FILESYSTEM) && !defined(NO_RSA)
 290static int verify_cb(int ok, X509_STORE_CTX *ctx)
 291{
 292    (void) ok;
 293    (void) ctx;
 294    fprintf(stderr, "ENTER verify_cb\n");
 295    return SSL_SUCCESS;
 296}
 297#endif
 298
 299int test_wolfSSL_X509_STORE_CTX(void)
 300{
 301    EXPECT_DECLS;
 302#if defined(OPENSSL_EXTRA) && !defined(NO_CERTS) && \
 303   !defined(NO_FILESYSTEM) && !defined(NO_RSA)
 304    X509_STORE_CTX* ctx = NULL;
 305    X509_STORE* str = NULL;
 306    X509* x509 = NULL;
 307#ifdef OPENSSL_ALL
 308    X509* x5092 = NULL;
 309    STACK_OF(X509) *sk = NULL;
 310    STACK_OF(X509) *sk2 = NULL;
 311    STACK_OF(X509) *sk3 = NULL;
 312#endif
 313
 314    ExpectNotNull(ctx = X509_STORE_CTX_new());
 315    ExpectNotNull((str = wolfSSL_X509_STORE_new()));
 316    ExpectNotNull((x509 =
 317        wolfSSL_X509_load_certificate_file(svrCertFile, SSL_FILETYPE_PEM)));
 318    ExpectIntEQ(X509_STORE_add_cert(str, x509), SSL_SUCCESS);
 319#ifdef OPENSSL_ALL
 320    /* sk_X509_new only in OPENSSL_ALL */
 321    sk = sk_X509_new_null();
 322    ExpectNotNull(sk);
 323    ExpectIntEQ(X509_STORE_CTX_init(ctx, str, x509, sk), SSL_SUCCESS);
 324#else
 325    ExpectIntEQ(X509_STORE_CTX_init(ctx, str, x509, NULL), SSL_SUCCESS);
 326#endif
 327    ExpectIntEQ(SSL_get_ex_data_X509_STORE_CTX_idx(), 0);
 328    X509_STORE_CTX_set_error(ctx, -5);
 329    X509_STORE_CTX_set_error(NULL, -5);
 330
 331    X509_STORE_CTX_free(ctx);
 332    ctx = NULL;
 333#ifdef OPENSSL_ALL
 334    sk_X509_pop_free(sk, NULL);
 335    sk = NULL;
 336#endif
 337    X509_STORE_free(str);
 338    str = NULL;
 339    X509_free(x509);
 340    x509 = NULL;
 341
 342    ExpectNotNull(ctx = X509_STORE_CTX_new());
 343    X509_STORE_CTX_set_verify_cb(ctx, verify_cb);
 344    X509_STORE_CTX_free(ctx);
 345    ctx = NULL;
 346
 347#ifdef OPENSSL_ALL
 348    /* test X509_STORE_CTX_get(1)_chain */
 349    ExpectNotNull((x509 = X509_load_certificate_file(svrCertFile,
 350                                                     SSL_FILETYPE_PEM)));
 351    ExpectNotNull((x5092 = X509_load_certificate_file(cliCertFile,
 352                                                     SSL_FILETYPE_PEM)));
 353    ExpectNotNull((sk = sk_X509_new_null()));
 354    ExpectIntEQ(sk_X509_push(sk, x509), 1);
 355    if (EXPECT_FAIL()) {
 356        X509_free(x509);
 357        x509 = NULL;
 358    }
 359    ExpectNotNull((str = X509_STORE_new()));
 360    ExpectNotNull((ctx = X509_STORE_CTX_new()));
 361    ExpectIntEQ(X509_STORE_CTX_init(ctx, str, x5092, sk), 1);
 362    ExpectNull((sk2 = X509_STORE_CTX_get_chain(NULL)));
 363    ExpectNull((sk2 = X509_STORE_CTX_get_chain(ctx)));
 364    ExpectNull((sk3 = X509_STORE_CTX_get1_chain(NULL)));
 365    ExpectNull((sk3 = X509_STORE_CTX_get1_chain(ctx)));
 366    X509_STORE_CTX_free(ctx);
 367    ctx = NULL;
 368    X509_STORE_free(str);
 369    str = NULL;
 370    /* CTX certs not freed yet */
 371    X509_free(x5092);
 372    x5092 = NULL;
 373    sk_X509_pop_free(sk, NULL);
 374    sk = NULL;
 375    /* sk3 is dup so free here */
 376    sk_X509_pop_free(sk3, NULL);
 377    sk3 = NULL;
 378#endif
 379
 380    /* test X509_STORE_CTX_get/set_ex_data */
 381    {
 382        int i = 0, tmpData = 5;
 383        void* tmpDataRet;
 384        ExpectNotNull(ctx = X509_STORE_CTX_new());
 385    #ifdef HAVE_EX_DATA
 386        for (i = 0; i < MAX_EX_DATA; i++) {
 387            ExpectIntEQ(X509_STORE_CTX_set_ex_data(ctx, i, &tmpData),
 388                        WOLFSSL_SUCCESS);
 389            tmpDataRet = (int*)X509_STORE_CTX_get_ex_data(ctx, i);
 390            ExpectNotNull(tmpDataRet);
 391            ExpectIntEQ(tmpData, *(int*)tmpDataRet);
 392        }
 393    #else
 394        ExpectIntEQ(X509_STORE_CTX_set_ex_data(ctx, i, &tmpData),
 395                    WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 396        tmpDataRet = (int*)X509_STORE_CTX_get_ex_data(ctx, i);
 397        ExpectNull(tmpDataRet);
 398    #endif
 399        X509_STORE_CTX_free(ctx);
 400        ctx = NULL;
 401    }
 402
 403    /* test X509_STORE_get/set_ex_data */
 404    {
 405        int i = 0, tmpData = 99;
 406        void* tmpDataRet;
 407        ExpectNotNull(str = X509_STORE_new());
 408    #ifdef HAVE_EX_DATA
 409        for (i = 0; i < MAX_EX_DATA; i++) {
 410            ExpectIntEQ(X509_STORE_set_ex_data(str, i, &tmpData),
 411                        WOLFSSL_SUCCESS);
 412            tmpDataRet = (int*)X509_STORE_get_ex_data(str, i);
 413            ExpectNotNull(tmpDataRet);
 414            ExpectIntEQ(tmpData, *(int*)tmpDataRet);
 415        }
 416    #else
 417        ExpectIntEQ(X509_STORE_set_ex_data(str, i, &tmpData),
 418                    WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 419        tmpDataRet = (int*)X509_STORE_get_ex_data(str, i);
 420        ExpectNull(tmpDataRet);
 421    #endif
 422        X509_STORE_free(str);
 423        str = NULL;
 424    }
 425
 426#endif /* defined(OPENSSL_EXTRA) && !defined(NO_CERTS) && \
 427        * !defined(NO_FILESYSTEM) && !defined(NO_RSA) */
 428
 429    return EXPECT_RESULT();
 430}
 431
 432#if defined(OPENSSL_EXTRA) && !defined(NO_CERTS) && \
 433   !defined(NO_FILESYSTEM) && !defined(NO_RSA)
 434
 435typedef struct {
 436    const char *caFile;
 437    const char *caIntFile;
 438    const char *caInt2File;
 439    const char *leafFile;
 440    X509 *x509Ca;
 441    X509 *x509CaInt;
 442    X509 *x509CaInt2;
 443    X509 *x509Leaf;
 444    STACK_OF(X509)* expectedChain;
 445} X509_STORE_test_data;
 446
 447static X509 * test_wolfSSL_X509_STORE_CTX_ex_helper(const char *file)
 448{
 449    XFILE fp = XBADFILE;
 450    X509 *x = NULL;
 451
 452    fp = XFOPEN(file, "rb");
 453    if (fp == NULL) {
 454        return NULL;
 455    }
 456    x = PEM_read_X509(fp, 0, 0, 0);
 457    XFCLOSE(fp);
 458
 459    return x;
 460}
 461
 462static int test_wolfSSL_X509_STORE_CTX_ex1(X509_STORE_test_data *testData)
 463{
 464    EXPECT_DECLS;
 465    X509_STORE* store = NULL;
 466    X509_STORE_CTX* ctx = NULL;
 467    STACK_OF(X509)* chain = NULL;
 468    int i = 0;
 469
 470    /* Test case 1, add X509 certs to store and verify */
 471    ExpectNotNull(store = X509_STORE_new());
 472    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509Ca), 1);
 473    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt), 1);
 474    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt2), 1);
 475    ExpectNotNull(ctx = X509_STORE_CTX_new());
 476    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, testData->x509Leaf, NULL), 1);
 477    ExpectIntEQ(X509_verify_cert(ctx), 1);
 478    ExpectNotNull(chain = X509_STORE_CTX_get_chain(ctx));
 479    ExpectIntEQ(sk_X509_num(chain), sk_X509_num(testData->expectedChain));
 480    for (i = 0; i < sk_X509_num(chain); i++) {
 481        ExpectIntEQ(X509_cmp(sk_X509_value(chain, i),
 482                             sk_X509_value(testData->expectedChain, i)), 0);
 483    }
 484    X509_STORE_CTX_free(ctx);
 485    X509_STORE_free(store);
 486    return EXPECT_RESULT();
 487}
 488
 489static int test_wolfSSL_X509_STORE_CTX_ex2(X509_STORE_test_data *testData)
 490{
 491    EXPECT_DECLS;
 492    X509_STORE* store = NULL;
 493    X509_STORE_CTX* ctx = NULL;
 494    STACK_OF(X509)* chain = NULL;
 495    int i = 0;
 496
 497    /* Test case 2, add certs by filename to store and verify */
 498    ExpectNotNull(store = X509_STORE_new());
 499    ExpectIntEQ(X509_STORE_load_locations(
 500        store, testData->caFile, NULL), 1);
 501    ExpectIntEQ(X509_STORE_load_locations(
 502        store, testData->caIntFile, NULL), 1);
 503    ExpectIntEQ(X509_STORE_load_locations(
 504        store, testData->caInt2File, NULL), 1);
 505    ExpectNotNull(ctx = X509_STORE_CTX_new());
 506    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, testData->x509Leaf, NULL), 1);
 507    ExpectIntEQ(X509_verify_cert(ctx), 1);
 508    ExpectNotNull(chain = X509_STORE_CTX_get_chain(ctx));
 509    ExpectIntEQ(sk_X509_num(chain), sk_X509_num(testData->expectedChain));
 510    for (i = 0; i < sk_X509_num(chain); i++) {
 511        ExpectIntEQ(X509_cmp(sk_X509_value(chain, i),
 512                             sk_X509_value(testData->expectedChain, i)), 0);
 513    }
 514    X509_STORE_CTX_free(ctx);
 515    X509_STORE_free(store);
 516    return EXPECT_RESULT();
 517}
 518
 519static int test_wolfSSL_X509_STORE_CTX_ex3(X509_STORE_test_data *testData)
 520{
 521    EXPECT_DECLS;
 522    X509_STORE* store = NULL;
 523    X509_STORE_CTX* ctx = NULL;
 524    STACK_OF(X509)* chain = NULL;
 525    int i = 0;
 526
 527    /* Test case 3, mix and match X509 with files */
 528    ExpectNotNull(store = X509_STORE_new());
 529    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt), 1);
 530    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt2), 1);
 531    ExpectIntEQ(X509_STORE_load_locations(
 532        store, testData->caFile, NULL), 1);
 533    ExpectNotNull(ctx = X509_STORE_CTX_new());
 534    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, testData->x509Leaf, NULL), 1);
 535    ExpectIntEQ(X509_verify_cert(ctx), 1);
 536    ExpectNotNull(chain = X509_STORE_CTX_get_chain(ctx));
 537    ExpectIntEQ(sk_X509_num(chain), sk_X509_num(testData->expectedChain));
 538    for (i = 0; i < sk_X509_num(chain); i++) {
 539        ExpectIntEQ(X509_cmp(sk_X509_value(chain, i),
 540                             sk_X509_value(testData->expectedChain, i)), 0);
 541    }
 542    X509_STORE_CTX_free(ctx);
 543    X509_STORE_free(store);
 544    return EXPECT_RESULT();
 545}
 546
 547static int test_wolfSSL_X509_STORE_CTX_ex4(X509_STORE_test_data *testData)
 548{
 549    EXPECT_DECLS;
 550    X509_STORE* store = NULL;
 551    X509_STORE_CTX* ctx = NULL;
 552    STACK_OF(X509)* chain = NULL;
 553    STACK_OF(X509)* inter = NULL;
 554    int i = 0;
 555
 556    /* Test case 4, CA loaded by file, intermediates passed on init */
 557    ExpectNotNull(store = X509_STORE_new());
 558    ExpectIntEQ(X509_STORE_load_locations(
 559        store, testData->caFile, NULL), 1);
 560    ExpectNotNull(inter = sk_X509_new_null());
 561    ExpectIntGE(sk_X509_push(inter, testData->x509CaInt), 1);
 562    ExpectIntGE(sk_X509_push(inter, testData->x509CaInt2), 1);
 563    ExpectNotNull(ctx = X509_STORE_CTX_new());
 564    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, testData->x509Leaf, inter), 1);
 565    ExpectIntEQ(X509_verify_cert(ctx), 1);
 566    ExpectNotNull(chain = X509_STORE_CTX_get_chain(ctx));
 567    ExpectIntEQ(sk_X509_num(chain), sk_X509_num(testData->expectedChain));
 568    for (i = 0; i < sk_X509_num(chain); i++) {
 569        ExpectIntEQ(X509_cmp(sk_X509_value(chain, i),
 570                             sk_X509_value(testData->expectedChain, i)), 0);
 571    }
 572    X509_STORE_CTX_free(ctx);
 573    X509_STORE_free(store);
 574    sk_X509_free(inter);
 575    return EXPECT_RESULT();
 576}
 577
 578static int test_wolfSSL_X509_STORE_CTX_ex5(X509_STORE_test_data *testData)
 579{
 580    EXPECT_DECLS;
 581    X509_STORE* store = NULL;
 582    X509_STORE_CTX* ctx = NULL;
 583    STACK_OF(X509)* chain = NULL;
 584    STACK_OF(X509)* trusted = NULL;
 585    int i = 0;
 586
 587    /* Test case 5, manually set trusted stack */
 588    ExpectNotNull(store = X509_STORE_new());
 589    ExpectNotNull(trusted = sk_X509_new_null());
 590    ExpectIntGE(sk_X509_push(trusted, testData->x509Ca), 1);
 591    ExpectIntGE(sk_X509_push(trusted, testData->x509CaInt), 1);
 592    ExpectIntGE(sk_X509_push(trusted, testData->x509CaInt2), 1);
 593    ExpectNotNull(ctx = X509_STORE_CTX_new());
 594    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, testData->x509Leaf, NULL), 1);
 595    X509_STORE_CTX_trusted_stack(ctx, trusted);
 596    ExpectIntEQ(X509_verify_cert(ctx), 1);
 597    ExpectNotNull(chain = X509_STORE_CTX_get_chain(ctx));
 598    ExpectIntEQ(sk_X509_num(chain), sk_X509_num(testData->expectedChain));
 599    for (i = 0; i < sk_X509_num(chain); i++) {
 600        ExpectIntEQ(X509_cmp(sk_X509_value(chain, i),
 601                             sk_X509_value(testData->expectedChain, i)), 0);
 602    }
 603    X509_STORE_CTX_free(ctx);
 604    X509_STORE_free(store);
 605    sk_X509_free(trusted);
 606    return EXPECT_RESULT();
 607}
 608
 609static int test_wolfSSL_X509_STORE_CTX_ex6(X509_STORE_test_data *testData)
 610{
 611    EXPECT_DECLS;
 612    X509_STORE* store = NULL;
 613    X509_STORE_CTX* ctx = NULL;
 614    STACK_OF(X509)* chain = NULL;
 615    STACK_OF(X509)* trusted = NULL;
 616    STACK_OF(X509)* inter = NULL;
 617    int i = 0;
 618
 619    /* Test case 6, manually set trusted stack will be unified with
 620     * any intermediates provided on init */
 621    ExpectNotNull(store = X509_STORE_new());
 622    ExpectNotNull(trusted = sk_X509_new_null());
 623    ExpectNotNull(inter = sk_X509_new_null());
 624    ExpectIntGE(sk_X509_push(trusted, testData->x509Ca), 1);
 625    ExpectIntGE(sk_X509_push(inter, testData->x509CaInt), 1);
 626    ExpectIntGE(sk_X509_push(inter, testData->x509CaInt2), 1);
 627    ExpectNotNull(ctx = X509_STORE_CTX_new());
 628    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, testData->x509Leaf, inter), 1);
 629    X509_STORE_CTX_trusted_stack(ctx, trusted);
 630    ExpectIntEQ(X509_verify_cert(ctx), 1);
 631    ExpectNotNull(chain = X509_STORE_CTX_get_chain(ctx));
 632    ExpectIntEQ(sk_X509_num(chain), sk_X509_num(testData->expectedChain));
 633    for (i = 0; i < sk_X509_num(chain); i++) {
 634        ExpectIntEQ(X509_cmp(sk_X509_value(chain, i),
 635                             sk_X509_value(testData->expectedChain, i)), 0);
 636    }
 637    X509_STORE_CTX_free(ctx);
 638    X509_STORE_free(store);
 639    sk_X509_free(trusted);
 640    sk_X509_free(inter);
 641    return EXPECT_RESULT();
 642}
 643
 644static int test_wolfSSL_X509_STORE_CTX_ex7(X509_STORE_test_data *testData)
 645{
 646    EXPECT_DECLS;
 647    X509_STORE* store = NULL;
 648    X509_STORE_CTX* ctx = NULL;
 649    STACK_OF(X509)* chain = NULL;
 650    int i = 0;
 651
 652    /* Test case 7, certs added to store after ctx init are still used */
 653    ExpectNotNull(store = X509_STORE_new());
 654    ExpectNotNull(ctx = X509_STORE_CTX_new());
 655    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, testData->x509Leaf, NULL), 1);
 656    ExpectIntNE(X509_verify_cert(ctx), 1);
 657    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt2), 1);
 658    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt), 1);
 659    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509Ca), 1);
 660    ExpectIntEQ(X509_verify_cert(ctx), 1);
 661    ExpectNotNull(chain = X509_STORE_CTX_get_chain(ctx));
 662    ExpectIntEQ(sk_X509_num(chain), sk_X509_num(testData->expectedChain));
 663    for (i = 0; i < sk_X509_num(chain); i++) {
 664        ExpectIntEQ(X509_cmp(sk_X509_value(chain, i),
 665                             sk_X509_value(testData->expectedChain, i)), 0);
 666    }
 667    X509_STORE_CTX_free(ctx);
 668    X509_STORE_free(store);
 669    return EXPECT_RESULT();
 670}
 671
 672static int test_wolfSSL_X509_STORE_CTX_ex8(X509_STORE_test_data *testData)
 673{
 674    EXPECT_DECLS;
 675    X509_STORE* store = NULL;
 676    X509_STORE_CTX* ctx = NULL;
 677    STACK_OF(X509)* chain = NULL;
 678    int i = 0;
 679
 680    /* Test case 8, Only full chain verifies */
 681    ExpectNotNull(store = X509_STORE_new());
 682    ExpectNotNull(ctx = X509_STORE_CTX_new());
 683    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, testData->x509Leaf, NULL), 1);
 684    ExpectIntNE(X509_verify_cert(ctx), 1);
 685    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt2), 1);
 686    ExpectIntNE(X509_verify_cert(ctx), 1);
 687    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt), 1);
 688    ExpectIntNE(X509_verify_cert(ctx), 1);
 689    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509Ca), 1);
 690    ExpectIntEQ(X509_verify_cert(ctx), 1);
 691    ExpectNotNull(chain = X509_STORE_CTX_get_chain(ctx));
 692    ExpectIntEQ(sk_X509_num(chain), sk_X509_num(testData->expectedChain));
 693    for (i = 0; i < sk_X509_num(chain); i++) {
 694        ExpectIntEQ(X509_cmp(sk_X509_value(chain, i),
 695                             sk_X509_value(testData->expectedChain, i)), 0);
 696    }
 697    X509_STORE_CTX_free(ctx);
 698    X509_STORE_free(store);
 699    return EXPECT_RESULT();
 700}
 701
 702static int test_wolfSSL_X509_STORE_CTX_ex9(X509_STORE_test_data *testData)
 703{
 704    EXPECT_DECLS;
 705    X509_STORE* store = NULL;
 706    X509_STORE_CTX* ctx = NULL;
 707    X509_STORE_CTX* ctx2 = NULL;
 708    STACK_OF(X509)* trusted = NULL;
 709
 710    /* Test case 9, certs added to store should not be reflected in ctx that
 711     * has been manually set with a trusted stack, but are reflected in ctx
 712     * that has not set trusted stack */
 713    ExpectNotNull(store = X509_STORE_new());
 714    ExpectNotNull(ctx = X509_STORE_CTX_new());
 715    ExpectNotNull(ctx2 = X509_STORE_CTX_new());
 716    ExpectNotNull(trusted = sk_X509_new_null());
 717    ExpectIntGE(sk_X509_push(trusted, testData->x509Ca), 1);
 718    ExpectIntGE(sk_X509_push(trusted, testData->x509CaInt), 1);
 719    ExpectIntGE(sk_X509_push(trusted, testData->x509CaInt2), 1);
 720    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, testData->x509Leaf, NULL), 1);
 721    ExpectIntEQ(X509_STORE_CTX_init(ctx2, store, testData->x509Leaf, NULL), 1);
 722    ExpectIntNE(X509_verify_cert(ctx), 1);
 723    ExpectIntNE(X509_verify_cert(ctx2), 1);
 724    X509_STORE_CTX_trusted_stack(ctx, trusted);
 725    /* CTX1 should now verify */
 726    ExpectIntEQ(X509_verify_cert(ctx), 1);
 727    ExpectIntNE(X509_verify_cert(ctx2), 1);
 728    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509Ca), 1);
 729    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt), 1);
 730    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt2), 1);
 731    /* CTX2 should now verify */
 732    ExpectIntEQ(X509_verify_cert(ctx2), 1);
 733    X509_STORE_CTX_free(ctx);
 734    X509_STORE_CTX_free(ctx2);
 735    X509_STORE_free(store);
 736    sk_X509_free(trusted);
 737    return EXPECT_RESULT();
 738}
 739
 740static int test_wolfSSL_X509_STORE_CTX_ex10(X509_STORE_test_data *testData)
 741{
 742    EXPECT_DECLS;
 743    X509_STORE* store = NULL;
 744    X509_STORE_CTX* ctx = NULL;
 745    STACK_OF(X509)* chain = NULL;
 746
 747    /* Test case 10, ensure partial chain flag works */
 748    ExpectNotNull(store = X509_STORE_new());
 749    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt), 1);
 750    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt2), 1);
 751    ExpectNotNull(ctx = X509_STORE_CTX_new());
 752    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, testData->x509Leaf, NULL), 1);
 753    /* Fails because chain is incomplete */
 754    ExpectIntNE(X509_verify_cert(ctx), 1);
 755    ExpectIntEQ(X509_STORE_set_flags(store, X509_V_FLAG_PARTIAL_CHAIN), 1);
 756    /* Partial chain now OK */
 757    ExpectIntEQ(X509_verify_cert(ctx), 1);
 758    ExpectNotNull(chain = X509_STORE_CTX_get_chain(ctx));
 759    X509_STORE_CTX_free(ctx);
 760    X509_STORE_free(store);
 761    return EXPECT_RESULT();
 762}
 763
 764static int test_wolfSSL_X509_STORE_CTX_ex11(X509_STORE_test_data *testData)
 765{
 766    EXPECT_DECLS;
 767    X509_STORE* store = NULL;
 768    X509_STORE_CTX* ctx = NULL;
 769    STACK_OF(X509)* chain = NULL;
 770
 771    /* Test case 11, test partial chain flag on ctx itself */
 772    ExpectNotNull(store = X509_STORE_new());
 773    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt), 1);
 774    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt2), 1);
 775    ExpectNotNull(ctx = X509_STORE_CTX_new());
 776    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, testData->x509Leaf, NULL), 1);
 777    /* Fails because chain is incomplete */
 778    ExpectIntNE(X509_verify_cert(ctx), 1);
 779    X509_STORE_CTX_set_flags(ctx, X509_V_FLAG_PARTIAL_CHAIN);
 780    /* Partial chain now OK */
 781    ExpectIntEQ(X509_verify_cert(ctx), 1);
 782    ExpectNotNull(chain = X509_STORE_CTX_get_chain(ctx));
 783    X509_STORE_CTX_free(ctx);
 784    X509_STORE_free(store);
 785    return EXPECT_RESULT();
 786}
 787
 788static int test_wolfSSL_X509_STORE_CTX_ex_partial_chain_neg(
 789    X509_STORE_test_data *testData)
 790{
 791    EXPECT_DECLS;
 792    X509_STORE* store = NULL;
 793    X509_STORE_CTX* ctx = NULL;
 794    STACK_OF(X509)* untrusted = NULL;
 795
 796    /* Negative partial-chain test: with X509_V_FLAG_PARTIAL_CHAIN set, the
 797     * intermediates are supplied ONLY as untrusted (passed through the
 798     * X509_STORE_CTX_init "chain" argument and never added to the store).
 799     * No certificate in the chain is in the store, so verification must
 800     * fail.  Pre-fix, wolfSSL_X509_verify_cert would incorrectly accept
 801     * this chain because its partial-chain fallback only checked that some
 802     * intermediate had been temporarily loaded into the CertManager, not
 803     * that any chain certificate was actually trusted. */
 804    ExpectNotNull(store = X509_STORE_new());
 805    /* Intentionally do NOT add x509CaInt, x509CaInt2, or x509Ca. */
 806    ExpectIntEQ(X509_STORE_set_flags(store, X509_V_FLAG_PARTIAL_CHAIN), 1);
 807
 808    ExpectNotNull(untrusted = sk_X509_new_null());
 809    ExpectIntGT(sk_X509_push(untrusted, testData->x509CaInt2), 0);
 810    ExpectIntGT(sk_X509_push(untrusted, testData->x509CaInt), 0);
 811
 812    ExpectNotNull(ctx = X509_STORE_CTX_new());
 813    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, testData->x509Leaf, untrusted),
 814        1);
 815    /* Must NOT verify: partial-chain does not relax the trust requirement. */
 816    ExpectIntNE(X509_verify_cert(ctx), 1);
 817    /* Verify the failure is specifically due to missing trust anchor, not
 818     * some unrelated error. */
 819    ExpectIntEQ(X509_STORE_CTX_get_error(ctx),
 820        X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY);
 821
 822    X509_STORE_CTX_free(ctx);
 823    X509_STORE_free(store);
 824    sk_X509_free(untrusted);
 825    return EXPECT_RESULT();
 826}
 827
 828static int test_wolfSSL_X509_STORE_CTX_ex_partial_chain_mixed(
 829    X509_STORE_test_data *testData)
 830{
 831    EXPECT_DECLS;
 832    X509_STORE* store = NULL;
 833    X509_STORE_CTX* ctx = NULL;
 834    STACK_OF(X509)* untrusted = NULL;
 835
 836    /* Mixed trusted-store + untrusted-chain partial-chain test: the store
 837     * trusts an intermediate (x509CaInt2, the leaf's direct issuer), while
 838     * an additional intermediate (x509CaInt) is supplied only as untrusted
 839     * via the chain argument.  With X509_V_FLAG_PARTIAL_CHAIN, verification
 840     * must succeed by terminating at the trusted intermediate.  This test
 841     * exercises the snapshot-based trust check in X509StoreCertIsTrusted:
 842     * the untrusted intermediate injected during verification must not be
 843     * treated as a trust anchor, but the intermediate already in the store
 844     * must be. */
 845    ExpectNotNull(store = X509_STORE_new());
 846    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509CaInt2), 1);
 847    ExpectIntEQ(X509_STORE_set_flags(store, X509_V_FLAG_PARTIAL_CHAIN), 1);
 848
 849    ExpectNotNull(untrusted = sk_X509_new_null());
 850    ExpectIntGT(sk_X509_push(untrusted, testData->x509CaInt), 0);
 851
 852    ExpectNotNull(ctx = X509_STORE_CTX_new());
 853    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, testData->x509Leaf, untrusted),
 854        1);
 855    /* Must verify: chain terminates at trusted intermediate in the store. */
 856    ExpectIntEQ(X509_verify_cert(ctx), 1);
 857    ExpectIntEQ(X509_STORE_CTX_get_error(ctx), X509_V_OK);
 858
 859    X509_STORE_CTX_free(ctx);
 860    X509_STORE_free(store);
 861    sk_X509_free(untrusted);
 862    return EXPECT_RESULT();
 863}
 864
 865static int test_wolfSSL_X509_STORE_CTX_ex_partial_chain_untrusted_terminal(
 866    X509_STORE_test_data *testData)
 867{
 868    EXPECT_DECLS;
 869    X509_STORE* store = NULL;
 870    X509_STORE_CTX* ctx = NULL;
 871    STACK_OF(X509)* untrusted = NULL;
 872
 873    /* Partial-chain boundary test: the store trusts a CA (x509Ca) that is
 874     * NOT reachable from the leaf given the supplied untrusted intermediates,
 875     * and an untrusted intermediate (x509CaInt2) IS the terminal of the
 876     * (truncated) chain.  With X509_V_FLAG_PARTIAL_CHAIN set, verification
 877     * must FAIL because the chain terminates at an untrusted certificate.
 878     *
 879     * This test specifically targets the snapshot-based trust check in
 880     * X509StoreCertIsTrusted.  Before addAllButSelfSigned injects
 881     * x509CaInt2, origTrustedSk is snapshotted from the caller-trusted set
 882     * and contains only x509Ca.  When the chain terminates at x509CaInt2,
 883     * the trust check consults origTrustedSk (not the mutated working
 884     * stack) and correctly finds no match.  A regression that consulted
 885     * the post-injection working stack instead of the snapshot would
 886     * incorrectly mark x509CaInt2 as trusted and cause verification to
 887     * succeed. */
 888    ExpectNotNull(store = X509_STORE_new());
 889    ExpectIntEQ(X509_STORE_add_cert(store, testData->x509Ca), 1);
 890    ExpectIntEQ(X509_STORE_set_flags(store, X509_V_FLAG_PARTIAL_CHAIN), 1);
 891
 892    /* Only x509CaInt2 supplied as untrusted; x509CaInt is intentionally
 893     * withheld so the chain cannot actually reach the trusted x509Ca. */
 894    ExpectNotNull(untrusted = sk_X509_new_null());
 895    ExpectIntGT(sk_X509_push(untrusted, testData->x509CaInt2), 0);
 896
 897    ExpectNotNull(ctx = X509_STORE_CTX_new());
 898    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, testData->x509Leaf, untrusted),
 899        1);
 900    /* Must NOT verify: the chain terminal (x509CaInt2) is not in the
 901     * original trust set, even though the store is non-empty. */
 902    ExpectIntNE(X509_verify_cert(ctx), 1);
 903    ExpectIntEQ(X509_STORE_CTX_get_error(ctx),
 904        X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY);
 905
 906    X509_STORE_CTX_free(ctx);
 907    X509_STORE_free(store);
 908    sk_X509_free(untrusted);
 909    return EXPECT_RESULT();
 910}
 911
 912#ifdef HAVE_ECC
 913static int test_wolfSSL_X509_STORE_CTX_ex12(void)
 914{
 915    EXPECT_DECLS;
 916    X509_STORE* store = NULL;
 917    X509_STORE_CTX* ctx = NULL;
 918    STACK_OF(X509)* chain = NULL;
 919    X509* rootEccX509 = NULL;
 920    X509* badAkiX509 = NULL;
 921    X509* ca1X509 = NULL;
 922
 923    const char* intCARootECCFile   = "./certs/ca-ecc-cert.pem";
 924    const char* intCA1ECCFile      = "./certs/intermediate/ca-int-ecc-cert.pem";
 925    const char* intCABadAKIECCFile = "./certs/intermediate/ca-ecc-bad-aki.pem";
 926
 927    /* Test case 12, multiple CAs with the same SKI including 1 with
 928       intentionally bad/unregistered AKI.  x509_verify_cert should still form a
 929       valid chain using the valid CA, ignoring the bad CA. Developed from
 930       customer provided reproducer. */
 931
 932    ExpectNotNull(store = X509_STORE_new());
 933    ExpectNotNull(rootEccX509 = test_wolfSSL_X509_STORE_CTX_ex_helper(
 934        intCARootECCFile));
 935    ExpectIntEQ(X509_STORE_add_cert(store, rootEccX509), 1);
 936    ExpectNotNull(badAkiX509 = test_wolfSSL_X509_STORE_CTX_ex_helper(
 937        intCABadAKIECCFile));
 938    ExpectNotNull(ctx = X509_STORE_CTX_new());
 939    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, badAkiX509, NULL), 1);
 940    ExpectIntEQ(X509_verify_cert(ctx), 0);
 941    X509_STORE_CTX_cleanup(ctx);
 942
 943    ExpectIntEQ(X509_STORE_add_cert(store, badAkiX509), 1);
 944    ExpectNotNull(ca1X509 = test_wolfSSL_X509_STORE_CTX_ex_helper(
 945        intCA1ECCFile));
 946    ExpectIntEQ(X509_STORE_CTX_init(ctx, store, ca1X509, NULL), 1);
 947    ExpectIntEQ(X509_verify_cert(ctx), 1);
 948    ExpectNotNull(chain = X509_STORE_CTX_get_chain(ctx));
 949
 950    X509_STORE_CTX_free(ctx);
 951    X509_STORE_free(store);
 952    X509_free(rootEccX509);
 953    X509_free(badAkiX509);
 954    X509_free(ca1X509);
 955    return EXPECT_RESULT();
 956}
 957#endif
 958#endif
 959
 960int test_wolfSSL_X509_STORE_CTX_ex(void)
 961{
 962    EXPECT_DECLS;
 963#if defined(OPENSSL_EXTRA) && !defined(NO_CERTS) && \
 964   !defined(NO_FILESYSTEM) && !defined(NO_RSA)
 965    X509_STORE_test_data testData;
 966    XMEMSET((void *)&testData, 0, sizeof(X509_STORE_test_data));
 967    testData.caFile =     "./certs/ca-cert.pem";
 968    testData.caIntFile =  "./certs/intermediate/ca-int-cert.pem";
 969    testData.caInt2File = "./certs/intermediate/ca-int2-cert.pem";
 970    testData.leafFile =   "./certs/intermediate/server-chain.pem";
 971
 972    ExpectNotNull(testData.x509Ca = \
 973                  test_wolfSSL_X509_STORE_CTX_ex_helper(testData.caFile));
 974    ExpectNotNull(testData.x509CaInt = \
 975                  test_wolfSSL_X509_STORE_CTX_ex_helper(testData.caIntFile));
 976    ExpectNotNull(testData.x509CaInt2 = \
 977                  test_wolfSSL_X509_STORE_CTX_ex_helper(testData.caInt2File));
 978    ExpectNotNull(testData.x509Leaf = \
 979                  test_wolfSSL_X509_STORE_CTX_ex_helper(testData.leafFile));
 980    ExpectNotNull(testData.expectedChain = sk_X509_new_null());
 981    ExpectIntGE(sk_X509_push(testData.expectedChain, testData.x509Leaf), 1);
 982    ExpectIntGE(sk_X509_push(testData.expectedChain, testData.x509CaInt2), 1);
 983    ExpectIntGE(sk_X509_push(testData.expectedChain, testData.x509CaInt), 1);
 984    ExpectIntGE(sk_X509_push(testData.expectedChain, testData.x509Ca), 1);
 985
 986    ExpectIntEQ(test_wolfSSL_X509_STORE_CTX_ex1(&testData), 1);
 987    ExpectIntEQ(test_wolfSSL_X509_STORE_CTX_ex2(&testData), 1);
 988    ExpectIntEQ(test_wolfSSL_X509_STORE_CTX_ex3(&testData), 1);
 989    ExpectIntEQ(test_wolfSSL_X509_STORE_CTX_ex4(&testData), 1);
 990    ExpectIntEQ(test_wolfSSL_X509_STORE_CTX_ex5(&testData), 1);
 991    ExpectIntEQ(test_wolfSSL_X509_STORE_CTX_ex6(&testData), 1);
 992    ExpectIntEQ(test_wolfSSL_X509_STORE_CTX_ex7(&testData), 1);
 993    ExpectIntEQ(test_wolfSSL_X509_STORE_CTX_ex8(&testData), 1);
 994    ExpectIntEQ(test_wolfSSL_X509_STORE_CTX_ex9(&testData), 1);
 995    ExpectIntEQ(test_wolfSSL_X509_STORE_CTX_ex10(&testData), 1);
 996    ExpectIntEQ(test_wolfSSL_X509_STORE_CTX_ex11(&testData), 1);
 997    ExpectIntEQ(test_wolfSSL_X509_STORE_CTX_ex_partial_chain_neg(&testData), 1);
 998    ExpectIntEQ(test_wolfSSL_X509_STORE_CTX_ex_partial_chain_mixed(&testData),
 999        1);
1000    ExpectIntEQ(
1001        test_wolfSSL_X509_STORE_CTX_ex_partial_chain_untrusted_terminal(
1002            &testData), 1);
1003#ifdef HAVE_ECC
1004    ExpectIntEQ(test_wolfSSL_X509_STORE_CTX_ex12(), 1);
1005#endif
1006
1007    if(testData.x509Ca) {
1008        X509_free(testData.x509Ca);
1009    }
1010    if(testData.x509CaInt) {
1011        X509_free(testData.x509CaInt);
1012    }
1013    if(testData.x509CaInt2) {
1014        X509_free(testData.x509CaInt2);
1015    }
1016    if(testData.x509Leaf) {
1017        X509_free(testData.x509Leaf);
1018    }
1019    if (testData.expectedChain) {
1020        sk_X509_free(testData.expectedChain);
1021    }
1022
1023#endif /* defined(OPENSSL_EXTRA) && !defined(NO_CERTS) && \
1024        * !defined(NO_FILESYSTEM) && !defined(NO_RSA) */
1025
1026    return EXPECT_RESULT();
1027}
1028
1029#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && !defined(NO_FILESYSTEM)
1030static int test_X509_STORE_untrusted_load_cert_to_stack(const char* filename,
1031        STACK_OF(X509)* chain)
1032{
1033    EXPECT_DECLS;
1034    XFILE fp = XBADFILE;
1035    X509* cert = NULL;
1036
1037    ExpectTrue((fp = XFOPEN(filename, "rb"))
1038            != XBADFILE);
1039    ExpectNotNull(cert = PEM_read_X509(fp, 0, 0, 0 ));
1040    if (fp != XBADFILE) {
1041        XFCLOSE(fp);
1042        fp = XBADFILE;
1043    }
1044    ExpectIntGT(sk_X509_push(chain, cert), 0);
1045    if (EXPECT_FAIL())
1046        X509_free(cert);
1047
1048    return EXPECT_RESULT();
1049}
1050
1051static int test_X509_STORE_untrusted_certs(const char** filenames, int ret,
1052        int err, int loadCA)
1053{
1054    EXPECT_DECLS;
1055    X509_STORE_CTX* ctx = NULL;
1056    X509_STORE* str = NULL;
1057    XFILE fp = XBADFILE;
1058    X509* cert = NULL;
1059    STACK_OF(X509)* untrusted = NULL;
1060
1061    ExpectTrue((fp = XFOPEN("./certs/intermediate/server-int-cert.pem", "rb"))
1062            != XBADFILE);
1063    ExpectNotNull(cert = PEM_read_X509(fp, 0, 0, 0 ));
1064    if (fp != XBADFILE) {
1065        XFCLOSE(fp);
1066        fp = XBADFILE;
1067    }
1068
1069    ExpectNotNull(str = X509_STORE_new());
1070    ExpectNotNull(ctx = X509_STORE_CTX_new());
1071    ExpectNotNull(untrusted = sk_X509_new_null());
1072
1073    ExpectIntEQ(X509_STORE_set_flags(str, 0), 1);
1074    if (loadCA) {
1075        ExpectIntEQ(X509_STORE_load_locations(str, "./certs/ca-cert.pem", NULL),
1076                1);
1077    }
1078    for (; *filenames; filenames++) {
1079        ExpectIntEQ(test_X509_STORE_untrusted_load_cert_to_stack(*filenames,
1080                untrusted), TEST_SUCCESS);
1081    }
1082
1083    ExpectIntEQ(X509_STORE_CTX_init(ctx, str, cert, untrusted), 1);
1084    ExpectIntEQ(X509_verify_cert(ctx), ret);
1085    ExpectIntEQ(X509_STORE_CTX_get_error(ctx), err);
1086
1087    X509_free(cert);
1088    X509_STORE_free(str);
1089    X509_STORE_CTX_free(ctx);
1090    sk_X509_pop_free(untrusted, NULL);
1091
1092    return EXPECT_RESULT();
1093}
1094#endif
1095
1096int test_X509_STORE_untrusted(void)
1097{
1098    EXPECT_DECLS;
1099#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && !defined(NO_FILESYSTEM)
1100    const char* untrusted1[] = {
1101        "./certs/intermediate/ca-int2-cert.pem",
1102        NULL
1103    };
1104    const char* untrusted2[] = {
1105        "./certs/intermediate/ca-int-cert.pem",
1106        "./certs/intermediate/ca-int2-cert.pem",
1107        NULL
1108    };
1109    const char* untrusted3[] = {
1110        "./certs/intermediate/ca-int-cert.pem",
1111        "./certs/intermediate/ca-int2-cert.pem",
1112        "./certs/ca-cert.pem",
1113        NULL
1114    };
1115    /* Adding unrelated certs that should be ignored */
1116    const char* untrusted4[] = {
1117        "./certs/client-ca.pem",
1118        "./certs/intermediate/ca-int-cert.pem",
1119        "./certs/server-cert.pem",
1120        "./certs/intermediate/ca-int2-cert.pem",
1121        NULL
1122    };
1123
1124    /* Only immediate issuer in untrusted chain. Fails since can't build chain
1125     * to loaded CA. */
1126    ExpectIntEQ(test_X509_STORE_untrusted_certs(untrusted1, 0,
1127            X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY, 1), TEST_SUCCESS);
1128    /* Succeeds because path to loaded CA is available. */
1129    ExpectIntEQ(test_X509_STORE_untrusted_certs(untrusted2, 1, 0, 1),
1130            TEST_SUCCESS);
1131    /* Root CA in untrusted chain is OK so long as CA has been loaded
1132     * properly */
1133    ExpectIntEQ(test_X509_STORE_untrusted_certs(untrusted3, 1, 0, 1),
1134            TEST_SUCCESS);
1135    /* Still needs properly loaded CA, while including it in untrusted
1136     * list is not an error, it also doesn't count for verify */
1137    ExpectIntEQ(test_X509_STORE_untrusted_certs(untrusted3, 0,
1138                X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY, 0),
1139            TEST_SUCCESS);
1140    /* Succeeds because path to loaded CA is available. */
1141    ExpectIntEQ(test_X509_STORE_untrusted_certs(untrusted4, 1, 0, 1),
1142            TEST_SUCCESS);
1143#endif
1144    return EXPECT_RESULT();
1145}
1146
1147#if defined(OPENSSL_ALL) && !defined(NO_RSA) && !defined(NO_FILESYSTEM) && \
1148    !defined(WOLFSSL_X509_STORE_ALLOW_NON_CA_INTERMEDIATE)
1149
1150static int last_errcode;
1151static int last_errdepth;
1152
1153static int X509Callback(int ok, X509_STORE_CTX *ctx)
1154{
1155
1156    if (!ok) {
1157        last_errcode  = X509_STORE_CTX_get_error(ctx);
1158        last_errdepth = X509_STORE_CTX_get_error_depth(ctx);
1159    }
1160    /* Always return OK to allow verification to continue.*/
1161    return 1;
1162}
1163
1164#endif
1165
1166int test_X509_STORE_InvalidCa(void)
1167{
1168    EXPECT_DECLS;
1169#if defined(OPENSSL_ALL) && !defined(NO_RSA) && !defined(NO_FILESYSTEM) && \
1170    !defined(WOLFSSL_X509_STORE_ALLOW_NON_CA_INTERMEDIATE)
1171    const char* filename = "./certs/intermediate/ca_false_intermediate/"
1172                                                    "test_int_not_cacert.pem";
1173    const char* srvfile = "./certs/intermediate/ca_false_intermediate/"
1174                                            "test_sign_bynoca_srv.pem";
1175    X509_STORE_CTX* ctx = NULL;
1176    X509_STORE* str = NULL;
1177    XFILE fp = XBADFILE;
1178    X509* cert = NULL;
1179    STACK_OF(X509)* untrusted = NULL;
1180
1181    last_errcode = 0;
1182    last_errdepth = 0;
1183
1184    ExpectTrue((fp = XFOPEN(srvfile, "rb"))
1185            != XBADFILE);
1186    ExpectNotNull(cert = PEM_read_X509(fp, 0, 0, 0 ));
1187    if (fp != XBADFILE) {
1188        XFCLOSE(fp);
1189        fp = XBADFILE;
1190    }
1191
1192    ExpectNotNull(str = X509_STORE_new());
1193    ExpectNotNull(ctx = X509_STORE_CTX_new());
1194    ExpectNotNull(untrusted = sk_X509_new_null());
1195
1196    /* create cert chain stack */
1197    ExpectIntEQ(test_X509_STORE_untrusted_load_cert_to_stack(filename,
1198                untrusted), TEST_SUCCESS);
1199
1200    X509_STORE_set_verify_cb(str, X509Callback);
1201
1202    ExpectIntEQ(X509_STORE_load_locations(str,
1203                "./certs/intermediate/ca_false_intermediate/test_ca.pem",
1204                                                                    NULL), 1);
1205
1206    ExpectIntEQ(X509_STORE_CTX_init(ctx, str, cert, untrusted), 1);
1207    ExpectIntEQ(X509_verify_cert(ctx), 1);
1208    ExpectIntEQ(last_errcode, X509_V_ERR_INVALID_CA);
1209    (void)last_errdepth;
1210    /* Defense in depth: ctx->error must not be clobbered back to X509_V_OK
1211     * by the later successful verification of the intermediate against the
1212     * trusted root.  The worst-seen error must persist. */
1213    ExpectIntEQ(X509_STORE_CTX_get_error(ctx), X509_V_ERR_INVALID_CA);
1214
1215    X509_free(cert);
1216    X509_STORE_free(str);
1217    X509_STORE_CTX_free(ctx);
1218    sk_X509_pop_free(untrusted, NULL);
1219#endif
1220    return EXPECT_RESULT();
1221}
1222
1223int test_X509_STORE_InvalidCa_NoCallback(void)
1224{
1225    EXPECT_DECLS;
1226#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && !defined(NO_FILESYSTEM) && \
1227    !defined(WOLFSSL_X509_STORE_ALLOW_NON_CA_INTERMEDIATE)
1228    const char* filename = "./certs/intermediate/ca_false_intermediate/"
1229                                                    "test_int_not_cacert.pem";
1230    const char* srvfile = "./certs/intermediate/ca_false_intermediate/"
1231                                            "test_sign_bynoca_srv.pem";
1232    X509_STORE_CTX* ctx = NULL;
1233    X509_STORE* str = NULL;
1234    XFILE fp = XBADFILE;
1235    X509* cert = NULL;
1236    STACK_OF(X509)* untrusted = NULL;
1237
1238    ExpectTrue((fp = XFOPEN(srvfile, "rb"))
1239            != XBADFILE);
1240    ExpectNotNull(cert = PEM_read_X509(fp, 0, 0, 0 ));
1241    if (fp != XBADFILE) {
1242        XFCLOSE(fp);
1243        fp = XBADFILE;
1244    }
1245
1246    ExpectNotNull(str = X509_STORE_new());
1247    ExpectNotNull(ctx = X509_STORE_CTX_new());
1248    ExpectNotNull(untrusted = sk_X509_new_null());
1249
1250    /* Create cert chain stack with an intermediate that is CA:FALSE. */
1251    ExpectIntEQ(test_X509_STORE_untrusted_load_cert_to_stack(filename,
1252                untrusted), TEST_SUCCESS);
1253
1254    ExpectIntEQ(X509_STORE_load_locations(str,
1255                "./certs/intermediate/ca_false_intermediate/test_ca.pem",
1256                                                                    NULL), 1);
1257    ExpectIntEQ(X509_STORE_CTX_init(ctx, str, cert, untrusted), 1);
1258    /* No verify callback: verification must fail on CA:FALSE issuer. */
1259    ExpectIntNE(X509_verify_cert(ctx), 1);
1260    ExpectIntEQ(X509_STORE_CTX_get_error(ctx), X509_V_ERR_INVALID_CA);
1261
1262    X509_free(cert);
1263    X509_STORE_free(str);
1264    X509_STORE_CTX_free(ctx);
1265    sk_X509_pop_free(untrusted, NULL);
1266#endif
1267    return EXPECT_RESULT();
1268}
1269
1270int test_wolfSSL_X509_STORE_CTX_trusted_stack_cleanup(void)
1271{
1272    int res = TEST_SKIPPED;
1273#if defined(OPENSSL_EXTRA)
1274    X509_STORE_CTX_cleanup(NULL);
1275    X509_STORE_CTX_trusted_stack(NULL, NULL);
1276
1277    res = TEST_SUCCESS;
1278#endif
1279    return res;
1280}
1281
1282int test_wolfSSL_X509_STORE_CTX_get_issuer(void)
1283{
1284    EXPECT_DECLS;
1285#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && !defined(NO_FILESYSTEM)
1286    X509_STORE_CTX* ctx = NULL;
1287    X509_STORE* str = NULL;
1288    X509* x509Ca = NULL;
1289    X509* x509Svr = NULL;
1290    X509* issuer = NULL;
1291    X509_NAME* caName = NULL;
1292    X509_NAME* issuerName = NULL;
1293
1294    ExpectNotNull(ctx = X509_STORE_CTX_new());
1295    ExpectNotNull((str = wolfSSL_X509_STORE_new()));
1296    ExpectNotNull((x509Ca =
1297            wolfSSL_X509_load_certificate_file(caCertFile, SSL_FILETYPE_PEM)));
1298    ExpectIntEQ(X509_STORE_add_cert(str, x509Ca), SSL_SUCCESS);
1299    ExpectNotNull((x509Svr =
1300            wolfSSL_X509_load_certificate_file(svrCertFile, SSL_FILETYPE_PEM)));
1301
1302    ExpectIntEQ(X509_STORE_CTX_init(ctx, str, x509Svr, NULL), SSL_SUCCESS);
1303
1304    /* Issuer0 is not set until chain is built for verification */
1305    ExpectNull(X509_STORE_CTX_get0_current_issuer(NULL));
1306    ExpectNull(issuer = X509_STORE_CTX_get0_current_issuer(ctx));
1307
1308    /* Issuer1 will use the store to make a new issuer */
1309    ExpectIntEQ(X509_STORE_CTX_get1_issuer(&issuer, ctx, x509Svr), 1);
1310    ExpectNotNull(issuer);
1311    X509_free(issuer);
1312
1313    ExpectIntEQ(X509_verify_cert(ctx), 1);
1314    ExpectNotNull(issuer = X509_STORE_CTX_get0_current_issuer(ctx));
1315    ExpectNotNull(caName = X509_get_subject_name(x509Ca));
1316    ExpectNotNull(issuerName = X509_get_subject_name(issuer));
1317#ifdef WOLFSSL_SIGNER_DER_CERT
1318    ExpectIntEQ(X509_NAME_cmp(caName, issuerName), 0);
1319#endif
1320
1321    X509_STORE_CTX_free(ctx);
1322    X509_free(x509Svr);
1323    X509_STORE_free(str);
1324    X509_free(x509Ca);
1325#endif
1326    return EXPECT_RESULT();
1327}
1328
1329int test_wolfSSL_X509_STORE_set_flags(void)
1330{
1331    EXPECT_DECLS;
1332#if defined(OPENSSL_EXTRA) && !defined(NO_CERTS) && \
1333   !defined(NO_FILESYSTEM) && !defined(NO_RSA)
1334    X509_STORE* store = NULL;
1335    X509* x509 = NULL;
1336
1337    ExpectNotNull((store = wolfSSL_X509_STORE_new()));
1338    ExpectNotNull((x509 = wolfSSL_X509_load_certificate_file(svrCertFile,
1339        WOLFSSL_FILETYPE_PEM)));
1340    ExpectIntEQ(X509_STORE_add_cert(store, x509), WOLFSSL_SUCCESS);
1341
1342#ifdef HAVE_CRL
1343    ExpectIntEQ(X509_STORE_set_flags(store, WOLFSSL_CRL_CHECKALL),
1344        WOLFSSL_SUCCESS);
1345#else
1346    ExpectIntEQ(X509_STORE_set_flags(store, WOLFSSL_CRL_CHECKALL),
1347        WC_NO_ERR_TRACE(NOT_COMPILED_IN));
1348#endif
1349
1350    wolfSSL_X509_free(x509);
1351    wolfSSL_X509_STORE_free(store);
1352#endif /* defined(OPENSSL_EXTRA) && !defined(NO_CERTS) &&
1353        * !defined(NO_FILESYSTEM) && !defined(NO_RSA) */
1354    return EXPECT_RESULT();
1355}
1356
1357int test_wolfSSL_X509_STORE(void)
1358{
1359    EXPECT_DECLS;
1360#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && !defined(NO_TLS) && \
1361    !defined(NO_FILESYSTEM)
1362    X509_STORE *store = NULL;
1363
1364#ifdef HAVE_CRL
1365    X509_STORE_CTX *storeCtx = NULL;
1366    X509 *ca = NULL;
1367    X509 *cert = NULL;
1368    const char srvCert[] = "./certs/server-revoked-cert.pem";
1369    const char caCert[] = "./certs/ca-cert.pem";
1370#ifndef WOLFSSL_CRL_ALLOW_MISSING_CDP
1371    X509_CRL *crl = NULL;
1372    const char crlPem[] = "./certs/crl/crl.revoked";
1373    XFILE fp = XBADFILE;
1374#endif /* !WOLFSSL_CRL_ALLOW_MISSING_CDP */
1375
1376    ExpectNotNull(store = (X509_STORE *)X509_STORE_new());
1377    ExpectNotNull((ca = wolfSSL_X509_load_certificate_file(caCert,
1378                           SSL_FILETYPE_PEM)));
1379    ExpectIntEQ(X509_STORE_add_cert(store, ca), SSL_SUCCESS);
1380    ExpectNotNull((cert = wolfSSL_X509_load_certificate_file(srvCert,
1381                    SSL_FILETYPE_PEM)));
1382    ExpectNotNull((storeCtx = X509_STORE_CTX_new()));
1383    ExpectIntEQ(X509_STORE_CTX_init(storeCtx, store, cert, NULL), SSL_SUCCESS);
1384    ExpectIntEQ(X509_verify_cert(storeCtx), SSL_SUCCESS);
1385    X509_STORE_free(store);
1386    store = NULL;
1387    X509_STORE_CTX_free(storeCtx);
1388    storeCtx = NULL;
1389    X509_free(cert);
1390    cert = NULL;
1391    X509_free(ca);
1392    ca = NULL;
1393
1394#ifndef WOLFSSL_CRL_ALLOW_MISSING_CDP
1395    /* should fail to verify now after adding in CRL */
1396    ExpectNotNull(store = (X509_STORE *)X509_STORE_new());
1397    ExpectNotNull((ca = wolfSSL_X509_load_certificate_file(caCert,
1398                           SSL_FILETYPE_PEM)));
1399    ExpectIntEQ(X509_STORE_add_cert(store, ca), SSL_SUCCESS);
1400    ExpectTrue((fp = XFOPEN(crlPem, "rb")) != XBADFILE);
1401    ExpectNotNull(crl = (X509_CRL *)PEM_read_X509_CRL(fp, (X509_CRL **)NULL,
1402                NULL, NULL));
1403    if (fp != XBADFILE)
1404        XFCLOSE(fp);
1405    ExpectIntEQ(X509_STORE_add_crl(store, crl), SSL_SUCCESS);
1406    ExpectIntEQ(X509_STORE_set_flags(store, X509_V_FLAG_CRL_CHECK),SSL_SUCCESS);
1407    ExpectNotNull((storeCtx = X509_STORE_CTX_new()));
1408    ExpectNotNull((cert = wolfSSL_X509_load_certificate_file(srvCert,
1409                    SSL_FILETYPE_PEM)));
1410    ExpectIntEQ(X509_STORE_CTX_init(storeCtx, store, cert, NULL), SSL_SUCCESS);
1411    ExpectIntNE(X509_verify_cert(storeCtx), SSL_SUCCESS);
1412    ExpectIntEQ(X509_STORE_CTX_get_error(storeCtx),
1413                WOLFSSL_X509_V_ERR_CERT_REVOKED);
1414    X509_CRL_free(crl);
1415    crl = NULL;
1416    X509_STORE_free(store);
1417    store = NULL;
1418    X509_STORE_CTX_free(storeCtx);
1419    storeCtx = NULL;
1420    X509_free(cert);
1421    cert = NULL;
1422    X509_free(ca);
1423    ca = NULL;
1424#endif /* !WOLFSSL_CRL_ALLOW_MISSING_CDP */
1425#endif /* HAVE_CRL */
1426
1427#if !defined(WOLFCRYPT_ONLY) && !defined(NO_FILESYSTEM)
1428    {
1429    #if !defined(NO_WOLFSSL_CLIENT) || !defined(NO_WOLFSSL_SERVER)
1430        SSL_CTX* ctx = NULL;
1431        SSL* ssl = NULL;
1432        int i;
1433        for (i = 0; i < 2; i++) {
1434        #ifndef NO_WOLFSSL_SERVER
1435            ExpectNotNull(ctx = SSL_CTX_new(wolfSSLv23_server_method()));
1436        #else
1437            ExpectNotNull(ctx = SSL_CTX_new(wolfSSLv23_client_method()));
1438        #endif
1439            ExpectNotNull(store = (X509_STORE *)X509_STORE_new());
1440            SSL_CTX_set_cert_store(ctx, store);
1441            ExpectNotNull(store = (X509_STORE *)X509_STORE_new());
1442            SSL_CTX_set_cert_store(ctx, store);
1443            ExpectNotNull(store = (X509_STORE *)X509_STORE_new());
1444            ExpectIntEQ(SSL_CTX_use_certificate_file(ctx, svrCertFile,
1445                    SSL_FILETYPE_PEM), SSL_SUCCESS);
1446            ExpectIntEQ(SSL_CTX_use_PrivateKey_file(ctx, svrKeyFile,
1447                    SSL_FILETYPE_PEM), SSL_SUCCESS);
1448            ExpectNotNull(ssl = SSL_new(ctx));
1449            if (i == 0) {
1450                ExpectIntEQ(SSL_set0_verify_cert_store(ssl, store),
1451                    SSL_SUCCESS);
1452            }
1453            else {
1454                ExpectIntEQ(SSL_set1_verify_cert_store(ssl, store),
1455                    SSL_SUCCESS);
1456                #ifdef OPENSSL_ALL
1457                ExpectIntEQ(SSL_CTX_set1_verify_cert_store(ctx, store),
1458                    SSL_SUCCESS);
1459                #endif
1460            }
1461            if (EXPECT_FAIL() || (i == 1)) {
1462                X509_STORE_free(store);
1463                store = NULL;
1464            }
1465            SSL_free(ssl);
1466            ssl = NULL;
1467            SSL_CTX_free(ctx);
1468            ctx = NULL;
1469        }
1470    #endif /* !NO_WOLFSSL_CLIENT || !NO_WOLFSSL_SERVER */
1471    }
1472#endif
1473#endif
1474    return EXPECT_RESULT();
1475}
1476
1477int test_wolfSSL_X509_STORE_load_locations(void)
1478{
1479    EXPECT_DECLS;
1480#if (defined(OPENSSL_ALL) || defined(WOLFSSL_APACHE_HTTPD)) && \
1481    !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR) && !defined(NO_RSA) && \
1482    !defined(NO_TLS)
1483    SSL_CTX *ctx = NULL;
1484    X509_STORE *store = NULL;
1485
1486    const char ca_file[] = "./certs/ca-cert.pem";
1487    const char client_pem_file[] = "./certs/client-cert.pem";
1488    const char client_der_file[] = "./certs/client-cert.der";
1489    const char ecc_file[] = "./certs/ecc-key.pem";
1490    const char certs_path[] = "./certs/";
1491    const char bad_path[] = "./bad-path/";
1492#ifdef HAVE_CRL
1493    const char crl_path[] = "./certs/crl/";
1494    const char crl_file[] = "./certs/crl/crl.pem";
1495#endif
1496
1497#ifndef NO_WOLFSSL_SERVER
1498    ExpectNotNull(ctx = SSL_CTX_new(SSLv23_server_method()));
1499#else
1500    ExpectNotNull(ctx = SSL_CTX_new(SSLv23_client_method()));
1501#endif
1502    ExpectNotNull(store = SSL_CTX_get_cert_store(ctx));
1503    ExpectIntEQ(wolfSSL_CertManagerLoadCA(store->cm, ca_file, NULL),
1504        WOLFSSL_SUCCESS);
1505
1506    /* Test bad arguments */
1507    ExpectIntEQ(X509_STORE_load_locations(NULL, ca_file, NULL),
1508        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1509    ExpectIntEQ(X509_STORE_load_locations(store, NULL, NULL),
1510        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1511    ExpectIntEQ(X509_STORE_load_locations(store, client_der_file, NULL),
1512        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1513    ExpectIntEQ(X509_STORE_load_locations(store, ecc_file, NULL),
1514        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1515    ExpectIntEQ(X509_STORE_load_locations(store, NULL, bad_path),
1516        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1517
1518#ifdef HAVE_CRL
1519    /* Test with CRL */
1520    ExpectIntEQ(X509_STORE_load_locations(store, crl_file, NULL),
1521        WOLFSSL_SUCCESS);
1522    ExpectIntEQ(X509_STORE_load_locations(store, NULL, crl_path),
1523        WOLFSSL_SUCCESS);
1524#endif
1525
1526    /* Test with CA */
1527    ExpectIntEQ(X509_STORE_load_locations(store, ca_file, NULL),
1528        WOLFSSL_SUCCESS);
1529
1530    /* Test with client_cert and certs path */
1531    ExpectIntEQ(X509_STORE_load_locations(store, client_pem_file, NULL),
1532        WOLFSSL_SUCCESS);
1533    ExpectIntEQ(X509_STORE_load_locations(store, NULL, certs_path),
1534        WOLFSSL_SUCCESS);
1535
1536#if defined(XGETENV) && !defined(NO_GETENV) && defined(_POSIX_C_SOURCE) && \
1537    _POSIX_C_SOURCE >= 200112L
1538    ExpectIntEQ(wolfSSL_CTX_UnloadCAs(ctx), WOLFSSL_SUCCESS);
1539    /* Test with env vars */
1540    ExpectIntEQ(setenv("SSL_CERT_FILE", client_pem_file, 1), 0);
1541    ExpectIntEQ(setenv("SSL_CERT_DIR", certs_path, 1), 0);
1542    ExpectIntEQ(X509_STORE_set_default_paths(store), WOLFSSL_SUCCESS);
1543#endif
1544
1545#if defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE)
1546    /* Clear nodes */
1547    ERR_clear_error();
1548#endif
1549
1550    SSL_CTX_free(ctx);
1551#endif
1552    return EXPECT_RESULT();
1553}
1554
1555int test_X509_STORE_get0_objects(void)
1556{
1557    EXPECT_DECLS;
1558#if defined(OPENSSL_ALL) && !defined(NO_FILESYSTEM) && !defined(NO_TLS) && \
1559    !defined(NO_WOLFSSL_DIR) && !defined(NO_RSA)
1560    X509_STORE *store = NULL;
1561    X509_STORE *store_cpy = NULL;
1562    SSL_CTX *ctx = NULL;
1563    X509_OBJECT *obj = NULL;
1564#ifdef HAVE_CRL
1565    X509_OBJECT *objCopy = NULL;
1566#endif
1567    STACK_OF(X509_OBJECT) *objs = NULL;
1568    STACK_OF(X509_OBJECT) *objsCopy = NULL;
1569    int i;
1570
1571    /* Setup store */
1572#ifndef NO_WOLFSSL_SERVER
1573    ExpectNotNull(ctx = SSL_CTX_new(SSLv23_server_method()));
1574#else
1575    ExpectNotNull(ctx = SSL_CTX_new(SSLv23_client_method()));
1576#endif
1577    ExpectNotNull(store_cpy = X509_STORE_new());
1578    ExpectNotNull(store = SSL_CTX_get_cert_store(ctx));
1579    ExpectIntEQ(X509_STORE_load_locations(store, cliCertFile, NULL),
1580        WOLFSSL_SUCCESS);
1581    ExpectIntEQ(X509_STORE_load_locations(store, caCertFile, NULL),
1582        WOLFSSL_SUCCESS);
1583    ExpectIntEQ(X509_STORE_load_locations(store, svrCertFile, NULL),
1584        WOLFSSL_SUCCESS);
1585#ifdef HAVE_CRL
1586    ExpectIntEQ(X509_STORE_load_locations(store, NULL, crlPemDir),
1587        WOLFSSL_SUCCESS);
1588#endif
1589    /* Store ready */
1590
1591    /* Similar to HaProxy ssl_set_cert_crl_file use case */
1592    ExpectNotNull(objs = X509_STORE_get0_objects(store));
1593#ifdef HAVE_CRL
1594#ifdef WOLFSSL_SIGNER_DER_CERT
1595    ExpectIntEQ(sk_X509_OBJECT_num(objs), 4);
1596#else
1597    ExpectIntEQ(sk_X509_OBJECT_num(objs), 1);
1598#endif
1599#else
1600#ifdef WOLFSSL_SIGNER_DER_CERT
1601    ExpectIntEQ(sk_X509_OBJECT_num(objs), 3);
1602#else
1603    ExpectIntEQ(sk_X509_OBJECT_num(objs), 0);
1604#endif
1605#endif
1606    ExpectIntEQ(sk_X509_OBJECT_num(NULL), 0);
1607    ExpectNull(sk_X509_OBJECT_value(NULL, 0));
1608    ExpectNull(sk_X509_OBJECT_value(NULL, 1));
1609    ExpectNull(sk_X509_OBJECT_value(objs, sk_X509_OBJECT_num(objs)));
1610    ExpectNull(sk_X509_OBJECT_value(objs, sk_X509_OBJECT_num(objs) + 1));
1611#ifndef NO_WOLFSSL_STUB
1612    ExpectNull(sk_X509_OBJECT_delete(objs, 0));
1613#endif
1614    ExpectNotNull(objsCopy = sk_X509_OBJECT_deep_copy(objs, NULL, NULL));
1615    ExpectIntEQ(sk_X509_OBJECT_num(objs), sk_X509_OBJECT_num(objsCopy));
1616    for (i = 0; i < sk_X509_OBJECT_num(objs) && EXPECT_SUCCESS(); i++) {
1617        obj = (X509_OBJECT*)sk_X509_OBJECT_value(objs, i);
1618    #ifdef HAVE_CRL
1619        objCopy = (X509_OBJECT*)sk_X509_OBJECT_value(objsCopy, i);
1620    #endif
1621        switch (X509_OBJECT_get_type(obj)) {
1622        case X509_LU_X509:
1623        {
1624            X509* x509 = NULL;
1625            X509_NAME *subj_name = NULL;
1626            ExpectNull(X509_OBJECT_get0_X509_CRL(NULL));
1627            ExpectNull(X509_OBJECT_get0_X509_CRL(obj));
1628            ExpectNotNull(x509 = X509_OBJECT_get0_X509(obj));
1629            ExpectIntEQ(X509_STORE_add_cert(store_cpy, x509), WOLFSSL_SUCCESS);
1630            ExpectNotNull(subj_name = X509_get_subject_name(x509));
1631            ExpectPtrEq(obj, X509_OBJECT_retrieve_by_subject(objs, X509_LU_X509,
1632                    subj_name));
1633
1634            break;
1635        }
1636        case X509_LU_CRL:
1637#ifdef HAVE_CRL
1638        {
1639            X509_CRL* crl = NULL;
1640            ExpectNull(X509_OBJECT_get0_X509(NULL));
1641            ExpectNull(X509_OBJECT_get0_X509(obj));
1642            ExpectNotNull(crl = X509_OBJECT_get0_X509_CRL(obj));
1643            ExpectIntEQ(X509_STORE_add_crl(store_cpy, crl), WOLFSSL_SUCCESS);
1644            ExpectNotNull(crl = X509_OBJECT_get0_X509_CRL(objCopy));
1645            break;
1646        }
1647#endif
1648        case X509_LU_NONE:
1649        default:
1650            Fail(("X509_OBJECT_get_type should return x509 or crl "
1651                    "(when built with crl support)"),
1652                    ("Unrecognized X509_OBJECT type or none"));
1653        }
1654    }
1655
1656    X509_STORE_free(store_cpy);
1657    SSL_CTX_free(ctx);
1658
1659    wolfSSL_sk_X509_OBJECT_free(NULL);
1660    objs = NULL;
1661    wolfSSL_sk_pop_free(objsCopy, NULL);
1662    objsCopy = NULL;
1663    ExpectNotNull(objs = wolfSSL_sk_X509_OBJECT_new());
1664    ExpectIntEQ(wolfSSL_sk_X509_OBJECT_push(NULL, NULL), WOLFSSL_FAILURE);
1665    ExpectIntEQ(wolfSSL_sk_X509_OBJECT_push(objs, NULL), WOLFSSL_FAILURE);
1666    ExpectIntEQ(wolfSSL_sk_X509_OBJECT_push(NULL, obj), WOLFSSL_FAILURE);
1667    ExpectNotNull(objsCopy = sk_X509_OBJECT_deep_copy(objs, NULL, NULL));
1668    wolfSSL_sk_X509_OBJECT_free(objsCopy);
1669    wolfSSL_sk_X509_OBJECT_free(objs);
1670#endif
1671    return EXPECT_RESULT();
1672}
1673
1674int test_wolfSSL_X509_STORE_get1_certs(void)
1675{
1676    EXPECT_DECLS;
1677#if defined(OPENSSL_EXTRA) && defined(WOLFSSL_SIGNER_DER_CERT) && \
1678    !defined(NO_FILESYSTEM) && !defined(NO_RSA)
1679    X509_STORE_CTX *storeCtx = NULL;
1680    X509_STORE *store = NULL;
1681    X509 *caX509 = NULL;
1682    X509 *svrX509 = NULL;
1683    X509_NAME *subject = NULL;
1684    WOLF_STACK_OF(WOLFSSL_X509) *certs = NULL;
1685
1686    ExpectNotNull(caX509 = X509_load_certificate_file(caCertFile,
1687        SSL_FILETYPE_PEM));
1688    ExpectNotNull((svrX509 = wolfSSL_X509_load_certificate_file(svrCertFile,
1689        SSL_FILETYPE_PEM)));
1690    ExpectNotNull(storeCtx = X509_STORE_CTX_new());
1691    ExpectNotNull(store = X509_STORE_new());
1692    ExpectNotNull(subject = X509_get_subject_name(caX509));
1693
1694    /* Errors */
1695    ExpectNull(X509_STORE_get1_certs(storeCtx, subject));
1696    ExpectNull(X509_STORE_get1_certs(NULL, subject));
1697    ExpectNull(X509_STORE_get1_certs(storeCtx, NULL));
1698
1699    ExpectIntEQ(X509_STORE_add_cert(store, caX509), SSL_SUCCESS);
1700    ExpectIntEQ(X509_STORE_CTX_init(storeCtx, store, caX509, NULL),
1701        SSL_SUCCESS);
1702
1703    /* Should find the cert */
1704    ExpectNotNull(certs = X509_STORE_get1_certs(storeCtx, subject));
1705    ExpectIntEQ(1, wolfSSL_sk_X509_num(certs));
1706
1707    sk_X509_pop_free(certs, NULL);
1708    certs = NULL;
1709
1710    /* Should not find the cert */
1711    ExpectNotNull(subject = X509_get_subject_name(svrX509));
1712    ExpectNotNull(certs = X509_STORE_get1_certs(storeCtx, subject));
1713    ExpectIntEQ(0, wolfSSL_sk_X509_num(certs));
1714
1715    sk_X509_pop_free(certs, NULL);
1716    certs = NULL;
1717
1718    X509_STORE_free(store);
1719    X509_STORE_CTX_free(storeCtx);
1720    X509_free(svrX509);
1721    X509_free(caX509);
1722#endif /* OPENSSL_EXTRA && WOLFSSL_SIGNER_DER_CERT && !NO_FILESYSTEM */
1723    return EXPECT_RESULT();
1724}
1725
1726#if defined(HAVE_SSL_MEMIO_TESTS_DEPENDENCIES) && \
1727    defined(WOLFSSL_LOCAL_X509_STORE) && \
1728    (defined(OPENSSL_ALL) || defined(WOLFSSL_QT)) && defined(HAVE_CRL)
1729static int test_wolfSSL_X509_STORE_set_get_crl_provider(X509_STORE_CTX* ctx,
1730        X509_CRL** crl_out, X509* cert) {
1731    X509_CRL *crl = NULL;
1732    XFILE fp = XBADFILE;
1733    char* cert_issuer = X509_NAME_oneline(X509_get_issuer_name(cert), NULL, 0);
1734    int ret = 0;
1735
1736    (void)ctx;
1737
1738    if (cert_issuer == NULL)
1739        return 0;
1740
1741    if ((fp = XFOPEN("certs/crl/crl.pem", "rb")) != XBADFILE) {
1742        PEM_read_X509_CRL(fp, &crl, NULL, NULL);
1743        XFCLOSE(fp);
1744        if (crl != NULL) {
1745            char* crl_issuer = X509_NAME_oneline(
1746                    X509_CRL_get_issuer(crl), NULL, 0);
1747            if ((crl_issuer != NULL) &&
1748                   (XSTRCMP(cert_issuer, crl_issuer) == 0)) {
1749                *crl_out = X509_CRL_dup(crl);
1750                if (*crl_out != NULL)
1751                    ret = 1;
1752            }
1753            OPENSSL_free(crl_issuer);
1754        }
1755    }
1756
1757    X509_CRL_free(crl);
1758    OPENSSL_free(cert_issuer);
1759    return ret;
1760}
1761
1762static int test_wolfSSL_X509_STORE_set_get_crl_provider2(X509_STORE_CTX* ctx,
1763        X509_CRL** crl_out, X509* cert) {
1764    (void)ctx;
1765    (void)cert;
1766    *crl_out = NULL;
1767    return 1;
1768}
1769
1770#ifndef NO_WOLFSSL_STUB
1771static int test_wolfSSL_X509_STORE_set_get_crl_check(X509_STORE_CTX* ctx,
1772        X509_CRL* crl) {
1773    (void)ctx;
1774    (void)crl;
1775    return 1;
1776}
1777#endif
1778
1779static int test_wolfSSL_X509_STORE_set_get_crl_verify(int ok,
1780        X509_STORE_CTX* ctx) {
1781    int cert_error = X509_STORE_CTX_get_error(ctx);
1782    X509_VERIFY_PARAM* param = X509_STORE_CTX_get0_param(ctx);
1783    int flags = X509_VERIFY_PARAM_get_flags(param);
1784    if ((flags & (X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL)) !=
1785            (X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL)) {
1786        /* Make sure the flags are set */
1787        return 0;
1788    }
1789    /* Ignore CRL missing error */
1790#ifndef OPENSSL_COMPATIBLE_DEFAULTS
1791    if (cert_error == WC_NO_ERR_TRACE(CRL_MISSING))
1792#else
1793    if (cert_error == X509_V_ERR_UNABLE_TO_GET_CRL)
1794#endif
1795        return 1;
1796    return ok;
1797}
1798
1799static int test_wolfSSL_X509_STORE_set_get_crl_ctx_ready(WOLFSSL_CTX* ctx)
1800{
1801    EXPECT_DECLS;
1802    X509_STORE* cert_store = NULL;
1803
1804    ExpectIntEQ(wolfSSL_CTX_EnableCRL(ctx, WOLFSSL_CRL_CHECKALL),
1805            WOLFSSL_SUCCESS);
1806    ExpectNotNull(cert_store = SSL_CTX_get_cert_store(ctx));
1807    X509_STORE_set_get_crl(cert_store,
1808            test_wolfSSL_X509_STORE_set_get_crl_provider);
1809#ifndef NO_WOLFSSL_STUB
1810    X509_STORE_set_check_crl(cert_store,
1811            test_wolfSSL_X509_STORE_set_get_crl_check);
1812#endif
1813
1814    return EXPECT_RESULT();
1815}
1816
1817static int test_wolfSSL_X509_STORE_set_get_crl_ctx_ready2(WOLFSSL_CTX* ctx)
1818{
1819    EXPECT_DECLS;
1820    X509_STORE* cert_store = NULL;
1821    X509_VERIFY_PARAM* param = NULL;
1822
1823    SSL_CTX_set_verify(ctx, WOLFSSL_VERIFY_PEER, NULL);
1824    ExpectIntEQ(wolfSSL_CTX_EnableCRL(ctx, WOLFSSL_CRL_CHECKALL),
1825            WOLFSSL_SUCCESS);
1826    ExpectNotNull(cert_store = SSL_CTX_get_cert_store(ctx));
1827    X509_STORE_set_get_crl(cert_store,
1828            test_wolfSSL_X509_STORE_set_get_crl_provider2);
1829#ifndef NO_WOLFSSL_STUB
1830    X509_STORE_set_check_crl(cert_store,
1831            test_wolfSSL_X509_STORE_set_get_crl_check);
1832#endif
1833    X509_STORE_set_verify_cb(cert_store,
1834            test_wolfSSL_X509_STORE_set_get_crl_verify);
1835    ExpectNotNull(X509_STORE_get0_param(cert_store));
1836    ExpectNotNull(param = X509_VERIFY_PARAM_new());
1837    ExpectIntEQ(X509_VERIFY_PARAM_inherit(NULL, NULL) , WOLFSSL_SUCCESS);
1838    ExpectIntEQ(X509_VERIFY_PARAM_inherit(param, NULL) , WOLFSSL_SUCCESS);
1839    ExpectIntEQ(X509_VERIFY_PARAM_inherit(param,
1840            X509_STORE_get0_param(cert_store)), WOLFSSL_SUCCESS);
1841    ExpectIntEQ(X509_VERIFY_PARAM_inherit(param,
1842            X509_STORE_get0_param(cert_store)), 1);
1843    ExpectIntEQ(X509_VERIFY_PARAM_set_flags(
1844        param, X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL), 1);
1845    ExpectIntEQ(X509_STORE_set1_param(cert_store, param), 1);
1846    ExpectIntEQ(X509_STORE_set_flags(cert_store,
1847            X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL), 1);
1848
1849
1850    X509_VERIFY_PARAM_free(param);
1851    return EXPECT_RESULT();
1852}
1853#endif
1854
1855/* This test mimics the usage of the CRL provider in gRPC */
1856int test_wolfSSL_X509_STORE_set_get_crl(void)
1857{
1858    EXPECT_DECLS;
1859#if defined(HAVE_SSL_MEMIO_TESTS_DEPENDENCIES) && \
1860    defined(WOLFSSL_LOCAL_X509_STORE) && \
1861    (defined(OPENSSL_ALL) || defined(WOLFSSL_QT)) && defined(HAVE_CRL)
1862    test_ssl_cbf func_cb_client;
1863    test_ssl_cbf func_cb_server;
1864
1865    XMEMSET(&func_cb_client, 0, sizeof(func_cb_client));
1866    XMEMSET(&func_cb_server, 0, sizeof(func_cb_server));
1867
1868    func_cb_client.ctx_ready = test_wolfSSL_X509_STORE_set_get_crl_ctx_ready;
1869
1870    ExpectIntEQ(test_wolfSSL_client_server_nofail_memio(&func_cb_client,
1871        &func_cb_server, NULL), TEST_SUCCESS);
1872
1873    XMEMSET(&func_cb_client, 0, sizeof(func_cb_client));
1874    XMEMSET(&func_cb_server, 0, sizeof(func_cb_server));
1875
1876    func_cb_client.ctx_ready = test_wolfSSL_X509_STORE_set_get_crl_ctx_ready2;
1877
1878    ExpectIntEQ(test_wolfSSL_client_server_nofail_memio(&func_cb_client,
1879        &func_cb_server, NULL), TEST_SUCCESS);
1880#endif
1881    return EXPECT_RESULT();
1882}
1883
1884int test_wolfSSL_X509_CA_num(void)
1885{
1886    EXPECT_DECLS;
1887#if defined(OPENSSL_EXTRA) && !defined(NO_CERTS) && !defined(NO_FILESYSTEM) && \
1888    defined(HAVE_ECC) && !defined(NO_RSA)
1889    WOLFSSL_X509_STORE *store = NULL;
1890    WOLFSSL_X509 *x509_1 = NULL;
1891    WOLFSSL_X509 *x509_2 = NULL;
1892    int ca_num = 0;
1893
1894    ExpectNotNull(store = wolfSSL_X509_STORE_new());
1895    ExpectNotNull(x509_1 = wolfSSL_X509_load_certificate_file(svrCertFile,
1896        WOLFSSL_FILETYPE_PEM));
1897    ExpectIntEQ(wolfSSL_X509_STORE_add_cert(store, x509_1), 1);
1898    ExpectIntEQ(ca_num = wolfSSL_X509_CA_num(store), 1);
1899
1900    ExpectNotNull(x509_2 = wolfSSL_X509_load_certificate_file(eccCertFile,
1901        WOLFSSL_FILETYPE_PEM));
1902    ExpectIntEQ(wolfSSL_X509_STORE_add_cert(store, x509_2), 1);
1903    ExpectIntEQ(ca_num = wolfSSL_X509_CA_num(store), 2);
1904
1905    wolfSSL_X509_free(x509_1);
1906    wolfSSL_X509_free(x509_2);
1907    wolfSSL_X509_STORE_free(store);
1908#endif
1909    return EXPECT_RESULT();
1910}
1911
1912/* Test of X509 store use outside of SSL context w/ CRL lookup (ALWAYS
1913 * returns 0) */
1914int test_X509_STORE_No_SSL_CTX(void)
1915{
1916    EXPECT_DECLS;
1917#if defined(OPENSSL_ALL) && defined(WOLFSSL_CERT_GEN) && \
1918    (defined(WOLFSSL_CERT_REQ) || defined(WOLFSSL_CERT_EXT)) && \
1919    !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR)  && \
1920    (defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL)) && \
1921    defined(HAVE_CRL) && !defined(NO_RSA)
1922
1923    X509_STORE *     store = NULL;
1924    X509_STORE_CTX * storeCtx = NULL;
1925    X509_CRL *       crl = NULL;
1926    X509 *           ca = NULL;
1927    X509 *           cert = NULL;
1928    const char       cliCrlPem[] = "./certs/crl/cliCrl.pem";
1929    const char       srvCert[] = "./certs/server-cert.pem";
1930    const char       caCert[] = "./certs/ca-cert.pem";
1931    const char       caDir[] = "./certs/crl/hash_pem";
1932    XFILE            fp = XBADFILE;
1933    X509_LOOKUP *    lookup = NULL;
1934
1935    ExpectNotNull(store = (X509_STORE *)X509_STORE_new());
1936
1937    /* Set up store with CA */
1938    ExpectNotNull((ca = wolfSSL_X509_load_certificate_file(caCert,
1939        SSL_FILETYPE_PEM)));
1940    ExpectIntEQ(X509_STORE_add_cert(store, ca), SSL_SUCCESS);
1941
1942    /* Add CRL lookup directory to store
1943     * NOTE: test uses ./certs/crl/hash_pem/0fdb2da4.r0, which is a copy
1944     * of crl.pem */
1945    ExpectNotNull((lookup = X509_STORE_add_lookup(store,
1946        X509_LOOKUP_hash_dir())));
1947    ExpectIntEQ(X509_LOOKUP_ctrl(lookup, X509_L_ADD_DIR, caDir,
1948        X509_FILETYPE_PEM, NULL), SSL_SUCCESS);
1949
1950    ExpectIntEQ(X509_STORE_set_flags(store, X509_V_FLAG_CRL_CHECK),
1951        SSL_SUCCESS);
1952
1953    /* Add CRL to store NOT containing the verified certificate, which
1954     * forces use of the CRL lookup directory */
1955    ExpectTrue((fp = XFOPEN(cliCrlPem, "rb")) != XBADFILE);
1956    ExpectNotNull(crl = (X509_CRL *)PEM_read_X509_CRL(fp, (X509_CRL **)NULL,
1957        NULL, NULL));
1958    if (fp != XBADFILE)
1959        XFCLOSE(fp);
1960    ExpectIntEQ(X509_STORE_add_crl(store, crl), SSL_SUCCESS);
1961
1962    /* Create verification context outside of an SSL session */
1963    ExpectNotNull((storeCtx = X509_STORE_CTX_new()));
1964    ExpectNotNull((cert = wolfSSL_X509_load_certificate_file(srvCert,
1965        SSL_FILETYPE_PEM)));
1966    ExpectIntEQ(X509_STORE_CTX_init(storeCtx, store, cert, NULL), SSL_SUCCESS);
1967
1968    /* Perform verification, which should NOT indicate CRL missing due to the
1969     * store CM's X509 store pointer being NULL */
1970    ExpectIntNE(X509_verify_cert(storeCtx), WC_NO_ERR_TRACE(CRL_MISSING));
1971
1972    X509_CRL_free(crl);
1973    X509_STORE_free(store);
1974    X509_STORE_CTX_free(storeCtx);
1975    X509_free(cert);
1976    X509_free(ca);
1977#endif
1978    return EXPECT_RESULT();
1979}
1980
1981/* Test that SSL_CTX_set_cert_store propagates certificates (including
1982 * non-self-signed intermediates) into the CertManager, and that certs
1983 * added to the store after set_cert_store also reach the CertManager.
1984 * Regression test for ZD 19760 / GitHub PR #8708.
1985 */
1986int test_wolfSSL_CTX_set_cert_store(void)
1987{
1988    EXPECT_DECLS;
1989#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && !defined(NO_FILESYSTEM) && \
1990    !defined(NO_WOLFSSL_CLIENT) && !defined(NO_TLS)
1991    SSL_CTX* ctx = NULL;
1992    X509_STORE* store = NULL;
1993    X509* rootCa = NULL;
1994    X509* intCa = NULL;
1995    X509* int2Ca = NULL;
1996    X509_STORE_CTX* storeCtx = NULL;
1997    X509* svrCert = NULL;
1998
1999    const char caCert[]     = "./certs/ca-cert.pem";
2000    const char intCaCert[]  = "./certs/intermediate/ca-int-cert.pem";
2001    const char int2CaCert[] = "./certs/intermediate/ca-int2-cert.pem";
2002    const char svrIntCert[] = "./certs/intermediate/server-int-cert.pem";
2003
2004    /* --- Part 1: Add certs to store BEFORE set_cert_store ---
2005     * Non-self-signed intermediates should be pushed into the CertManager
2006     * when set_cert_store is called. */
2007    ExpectNotNull(store = X509_STORE_new());
2008    ExpectNotNull(rootCa = wolfSSL_X509_load_certificate_file(caCert,
2009                    SSL_FILETYPE_PEM));
2010    ExpectNotNull(intCa = wolfSSL_X509_load_certificate_file(intCaCert,
2011                    SSL_FILETYPE_PEM));
2012    ExpectNotNull(int2Ca = wolfSSL_X509_load_certificate_file(int2CaCert,
2013                    SSL_FILETYPE_PEM));
2014
2015    ExpectIntEQ(X509_STORE_add_cert(store, rootCa), SSL_SUCCESS);
2016    ExpectIntEQ(X509_STORE_add_cert(store, intCa), SSL_SUCCESS);
2017    ExpectIntEQ(X509_STORE_add_cert(store, int2Ca), SSL_SUCCESS);
2018
2019    ExpectNotNull(ctx = SSL_CTX_new(TLS_client_method()));
2020
2021    /* This should push intermediates from store->certs into the CM */
2022    SSL_CTX_set_cert_store(ctx, store);
2023
2024    /* After set_cert_store, store->certs and store->trusted should be NULLed
2025     * to signal CTX ownership */
2026    if (EXPECT_SUCCESS()) {
2027        ExpectNull(store->certs);
2028        ExpectNull(store->trusted);
2029    }
2030
2031    /* Verify using CertManagerVerify - this only checks the CM, not the
2032     * store's certs stack, so it proves the intermediates were pushed */
2033    ExpectIntEQ(wolfSSL_CertManagerVerify(wolfSSL_CTX_GetCertManager(ctx),
2034                svrIntCert, SSL_FILETYPE_PEM), WOLFSSL_SUCCESS);
2035
2036    /* Also verify using X509_verify_cert for completeness */
2037    ExpectNotNull(svrCert = wolfSSL_X509_load_certificate_file(svrIntCert,
2038                    SSL_FILETYPE_PEM));
2039    ExpectNotNull(storeCtx = X509_STORE_CTX_new());
2040    if (EXPECT_SUCCESS()) {
2041        ExpectIntEQ(X509_STORE_CTX_init(storeCtx,
2042                    SSL_CTX_get_cert_store(ctx), svrCert, NULL), SSL_SUCCESS);
2043        ExpectIntEQ(X509_verify_cert(storeCtx), SSL_SUCCESS);
2044    }
2045
2046    X509_STORE_CTX_free(storeCtx);
2047    storeCtx = NULL;
2048    X509_free(svrCert);
2049    svrCert = NULL;
2050    SSL_CTX_free(ctx);
2051    ctx = NULL;
2052    /* store is freed by SSL_CTX_free */
2053    store = NULL;
2054
2055    X509_free(rootCa);
2056    rootCa = NULL;
2057    X509_free(intCa);
2058    intCa = NULL;
2059    X509_free(int2Ca);
2060    int2Ca = NULL;
2061
2062    /* --- Part 2: Add certs to store AFTER set_cert_store ---
2063     * When store->certs is NULL (CTX-owned), X509_STORE_add_cert should
2064     * route non-self-signed certs directly to the CertManager. */
2065    ExpectNotNull(store = X509_STORE_new());
2066    ExpectNotNull(ctx = SSL_CTX_new(TLS_client_method()));
2067
2068    /* Attach empty store first */
2069    SSL_CTX_set_cert_store(ctx, store);
2070
2071    /* Now add certs after ownership transfer */
2072    ExpectNotNull(rootCa = wolfSSL_X509_load_certificate_file(caCert,
2073                    SSL_FILETYPE_PEM));
2074    ExpectNotNull(intCa = wolfSSL_X509_load_certificate_file(intCaCert,
2075                    SSL_FILETYPE_PEM));
2076    ExpectNotNull(int2Ca = wolfSSL_X509_load_certificate_file(int2CaCert,
2077                    SSL_FILETYPE_PEM));
2078
2079    ExpectIntEQ(X509_STORE_add_cert(store, rootCa), SSL_SUCCESS);
2080    ExpectIntEQ(X509_STORE_add_cert(store, intCa), SSL_SUCCESS);
2081    ExpectIntEQ(X509_STORE_add_cert(store, int2Ca), SSL_SUCCESS);
2082
2083    /* Verify that certs added after set_cert_store are in the CM */
2084    ExpectIntEQ(wolfSSL_CertManagerVerify(wolfSSL_CTX_GetCertManager(ctx),
2085                svrIntCert, SSL_FILETYPE_PEM), WOLFSSL_SUCCESS);
2086
2087    SSL_CTX_free(ctx);
2088    /* store freed by SSL_CTX_free */
2089    X509_free(rootCa);
2090    X509_free(intCa);
2091    X509_free(int2Ca);
2092#endif
2093    return EXPECT_RESULT();
2094}
2095