luna - wolfssl/tests/api/test

   1/* test_ocsp.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#include <tests/api/test_ocsp.h>
  25#include <tests/api/test_ocsp_test_blobs.h>
  26#include <wolfssl/internal.h>
  27#include <wolfssl/ocsp.h>
  28#include <wolfssl/ssl.h>
  29#include <wolfssl/wolfcrypt/asn.h>
  30
  31#if defined(HAVE_OCSP) && !defined(NO_SHA) && !defined(NO_RSA)
  32struct ocsp_cb_ctx {
  33    byte* response;
  34    int responseSz;
  35};
  36
  37struct test_conf {
  38    unsigned char* resp;
  39    int respSz;
  40    unsigned char* ca0;
  41    int ca0Sz;
  42    unsigned char* ca1;
  43    int ca1Sz;
  44    unsigned char* targetCert;
  45    int targetCertSz;
  46};
  47
  48static int ocsp_cb(void* ctx, const char* url, int urlSz, unsigned char* req,
  49    int reqSz, unsigned char** respBuf)
  50{
  51    struct ocsp_cb_ctx* cb_ctx = (struct ocsp_cb_ctx*)ctx;
  52    (void)url;
  53    (void)urlSz;
  54    (void)req;
  55    (void)reqSz;
  56
  57    *respBuf = cb_ctx->response;
  58    return cb_ctx->responseSz;
  59}
  60
  61static int test_ocsp_response_with_cm(struct test_conf* c, int expectedRet)
  62{
  63    EXPECT_DECLS;
  64    WOLFSSL_CERT_MANAGER* cm = NULL;
  65    struct ocsp_cb_ctx cb_ctx;
  66
  67    ExpectNotNull(cm = wolfSSL_CertManagerNew());
  68    ExpectIntEQ(wolfSSL_CertManagerEnableOCSP(cm,
  69                    WOLFSSL_OCSP_URL_OVERRIDE | WOLFSSL_OCSP_NO_NONCE),
  70        WOLFSSL_SUCCESS);
  71    ExpectIntEQ(wolfSSL_CertManagerSetOCSPOverrideURL(cm, "http://foo.com"),
  72        WOLFSSL_SUCCESS);
  73    cb_ctx.response = (byte*)c->resp;
  74    cb_ctx.responseSz = c->respSz;
  75    ExpectIntEQ(
  76        wolfSSL_CertManagerSetOCSP_Cb(cm, ocsp_cb, NULL, (void*)&cb_ctx),
  77        WOLFSSL_SUCCESS);
  78    /* add ca in cm */
  79    if (c->ca0 != NULL) {
  80        ExpectIntEQ(wolfSSL_CertManagerLoadCABuffer(cm, c->ca0, c->ca0Sz,
  81                        WOLFSSL_FILETYPE_ASN1),
  82            WOLFSSL_SUCCESS);
  83    }
  84    if (c->ca1 != NULL) {
  85        ExpectIntEQ(wolfSSL_CertManagerLoadCABuffer(cm, c->ca1, c->ca1Sz,
  86                        WOLFSSL_FILETYPE_ASN1),
  87            WOLFSSL_SUCCESS);
  88    }
  89    /* check cert */
  90    ExpectIntEQ(
  91        wolfSSL_CertManagerCheckOCSP(cm, c->targetCert, c->targetCertSz),
  92        expectedRet);
  93    if (cm != NULL)
  94        wolfSSL_CertManagerFree(cm);
  95    return EXPECT_RESULT();
  96}
  97
  98int test_ocsp_response_parsing(void)
  99{
 100    EXPECT_DECLS;
 101    struct test_conf conf;
 102    int  expectedRet;
 103
 104    conf.resp = (unsigned char*)resp;
 105    conf.respSz = sizeof(resp);
 106    conf.ca0 = root_ca_cert_pem;
 107    conf.ca0Sz = sizeof(root_ca_cert_pem);
 108    conf.ca1 = NULL;
 109    conf.ca1Sz = 0;
 110    conf.targetCert = intermediate1_ca_cert_pem;
 111    conf.targetCertSz = sizeof(intermediate1_ca_cert_pem);
 112    ExpectIntEQ(test_ocsp_response_with_cm(&conf, WOLFSSL_SUCCESS),
 113        TEST_SUCCESS);
 114
 115    conf.resp = (unsigned char*)resp_multi;
 116    conf.respSz = sizeof(resp_multi);
 117    conf.ca0 = root_ca_cert_pem;
 118    conf.ca0Sz = sizeof(root_ca_cert_pem);
 119    conf.ca1 = NULL;
 120    conf.ca1Sz = 0;
 121    conf.targetCert = intermediate1_ca_cert_pem;
 122    conf.targetCertSz = sizeof(intermediate1_ca_cert_pem);
 123    ExpectIntEQ(test_ocsp_response_with_cm(&conf, WOLFSSL_SUCCESS),
 124        TEST_SUCCESS);
 125
 126    conf.resp = (unsigned char*)resp_bad_noauth;
 127    conf.respSz = sizeof(resp_bad_noauth);
 128    conf.ca0 = root_ca_cert_pem;
 129    conf.ca0Sz = sizeof(root_ca_cert_pem);
 130    conf.ca1 = ca_cert_pem;
 131    conf.ca1Sz = sizeof(ca_cert_pem);
 132    conf.targetCert = server_cert_pem;
 133    conf.targetCertSz = sizeof(server_cert_pem);
 134    expectedRet = OCSP_LOOKUP_FAIL;
 135#ifdef WOLFSSL_NO_OCSP_ISSUER_CHECK
 136    expectedRet = WOLFSSL_SUCCESS;
 137#endif
 138    ExpectIntEQ(test_ocsp_response_with_cm(&conf, expectedRet), TEST_SUCCESS);
 139
 140    /* Test response with CERT_UNKNOWN status */
 141    conf.resp = (unsigned char*)resp_cert_unknown;
 142    conf.respSz = sizeof(resp_cert_unknown);
 143    conf.ca0 = root_ca_cert_pem;
 144    conf.ca0Sz = sizeof(root_ca_cert_pem);
 145    conf.ca1 = NULL;
 146    conf.ca1Sz = 0;
 147    conf.targetCert = intermediate1_ca_cert_pem;
 148    conf.targetCertSz = sizeof(intermediate1_ca_cert_pem);
 149    ExpectIntEQ(test_ocsp_response_with_cm(&conf, OCSP_CERT_UNKNOWN),
 150        TEST_SUCCESS);
 151
 152    /* Test response with unusable internal cert but that can be verified in CM
 153     */
 154    conf.resp = (unsigned char*)resp_bad_embedded_cert;
 155    conf.respSz = sizeof(resp_bad_embedded_cert);
 156    conf.ca0 = root_ca_cert_pem;
 157    conf.ca0Sz = sizeof(root_ca_cert_pem);
 158    conf.ca1 = NULL;
 159    conf.ca1Sz = 0;
 160    conf.targetCert = intermediate1_ca_cert_pem;
 161    conf.targetCertSz = sizeof(intermediate1_ca_cert_pem);
 162    ExpectIntEQ(test_ocsp_response_with_cm(&conf, WOLFSSL_SUCCESS),
 163        TEST_SUCCESS);
 164    return EXPECT_SUCCESS();
 165}
 166#else  /* HAVE_OCSP && !NO_SHA */
 167int test_ocsp_response_parsing(void)
 168{
 169    return TEST_SKIPPED;
 170}
 171#endif /* HAVE_OCSP && !NO_SHA */
 172
 173#if defined(HAVE_OCSP) && (defined(OPENSSL_ALL) || defined(OPENSSL_EXTRA)) && \
 174    !defined(NO_RSA)
 175static int test_ocsp_create_x509store(WOLFSSL_X509_STORE** store,
 176    unsigned char* ca, int caSz)
 177{
 178    EXPECT_DECLS;
 179    WOLFSSL_X509* cert = NULL;
 180
 181    ExpectNotNull(*store = wolfSSL_X509_STORE_new());
 182    ExpectNotNull(cert = wolfSSL_X509_d2i(&cert, ca, caSz));
 183    ExpectIntEQ(wolfSSL_X509_STORE_add_cert(*store, cert), WOLFSSL_SUCCESS);
 184    wolfSSL_X509_free(cert);
 185    return EXPECT_RESULT();
 186}
 187
 188static int test_create_stack_of_x509(WOLF_STACK_OF(WOLFSSL_X509) * *certs,
 189    unsigned char* der, int derSz)
 190{
 191    EXPECT_DECLS;
 192    WOLFSSL_X509* cert = NULL;
 193
 194    ExpectNotNull(*certs = wolfSSL_sk_X509_new_null());
 195    ExpectNotNull(cert = wolfSSL_X509_d2i(&cert, der, derSz));
 196    ExpectIntEQ(wolfSSL_sk_X509_push(*certs, cert), 1);
 197    return EXPECT_RESULT();
 198}
 199
 200int test_ocsp_basic_verify(void)
 201{
 202    EXPECT_DECLS;
 203    WOLF_STACK_OF(WOLFSSL_X509)* certs = NULL;
 204    WOLFSSL_X509_STORE* store = NULL;
 205    const unsigned char* ptr = NULL;
 206    OcspResponse* response = NULL;
 207    DecodedCert cert;
 208    int expectedRet;
 209
 210    wc_InitDecodedCert(&cert, ocsp_responder_cert_pem,
 211        sizeof(ocsp_responder_cert_pem), NULL);
 212    ExpectIntEQ(wc_ParseCert(&cert, CERT_TYPE, 0, NULL), 0);
 213
 214    /* just decoding */
 215    ptr = (const unsigned char*)resp;
 216    ExpectNotNull(
 217        response = wolfSSL_d2i_OCSP_RESPONSE(NULL, &ptr, sizeof(resp)));
 218    ExpectPtrEq(ptr, (const unsigned char*)resp + sizeof(resp));
 219    ExpectIntEQ(response->responseStatus, 0);
 220    ExpectIntEQ(response->responderIdType, OCSP_RESPONDER_ID_NAME);
 221    ExpectBufEQ(response->responderId.nameHash, cert.subjectHash,
 222        OCSP_DIGEST_SIZE);
 223    wolfSSL_OCSP_RESPONSE_free(response);
 224
 225    /* responder Id by key hash */
 226    ptr = (const unsigned char*)resp_rid_bykey;
 227    ExpectNotNull(response = wolfSSL_d2i_OCSP_RESPONSE(NULL, &ptr,
 228                      sizeof(resp_rid_bykey)));
 229    ExpectPtrEq(ptr, (const unsigned char*)resp_rid_bykey +
 230        sizeof(resp_rid_bykey));
 231    ExpectIntEQ(response->responseStatus, 0);
 232    ExpectIntEQ(response->responderIdType, OCSP_RESPONDER_ID_KEY);
 233    ExpectBufEQ(response->responderId.keyHash, cert.subjectKeyHash,
 234        OCSP_RESPONDER_ID_KEY_SZ);
 235    wolfSSL_OCSP_RESPONSE_free(response);
 236
 237    /* decoding with no embedded certificates */
 238    ptr = (const unsigned char*)resp_nocert;
 239    ExpectNotNull(
 240        response = wolfSSL_d2i_OCSP_RESPONSE(NULL, &ptr, sizeof(resp_nocert)));
 241    ExpectPtrEq(ptr, (const unsigned char*)resp_nocert + sizeof(resp_nocert));
 242    ExpectIntEQ(response->responseStatus, 0);
 243    wolfSSL_OCSP_RESPONSE_free(response);
 244
 245    /* decoding an invalid response */
 246    ptr = (const unsigned char*)resp_bad;
 247    ExpectNull(
 248        response = wolfSSL_d2i_OCSP_RESPONSE(NULL, &ptr, sizeof(resp_bad)));
 249
 250    ptr = (const unsigned char*)resp;
 251    ExpectNotNull(
 252        response = wolfSSL_d2i_OCSP_RESPONSE(NULL, &ptr, sizeof(resp)));
 253    ExpectPtrEq(ptr, (const unsigned char*)resp + sizeof(resp));
 254    /* no verify signer certificate */
 255    ExpectIntEQ(wolfSSL_OCSP_basic_verify(response, NULL, NULL, OCSP_NOVERIFY),
 256        WOLFSSL_SUCCESS);
 257    /* verify that the signature is checked */
 258    if (EXPECT_SUCCESS()) {
 259        ((byte *)(wc_ptr_t)response->sig)[0] ^= 0xff;
 260    }
 261    ExpectIntEQ(wolfSSL_OCSP_basic_verify(response, NULL, NULL, OCSP_NOVERIFY),
 262        WOLFSSL_FAILURE);
 263    wolfSSL_OCSP_RESPONSE_free(response);
 264    response = NULL;
 265
 266    /* populate a store with root-ca-cert */
 267    ExpectIntEQ(test_ocsp_create_x509store(&store, root_ca_cert_pem,
 268                    sizeof(root_ca_cert_pem)),
 269        TEST_SUCCESS);
 270
 271    /* populate a WOLF_STACK_OF(WOLFSSL_X509) with responder certificate */
 272    ExpectIntEQ(test_create_stack_of_x509(&certs, ocsp_responder_cert_pem,
 273                    sizeof(ocsp_responder_cert_pem)),
 274        TEST_SUCCESS);
 275
 276    /* cert not embedded, cert in certs, validated using store */
 277    ptr = (const unsigned char*)resp_nocert;
 278    ExpectNotNull(
 279        response = wolfSSL_d2i_OCSP_RESPONSE(NULL, &ptr, sizeof(resp_nocert)));
 280    ExpectPtrEq(ptr, (const unsigned char*)resp_nocert + sizeof(resp_nocert));
 281    ExpectIntEQ(wolfSSL_OCSP_basic_verify(response, certs, store, 0),
 282        WOLFSSL_SUCCESS);
 283    wolfSSL_OCSP_RESPONSE_free(response);
 284    response = NULL;
 285
 286    /* cert embedded, verified using store */
 287    ptr = (const unsigned char*)resp;
 288    ExpectNotNull(
 289        response = wolfSSL_d2i_OCSP_RESPONSE(NULL, &ptr, sizeof(resp)));
 290    ExpectPtrEq(ptr, (const unsigned char*)resp + sizeof(resp));
 291    ExpectIntEQ(wolfSSL_OCSP_basic_verify(response, NULL, store, 0),
 292        WOLFSSL_SUCCESS);
 293    /* make invalid signature */
 294    if (EXPECT_SUCCESS()) {
 295        ((byte *)(wc_ptr_t)response->sig)[0] ^= 0xff;
 296    }
 297    ExpectIntEQ(wolfSSL_OCSP_basic_verify(response, NULL, store, 0),
 298        WOLFSSL_FAILURE);
 299    if (EXPECT_SUCCESS()) {
 300        ((byte *)(wc_ptr_t)response->sig)[0] ^= 0xff;
 301    }
 302
 303    /* cert embedded and in certs, no store needed bc OCSP_TRUSTOTHER */
 304    ExpectIntEQ(
 305        wolfSSL_OCSP_basic_verify(response, certs, NULL, OCSP_TRUSTOTHER),
 306        WOLFSSL_SUCCESS);
 307    /* this should also pass */
 308    ExpectIntEQ(
 309        wolfSSL_OCSP_basic_verify(response, certs, store, OCSP_NOINTERN),
 310        WOLFSSL_SUCCESS);
 311    /* this should not */
 312    ExpectIntNE(wolfSSL_OCSP_basic_verify(response, NULL, store, OCSP_NOINTERN),
 313        WOLFSSL_SUCCESS);
 314    wolfSSL_OCSP_RESPONSE_free(response);
 315    response = NULL;
 316
 317    /* cert not embedded, not certs */
 318    ptr = (const unsigned char*)resp_nocert;
 319    ExpectNotNull(
 320        response = wolfSSL_d2i_OCSP_RESPONSE(NULL, &ptr, sizeof(resp_nocert)));
 321    ExpectPtrEq(ptr, (const unsigned char*)resp_nocert + sizeof(resp_nocert));
 322    ExpectIntNE(wolfSSL_OCSP_basic_verify(response, NULL, store, 0),
 323        WOLFSSL_SUCCESS);
 324    wolfSSL_OCSP_RESPONSE_free(response);
 325    response = NULL;
 326
 327    wolfSSL_sk_X509_pop_free(certs, wolfSSL_X509_free);
 328    certs = NULL;
 329    wolfSSL_X509_STORE_free(store);
 330    store = NULL;
 331
 332    ExpectIntEQ(test_ocsp_create_x509store(&store, root_ca_cert_pem,
 333                    sizeof(root_ca_cert_pem)),
 334        TEST_SUCCESS);
 335    ExpectIntEQ(test_create_stack_of_x509(&certs, root_ca_cert_pem,
 336                    sizeof(root_ca_cert_pem)),
 337        TEST_SUCCESS);
 338
 339    /* multiple responses in a ocsp response */
 340    ptr = (const unsigned char*)resp_multi;
 341    ExpectNotNull(
 342        response = wolfSSL_d2i_OCSP_RESPONSE(NULL, &ptr, sizeof(resp_multi)));
 343    ExpectPtrEq(ptr, (const unsigned char*)resp_multi + sizeof(resp_multi));
 344    ExpectIntEQ(wolfSSL_OCSP_basic_verify(response, certs, store, 0),
 345        WOLFSSL_SUCCESS);
 346    wolfSSL_OCSP_RESPONSE_free(response);
 347    response = NULL;
 348
 349    /* cert in certs, cert verified on store, not authorized to verify all
 350     * responses */
 351    ptr = (const unsigned char*)resp_bad_noauth;
 352    ExpectNotNull(response = wolfSSL_d2i_OCSP_RESPONSE(NULL, &ptr,
 353                      sizeof(resp_bad_noauth)));
 354    ExpectPtrEq(ptr, (const unsigned char*)resp_bad_noauth +
 355        sizeof(resp_bad_noauth));
 356
 357    expectedRet = WOLFSSL_FAILURE;
 358#ifdef WOLFSSL_NO_OCSP_ISSUER_CHECK
 359    expectedRet = WOLFSSL_SUCCESS;
 360#endif
 361    ExpectIntEQ(wolfSSL_OCSP_basic_verify(response, certs, store, 0),
 362        expectedRet);
 363    /* should pass with OCSP_NOCHECKS ...*/
 364    ExpectIntEQ(
 365        wolfSSL_OCSP_basic_verify(response, certs, store, OCSP_NOCHECKS),
 366        WOLFSSL_SUCCESS);
 367    /* or with OSCP_TRUSTOTHER */
 368    ExpectIntEQ(
 369        wolfSSL_OCSP_basic_verify(response, certs, store, OCSP_TRUSTOTHER),
 370        WOLFSSL_SUCCESS);
 371    wolfSSL_OCSP_RESPONSE_free(response);
 372
 373    wc_FreeDecodedCert(&cert);
 374    wolfSSL_sk_X509_pop_free(certs, wolfSSL_X509_free);
 375    wolfSSL_X509_STORE_free(store);
 376    return EXPECT_RESULT();
 377}
 378#else
 379int test_ocsp_basic_verify(void)
 380{
 381    return TEST_SKIPPED;
 382}
 383#endif /* HAVE_OCSP  && (OPENSSL_ALL || OPENSSL_EXTRA) */
 384
 385#if defined(HAVE_OCSP) && (defined(OPENSSL_ALL) || defined(OPENSSL_EXTRA)) && \
 386    !defined(NO_RSA) && !defined(WOLFSSL_NO_OCSP_ISSUER_CHECK)
 387/* Verify that OCSP responder authorization is bound to BOTH halves of the
 388 * CertID (issuerNameHash AND issuerKeyHash). The forged response in
 389 * resp_certid_keyhash_mismatch was signed by the legitimate ocsp-responder
 390 * (so the response signature itself verifies) but its CertID pairs the
 391 * legitimate root CA's name hash with the imposter root CA's key hash. With
 392 * a name-only authorization check the response would be incorrectly
 393 * accepted; the CertID-bound check must reject it. */
 394int test_ocsp_responder_keyhash_binding(void)
 395{
 396    EXPECT_DECLS;
 397    WOLF_STACK_OF(WOLFSSL_X509)* certs = NULL;
 398    WOLFSSL_X509_STORE* store = NULL;
 399    const unsigned char* ptr = NULL;
 400    OcspResponse* response = NULL;
 401
 402    ExpectIntEQ(test_ocsp_create_x509store(&store, root_ca_cert_pem,
 403                    sizeof(root_ca_cert_pem)),
 404        TEST_SUCCESS);
 405    ExpectIntEQ(test_create_stack_of_x509(&certs, ocsp_responder_cert_pem,
 406                    sizeof(ocsp_responder_cert_pem)),
 407        TEST_SUCCESS);
 408
 409    ptr = (const unsigned char*)resp_certid_keyhash_mismatch;
 410    ExpectNotNull(response = wolfSSL_d2i_OCSP_RESPONSE(NULL, &ptr,
 411                      sizeof(resp_certid_keyhash_mismatch)));
 412    ExpectIntNE(wolfSSL_OCSP_basic_verify(response, certs, store, 0),
 413        WOLFSSL_SUCCESS);
 414
 415    wolfSSL_OCSP_RESPONSE_free(response);
 416    wolfSSL_sk_X509_pop_free(certs, wolfSSL_X509_free);
 417    wolfSSL_X509_STORE_free(store);
 418    return EXPECT_RESULT();
 419}
 420#else
 421int test_ocsp_responder_keyhash_binding(void)
 422{
 423    return TEST_SKIPPED;
 424}
 425#endif
 426
 427#if defined(HAVE_OCSP) && defined(HAVE_SSL_MEMIO_TESTS_DEPENDENCIES) &&     \
 428    defined(HAVE_CERTIFICATE_STATUS_REQUEST) && !defined(WOLFSSL_NO_TLS12) &&  \
 429    defined(OPENSSL_ALL) && !defined(WOLFSSL_SMALL_CERT_VERIFY)
 430
 431struct _test_ocsp_status_callback_ctx {
 432    byte* ocsp_resp;
 433    int ocsp_resp_sz;
 434    int invoked;
 435};
 436
 437static int test_ocsp_status_callback_cb(WOLFSSL* ssl, void* ctx)
 438{
 439    struct _test_ocsp_status_callback_ctx* _ctx =
 440        (struct _test_ocsp_status_callback_ctx*)ctx;
 441    byte* allocated;
 442
 443    _ctx->invoked++;
 444    allocated = (byte*)XMALLOC(_ctx->ocsp_resp_sz, NULL, 0);
 445    if (allocated == NULL)
 446        return SSL_TLSEXT_ERR_ALERT_FATAL;
 447    XMEMCPY(allocated, _ctx->ocsp_resp, _ctx->ocsp_resp_sz);
 448    SSL_set_tlsext_status_ocsp_resp(ssl, allocated, _ctx->ocsp_resp_sz);
 449    return SSL_TLSEXT_ERR_OK;
 450}
 451
 452static int test_ocsp_status_callback_cb_noack(WOLFSSL* ssl, void* ctx)
 453{
 454    struct _test_ocsp_status_callback_ctx* _ctx =
 455        (struct _test_ocsp_status_callback_ctx*)ctx;
 456    (void)ssl;
 457
 458    _ctx->invoked++;
 459    return SSL_TLSEXT_ERR_NOACK;
 460}
 461
 462static int test_ocsp_status_callback_cb_err(WOLFSSL* ssl, void* ctx)
 463{
 464    struct _test_ocsp_status_callback_ctx* _ctx =
 465        (struct _test_ocsp_status_callback_ctx*)ctx;
 466    (void)ssl;
 467
 468    _ctx->invoked++;
 469    return SSL_TLSEXT_ERR_ALERT_FATAL;
 470}
 471
 472static int test_ocsp_status_callback_test_setup(
 473    struct _test_ocsp_status_callback_ctx* cb_ctx,
 474    struct test_ssl_memio_ctx* test_ctx, method_provider cm, method_provider sm)
 475{
 476    int ret;
 477
 478    cb_ctx->invoked = 0;
 479    XMEMSET(test_ctx, 0, sizeof(*test_ctx));
 480    test_ctx->c_cb.caPemFile = "./certs/ocsp/root-ca-cert.pem";
 481    test_ctx->s_cb.certPemFile = "./certs/ocsp/server1-cert.pem";
 482    test_ctx->s_cb.keyPemFile = "./certs/ocsp/server1-key.pem";
 483    test_ctx->c_cb.method = cm;
 484    test_ctx->s_cb.method = sm;
 485    ret = test_ssl_memio_setup(test_ctx);
 486    wolfSSL_set_verify(test_ctx->c_ssl, WOLFSSL_VERIFY_DEFAULT, NULL);
 487    return ret;
 488}
 489
 490int test_ocsp_status_callback(void)
 491{
 492    struct test_params {
 493        method_provider c_method;
 494        method_provider s_method;
 495    };
 496
 497    const char* responseFile = "./certs/ocsp/test-leaf-response.der";
 498    struct _test_ocsp_status_callback_ctx cb_ctx;
 499    struct test_ssl_memio_ctx test_ctx;
 500    int enable_client_ocsp;
 501    int enable_must_staple;
 502    XFILE f = XBADFILE;
 503    byte data[4096];
 504    unsigned int i;
 505    EXPECT_DECLS;
 506
 507    struct test_params params[] = {
 508        {wolfTLSv1_2_client_method, wolfTLSv1_2_server_method},
 509#if defined(WOLFSSL_TLS13)
 510        {wolfTLSv1_3_client_method, wolfTLSv1_3_server_method},
 511#endif
 512#if defined(WOLFSSL_DTLS)
 513        {wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method},
 514#endif
 515#if defined(WOLFSSL_DTLS13)
 516        {wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method},
 517#endif
 518    };
 519
 520    XMEMSET(&cb_ctx, 0, sizeof(cb_ctx));
 521    f = XFOPEN(responseFile, "rb");
 522    if (f == XBADFILE)
 523        return -1;
 524    cb_ctx.ocsp_resp_sz = (word32)XFREAD(data, 1, 4096, f);
 525    if (f != XBADFILE) {
 526        XFCLOSE(f);
 527        f = XBADFILE;
 528    }
 529    cb_ctx.ocsp_resp = data;
 530
 531    for (i = 0; i < sizeof(params) / sizeof(params[0]); i++) {
 532        for (enable_client_ocsp = 0; enable_client_ocsp <= 1;
 533            enable_client_ocsp++) {
 534            ExpectIntEQ(test_ocsp_status_callback_test_setup(&cb_ctx, &test_ctx,
 535                            params[i].c_method, params[i].s_method),
 536                TEST_SUCCESS);
 537            ExpectIntEQ(SSL_CTX_set_tlsext_status_cb(test_ctx.s_ctx,
 538                            test_ocsp_status_callback_cb),
 539                SSL_SUCCESS);
 540            ExpectIntEQ(
 541                SSL_CTX_set_tlsext_status_arg(test_ctx.s_ctx, (void*)&cb_ctx),
 542                SSL_SUCCESS);
 543            if (enable_client_ocsp) {
 544                ExpectIntEQ(wolfSSL_UseOCSPStapling(test_ctx.c_ssl,
 545                                WOLFSSL_CSR_OCSP, 0),
 546                    WOLFSSL_SUCCESS);
 547                ExpectIntEQ(wolfSSL_CTX_EnableOCSPStapling(test_ctx.c_ctx),
 548                    WOLFSSL_SUCCESS);
 549                ExpectIntEQ(wolfSSL_CTX_EnableOCSPMustStaple(test_ctx.c_ctx),
 550                    WOLFSSL_SUCCESS);
 551            }
 552            ExpectIntEQ(test_ssl_memio_do_handshake(&test_ctx, 10, NULL),
 553                TEST_SUCCESS);
 554            ExpectIntEQ(cb_ctx.invoked, enable_client_ocsp ? 1 : 0);
 555            test_ssl_memio_cleanup(&test_ctx);
 556            if (!EXPECT_SUCCESS())
 557                return EXPECT_RESULT();
 558        }
 559    }
 560#if defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
 561    /* test client sending both OCSPv1 and OCSPv2/MultiOCSP */
 562    /* StatusCb only supports OCSPv1 */
 563    ExpectIntEQ(test_ocsp_status_callback_test_setup(&cb_ctx, &test_ctx,
 564                    wolfTLSv1_2_client_method, wolfTLSv1_2_server_method),
 565        TEST_SUCCESS);
 566    ExpectIntEQ(SSL_CTX_set_tlsext_status_cb(test_ctx.s_ctx,
 567                    test_ocsp_status_callback_cb),
 568        SSL_SUCCESS);
 569    ExpectIntEQ(SSL_CTX_set_tlsext_status_arg(test_ctx.s_ctx, (void*)&cb_ctx),
 570        SSL_SUCCESS);
 571    ExpectIntEQ(wolfSSL_CTX_EnableOCSPStapling(test_ctx.c_ctx),
 572        WOLFSSL_SUCCESS);
 573    ExpectIntEQ(wolfSSL_CTX_EnableOCSPMustStaple(test_ctx.c_ctx),
 574        WOLFSSL_SUCCESS);
 575    ExpectIntEQ(wolfSSL_UseOCSPStapling(test_ctx.c_ssl, WOLFSSL_CSR_OCSP, 0),
 576        WOLFSSL_SUCCESS);
 577    ExpectIntEQ(
 578        wolfSSL_UseOCSPStaplingV2(test_ctx.c_ssl, WOLFSSL_CSR2_OCSP_MULTI, 0),
 579        WOLFSSL_SUCCESS);
 580    wolfSSL_set_verify(test_ctx.c_ssl, WOLFSSL_VERIFY_DEFAULT, NULL);
 581    ExpectIntEQ(test_ssl_memio_do_handshake(&test_ctx, 10, NULL), TEST_SUCCESS);
 582    ExpectIntEQ(cb_ctx.invoked, 1);
 583    test_ssl_memio_cleanup(&test_ctx);
 584
 585    if (!EXPECT_SUCCESS())
 586        return EXPECT_RESULT();
 587#endif /* defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2) */
 588    /* test cb returning NO_ACK, not acking the OCSP */
 589    for (i = 0; i < sizeof(params) / sizeof(params[0]); i++) {
 590        for (enable_must_staple = 0; enable_must_staple <= 1;
 591            enable_must_staple++) {
 592            ExpectIntEQ(test_ocsp_status_callback_test_setup(&cb_ctx, &test_ctx,
 593                            params[i].c_method, params[i].s_method),
 594                TEST_SUCCESS);
 595            ExpectIntEQ(SSL_CTX_set_tlsext_status_cb(test_ctx.s_ctx,
 596                            test_ocsp_status_callback_cb_noack),
 597                SSL_SUCCESS);
 598            ExpectIntEQ(
 599                SSL_CTX_set_tlsext_status_arg(test_ctx.s_ctx, (void*)&cb_ctx),
 600                SSL_SUCCESS);
 601            ExpectIntEQ(wolfSSL_CTX_EnableOCSPStapling(test_ctx.c_ctx),
 602                WOLFSSL_SUCCESS);
 603            ExpectIntEQ(
 604                wolfSSL_UseOCSPStapling(test_ctx.c_ssl, WOLFSSL_CSR_OCSP, 0),
 605                WOLFSSL_SUCCESS);
 606            if (enable_must_staple)
 607                ExpectIntEQ(wolfSSL_CTX_EnableOCSPMustStaple(test_ctx.c_ctx),
 608                    WOLFSSL_SUCCESS);
 609            wolfSSL_set_verify(test_ctx.c_ssl, WOLFSSL_VERIFY_DEFAULT, NULL);
 610            ExpectIntEQ(test_ssl_memio_do_handshake(&test_ctx, 10, NULL),
 611                enable_must_staple ? TEST_FAIL : TEST_SUCCESS);
 612            ExpectIntEQ(cb_ctx.invoked, 1);
 613            test_ssl_memio_cleanup(&test_ctx);
 614            if (!EXPECT_SUCCESS())
 615                return EXPECT_RESULT();
 616        }
 617    }
 618
 619    /* test cb returning err aborting handshake */
 620    for (i = 0; i < sizeof(params) / sizeof(params[0]); i++) {
 621        for (enable_client_ocsp = 0; enable_client_ocsp <= 1;
 622            enable_client_ocsp++) {
 623            ExpectIntEQ(test_ocsp_status_callback_test_setup(&cb_ctx, &test_ctx,
 624                            params[i].c_method, params[i].s_method),
 625                TEST_SUCCESS);
 626            ExpectIntEQ(SSL_CTX_set_tlsext_status_cb(test_ctx.s_ctx,
 627                            test_ocsp_status_callback_cb_err),
 628                SSL_SUCCESS);
 629            ExpectIntEQ(
 630                SSL_CTX_set_tlsext_status_arg(test_ctx.s_ctx, (void*)&cb_ctx),
 631                SSL_SUCCESS);
 632            if (enable_client_ocsp)
 633                ExpectIntEQ(wolfSSL_CTX_EnableOCSPStapling(test_ctx.c_ctx),
 634                    WOLFSSL_SUCCESS);
 635            ExpectIntEQ(
 636                wolfSSL_UseOCSPStapling(test_ctx.c_ssl, WOLFSSL_CSR_OCSP, 0),
 637                WOLFSSL_SUCCESS);
 638            wolfSSL_set_verify(test_ctx.c_ssl, WOLFSSL_VERIFY_DEFAULT, NULL);
 639            ExpectIntEQ(test_ssl_memio_do_handshake(&test_ctx, 10, NULL),
 640                enable_client_ocsp ? TEST_FAIL : TEST_SUCCESS);
 641            ExpectIntEQ(cb_ctx.invoked, enable_client_ocsp ? 1 : 0);
 642            test_ssl_memio_cleanup(&test_ctx);
 643            if (!EXPECT_SUCCESS())
 644                return EXPECT_RESULT();
 645        }
 646    }
 647
 648    return EXPECT_RESULT();
 649}
 650
 651#else
 652int test_ocsp_status_callback(void)
 653{
 654    return TEST_SKIPPED;
 655}
 656#endif /* defined(HAVE_OCSP) && defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES)  \
 657        && defined(HAVE_CERTIFICATE_STATUS_REQUEST) &&                         \
 658        !defined(WOLFSSL_NO_TLS12)                                             \
 659        && defined(OPENSSL_ALL) */
 660
 661#if !defined(NO_SHA) && defined(OPENSSL_ALL) && defined(HAVE_OCSP) &&          \
 662    !defined(WOLFSSL_SM3) && !defined(WOLFSSL_SM2) && !defined(NO_RSA)
 663int test_ocsp_certid_enc_dec(void)
 664{
 665    EXPECT_DECLS;
 666    WOLFSSL_OCSP_CERTID* certIdDec = NULL;
 667    WOLFSSL_OCSP_CERTID* certId = NULL;
 668    WOLFSSL_X509* subject = NULL;
 669    WOLFSSL_X509* issuer = NULL;
 670    unsigned char* temp = NULL;
 671    unsigned char* der2 = NULL;
 672    unsigned char* der = NULL;
 673    int derSz = 0, derSz1 = 0;
 674
 675    /* Load test certificates */
 676    ExpectNotNull(
 677        subject = wolfSSL_X509_load_certificate_file(
 678            "./certs/ocsp/intermediate1-ca-cert.pem", WOLFSSL_FILETYPE_PEM));
 679    ExpectNotNull(issuer = wolfSSL_X509_load_certificate_file(
 680                      "./certs/ocsp/root-ca-cert.pem", WOLFSSL_FILETYPE_PEM));
 681
 682    /* Create CERTID from certificates */
 683    ExpectNotNull(certId = wolfSSL_OCSP_cert_to_id(NULL, subject, issuer));
 684
 685    /* get len */
 686    ExpectIntGT(derSz = wolfSSL_i2d_OCSP_CERTID(certId, NULL), 0);
 687
 688    /* encode it */
 689    ExpectIntGT(derSz1 = wolfSSL_i2d_OCSP_CERTID(certId, &der), 0);
 690    ExpectIntEQ(derSz, derSz1);
 691
 692    if (EXPECT_SUCCESS())
 693        temp = der2 = (unsigned char*)XMALLOC(derSz, NULL, DYNAMIC_TYPE_OPENSSL);
 694    ExpectNotNull(der2);
 695    /* encode without allocation */
 696    ExpectIntGT(derSz1 = wolfSSL_i2d_OCSP_CERTID(certId, &der2), 0);
 697    ExpectIntEQ(derSz, derSz1);
 698    ExpectPtrEq(der2, temp + derSz);
 699    ExpectBufEQ(der, temp, derSz);
 700    XFREE(temp, NULL, DYNAMIC_TYPE_OPENSSL);
 701
 702    /* save original */
 703    temp = der;
 704    /* decode it */
 705    ExpectNotNull(certIdDec = wolfSSL_d2i_OCSP_CERTID(NULL,
 706                      (const unsigned char**)&der, derSz));
 707    /* check ptr is advanced */
 708    ExpectPtrEq(der, temp + derSz);
 709    der = der2;
 710    XFREE(temp, NULL, DYNAMIC_TYPE_OPENSSL);
 711
 712    /* compare */
 713    ExpectIntEQ(wolfSSL_OCSP_id_cmp(certId, certIdDec), 0);
 714
 715    wolfSSL_OCSP_CERTID_free(certId);
 716    wolfSSL_OCSP_CERTID_free(certIdDec);
 717    wolfSSL_X509_free(subject);
 718    wolfSSL_X509_free(issuer);
 719    return EXPECT_SUCCESS();
 720}
 721int test_ocsp_certid_dup(void)
 722{
 723    EXPECT_DECLS;
 724    WOLFSSL_OCSP_CERTID* certId = NULL;
 725    WOLFSSL_OCSP_CERTID* certIdDup = NULL;
 726    WOLFSSL_X509* subject = NULL;
 727    WOLFSSL_X509* issuer = NULL;
 728
 729    /* Load test certificates */
 730    ExpectNotNull(
 731        subject = wolfSSL_X509_load_certificate_file(
 732            "./certs/ocsp/intermediate1-ca-cert.pem", WOLFSSL_FILETYPE_PEM));
 733    ExpectNotNull(issuer = wolfSSL_X509_load_certificate_file(
 734                      "./certs/ocsp/root-ca-cert.pem", WOLFSSL_FILETYPE_PEM));
 735
 736    /* Create CERTID from certificates */
 737    ExpectNotNull(certId = wolfSSL_OCSP_cert_to_id(NULL, subject, issuer));
 738
 739    /* Dup */
 740    ExpectNotNull(certIdDup = wolfSSL_OCSP_CERTID_dup(certId));
 741
 742    /* Verify the dup compares equal */
 743    ExpectIntEQ(wolfSSL_OCSP_id_cmp(certId, certIdDup), 0);
 744
 745    /* Verify status is a distinct allocation (deep copy) */
 746    ExpectPtrNE(certId->status, certIdDup->status);
 747
 748    /* Freeing both must not double-free (ASAN will catch it) */
 749    wolfSSL_OCSP_CERTID_free(certId);
 750    wolfSSL_OCSP_CERTID_free(certIdDup);
 751
 752    wolfSSL_X509_free(subject);
 753    wolfSSL_X509_free(issuer);
 754    return EXPECT_SUCCESS();
 755}
 756
 757#else /* !NO_SHA && OPENSSL_ALL && HAVE_OCSP && !WOLFSSL_SM3 && !WOLFSSL_SM2 */
 758int test_ocsp_certid_enc_dec(void)
 759{
 760    return TEST_SKIPPED;
 761}
 762int test_ocsp_certid_dup(void)
 763{
 764    return TEST_SKIPPED;
 765}
 766#endif
 767
 768#if defined(HAVE_OCSP) && defined(WOLFSSL_CERT_SETUP_CB) && \
 769    defined(HAVE_SSL_MEMIO_TESTS_DEPENDENCIES) && !defined(NO_RSA) && \
 770    (defined(HAVE_CERTIFICATE_STATUS_REQUEST) || \
 771     defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)) && \
 772    defined(SESSION_CERTS)
 773
 774static struct {
 775    size_t chainLen;
 776    byte failStaple:2;
 777} test_ocsp_tls_cert_cb_opts;
 778/* --- certificate-selection callback ----------------------------------- */
 779static int test_ocsp_tls_cert_cb_cert_cb(WOLFSSL* ssl, void* arg)
 780{
 781    (void)arg;
 782    switch (test_ocsp_tls_cert_cb_opts.chainLen) {
 783        case 1:
 784            if (wolfSSL_use_certificate_file(ssl,
 785                    "./certs/ocsp/server1-cert.pem", WOLFSSL_FILETYPE_PEM)
 786                    != WOLFSSL_SUCCESS)
 787                return 0;
 788            break;
 789        case 2: {
 790            /* We need to limit the buffer to only the leaf and int certs */
 791            byte* buf = NULL;
 792            size_t bufLen = 0;
 793            byte* lastCert = NULL;
 794            byte loaded = 0;
 795
 796            if (wc_FileLoad("./certs/ocsp/server1-cert.pem", &buf, &bufLen,
 797                    NULL) != 0)
 798                return 0;
 799            /* Find the last cert */
 800            lastCert = (byte*)XSTRNSTR((char*)buf,
 801                    "-----BEGIN CERTIFICATE-----", (unsigned int)bufLen);
 802            if (lastCert != NULL) {
 803                lastCert = (byte*)XSTRNSTR((char*)lastCert + 1,
 804                        "-----BEGIN CERTIFICATE-----",
 805                        (unsigned int)(bufLen - (lastCert - buf)));
 806            }
 807            if (lastCert != NULL) {
 808                lastCert = (byte*)XSTRNSTR((char*)lastCert + 1,
 809                        "-----BEGIN CERTIFICATE-----",
 810                        (unsigned int)(bufLen - (lastCert - buf)));
 811            }
 812            if (lastCert != NULL) {
 813                if (wolfSSL_use_certificate_chain_buffer(ssl, buf, lastCert - buf)
 814                        == WOLFSSL_SUCCESS)
 815                    loaded = 1;
 816            }
 817            XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 818            if (!loaded)
 819                return 0;
 820            break;
 821        }
 822        case 3:
 823            if (wolfSSL_use_certificate_chain_file(ssl,
 824                    "./certs/ocsp/server1-cert.pem")
 825                    != WOLFSSL_SUCCESS)
 826                return 0;
 827            break;
 828    }
 829    if (wolfSSL_use_PrivateKey_file(ssl,
 830            "./certs/ocsp/server1-key.pem",  WOLFSSL_FILETYPE_PEM)
 831            != WOLFSSL_SUCCESS)
 832        return 0;
 833    return 1;  /* success */
 834}
 835
 836static int test_ocsp_tls_cert_cb_status_cb(WOLFSSL* ssl, void* ioCtx)
 837{
 838    byte* leaf_resp = NULL;
 839    byte* int_resp = NULL;
 840    byte* root_resp = NULL;
 841    int ret = WOLFSSL_OCSP_STATUS_CB_ALERT_FATAL;
 842    (void)ioCtx;
 843    leaf_resp = (byte*)XMALLOC(sizeof(resp_server1_cert), NULL, 0);
 844    int_resp = (byte*)XMALLOC(sizeof(resp_intermediate1_cert), NULL, 0);
 845    root_resp = (byte*)XMALLOC(sizeof(resp_root_ca_cert), NULL, 0);
 846    if (leaf_resp != NULL && int_resp != NULL && root_resp != NULL) {
 847        XMEMCPY(leaf_resp, resp_server1_cert, sizeof(resp_server1_cert));
 848        XMEMCPY(int_resp, resp_intermediate1_cert, sizeof(resp_intermediate1_cert));
 849        XMEMCPY(root_resp, resp_root_ca_cert, sizeof(resp_root_ca_cert));
 850        /* 320 is inside the signature so flipping bits should cause errors */
 851        switch (test_ocsp_tls_cert_cb_opts.failStaple) {
 852            case 1:
 853                leaf_resp[320] = ~leaf_resp[320];
 854                break;
 855            case 2:
 856                int_resp[320] = ~int_resp[320];
 857                break;
 858            case 3:
 859                root_resp[320] = ~root_resp[320];
 860                break;
 861        }
 862        if (wolfSSL_set_tlsext_status_ocsp_resp_multi(ssl, leaf_resp,
 863                sizeof(resp_server1_cert), 0) == WOLFSSL_SUCCESS)
 864            leaf_resp = NULL;
 865        if (wolfSSL_set_tlsext_status_ocsp_resp_multi(ssl, int_resp,
 866                sizeof(resp_intermediate1_cert), 1) == WOLFSSL_SUCCESS)
 867            int_resp = NULL;
 868        if (wolfSSL_set_tlsext_status_ocsp_resp_multi(ssl, root_resp,
 869                sizeof(resp_root_ca_cert), 2) == WOLFSSL_SUCCESS)
 870            root_resp = NULL;
 871        /* If all responses loaded then return OK */
 872        if (leaf_resp == NULL && int_resp == NULL && root_resp == NULL)
 873            ret = WOLFSSL_OCSP_STATUS_CB_OK;
 874    }
 875    XFREE(leaf_resp, NULL, 0);
 876    XFREE(int_resp, NULL, 0);
 877    XFREE(root_resp, NULL, 0);
 878    return ret;
 879}
 880
 881static int test_ocsp_tls_cert_cb_verify_cb(int preverify,
 882        WOLFSSL_X509_STORE_CTX* store)
 883{
 884    int ret = 1;
 885    int err = wolfSSL_X509_STORE_CTX_get_error(store);
 886    int idx = wolfSSL_X509_STORE_CTX_get_error_depth(store);
 887
 888    if (err == WC_NO_ERR_TRACE(ASN_NO_SIGNER_E) ||
 889            err == WC_NO_ERR_TRACE(ASN_SELF_SIGNED_E)
 890#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) || \
 891    defined(HAVE_WEBSERVER) || defined(HAVE_MEMCACHED)
 892            || err == WOLFSSL_X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY
 893            || err == WOLFSSL_X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT
 894#endif
 895            ) {
 896        WOLFSSL_BUFFER_INFO* bInfo = &store->certs[idx];
 897        WOLFSSL_CERT_MANAGER* cm = NULL;
 898        DecodedCert cert;
 899        byte certInit = 0;
 900
 901        ret = 1;
 902        cm = wolfSSL_CertManagerNew();
 903        if (cm == NULL)
 904            ret = 0;
 905        if (ret == 1 &&
 906            wolfSSL_CertManagerLoadCA(cm, "./certs/ocsp/root-ca-cert.pem", NULL)
 907                != WOLFSSL_SUCCESS)
 908            ret = 0;
 909        /* If verifying leaf cert then we need to load the intermediate CA */
 910        if (ret == 1 && idx == 0 &&
 911            wolfSSL_CertManagerLoadCA(cm, "./certs/ocsp/intermediate1-ca-cert.pem", NULL)
 912                != WOLFSSL_SUCCESS)
 913            ret = 0;
 914
 915        /* Verify cert with CA */
 916        if (ret == 1) {
 917            wc_InitDecodedCert(&cert, bInfo->buffer, bInfo->length, NULL);
 918            certInit = 1;
 919        }
 920        if (ret == 1 && wc_ParseCert(&cert, CERT_TYPE, VERIFY, cm) != 0)
 921            ret = 0;
 922
 923        if (certInit)
 924            wc_FreeDecodedCert(&cert);
 925        wolfSSL_CertManagerFree(cm);
 926    }
 927    (void)preverify;
 928    return ret;
 929}
 930
 931static int test_ocsp_tls_cert_cb_ocsp_verify_cb(WOLFSSL* ssl, int err,
 932        byte* staple, word32 stapleSz, word32 idx, void* arg)
 933{
 934    (void)ssl;
 935    (void)arg;
 936    if (err != 0) {
 937        WOLFSSL_CERT_MANAGER* cm = NULL;
 938        DecodedCert cert;
 939        byte certInit = 0;
 940        WOLFSSL_OCSP* ocsp = NULL;
 941        WOLFSSL_X509_CHAIN* peerCerts;
 942
 943        cm = wolfSSL_CertManagerNew();
 944        if (cm == NULL)
 945            goto cleanup;
 946        if (wolfSSL_CertManagerLoadCA(cm, "./certs/ocsp/root-ca-cert.pem", NULL)
 947                != WOLFSSL_SUCCESS)
 948            goto cleanup;
 949        /* If verifying leaf cert then we need to load the intermediate CA */
 950        if (idx == 0 && wolfSSL_CertManagerLoadCA(cm,
 951                "./certs/ocsp/intermediate1-ca-cert.pem", NULL)
 952                != WOLFSSL_SUCCESS)
 953            goto cleanup;
 954
 955        peerCerts = wolfSSL_get_peer_chain(ssl);
 956        if (peerCerts == NULL || wolfSSL_get_chain_count(peerCerts) <= (int)idx)
 957            goto cleanup;
 958
 959        /* Verify cert with CA */
 960        wc_InitDecodedCert(&cert, wolfSSL_get_chain_cert(peerCerts, idx),
 961                wolfSSL_get_chain_length(peerCerts, idx), NULL);
 962        certInit = 1;
 963        if (wc_ParseCert(&cert, CERT_TYPE, VERIFY, cm) != 0)
 964            goto cleanup;
 965        if ((ocsp = wc_NewOCSP(cm)) == NULL)
 966            goto cleanup;
 967        if (wc_CheckCertOcspResponse(ocsp, &cert, staple, stapleSz, NULL) != 0)
 968            goto cleanup;
 969
 970        err = 0;
 971cleanup:
 972        wc_FreeOCSP(ocsp);
 973        if (certInit)
 974            wc_FreeDecodedCert(&cert);
 975        wolfSSL_CertManagerFree(cm);
 976    }
 977    return err;
 978}
 979
 980static int test_ocsp_tls_cert_cb_ctx_ready(WOLFSSL_CTX* ctx)
 981{
 982    /* server: dynamic cert */
 983    wolfSSL_CTX_set_cert_cb(ctx, test_ocsp_tls_cert_cb_cert_cb, NULL);
 984    return TEST_SUCCESS;
 985}
 986
 987/* --- very small OCSP-status callback ---------------------------------- */
 988/* no status callback path - context struct not needed */
 989
 990/* --- the actual test case --------------------------------------------- */
 991int test_ocsp_tls_cert_cb(void)
 992{
 993    EXPECT_DECLS;
 994    size_t i, j, chainLen;
 995    struct {
 996        method_provider client_meth;
 997        method_provider server_meth;
 998        const char* tls_version;
 999        byte useV2:1;
1000        byte useV2multi:1;
1001        byte maxFail:2;
1002    } params[] = {
1003#if !defined(WOLFSSL_NO_TLS12)
1004        { wolfTLSv1_2_client_method, wolfTLSv1_2_server_method, "TLSv1_2", 0, 0, 1 },
1005        { wolfTLSv1_2_client_method, wolfTLSv1_2_server_method, "TLSv1_2", 1, 0, 1 },
1006        { wolfTLSv1_2_client_method, wolfTLSv1_2_server_method, "TLSv1_2", 1, 1, 1 },
1007        { wolfTLSv1_2_client_method, wolfTLSv1_2_server_method, "TLSv1_2", 0, 0, 1 },
1008        { wolfTLSv1_2_client_method, wolfTLSv1_2_server_method, "TLSv1_2", 1, 0, 1 },
1009        { wolfTLSv1_2_client_method, wolfTLSv1_2_server_method, "TLSv1_2", 1, 1, 3 },
1010#ifdef WOLFSSL_DTLS
1011        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method, "DTLSv1_2", 0, 0, 1 },
1012        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method, "DTLSv1_2", 1, 0, 1 },
1013        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method, "DTLSv1_2", 1, 1, 1 },
1014        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method, "DTLSv1_2", 0, 0, 1 },
1015        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method, "DTLSv1_2", 1, 0, 1 },
1016        { wolfDTLSv1_2_client_method, wolfDTLSv1_2_server_method, "DTLSv1_2", 1, 1, 3 },
1017#endif
1018#endif
1019#ifdef WOLFSSL_TLS13
1020        { wolfTLSv1_3_client_method, wolfTLSv1_3_server_method, "TLSv1_3", 0, 0, 3 },
1021        { wolfTLSv1_3_client_method, wolfTLSv1_3_server_method, "TLSv1_3", 0, 0, 1 },
1022#ifdef WOLFSSL_DTLS13
1023        { wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method, "DTLSv1_3", 0, 0, 3 },
1024        { wolfDTLSv1_3_client_method, wolfDTLSv1_3_server_method, "DTLSv1_3", 0, 0, 1 },
1025#endif
1026#endif
1027    };
1028
1029    for (i = 0; i < XELEM_CNT(params) && !EXPECT_FAIL(); i++) {
1030        printf("\nTesting %s\n", params[i].tls_version);
1031        for (chainLen = 1; chainLen <= 3 && !EXPECT_FAIL(); chainLen++) {
1032            printf("\tWith chain length %zu\n", chainLen);
1033            /* 0   - all staples valid
1034             * 1-3 - break the corresponding staple */
1035            for (j = 0; j <= params[i].maxFail && j <= chainLen && !EXPECT_FAIL(); j++) {
1036                struct test_ssl_memio_ctx test_ctx;
1037                byte skip = 0;
1038
1039                test_ocsp_tls_cert_cb_opts.failStaple = j;
1040                printf("\t%s (%zu)", j ? "with failing staple" : "correct staple", j);
1041
1042                XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1043                test_ctx.c_cb.caPemFile  = "";
1044                /* Do NOT preload any cert/key into the server context: leave empty strings
1045                   so that ctx setup code skips loading them entirely and the only cert
1046                   comes from the per-connection callback below. */
1047                test_ctx.s_cb.certPemFile = "";  /* nothing pre-loaded */
1048                test_ctx.s_cb.keyPemFile  = "";
1049
1050                test_ctx.c_cb.method = params[i].client_meth;
1051                test_ctx.s_cb.method = params[i].server_meth;
1052
1053                test_ocsp_tls_cert_cb_opts.chainLen = chainLen;
1054
1055                test_ctx.s_cb.ctx_ready = test_ocsp_tls_cert_cb_ctx_ready;
1056
1057                ExpectIntEQ(test_ssl_memio_setup(&test_ctx), TEST_SUCCESS);
1058
1059                /* Unload the certificate that test helpers may have put into the server
1060                   SSL object - we want the server to *not* have any certificate at the
1061                   moment it parses ClientHello so that the early OCSP code path fails. */
1062                ExpectIntEQ(wolfSSL_UnloadCertsKeys(test_ctx.s_ssl), WOLFSSL_SUCCESS);
1063
1064                /* turn on OCSP stapling on the server side */
1065                ExpectIntEQ(wolfSSL_CTX_EnableOCSPStapling(test_ctx.s_ctx), WOLFSSL_SUCCESS);
1066                ExpectIntEQ(wolfSSL_CTX_set_tlsext_status_cb(test_ctx.s_ctx,
1067                        test_ocsp_tls_cert_cb_status_cb), WOLFSSL_SUCCESS);
1068
1069                /* client: request stapling */
1070                wolfSSL_set_verify(test_ctx.c_ssl, WOLFSSL_VERIFY_DEFAULT,
1071                        test_ocsp_tls_cert_cb_verify_cb);
1072                wolfSSL_CTX_set_ocsp_status_verify_cb(test_ctx.c_ctx,
1073                        test_ocsp_tls_cert_cb_ocsp_verify_cb, NULL);
1074
1075                /* Set the ssl object as the cert callback context as there is
1076                 * no way to get ssl from the store without OPENSSL_EXTRA */
1077                wolfSSL_SetCertCbCtx(test_ctx.c_ssl, test_ctx.c_ssl);
1078                ExpectIntEQ(wolfSSL_CTX_EnableOCSPStapling(test_ctx.c_ctx), WOLFSSL_SUCCESS);
1079                ExpectIntEQ(wolfSSL_CTX_EnableOCSPMustStaple(test_ctx.c_ctx), WOLFSSL_SUCCESS);
1080                if (params[i].useV2) {
1081    #ifdef HAVE_CERTIFICATE_STATUS_REQUEST_V2
1082                    printf("\twith V2 %s\n", params[i].useV2multi ? "multi" : "single");
1083                    ExpectIntEQ(wolfSSL_UseOCSPStaplingV2(test_ctx.c_ssl,
1084                            params[i].useV2multi ?
1085                                    WOLFSSL_CSR2_OCSP_MULTI : WOLFSSL_CSR2_OCSP,
1086                                    WOLFSSL_CSR2_OCSP_USE_NONCE),
1087                            WOLFSSL_SUCCESS);
1088    #else
1089                    skip = 1;
1090    #endif
1091                }
1092                else {
1093    #ifdef HAVE_CERTIFICATE_STATUS_REQUEST
1094                    printf("\twith V1\n");
1095                    ExpectIntEQ(wolfSSL_UseOCSPStapling(test_ctx.c_ssl,
1096                            WOLFSSL_CSR_OCSP, 0),
1097                            WOLFSSL_SUCCESS);
1098    #else
1099                    skip = 1;
1100    #endif
1101                }
1102
1103                if (!skip) {
1104                    ExpectIntEQ(test_ssl_memio_do_handshake(&test_ctx, 10, NULL),
1105                            j == 0 ? TEST_SUCCESS : TEST_FAIL);
1106                    if (j != 0) {
1107                        WOLFSSL_ALERT_HISTORY h;
1108                        XMEMSET(&h, 0, sizeof(h));
1109                        ExpectIntEQ(wolfSSL_get_alert_history(test_ctx.s_ssl, &h),
1110                                WOLFSSL_SUCCESS);
1111                        ExpectIntEQ(h.last_rx.level, alert_fatal);
1112                        ExpectIntEQ(h.last_rx.code, bad_certificate_status_response);
1113                    }
1114                }
1115                else {
1116                    /* coverity[deadcode] - skip is only set for some build configs */
1117                    printf("\tskipping test case\n");
1118                }
1119
1120                test_ssl_memio_cleanup(&test_ctx);
1121            }
1122        }
1123    }
1124
1125    return EXPECT_RESULT();
1126}
1127
1128#else  /* feature guards */
1129int test_ocsp_tls_cert_cb(void)
1130{
1131    return TEST_SKIPPED;
1132}
1133#endif
1134
1135/*
1136 * Test: OCSP returns CERT_UNKNOWN for the leaf cert, CRL says cert is valid.
1137 * Expects the TLS handshake to succeed via CRL fallback.
1138 *
1139 * Uses:
1140 *  - server-cert.pem (serial 0x01, issued by ca-cert.pem)
1141 *  - resp_server_cert_unknown: OCSP response with CERT_UNKNOWN for serial 0x01
1142 *  - crl/crl.pem: CRL from ca-cert.pem, only revokes serial 0x02
1143 */
1144#if defined(HAVE_OCSP) && defined(HAVE_CRL) && \
1145    defined(HAVE_SSL_MEMIO_TESTS_DEPENDENCIES) && !defined(NO_RSA) && \
1146    !defined(NO_SHA)
1147
1148static int test_ocsp_unknown_crl_fallback_ocsp_io_cb(void* ioCtx,
1149    const char* url, int urlSz, unsigned char* request, int requestSz,
1150    unsigned char** response)
1151{
1152    (void)url;
1153    (void)urlSz;
1154    (void)request;
1155    (void)requestSz;
1156
1157    /* Return the pre-built CERT_UNKNOWN response for server-cert.pem */
1158    *response = (unsigned char*)ioCtx;
1159    return (int)sizeof(resp_server_cert_unknown);
1160}
1161
1162static int test_ocsp_unknown_crl_fallback_ctx_ready(WOLFSSL_CTX* ctx)
1163{
1164    EXPECT_DECLS;
1165
1166    /* Enable OCSP on client with URL override so no real network is needed */
1167    ExpectIntEQ(wolfSSL_CTX_EnableOCSP(ctx,
1168                    WOLFSSL_OCSP_URL_OVERRIDE | WOLFSSL_OCSP_NO_NONCE),
1169        WOLFSSL_SUCCESS);
1170    ExpectIntEQ(wolfSSL_CTX_SetOCSP_OverrideURL(ctx, "http://dummy.test"),
1171        WOLFSSL_SUCCESS);
1172    /* Set the OCSP I/O callback to return our CERT_UNKNOWN response blob */
1173    ExpectIntEQ(wolfSSL_CTX_SetOCSP_Cb(ctx,
1174                    test_ocsp_unknown_crl_fallback_ocsp_io_cb, NULL,
1175                    (void*)resp_server_cert_unknown),
1176        WOLFSSL_SUCCESS);
1177
1178    /* Enable CRL checking (already loaded via crlPemFile in the framework) */
1179
1180    return EXPECT_RESULT();
1181}
1182
1183int test_ocsp_cert_unknown_crl_fallback(void)
1184{
1185    EXPECT_DECLS;
1186    struct test_ssl_memio_ctx test_ctx;
1187
1188    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1189
1190    /* Server setup: use standard server cert issued by ca-cert.pem */
1191    test_ctx.s_cb.certPemFile = "./certs/server-cert.pem";
1192    test_ctx.s_cb.keyPemFile  = "./certs/server-key.pem";
1193
1194    /* Client setup: CA cert, CRL file, and custom ctx_ready for OCSP */
1195    test_ctx.c_cb.caPemFile   = "./certs/ca-cert.pem";
1196    test_ctx.c_cb.crlPemFile  = "./certs/crl/crl.pem";
1197    test_ctx.c_cb.ctx_ready   = test_ocsp_unknown_crl_fallback_ctx_ready;
1198
1199    ExpectIntEQ(test_ssl_memio_setup(&test_ctx), TEST_SUCCESS);
1200
1201    /* The OCSP response returns CERT_UNKNOWN for the server cert.
1202     * CRL (crl.pem) does NOT revoke serial 0x01 (only 0x02 is revoked).
1203     * If OCSP CERT_UNKNOWN correctly falls back to CRL, the handshake
1204     * should succeed.
1205     */
1206    ExpectIntEQ(test_ssl_memio_do_handshake(&test_ctx, 10, NULL),
1207        TEST_SUCCESS);
1208
1209    test_ssl_memio_cleanup(&test_ctx);
1210    return EXPECT_RESULT();
1211}
1212
1213#else
1214int test_ocsp_cert_unknown_crl_fallback(void)
1215{
1216    return TEST_SKIPPED;
1217}
1218#endif /* HAVE_OCSP && HAVE_CRL && HAVE_SSL_MEMIO_TESTS_DEPENDENCIES && */
1219       /* !NO_RSA && !NO_SHA */
1220
1221/*
1222 * Test: OCSP returns CERT_UNKNOWN for a non-leaf (intermediate) cert,
1223 * CRL says the cert is valid. With both OCSP_CHECKALL and CRL_CHECKALL
1224 * enabled, the CRL fallback for non-leaf certs should kick in.
1225 *
1226 * Chain: server1 (serial 0x05) -> intermediate1 (serial 0x01) -> root-ca
1227 *
1228 * OCSP responses:
1229 *  - intermediate1: resp_cert_unknown (CERT_UNKNOWN)
1230 *  - server1:       resp_server1_cert (CERT_GOOD)
1231 *
1232 * CRL files (empty = no revocations):
1233 *  - root-ca-crl.pem:          covers intermediate1 (serial 0x01 not revoked)
1234 *  - intermediate1-ca-crl.pem: covers server1 (serial 0x05 not revoked)
1235 */
1236#if defined(HAVE_OCSP) && defined(HAVE_CRL) && \
1237    defined(HAVE_SSL_MEMIO_TESTS_DEPENDENCIES) && !defined(NO_RSA) && \
1238    !defined(NO_SHA)
1239
1240static int test_ocsp_unknown_nonleaf_call_count;
1241
1242static int test_ocsp_unknown_nonleaf_ocsp_io_cb(void* ioCtx,
1243    const char* url, int urlSz, unsigned char* request, int requestSz,
1244    unsigned char** response)
1245{
1246    (void)ioCtx;
1247    (void)url;
1248    (void)urlSz;
1249    (void)request;
1250    (void)requestSz;
1251
1252    test_ocsp_unknown_nonleaf_call_count++;
1253
1254    if (test_ocsp_unknown_nonleaf_call_count == 1) {
1255        /* First OCSP lookup: non-leaf cert (intermediate1).
1256         * Return CERT_UNKNOWN. */
1257        *response = (unsigned char*)resp_cert_unknown;
1258        return (int)sizeof(resp_cert_unknown);
1259    }
1260    else {
1261        /* Second OCSP lookup: leaf cert (server1).
1262         * Return CERT_GOOD. */
1263        *response = (unsigned char*)resp_server1_cert;
1264        return (int)sizeof(resp_server1_cert);
1265    }
1266}
1267
1268static int test_ocsp_unknown_nonleaf_ctx_ready(WOLFSSL_CTX* ctx)
1269{
1270    EXPECT_DECLS;
1271
1272    /* Need VERIFY_PEER so chain certs get added to the CM. Without it
1273     * (e.g. OPENSSL_COMPATIBLE_DEFAULTS sets VERIFY_NONE), the intermediate
1274     * CA won't be registered and the leaf cert's issuerKeyHash stays zero,
1275     * causing the OCSP CertID comparison to fail. */
1276    wolfSSL_CTX_set_verify(ctx, WOLFSSL_VERIFY_PEER, NULL);
1277
1278    /* Enable OCSP with CHECKALL so non-leaf certs are also OCSP-checked */
1279    ExpectIntEQ(wolfSSL_CTX_EnableOCSP(ctx, WOLFSSL_OCSP_CHECKALL |
1280                    WOLFSSL_OCSP_URL_OVERRIDE | WOLFSSL_OCSP_NO_NONCE),
1281        WOLFSSL_SUCCESS);
1282    ExpectIntEQ(wolfSSL_CTX_SetOCSP_OverrideURL(ctx, "http://dummy.test"),
1283        WOLFSSL_SUCCESS);
1284    /* Set the OCSP I/O callback to return our test responses */
1285    ExpectIntEQ(wolfSSL_CTX_SetOCSP_Cb(ctx,
1286                    test_ocsp_unknown_nonleaf_ocsp_io_cb, NULL, NULL),
1287        WOLFSSL_SUCCESS);
1288
1289    /* Load CRL from root-ca (covers intermediate1, serial 0x01 not revoked).
1290     * The leaf cert (server1) gets CERT_GOOD from OCSP so doesn't need CRL. */
1291    ExpectIntEQ(wolfSSL_CTX_EnableCRL(ctx, WOLFSSL_CRL_CHECKALL),
1292        WOLFSSL_SUCCESS);
1293    ExpectIntEQ(wolfSSL_CTX_LoadCRLFile(ctx,
1294                    "./certs/ocsp/root-ca-crl.pem", WOLFSSL_FILETYPE_PEM),
1295        WOLFSSL_SUCCESS);
1296
1297    return EXPECT_RESULT();
1298}
1299
1300int test_ocsp_cert_unknown_crl_fallback_nonleaf(void)
1301{
1302    EXPECT_DECLS;
1303    struct test_ssl_memio_ctx test_ctx;
1304
1305    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1306    test_ocsp_unknown_nonleaf_call_count = 0;
1307
1308    /* Server: server1-chain-noroot.pem contains server1 + intermediate1
1309     * (no root-ca, since the client already trusts root-ca) */
1310    test_ctx.s_cb.certPemFile = "./certs/ocsp/server1-chain-noroot.pem";
1311    test_ctx.s_cb.keyPemFile  = "./certs/ocsp/server1-key.pem";
1312
1313    /* Client: trust root-ca, enable OCSP+CRL in ctx_ready */
1314    test_ctx.c_cb.caPemFile = "./certs/ocsp/root-ca-cert.pem";
1315    test_ctx.c_cb.ctx_ready = test_ocsp_unknown_nonleaf_ctx_ready;
1316
1317    ExpectIntEQ(test_ssl_memio_setup(&test_ctx), TEST_SUCCESS);
1318
1319    /* OCSP returns CERT_UNKNOWN for intermediate1 (non-leaf).
1320     * CRL (root-ca-crl.pem) has no revocations, so intermediate1 is valid.
1321     * If the non-leaf OCSP->CRL fallback works, the handshake should succeed.
1322     */
1323    ExpectIntEQ(test_ssl_memio_do_handshake(&test_ctx, 10, NULL),
1324        TEST_SUCCESS);
1325
1326    test_ssl_memio_cleanup(&test_ctx);
1327    return EXPECT_RESULT();
1328}
1329
1330#else
1331int test_ocsp_cert_unknown_crl_fallback_nonleaf(void)
1332{
1333    return TEST_SKIPPED;
1334}
1335#endif /* HAVE_OCSP && HAVE_CRL && HAVE_SSL_MEMIO_TESTS_DEPENDENCIES */
1336
1337#if defined(HAVE_OCSP) && defined(WOLFSSL_TLS13) &&                 \
1338    defined(WOLFSSL_NONBLOCK_OCSP) && defined(HAVE_MAX_FRAGMENT) && \
1339    defined(HAVE_SSL_MEMIO_TESTS_DEPENDENCIES) &&                   \
1340    !defined(NO_RSA) && !defined(NO_SHA)
1341
1342/* Number of times the OCSP IO callback has been called. */
1343static int test_tls13_nonblock_ocsp_mfl_cb_cnt;
1344
1345/*
1346 * OCSP IO callback: simulates a nonblocking responder. Returns WANT_READ
1347 * a few times before finally returning the OCSP response.
1348 */
1349static int test_tls13_nonblock_ocsp_mfl_io_cb(void* ioCtx, const char* url,
1350    int urlSz, unsigned char* req, int reqSz, unsigned char** respBuf)
1351{
1352    (void)ioCtx;
1353    (void)url;
1354    (void)urlSz;
1355    (void)req;
1356    (void)reqSz;
1357
1358    if (test_tls13_nonblock_ocsp_mfl_cb_cnt++ < 5)
1359        return WOLFSSL_CBIO_ERR_WANT_READ;
1360
1361    *respBuf = (unsigned char*)resp_server1_cert;
1362    return (int)sizeof(resp_server1_cert);
1363}
1364
1365/* CTX-ready callback: enable client-side OCSP with URL override. */
1366static int test_tls13_nonblock_ocsp_mfl_ctx_ready(WOLFSSL_CTX* ctx)
1367{
1368    EXPECT_DECLS;
1369    ExpectIntEQ(wolfSSL_CTX_EnableOCSP(ctx,
1370                    WOLFSSL_OCSP_URL_OVERRIDE | WOLFSSL_OCSP_NO_NONCE),
1371        WOLFSSL_SUCCESS);
1372    ExpectIntEQ(wolfSSL_CTX_SetOCSP_OverrideURL(ctx, "http://example.com"),
1373        WOLFSSL_SUCCESS);
1374    /* NULL free-callback: resp points to static array, must not be freed. */
1375    ExpectIntEQ(wolfSSL_CTX_SetOCSP_Cb(ctx,
1376                    test_tls13_nonblock_ocsp_mfl_io_cb, NULL, NULL),
1377        WOLFSSL_SUCCESS);
1378    return EXPECT_RESULT();
1379}
1380
1381/* SSL-ready callback: cap record payload at 1024 bytes. */
1382static int test_tls13_nonblock_ocsp_mfl_ssl_ready(WOLFSSL* ssl)
1383{
1384    EXPECT_DECLS;
1385    ExpectIntEQ(wolfSSL_UseMaxFragment(ssl, WOLFSSL_MFL_2_10), WOLFSSL_SUCCESS);
1386    return EXPECT_RESULT();
1387}
1388
1389int test_tls13_nonblock_ocsp_low_mfl(void)
1390{
1391    EXPECT_DECLS;
1392    struct test_ssl_memio_ctx test_ctx;
1393
1394    XMEMSET(&test_ctx, 0, sizeof(test_ctx));
1395    test_tls13_nonblock_ocsp_mfl_cb_cnt = 0;
1396
1397    /*
1398     * Server: two-cert chain (server1 + intermediate1, no root).
1399     * Total DER size ~2534 bytes -> splits into 3 TLS records at MFL=1024.
1400     */
1401    test_ctx.s_cb.certPemFile = "./certs/ocsp/server1-chain-noroot.pem";
1402    test_ctx.s_cb.keyPemFile  = "./certs/ocsp/server1-key.pem";
1403    test_ctx.s_cb.method      = wolfTLSv1_3_server_method;
1404
1405    /* Client: trust root-ca, TLS 1.3, OCSP + MFL=1024. */
1406    test_ctx.c_cb.caPemFile = "./certs/ocsp/root-ca-cert.pem";
1407    test_ctx.c_cb.method    = wolfTLSv1_3_client_method;
1408    test_ctx.c_cb.ctx_ready = test_tls13_nonblock_ocsp_mfl_ctx_ready;
1409    test_ctx.c_cb.ssl_ready = test_tls13_nonblock_ocsp_mfl_ssl_ready;
1410
1411    ExpectIntEQ(test_ssl_memio_setup(&test_ctx), TEST_SUCCESS);
1412    ExpectIntEQ(test_ssl_memio_do_handshake(&test_ctx, 10, NULL),
1413        TEST_SUCCESS);
1414
1415    /* The OCSP callback must have been retried (called more than once). */
1416    ExpectIntGT(test_tls13_nonblock_ocsp_mfl_cb_cnt, 1);
1417
1418    test_ssl_memio_cleanup(&test_ctx);
1419    return EXPECT_RESULT();
1420}
1421
1422#else
1423int test_tls13_nonblock_ocsp_low_mfl(void)
1424{
1425    return TEST_SKIPPED;
1426}
1427#endif
1428
1429#if defined(HAVE_OCSP_RESPONDER) && defined(WOLFSSL_ASN_TEMPLATE) && \
1430    !defined(NO_SHA) && !defined(NO_RSA)
1431/* Structure to hold test configuration */
1432typedef struct {
1433    const char* caCertPath;
1434    const char* responderCertPath;
1435    const char* responderKeyPath;
1436    const char* targetCertPath;
1437    enum Ocsp_Cert_Status certStatus;
1438    time_t revocationTime;               /* Used when status is CERT_REVOKED */
1439    enum WC_CRL_Reason revocationReason; /* Used when status is CERT_REVOKED */
1440    word32 validityPeriod;               /* Used when status is CERT_GOOD */
1441    int expectedResult;
1442    const char* testName;
1443} OcspResponderTestConfig;
1444
1445/* Helper function to run a single OCSP responder test configuration */
1446static int ocspResponderTest_Run(OcspResponderTestConfig* config, int sendCerts)
1447{
1448    EXPECT_DECLS;
1449    OcspResponder* responder = NULL;
1450    OcspRequest* clientReq = NULL;
1451    DecodedCert targetCert;
1452    DecodedCert decodedCaCert;
1453    WOLFSSL_CERT_MANAGER* cm = NULL;
1454    byte caCertDer[4096];
1455    byte responderCertDer[4096];
1456    byte responderKeyDer[4096];
1457    byte targetCertDer[4096];
1458    byte* respBuf = NULL;
1459    word32 caCertSz = sizeof(caCertDer);
1460    word32 responderCertSz = sizeof(responderCertDer);
1461    word32 responderKeyDerSz = sizeof(responderKeyDer);
1462    word32 targetCertSz = sizeof(targetCertDer);
1463    word32 respSz = 0;
1464    byte reqBuf[1024];
1465    int reqSz = 0;
1466    char caSubject[WC_ASN_NAME_MAX];
1467    word32 caSubjectSz = sizeof(caSubject);
1468    byte serial[EXTERNAL_SERIAL_SIZE];
1469    word32 serialSz = sizeof(serial);
1470    XFILE f = XBADFILE;
1471    byte usingAuthCa = XSTRCMP(config->caCertPath, config->responderCertPath) != 0;
1472
1473    printf("\nRunning OCSP Responder Test: %s (sendCerts=%d)\n",
1474           config->testName, sendCerts);
1475
1476    XMEMSET(&targetCert, 0, sizeof(targetCert));
1477    XMEMSET(&decodedCaCert, 0, sizeof(decodedCaCert));
1478
1479    /* Create certificate manager */
1480    ExpectNotNull(cm = wolfSSL_CertManagerNew());
1481
1482    /* Load CA certificate */
1483    ExpectTrue((f = XFOPEN(config->caCertPath, "rb")) != XBADFILE);
1484    ExpectIntGT(caCertSz = (word32)XFREAD(caCertDer, 1,
1485                                          caCertSz, f), 0);
1486    if (f != XBADFILE) {
1487        XFCLOSE(f);
1488        f = XBADFILE;
1489    }
1490    ExpectIntEQ(wolfSSL_CertManagerLoadCABuffer(cm, caCertDer, caCertSz,
1491                                                WOLFSSL_FILETYPE_ASN1),
1492                WOLFSSL_SUCCESS);
1493
1494    wc_InitDecodedCert(&decodedCaCert, caCertDer, caCertSz, NULL);
1495    ExpectIntEQ(wc_ParseCert(&decodedCaCert, CERT_TYPE, 0, NULL), 0);
1496
1497    /* Load responder certificate */
1498    ExpectTrue((f = XFOPEN(config->responderCertPath, "rb")) != XBADFILE);
1499    ExpectIntGT(responderCertSz = (word32)XFREAD(responderCertDer, 1,
1500                                          responderCertSz, f), 0);
1501    if (f != XBADFILE) {
1502        XFCLOSE(f);
1503        f = XBADFILE;
1504    }
1505
1506    if (usingAuthCa && !sendCerts) {
1507        /* If responder is not sending certs then it must be loaded into cm */
1508        ExpectIntEQ(wolfSSL_CertManagerLoadCABuffer(cm, responderCertDer,
1509                responderCertSz, WOLFSSL_FILETYPE_ASN1), WOLFSSL_SUCCESS);
1510    }
1511
1512    /* Load responder private key */
1513    ExpectTrue((f = XFOPEN(config->responderKeyPath, "rb")) != XBADFILE);
1514    ExpectIntGT(responderKeyDerSz = (word32)XFREAD(responderKeyDer, 1,
1515                                          responderKeyDerSz, f), 0);
1516    if (f != XBADFILE) {
1517        XFCLOSE(f);
1518        f = XBADFILE;
1519    }
1520
1521    /* Load target certificate */
1522    ExpectTrue((f = XFOPEN(config->targetCertPath, "rb")) != XBADFILE);
1523    ExpectIntGT(targetCertSz = (word32)XFREAD(targetCertDer, 1,
1524                                          targetCertSz, f), 0);
1525    if (f != XBADFILE) {
1526        XFCLOSE(f);
1527        f = XBADFILE;
1528    }
1529
1530    /* Parse target certificate */
1531    wc_InitDecodedCert(&targetCert, targetCertDer, targetCertSz, NULL);
1532    ExpectIntEQ(wc_ParseCert(&targetCert, CERT_TYPE, 0, cm), 0);
1533
1534    /* Create OCSP request from target certificate */
1535    ExpectNotNull(clientReq = wc_OcspRequest_new(NULL));
1536    ExpectIntEQ(wc_InitOcspRequest(clientReq, &targetCert, 1, NULL), 0);
1537    ExpectIntGT(reqSz = wc_EncodeOcspRequest(clientReq, reqBuf,
1538                                              sizeof(reqBuf)), 0);
1539
1540    /* Create OCSP Responder */
1541    ExpectNotNull(responder = wc_OcspResponder_new(NULL, sendCerts));
1542
1543    /* Add responder (authorized) to responder */
1544    ExpectIntEQ(wc_OcspResponder_AddSigner(responder,
1545            responderCertDer, responderCertSz,
1546            responderKeyDer, responderKeyDerSz,
1547            usingAuthCa ? caCertDer : NULL, usingAuthCa ? caCertSz : 0), 0);
1548
1549    /* Set certificate status */
1550    ExpectIntEQ(wc_GetDecodedCertSubject(&decodedCaCert, caSubject, &caSubjectSz), 0);
1551    ExpectIntGT(caSubjectSz, 0);
1552    ExpectIntEQ(wc_GetDecodedCertSerial(&targetCert, serial, &serialSz), 0);
1553    ExpectIntGT(serialSz, 0);
1554
1555    ExpectIntEQ(wc_OcspResponder_SetCertStatus(responder,
1556                                               caSubject, caSubjectSz,
1557                                               serial, serialSz,
1558                                               config->certStatus,
1559                                               config->revocationTime,
1560                                               config->revocationReason,
1561                                               config->validityPeriod), 0);
1562
1563    /* Get required response size */
1564    ExpectIntEQ(wc_OcspResponder_WriteResponse(responder, reqBuf, reqSz,
1565                                               NULL, &respSz), 0);
1566
1567    /* Allocate response buffer */
1568    ExpectNotNull(respBuf = (byte*)XMALLOC(respSz, NULL,
1569            DYNAMIC_TYPE_TMP_BUFFER));
1570
1571    /* Generate OCSP response */
1572    ExpectIntEQ(wc_OcspResponder_WriteResponse(responder, reqBuf, reqSz,
1573                                               respBuf, &respSz), 0);
1574
1575    /* Verify response matches expected result */
1576    {
1577        WOLFSSL_OCSP* ocsp = NULL;
1578        ExpectNotNull(ocsp = wc_NewOCSP(cm));
1579        ExpectIntEQ(wc_CheckCertOcspResponse(ocsp, &targetCert, respBuf,
1580                respSz, NULL), config->expectedResult);
1581        wc_FreeOCSP(ocsp);
1582    }
1583
1584    /* Cleanup */
1585    XFREE(respBuf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1586    wc_OcspRequest_free(clientReq);
1587    wc_OcspResponder_free(responder);
1588    wc_FreeDecodedCert(&targetCert);
1589    wc_FreeDecodedCert(&decodedCaCert);
1590    wolfSSL_CertManagerFree(cm);
1591
1592    return EXPECT_RESULT();
1593}
1594
1595int test_ocsp_responder(void)
1596{
1597    EXPECT_DECLS;
1598    time_t now = wc_Time(NULL);
1599    OcspResponderTestConfig configs[] = {
1600        {
1601            "./certs/ca-cert.der",
1602            "./certs/ca-cert.der",
1603            "./certs/ca-key.der",
1604            "./certs/server-cert.der",
1605            CERT_GOOD,
1606            0, WC_CRL_REASON_UNSPECIFIED,
1607            86400, /* validityPeriod - 24 hours */
1608            0,
1609            "RSA server cert - GOOD status"
1610        },
1611        {
1612            "./certs/ca-cert.der",
1613            "./certs/ca-cert.der",
1614            "./certs/ca-key.der",
1615            "./certs/server-cert.der",
1616            CERT_REVOKED,
1617            now, WC_CRL_REASON_KEY_COMPROMISE,  /* Revoked due to key compromise */
1618            0,     /* validityPeriod (not used for REVOKED) */
1619            OCSP_CERT_REVOKED,
1620            "RSA server cert - REVOKED status"
1621        },
1622        {
1623            "./certs/ca-cert.der",
1624            "./certs/ca-cert.der",
1625            "./certs/ca-key.der",
1626            "./certs/server-cert.der",
1627            CERT_UNKNOWN,
1628            0, WC_CRL_REASON_UNSPECIFIED,
1629            0,     /* validityPeriod (not used for UNKNOWN) */
1630            OCSP_CERT_UNKNOWN,
1631            "RSA server cert - UNKNOWN status"
1632        },
1633        {
1634            "./certs/ocsp/root-ca-cert.der",
1635            "./certs/ocsp/ocsp-responder-cert.der",
1636            "./certs/ocsp/ocsp-responder-key.der",
1637            "./certs/ocsp/intermediate1-ca-cert.der",
1638            CERT_GOOD,
1639            0, WC_CRL_REASON_UNSPECIFIED,
1640            86400, /* validityPeriod - 24 hours */
1641            0,
1642            "RSA int1 cert with responder - GOOD status"
1643        },
1644        {
1645            "./certs/ocsp/root-ca-cert.der",
1646            "./certs/ocsp/ocsp-responder-cert.der",
1647            "./certs/ocsp/ocsp-responder-key.der",
1648            "./certs/ocsp/intermediate1-ca-cert.der",
1649            CERT_REVOKED,
1650            now, WC_CRL_REASON_KEY_COMPROMISE,  /* Revoked due to key compromise */
1651            0,     /* validityPeriod (not used for REVOKED) */
1652            OCSP_CERT_REVOKED,
1653            "RSA int1 cert with responder - REVOKED status"
1654        },
1655        {
1656            "./certs/ocsp/root-ca-cert.der",
1657            "./certs/ocsp/ocsp-responder-cert.der",
1658            "./certs/ocsp/ocsp-responder-key.der",
1659            "./certs/ocsp/intermediate1-ca-cert.der",
1660            CERT_UNKNOWN,
1661            0, WC_CRL_REASON_UNSPECIFIED,
1662            0,     /* validityPeriod (not used for UNKNOWN) */
1663            OCSP_CERT_UNKNOWN,
1664            "RSA int1 cert with responder - UNKNOWN status"
1665        },
1666#ifdef HAVE_ECC
1667        {
1668            "./certs/ca-ecc-cert.der",
1669            "./certs/ca-ecc-cert.der",
1670            "./certs/ca-ecc-key.der",
1671            "./certs/server-ecc.der",
1672            CERT_GOOD,
1673            0, WC_CRL_REASON_UNSPECIFIED,
1674            86400, /* validityPeriod - 24 hours */
1675            0,
1676            "ECC server cert - GOOD status"
1677        },
1678        {
1679            "./certs/ca-ecc-cert.der",
1680            "./certs/ca-ecc-cert.der",
1681            "./certs/ca-ecc-key.der",
1682            "./certs/server-ecc.der",
1683            CERT_REVOKED,
1684            now, WC_CRL_REASON_AFFILIATION_CHANGED,
1685            0,     /* validityPeriod (not used for REVOKED) */
1686            OCSP_CERT_REVOKED,
1687            "ECC server cert - REVOKED status"
1688        },
1689        {
1690            "./certs/ca-ecc-cert.der",
1691            "./certs/ca-ecc-cert.der",
1692            "./certs/ca-ecc-key.der",
1693            "./certs/server-ecc.der",
1694            CERT_UNKNOWN,
1695            0, WC_CRL_REASON_UNSPECIFIED,
1696            0,     /* validityPeriod (not used for UNKNOWN) */
1697            OCSP_CERT_UNKNOWN,
1698            "ECC server cert - UNKNOWN status"
1699        }
1700#endif
1701    };
1702    int i;
1703    int numTests = (int)(sizeof(configs) / sizeof(configs[0]));
1704
1705    /* Run each test configuration twice: once without certs, once with certs */
1706    for (i = 0; i < numTests; i++) {
1707        ExpectIntEQ(ocspResponderTest_Run(&configs[i], 0), TEST_SUCCESS);
1708        ExpectIntEQ(ocspResponderTest_Run(&configs[i], 1), TEST_SUCCESS);
1709    }
1710
1711    return EXPECT_RESULT();
1712}
1713#else
1714int test_ocsp_responder(void)
1715{
1716    return TEST_SKIPPED;
1717}
1718#endif /* HAVE_OCSP_RESPONDER && !NO_SHA && !NO_RSA */