luna - wolfssl/src/ocsp.c

   1/* 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 <wolfssl/wolfcrypt/libwolfssl_sources.h>
  23
  24  /* Name change compatibility layer no longer needs to be included here */
  25
  26/*
  27 * WOLFSSL_NO_OCSP_ISSUER_CHAIN_CHECK:
  28 *     Disable looking for an authorized responder in the verification path of
  29 *     the issuer. This will make the authorized responder only look at the
  30 *     OCSP response signer and direct issuer.
  31 */
  32
  33/*
  34 * OCSP responder missing features:
  35 * - Support for multiple requests and responses in a single OCSP exchange
  36 * - Support name-based responder ID
  37 * - Support for singleExtensions
  38 */
  39
  40#ifndef WOLFCRYPT_ONLY
  41#ifdef HAVE_OCSP
  42
  43#include <wolfssl/error-ssl.h>
  44#include <wolfssl/ocsp.h>
  45#include <wolfssl/internal.h>
  46
  47#ifdef NO_INLINE
  48    #include <wolfssl/wolfcrypt/misc.h>
  49#else
  50    #define WOLFSSL_MISC_INCLUDED
  51    #include <wolfcrypt/src/misc.c>
  52#endif
  53
  54/* Allocates and initializes a WOLFSSL_OCSP object. Returns pointer on success, NULL on failure. */
  55WOLFSSL_OCSP* wc_NewOCSP(WOLFSSL_CERT_MANAGER* cm)
  56{
  57    WOLFSSL_OCSP* ocsp = NULL;
  58    ocsp = (WOLFSSL_OCSP*)XMALLOC(sizeof(WOLFSSL_OCSP), cm ? cm->heap : NULL, DYNAMIC_TYPE_OCSP);
  59    if (ocsp == NULL)
  60        return NULL;
  61    if (InitOCSP(ocsp, cm) != 0) {
  62        XFREE(ocsp, cm ? cm->heap : NULL, DYNAMIC_TYPE_OCSP);
  63        return NULL;
  64    }
  65    return ocsp;
  66}
  67
  68/* Frees a WOLFSSL_OCSP object allocated by wc_NewOCSP. */
  69void wc_FreeOCSP(WOLFSSL_OCSP* ocsp)
  70{
  71    if (ocsp) {
  72        FreeOCSP(ocsp, 1);
  73    }
  74}
  75
  76int wc_CheckCertOcspResponse(WOLFSSL_OCSP *ocsp, DecodedCert *cert,
  77        byte *response, int responseSz, void* heap)
  78{
  79    int ret = WC_NO_ERR_TRACE(ASN_OCSP_CONFIRM_E);
  80
  81#ifdef WOLFSSL_SMALL_STACK
  82    OcspRequest* ocspRequest;
  83#else
  84    OcspRequest ocspRequest[1];
  85#endif
  86
  87
  88#ifdef WOLFSSL_SMALL_STACK
  89    ocspRequest = (OcspRequest*)XMALLOC(sizeof(OcspRequest), NULL,
  90                                                       DYNAMIC_TYPE_TMP_BUFFER);
  91    if (ocspRequest == NULL) {
  92        WOLFSSL_LEAVE("wc_CheckCertOcspResponse", MEMORY_ERROR);
  93        return MEMORY_E;
  94    }
  95#endif
  96
  97    if (InitOcspRequest(ocspRequest, cert, ocsp->cm->ocspSendNonce,
  98                                                         ocsp->cm->heap) == 0) {
  99        ret = CheckOcspResponse(ocsp, response, responseSz, NULL, NULL, NULL,
 100                ocspRequest, heap);
 101        FreeOcspRequest(ocspRequest);
 102    }
 103
 104#ifdef WOLFSSL_SMALL_STACK
 105    XFREE(ocspRequest, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 106#endif
 107
 108    WOLFSSL_LEAVE("wc_CheckCertOcspResponse", ret);
 109    return ret;
 110}
 111
 112int InitOCSP(WOLFSSL_OCSP* ocsp, WOLFSSL_CERT_MANAGER* cm)
 113{
 114    WOLFSSL_ENTER("InitOCSP");
 115
 116    ForceZero(ocsp, sizeof(WOLFSSL_OCSP));
 117
 118    if (wc_InitMutex(&ocsp->ocspLock) != 0)
 119        return BAD_MUTEX_E;
 120
 121    ocsp->cm = cm;
 122
 123    return 0;
 124}
 125
 126
 127static int InitOcspEntry(OcspEntry* entry, OcspRequest* request)
 128{
 129    WOLFSSL_ENTER("InitOcspEntry");
 130
 131    ForceZero(entry, sizeof(OcspEntry));
 132
 133    XMEMCPY(entry->issuerHash,    request->issuerHash,    OCSP_DIGEST_SIZE);
 134    XMEMCPY(entry->issuerKeyHash, request->issuerKeyHash, OCSP_DIGEST_SIZE);
 135
 136    return 0;
 137}
 138
 139
 140static void FreeOcspEntry(OcspEntry* entry, void* heap)
 141{
 142    CertStatus *status, *next;
 143
 144    if (entry == NULL || !entry->ownStatus)
 145        return;
 146
 147    WOLFSSL_ENTER("FreeOcspEntry");
 148
 149    for (status = entry->status; status; status = next) {
 150        next = status->next;
 151
 152        XFREE(status->rawOcspResponse, heap, DYNAMIC_TYPE_OCSP_STATUS);
 153
 154#ifdef OPENSSL_EXTRA
 155        if (status->serialInt) {
 156            if (status->serialInt->isDynamic) {
 157                XFREE(status->serialInt->data, NULL, DYNAMIC_TYPE_OPENSSL);
 158            }
 159            XFREE(status->serialInt, NULL, DYNAMIC_TYPE_OPENSSL);
 160        }
 161        status->serialInt = NULL;
 162#endif
 163
 164        XFREE(status, heap, DYNAMIC_TYPE_OCSP_STATUS);
 165    }
 166
 167    (void)heap;
 168}
 169
 170
 171void FreeOCSP(WOLFSSL_OCSP* ocsp, int dynamic)
 172{
 173    OcspEntry *entry, *next;
 174    void* heap = (ocsp->cm != NULL) ? ocsp->cm->heap : NULL;
 175
 176    WOLFSSL_ENTER("FreeOCSP");
 177
 178    for (entry = ocsp->ocspList; entry; entry = next) {
 179        next = entry->next;
 180        FreeOcspEntry(entry, heap);
 181        XFREE(entry, heap, DYNAMIC_TYPE_OCSP_ENTRY);
 182    }
 183
 184    wc_FreeMutex(&ocsp->ocspLock);
 185
 186    if (dynamic)
 187        XFREE(ocsp, heap, DYNAMIC_TYPE_OCSP);
 188
 189}
 190
 191
 192static int xstat2err(int st)
 193{
 194    switch (st) {
 195        case CERT_GOOD:
 196            return 0;
 197        case CERT_REVOKED:
 198            return OCSP_CERT_REVOKED;
 199        default:
 200            return OCSP_CERT_UNKNOWN;
 201    }
 202}
 203
 204int CheckCertOCSP_ex(WOLFSSL_OCSP* ocsp, DecodedCert* cert, WOLFSSL* ssl)
 205{
 206    int ret = WC_NO_ERR_TRACE(OCSP_LOOKUP_FAIL);
 207
 208    WC_DECLARE_VAR(ocspRequest, OcspRequest, 1, 0);
 209
 210    WOLFSSL_ENTER("CheckCertOCSP");
 211
 212
 213#ifdef WOLFSSL_SMALL_STACK
 214    ocspRequest = (OcspRequest*)XMALLOC(sizeof(OcspRequest), NULL,
 215                                                       DYNAMIC_TYPE_TMP_BUFFER);
 216    if (ocspRequest == NULL) {
 217        WOLFSSL_LEAVE("CheckCertOCSP", MEMORY_ERROR);
 218        return MEMORY_E;
 219    }
 220#endif
 221
 222    if (InitOcspRequest(ocspRequest, cert, ocsp->cm->ocspSendNonce,
 223                                                         ocsp->cm->heap) == 0) {
 224        ocspRequest->ssl = ssl;
 225        ret = CheckOcspRequest(ocsp, ocspRequest, NULL, NULL);
 226
 227        FreeOcspRequest(ocspRequest);
 228    }
 229
 230    WC_FREE_VAR_EX(ocspRequest, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 231
 232    WOLFSSL_LEAVE("CheckCertOCSP", ret);
 233    return ret;
 234}
 235int CheckCertOCSP(WOLFSSL_OCSP* ocsp, DecodedCert* cert)
 236{
 237    return CheckCertOCSP_ex(ocsp, cert, NULL);
 238}
 239
 240static int GetOcspEntry(WOLFSSL_OCSP* ocsp, OcspRequest* request,
 241                                                              OcspEntry** entry)
 242{
 243    WOLFSSL_ENTER("GetOcspEntry");
 244
 245    *entry = NULL;
 246
 247    if (wc_LockMutex(&ocsp->ocspLock) != 0) {
 248        WOLFSSL_LEAVE("GetOcspEntry", BAD_MUTEX_E);
 249        return BAD_MUTEX_E;
 250    }
 251
 252    for (*entry = ocsp->ocspList; *entry; *entry = (*entry)->next)
 253        if (XMEMCMP((*entry)->issuerHash,    request->issuerHash,
 254                                                         OCSP_DIGEST_SIZE) == 0
 255        &&  XMEMCMP((*entry)->issuerKeyHash, request->issuerKeyHash,
 256                                                         OCSP_DIGEST_SIZE) == 0)
 257            break;
 258
 259    if (*entry == NULL) {
 260        *entry = (OcspEntry*)XMALLOC(sizeof(OcspEntry),
 261                                       ocsp->cm->heap, DYNAMIC_TYPE_OCSP_ENTRY);
 262        if (*entry) {
 263            InitOcspEntry(*entry, request);
 264            (*entry)->next = ocsp->ocspList;
 265            ocsp->ocspList = *entry;
 266        }
 267    }
 268
 269    wc_UnLockMutex(&ocsp->ocspLock);
 270
 271    return *entry ? 0 : MEMORY_ERROR;
 272}
 273
 274
 275/* Mallocs responseBuffer->buffer and is up to caller to free on success
 276 *
 277 * Returns OCSP status
 278 */
 279static int GetOcspStatus(WOLFSSL_OCSP* ocsp, OcspRequest* request,
 280                  OcspEntry* entry, CertStatus** status, buffer* responseBuffer,
 281                  void* heap)
 282{
 283    int ret = WC_NO_ERR_TRACE(OCSP_INVALID_STATUS);
 284
 285    WOLFSSL_ENTER("GetOcspStatus");
 286
 287    (void)heap;
 288    *status = NULL;
 289
 290    if (wc_LockMutex(&ocsp->ocspLock) != 0) {
 291        WOLFSSL_LEAVE("GetOcspStatus", BAD_MUTEX_E);
 292        return BAD_MUTEX_E;
 293    }
 294
 295    for (*status = entry->status; *status; *status = (*status)->next)
 296        if ((*status)->serialSz == request->serialSz
 297        &&  !XMEMCMP((*status)->serial, request->serial, (size_t)(*status)->serialSz))
 298            break;
 299
 300    if (responseBuffer && *status && !(*status)->rawOcspResponse) {
 301        /* force fetching again */
 302        ret = OCSP_INVALID_STATUS;
 303    }
 304    else if (*status) {
 305#ifndef NO_ASN_TIME
 306        if (XVALIDATE_DATE((*status)->thisDate,
 307                           (*status)->thisDateFormat, ASN_BEFORE, MAX_DATE_SIZE)
 308        &&  ((*status)->nextDate[0] != 0)
 309        &&  XVALIDATE_DATE((*status)->nextDate,
 310                           (*status)->nextDateFormat, ASN_AFTER, MAX_DATE_SIZE))
 311#endif
 312        {
 313            ret = xstat2err((*status)->status);
 314
 315            if (responseBuffer) {
 316                responseBuffer->buffer = (byte*)XMALLOC(
 317                   (*status)->rawOcspResponseSz, heap,
 318                   DYNAMIC_TYPE_TMP_BUFFER);
 319
 320                if (responseBuffer->buffer) {
 321                    responseBuffer->length = (*status)->rawOcspResponseSz;
 322                    XMEMCPY(responseBuffer->buffer,
 323                            (*status)->rawOcspResponse,
 324                            (*status)->rawOcspResponseSz);
 325                }
 326            }
 327        }
 328    }
 329
 330    wc_UnLockMutex(&ocsp->ocspLock);
 331
 332    return ret;
 333}
 334
 335/* Check that the response for validity. Store result in status.
 336 *
 337 * ocsp           Context object for OCSP status.
 338 * response       OCSP response message data.
 339 * responseSz     Length of OCSP response message data.
 340 * responseBuffer Buffer object to return the response with.
 341 * status         The certificate status object.
 342 * entry          The OCSP entry for this certificate.
 343 * ocspRequest    Request corresponding to response.
 344 * heap           Heap hint used for responseBuffer
 345 * returns OCSP_LOOKUP_FAIL when the response is bad and 0 otherwise.
 346 */
 347int CheckOcspResponse(WOLFSSL_OCSP *ocsp, byte *response, int responseSz,
 348                      WOLFSSL_BUFFER_INFO *responseBuffer, CertStatus *status,
 349                      OcspEntry *entry, OcspRequest *ocspRequest, void* heap)
 350{
 351#ifdef WOLFSSL_SMALL_STACK
 352    CertStatus*   newStatus;
 353    OcspEntry*    newSingle;
 354    OcspResponse* ocspResponse;
 355#else
 356    CertStatus    newStatus[1];
 357    OcspEntry     newSingle[1];
 358    OcspResponse  ocspResponse[1];
 359#endif
 360    int           ret;
 361    int           validated      = 0;    /* ocsp validation flag */
 362
 363    (void)heap;
 364
 365#ifdef WOLFSSL_SMALL_STACK
 366    newStatus = (CertStatus*)XMALLOC(sizeof(CertStatus), NULL,
 367                                                       DYNAMIC_TYPE_OCSP_STATUS);
 368    newSingle = (OcspEntry*)XMALLOC(sizeof(OcspEntry), NULL,
 369                                                       DYNAMIC_TYPE_OCSP_ENTRY);
 370    ocspResponse = (OcspResponse*)XMALLOC(sizeof(OcspResponse), NULL,
 371                                                       DYNAMIC_TYPE_OCSP_REQUEST);
 372
 373    if (newStatus == NULL || newSingle == NULL || ocspResponse == NULL) {
 374        XFREE(newStatus, NULL, DYNAMIC_TYPE_OCSP_STATUS);
 375        XFREE(newSingle, NULL, DYNAMIC_TYPE_OCSP_ENTRY);
 376        XFREE(ocspResponse, NULL, DYNAMIC_TYPE_OCSP_REQUEST);
 377
 378        WOLFSSL_LEAVE("CheckOcspResponse", MEMORY_ERROR);
 379        return MEMORY_E;
 380    }
 381#endif
 382    InitOcspResponse(ocspResponse, newSingle, newStatus, response,
 383                     (word32)responseSz, ocsp->cm->heap);
 384#if defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2) && !defined(NO_TLS)
 385    if (ocspRequest != NULL && ocspRequest->ssl != NULL &&
 386           TLSX_CSR2_IsMulti(((WOLFSSL*)ocspRequest->ssl)->extensions)) {
 387        ocspResponse->pendingCAs = TLSX_CSR2_GetPendingSigners(((WOLFSSL*)ocspRequest->ssl)->extensions);
 388    }
 389#endif
 390    ret = OcspResponseDecode(ocspResponse, ocsp->cm, ocsp->cm->heap, 0, 0);
 391    if (ret != 0) {
 392        ocsp->error = ret;
 393        WOLFSSL_LEAVE("OcspResponseDecode failed", ocsp->error);
 394        goto end;
 395    }
 396
 397    if (ocspResponse->responseStatus != OCSP_SUCCESSFUL) {
 398        WOLFSSL_MSG("OcspResponse status bad");
 399        goto end;
 400    }
 401    if (ocspRequest != NULL) {
 402        /* Has the chance to bubble up response changing ocspResponse->single to
 403           no longer be pointing at newSingle */
 404        ret = CompareOcspReqResp(ocspRequest, ocspResponse);
 405        if (ret != 0) {
 406            goto end;
 407        }
 408    }
 409
 410    if (responseBuffer) {
 411        responseBuffer->buffer = (byte*)XMALLOC((size_t)responseSz, heap,
 412                                                DYNAMIC_TYPE_TMP_BUFFER);
 413
 414        if (responseBuffer->buffer) {
 415            responseBuffer->length = (unsigned int)responseSz;
 416            XMEMCPY(responseBuffer->buffer, response, (size_t)responseSz);
 417        }
 418    }
 419
 420    ret = xstat2err(ocspResponse->single->status->status);
 421    if (ret == 0) {
 422        validated = 1;
 423    }
 424
 425    if (wc_LockMutex(&ocsp->ocspLock) != 0) {
 426        ret = BAD_MUTEX_E;
 427        goto end;
 428    }
 429
 430    if (status != NULL) {
 431        XFREE(status->rawOcspResponse, ocsp->cm->heap, DYNAMIC_TYPE_OCSP_STATUS);
 432
 433        /* Replace existing certificate entry with updated */
 434        ocspResponse->single->status->next = status->next;
 435        XMEMCPY(status, ocspResponse->single->status, sizeof(CertStatus));
 436    }
 437    else if (entry != NULL) {
 438        /* Save new certificate entry */
 439        status = (CertStatus*)XMALLOC(sizeof(CertStatus),
 440                                      ocsp->cm->heap, DYNAMIC_TYPE_OCSP_STATUS);
 441        if (status != NULL) {
 442            XMEMCPY(status, ocspResponse->single->status, sizeof(CertStatus));
 443            status->next  = entry->status;
 444            entry->status = status;
 445            entry->ownStatus = 1;
 446            entry->totalStatus++;
 447        }
 448    }
 449
 450    if (status && responseBuffer && responseBuffer->buffer) {
 451        status->rawOcspResponse = (byte*)XMALLOC(responseBuffer->length,
 452                                                 ocsp->cm->heap,
 453                                                 DYNAMIC_TYPE_OCSP_STATUS);
 454
 455        if (status->rawOcspResponse) {
 456            status->rawOcspResponseSz = responseBuffer->length;
 457            XMEMCPY(status->rawOcspResponse, responseBuffer->buffer,
 458                    responseBuffer->length);
 459        }
 460    }
 461
 462    wc_UnLockMutex(&ocsp->ocspLock);
 463
 464end:
 465    if (ret == 0 && validated == 1) {
 466        WOLFSSL_MSG("New OcspResponse validated");
 467    }
 468    else if (ret == WC_NO_ERR_TRACE(OCSP_CERT_REVOKED)) {
 469        WOLFSSL_MSG("OCSP revoked");
 470    }
 471    else if (ret == WC_NO_ERR_TRACE(OCSP_CERT_UNKNOWN)) {
 472        WOLFSSL_MSG("OCSP unknown");
 473    }
 474    else {
 475        WOLFSSL_MSG("OCSP lookup failure");
 476        ret = OCSP_LOOKUP_FAIL;
 477    }
 478
 479    FreeOcspResponse(ocspResponse);
 480    WC_FREE_VAR_EX(newStatus, NULL, DYNAMIC_TYPE_OCSP_STATUS);
 481    WC_FREE_VAR_EX(newSingle, NULL, DYNAMIC_TYPE_OCSP_ENTRY);
 482    WC_FREE_VAR_EX(ocspResponse, NULL, DYNAMIC_TYPE_OCSP_REQUEST);
 483    return ret;
 484}
 485
 486/* 0 on success */
 487/* allow user to override the maximum request size at build-time */
 488#ifndef OCSP_MAX_REQUEST_SZ
 489#define OCSP_MAX_REQUEST_SZ 2048
 490#endif
 491int CheckOcspRequest(WOLFSSL_OCSP* ocsp, OcspRequest* ocspRequest,
 492                     buffer* responseBuffer, void* heap)
 493{
 494    OcspEntry*  entry          = NULL;
 495    CertStatus* status         = NULL;
 496    byte*       request        = NULL;
 497    int         requestSz      = OCSP_MAX_REQUEST_SZ;
 498    int         responseSz     = 0;
 499    byte*       response       = NULL;
 500    const char* url            = NULL;
 501    int         urlSz          = 0;
 502    int         ret            = -1;
 503    WOLFSSL*    ssl;
 504    void*       ioCtx;
 505
 506    WOLFSSL_ENTER("CheckOcspRequest");
 507
 508    if (ocsp == NULL || ocspRequest == NULL)
 509        return BAD_FUNC_ARG;
 510
 511    if (responseBuffer) {
 512        responseBuffer->buffer = NULL;
 513        responseBuffer->length = 0;
 514    }
 515
 516    ret = GetOcspEntry(ocsp, ocspRequest, &entry);
 517    if (ret != 0)
 518        return ret;
 519
 520    ret = GetOcspStatus(ocsp, ocspRequest, entry, &status, responseBuffer,
 521                        heap);
 522    if (ret != WC_NO_ERR_TRACE(OCSP_INVALID_STATUS))
 523        return ret;
 524
 525    if (responseBuffer) {
 526        XFREE(responseBuffer->buffer, heap, DYNAMIC_TYPE_TMP_BUFFER);
 527        responseBuffer->buffer = NULL;
 528    }
 529
 530    /* get SSL and IOCtx */
 531    ssl = (WOLFSSL*)ocspRequest->ssl;
 532    ioCtx = (ssl && ssl->ocspIOCtx != NULL) ?
 533                                        ssl->ocspIOCtx : ocsp->cm->ocspIOCtx;
 534
 535    if (ocsp->cm->ocspUseOverrideURL) {
 536        url = ocsp->cm->ocspOverrideURL;
 537        if (url != NULL && url[0] != '\0')
 538            urlSz = (int)XSTRLEN(url);
 539        else
 540            return OCSP_NEED_URL;
 541    }
 542    else if (ocspRequest->urlSz != 0 && ocspRequest->url != NULL) {
 543        url = (const char *)ocspRequest->url;
 544        urlSz = ocspRequest->urlSz;
 545    }
 546    else {
 547        /* cert doesn't have extAuthInfo, assuming CERT_GOOD */
 548        WOLFSSL_MSG("Cert has no OCSP URL, assuming CERT_GOOD");
 549        return 0;
 550    }
 551
 552    request = (byte*)XMALLOC((size_t)requestSz, ocsp->cm->heap, DYNAMIC_TYPE_OCSP);
 553    if (request == NULL) {
 554        WOLFSSL_LEAVE("CheckOcspRequest", MEMORY_ERROR);
 555        return MEMORY_ERROR;
 556    }
 557
 558    requestSz = EncodeOcspRequest(ocspRequest, request, (word32)requestSz);
 559    if (requestSz > 0 && ocsp->cm->ocspIOCb) {
 560        responseSz = ocsp->cm->ocspIOCb(ioCtx, url, urlSz,
 561                                        request, requestSz, &response);
 562    }
 563    if (responseSz == WC_NO_ERR_TRACE(WOLFSSL_CBIO_ERR_WANT_READ)) {
 564        ret = OCSP_WANT_READ;
 565    }
 566    else if (responseSz == WC_NO_ERR_TRACE(WOLFSSL_CBIO_ERR_TIMEOUT)){
 567        ret = HTTP_TIMEOUT;
 568    }
 569
 570    XFREE(request, ocsp->cm->heap, DYNAMIC_TYPE_OCSP);
 571
 572    if (responseSz >= 0 && response) {
 573        ret = CheckOcspResponse(ocsp, response, responseSz, responseBuffer, status,
 574                            entry, ocspRequest, heap);
 575    }
 576
 577    if (response != NULL && ocsp->cm->ocspRespFreeCb)
 578        ocsp->cm->ocspRespFreeCb(ioCtx, response);
 579
 580    /* Keep responseBuffer in the case of getting to response check. Caller
 581     * should free responseBuffer after checking OCSP return value in "ret" */
 582    WOLFSSL_LEAVE("CheckOcspRequest", ret);
 583    return ret;
 584}
 585
 586#ifndef WOLFSSL_NO_OCSP_ISSUER_CHAIN_CHECK
 587static int CheckOcspResponderChain(OcspEntry* single, byte* issuerNameHash,
 588        byte* issuerKeyHash, void* vp, Signer* pendingCAs) {
 589    /* Attempt to build a chain up to cert's issuer */
 590    WOLFSSL_CERT_MANAGER* cm = (WOLFSSL_CERT_MANAGER*)vp;
 591    Signer* ca = NULL;
 592    Signer* prev = NULL;
 593    int passed = 0;
 594
 595    /*
 596     *       Relation between certs:
 597     *                 CA
 598     *        /                 \
 599     *  intermediate(s)   cert in OCSP response
 600     *        |           with OCSP key usage ext
 601     *  issuer of cert
 602     *  in OCSP request
 603     */
 604
 605    if (issuerKeyHash == NULL)
 606        return 0;
 607
 608    /* Select CertID issuer by key hash so a same-DN / different-key trust
 609     * anchor cannot hijack the starting point. */
 610    ca = GetCAByKeyHash(cm, single->issuerKeyHash);
 611    if (ca != NULL && XMEMCMP(ca->subjectNameHash, single->issuerHash,
 612            OCSP_DIGEST_SIZE) != 0) {
 613        ca = NULL;
 614    }
 615#if defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
 616    if (ca == NULL && pendingCAs != NULL) {
 617        ca = findSignerByKeyHash(pendingCAs, single->issuerKeyHash);
 618        if (ca != NULL && XMEMCMP(ca->subjectNameHash, single->issuerHash,
 619                OCSP_DIGEST_SIZE) != 0) {
 620            ca = NULL;
 621        }
 622    }
 623#else
 624    (void)pendingCAs;
 625#endif
 626    for (; ca != NULL && ca != prev;
 627            prev = ca) {
 628        Signer* parent = GetCAByName(cm, ca->issuerNameHash);
 629#if defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
 630        if (parent == NULL && pendingCAs != NULL) {
 631            parent = findSignerByName(pendingCAs, ca->issuerNameHash);
 632        }
 633#endif
 634        if (parent == NULL || parent == ca)
 635            break;
 636
 637        if (XMEMCMP(parent->subjectNameHash, issuerNameHash,
 638                    OCSP_DIGEST_SIZE) == 0 &&
 639            XMEMCMP(parent->subjectKeyHash, issuerKeyHash,
 640                    KEYID_SIZE) == 0) {
 641            WOLFSSL_MSG("\tOCSP Response signed by authorized "
 642                    "responder delegated by issuer "
 643                    "(found in chain)");
 644            passed = 1;
 645            break;
 646        }
 647        ca = parent;
 648    }
 649    return passed;
 650}
 651#endif
 652
 653/* Enforce https://www.rfc-editor.org/rfc/rfc6960#section-4.2.2.2. Both halves
 654 * of CertID (issuerNameHash and issuerKeyHash) must match; name-only matching
 655 * would authorize a same-DN / different-key CA. issuerKeyHash may be NULL when
 656 * unavailable, which disables the delegated branch. */
 657int CheckOcspResponder(OcspResponse *bs, byte* subjectNameHash,
 658        byte* subjectKeyHash, byte extExtKeyUsage, byte* issuerNameHash,
 659        byte* issuerKeyHash, void* vp)
 660{
 661    int ret = 0;
 662    OcspEntry* single;
 663
 664    /* Both evaluate to enum values so can't use a pre-processor check */
 665    WOLFSSL_ASSERT_EQ(OCSP_DIGEST_SIZE, SIGNER_DIGEST_SIZE);
 666
 667    (void)vp;
 668
 669    WOLFSSL_ENTER("CheckOcspResponder");
 670
 671    /* In the future if this API is used more then it could be beneficial to
 672     * implement calling InitDecodedCert and ParseCertRelative here
 673     * automatically when cert == NULL. */
 674    if (bs == NULL || subjectNameHash == NULL || issuerNameHash == NULL)
 675        return BAD_FUNC_ARG;
 676
 677    for (single = bs->single; single != NULL; single = single->next) {
 678        int passed = 0;
 679
 680        if (subjectKeyHash != NULL &&
 681                XMEMCMP(subjectNameHash, single->issuerHash,
 682                    OCSP_DIGEST_SIZE) == 0 &&
 683                XMEMCMP(subjectKeyHash, single->issuerKeyHash,
 684                    KEYID_SIZE) == 0) {
 685            WOLFSSL_MSG("\tOCSP Response signed by issuer");
 686            passed = 1;
 687        }
 688        else if ((extExtKeyUsage & EXTKEYUSE_OCSP_SIGN) != 0) {
 689            if (issuerKeyHash != NULL &&
 690                    XMEMCMP(issuerNameHash, single->issuerHash,
 691                        OCSP_DIGEST_SIZE) == 0 &&
 692                    XMEMCMP(issuerKeyHash, single->issuerKeyHash,
 693                        KEYID_SIZE) == 0) {
 694                WOLFSSL_MSG("\tOCSP Response signed by authorized responder "
 695                            "delegated by issuer");
 696                passed = 1;
 697            }
 698#ifndef WOLFSSL_NO_OCSP_ISSUER_CHAIN_CHECK
 699            else if (vp != NULL) {
 700                passed = CheckOcspResponderChain(single, issuerNameHash,
 701                        issuerKeyHash, vp, bs->pendingCAs);
 702            }
 703#endif
 704        }
 705
 706        if (!passed) {
 707            WOLFSSL_MSG("\tOCSP Responder not authorized");
 708            ret = BAD_OCSP_RESPONDER;
 709            break;
 710        }
 711    }
 712    return ret;
 713}
 714
 715
 716OcspRequest* wc_OcspRequest_new(void* heap)
 717{
 718    OcspRequest* request = (OcspRequest*)XMALLOC(sizeof(OcspRequest), heap,
 719                                                 DYNAMIC_TYPE_OCSP_REQUEST);
 720    if (request != NULL) {
 721        XMEMSET(request, 0, sizeof(OcspRequest));
 722        request->heap = heap;
 723    }
 724
 725    return request;
 726}
 727
 728void wc_OcspRequest_free(OcspRequest* request)
 729{
 730    if (request != NULL) {
 731        FreeOcspRequest(request);
 732        XFREE(request, request->heap, DYNAMIC_TYPE_OCSP_REQUEST);
 733    }
 734}
 735
 736OcspResponse* wc_OcspResponse_new(void* heap)
 737{
 738    OcspResponse* response = (OcspResponse*)XMALLOC(sizeof(OcspResponse),
 739                                                   heap,
 740                                                   DYNAMIC_TYPE_OCSP_RESPONSE);
 741    if (response != NULL) {
 742        XMEMSET(response, 0, sizeof(OcspResponse));
 743        response->heap = heap;
 744    }
 745
 746    return response;
 747}
 748
 749void wc_OcspResponse_free(OcspResponse* response)
 750{
 751    if (response != NULL) {
 752        FreeOcspResponse(response);
 753        XFREE(response, response->heap, DYNAMIC_TYPE_OCSP_RESPONSE);
 754    }
 755}
 756
 757/* compatibility layer OCSP functions */
 758#ifdef OPENSSL_EXTRA
 759int wolfSSL_OCSP_resp_find_status(WOLFSSL_OCSP_BASICRESP *bs,
 760    WOLFSSL_OCSP_CERTID* id, int* status, int* reason,
 761    WOLFSSL_ASN1_TIME** revtime, WOLFSSL_ASN1_TIME** thisupd,
 762    WOLFSSL_ASN1_TIME** nextupd)
 763{
 764    WOLFSSL_OCSP_SINGLERESP* single;
 765
 766    if (bs == NULL || id == NULL)
 767        return WOLFSSL_FAILURE;
 768
 769    single = bs->single;
 770    while (single != NULL) {
 771        if (single->status != NULL && id->status != NULL &&
 772            (XMEMCMP(single->status->serial, id->status->serial,
 773                     (size_t)single->status->serialSz) == 0)
 774         && (XMEMCMP(single->issuerHash, id->issuerHash, OCSP_DIGEST_SIZE) == 0)
 775         && (XMEMCMP(single->issuerKeyHash, id->issuerKeyHash, OCSP_DIGEST_SIZE) == 0)) {
 776            break;
 777        }
 778        single = single->next;
 779    }
 780
 781    if (single == NULL)
 782        return WOLFSSL_FAILURE;
 783
 784    if (status != NULL)
 785        *status = single->status->status;
 786#ifdef WOLFSSL_OCSP_PARSE_STATUS
 787    if (thisupd != NULL)
 788        *thisupd = &single->status->thisDateParsed;
 789    if (nextupd != NULL)
 790        *nextupd = &single->status->nextDateParsed;
 791#else
 792    if (thisupd != NULL)
 793        *thisupd = NULL;
 794    if (nextupd != NULL)
 795        *nextupd = NULL;
 796#endif
 797
 798    /* TODO: Not needed for Nginx or httpd */
 799    if (reason != NULL)
 800        *reason = 0;
 801    if (revtime != NULL)
 802        *revtime = NULL;
 803
 804    return WOLFSSL_SUCCESS;
 805}
 806
 807const char *wolfSSL_OCSP_cert_status_str(long s)
 808{
 809    switch (s) {
 810        case CERT_GOOD:
 811            return "good";
 812        case CERT_REVOKED:
 813            return "revoked";
 814        case CERT_UNKNOWN:
 815            return "unknown";
 816        default:
 817            return "(UNKNOWN)";
 818    }
 819}
 820
 821int wolfSSL_OCSP_check_validity(WOLFSSL_ASN1_TIME* thisupd,
 822    WOLFSSL_ASN1_TIME* nextupd, long sec, long maxsec)
 823{
 824    (void)thisupd;
 825    (void)nextupd;
 826    (void)sec;
 827    (void)maxsec;
 828    /* Dates validated in DecodeSingleResponse. */
 829    return WOLFSSL_SUCCESS;
 830}
 831
 832void wolfSSL_OCSP_CERTID_free(WOLFSSL_OCSP_CERTID* certId)
 833{
 834    FreeOcspEntry(certId, NULL);
 835    XFREE(certId, NULL, DYNAMIC_TYPE_OPENSSL);
 836}
 837
 838WOLFSSL_OCSP_CERTID* wolfSSL_OCSP_cert_to_id(
 839    const WOLFSSL_EVP_MD *dgst, const WOLFSSL_X509 *subject,
 840    const WOLFSSL_X509 *issuer)
 841{
 842    WOLFSSL_OCSP_CERTID* certId = NULL;
 843    CertStatus* certStatus = NULL;
 844    WOLFSSL_CERT_MANAGER* cm = NULL;
 845    int ret = -1;
 846    DerBuffer* derCert = NULL;
 847    int dgstType;
 848    WC_DECLARE_VAR(cert, DecodedCert, 1, 0);
 849
 850    if (dgst == NULL) {
 851        dgstType = WC_HASH_TYPE_SHA;
 852    }
 853    else if (wolfSSL_EVP_get_hashinfo(dgst, &dgstType, NULL) !=
 854             WOLFSSL_SUCCESS) {
 855        return NULL;
 856    }
 857
 858    if (dgstType != OCSP_DIGEST)
 859        return NULL;
 860
 861    cm = wolfSSL_CertManagerNew();
 862    if (cm == NULL
 863            || subject == NULL || subject->derCert == NULL
 864            || issuer  == NULL || issuer->derCert  == NULL)
 865        goto out;
 866
 867    WC_ALLOC_VAR_EX(cert, DecodedCert, 1, cm->heap, DYNAMIC_TYPE_DCERT,
 868        goto out);
 869
 870    ret = AllocDer(&derCert, issuer->derCert->length,
 871        issuer->derCert->type, NULL);
 872    if (ret == 0) {
 873        /* AddCA() frees the buffer. */
 874        XMEMCPY(derCert->buffer, issuer->derCert->buffer,
 875                issuer->derCert->length);
 876        ret = AddCA(cm, &derCert, WOLFSSL_USER_CA, 1);
 877        if (ret != WOLFSSL_SUCCESS) {
 878            goto out;
 879        }
 880        derCert = NULL;
 881    }
 882
 883    ret = -1;
 884
 885    certId = (WOLFSSL_OCSP_CERTID*)XMALLOC(sizeof(WOLFSSL_OCSP_CERTID),
 886                                           cm->heap, DYNAMIC_TYPE_OPENSSL);
 887    if (certId == NULL)
 888        goto out;
 889
 890    certStatus = (CertStatus*)XMALLOC(sizeof(CertStatus), cm->heap,
 891                                           DYNAMIC_TYPE_OPENSSL);
 892    if (certStatus == NULL)
 893        goto out;
 894
 895    XMEMSET(certId, 0, sizeof(WOLFSSL_OCSP_CERTID));
 896    XMEMSET(certStatus, 0, sizeof(CertStatus));
 897
 898    certId->status = certStatus;
 899    certId->ownStatus = 1;
 900
 901    InitDecodedCert(cert, subject->derCert->buffer,
 902                    subject->derCert->length, NULL);
 903    if (ParseCertRelative(cert, CERT_TYPE, VERIFY_OCSP, cm, NULL) != 0) {
 904        FreeDecodedCert(cert);
 905        goto out;
 906    }
 907    else {
 908        certId->hashAlgoOID = wc_HashGetOID(OCSP_DIGEST);
 909        XMEMCPY(certId->issuerHash, cert->issuerHash, OCSP_DIGEST_SIZE);
 910        XMEMCPY(certId->issuerKeyHash, cert->issuerKeyHash, OCSP_DIGEST_SIZE);
 911        XMEMCPY(certId->status->serial, cert->serial, (size_t)cert->serialSz);
 912        certId->status->serialSz = cert->serialSz;
 913        FreeDecodedCert(cert);
 914    }
 915
 916    ret = 0;
 917
 918out:
 919
 920    if (ret != 0) {
 921        if (derCert != NULL)
 922            FreeDer(&derCert);
 923        if (cm != NULL) {
 924            XFREE(certId, cm->heap, DYNAMIC_TYPE_OPENSSL);
 925            certId = NULL;
 926            XFREE(certStatus, cm->heap, DYNAMIC_TYPE_OPENSSL);
 927        }
 928    }
 929
 930#ifdef WOLFSSL_SMALL_STACK
 931    if (cm != NULL)
 932        XFREE(cert, cm->heap, DYNAMIC_TYPE_DCERT);
 933#endif
 934
 935    if (cm != NULL)
 936        wolfSSL_CertManagerFree(cm);
 937
 938    return certId;
 939}
 940
 941void wolfSSL_OCSP_BASICRESP_free(WOLFSSL_OCSP_BASICRESP* basicResponse)
 942{
 943    wolfSSL_OCSP_RESPONSE_free(basicResponse);
 944}
 945
 946/* Calculate ancode CertID DER encoding following RFC 6960:
 947   CertID ::= SEQUENCE {
 948       hashAlgorithm       AlgorithmIdentifier,
 949       issuerNameHash      OCTET STRING,
 950       issuerKeyHash       OCTET STRING,
 951       serialNumber        CertificateSerialNumber }
 952*/
 953static int OcspEncodeCertID(WOLFSSL_OCSP_CERTID* id, byte* output,
 954    word32* totalSz, word32* intSize)
 955{
 956    word32 idx = 0;
 957    int ret;
 958
 959    if (id == NULL || totalSz == NULL || intSize == NULL ||
 960        (output != NULL && (*totalSz == 0 || *totalSz <= *intSize)))
 961        return BAD_FUNC_ARG;
 962
 963    if (output != NULL) {
 964        ret = SetSequence(*intSize, output);
 965        if (ret < 0)
 966            return ret;
 967        idx += ret;
 968    }
 969
 970    ret = SetAlgoID(id->hashAlgoOID, ((output != NULL) ? output + idx : output),
 971        oidHashType, 0);
 972    if (ret <= 0)
 973        return -1;
 974    idx += ret;
 975
 976    /* issuerNameHash */
 977    ret = SetOctetString(OCSP_DIGEST_SIZE, ((output != NULL) ? output + idx : output));
 978    if (ret < 0)
 979        return ret;
 980    idx += ret;
 981    if (output != NULL)
 982        XMEMCPY(output + idx, id->issuerHash, OCSP_DIGEST_SIZE);
 983    idx += OCSP_DIGEST_SIZE;
 984
 985    /* issuerKeyHash */
 986    ret = SetOctetString(OCSP_DIGEST_SIZE, ((output != NULL) ? output + idx : output));
 987    if (ret < 0)
 988        return ret;
 989    idx += ret;
 990    if (output != NULL)
 991        XMEMCPY(output + idx, id->issuerKeyHash, OCSP_DIGEST_SIZE);
 992    idx += OCSP_DIGEST_SIZE;
 993
 994    /* serialNumber */
 995    ret = SetASNInt(id->status->serialSz, id->status->serial[0], ((output != NULL) ? output + idx : output));
 996    if (ret < 0)
 997        return ret;
 998    idx += ret;
 999    if (output != NULL)
1000        XMEMCPY(output + idx, id->status->serial, id->status->serialSz);
1001    idx += id->status->serialSz;
1002
1003    if (output == NULL) {
1004        *intSize = idx;
1005        ret = SetSequence(idx, NULL);
1006        if (ret < 0)
1007            return ret;
1008        idx += ret;
1009        *totalSz = idx;
1010    }
1011    else if (idx != *totalSz) {
1012        return BUFFER_E;
1013    }
1014
1015    return 0;
1016}
1017
1018static int OcspRespIdMatches(OcspResponse* resp, const byte* NameHash,
1019    const byte* keyHash)
1020{
1021    if (resp->responderIdType == OCSP_RESPONDER_ID_NAME) {
1022        return XMEMCMP(NameHash, resp->responderId.nameHash,
1023                   SIGNER_DIGEST_SIZE) == 0;
1024    }
1025    else if (resp->responderIdType == OCSP_RESPONDER_ID_KEY) {
1026        return XMEMCMP(keyHash, resp->responderId.keyHash,
1027                   OCSP_RESPONDER_ID_KEY_SZ) == 0;
1028    }
1029
1030    return 0;
1031}
1032
1033static int OcspFindSigner(WOLFSSL_OCSP_BASICRESP *resp,
1034    WOLF_STACK_OF(WOLFSSL_X509) *certs, DecodedCert **signer, int *embedded,
1035    unsigned long flags)
1036{
1037    WOLFSSL_X509 *signer_x509 = NULL;
1038    DecodedCert *certDecoded;
1039    int i;
1040
1041    certDecoded = (DecodedCert *)XMALLOC(sizeof(*certDecoded), resp->heap,
1042                                            DYNAMIC_TYPE_DCERT);
1043    if (certDecoded == NULL)
1044        return MEMORY_E;
1045
1046    for (i = 0; i < wolfSSL_sk_X509_num(certs); i++) {
1047        signer_x509 = wolfSSL_sk_X509_value(certs, i);
1048        if (signer_x509 == NULL)
1049            continue;
1050
1051        InitDecodedCert(certDecoded, signer_x509->derCert->buffer,
1052                       signer_x509->derCert->length, resp->heap);
1053        if (ParseCertRelative(certDecoded, CERT_TYPE, NO_VERIFY,
1054                NULL, NULL) == 0) {
1055                if (OcspRespIdMatches(resp, certDecoded->subjectHash,
1056                        certDecoded->subjectKeyHash)) {
1057                    *signer = certDecoded;
1058                    *embedded = 0;
1059                    return 0;
1060                }
1061        }
1062        FreeDecodedCert(certDecoded);
1063    }
1064
1065    if (flags & WOLFSSL_OCSP_NOINTERN) {
1066        XFREE(certDecoded, resp->heap, DYNAMIC_TYPE_DCERT);
1067        return ASN_NO_SIGNER_E;
1068    }
1069
1070    /* not found in certs, search the cert embedded in the response */
1071    InitDecodedCert(certDecoded, resp->cert, resp->certSz, resp->heap);
1072    if (ParseCertRelative(certDecoded, CERT_TYPE, NO_VERIFY, NULL, NULL) == 0) {
1073        if (OcspRespIdMatches(resp, certDecoded->subjectHash,
1074                certDecoded->subjectKeyHash)) {
1075            *signer = certDecoded;
1076            *embedded = 1;
1077            return 0;
1078        }
1079    }
1080    FreeDecodedCert(certDecoded);
1081
1082    XFREE(certDecoded, resp->heap, DYNAMIC_TYPE_DCERT);
1083    return ASN_NO_SIGNER_E;
1084}
1085
1086static int OcspVerifySigner(WOLFSSL_OCSP_BASICRESP *resp, DecodedCert *cert,
1087     WOLFSSL_X509_STORE *st, unsigned long flags)
1088{
1089    WC_DECLARE_VAR(c, DecodedCert, 1, 0);
1090
1091    int ret = -1;
1092    if (st == NULL)
1093        return ASN_OCSP_CONFIRM_E;
1094
1095    WC_ALLOC_VAR_EX(c, DecodedCert, 1, NULL, DYNAMIC_TYPE_DCERT,
1096        return MEMORY_E);
1097
1098    InitDecodedCert(c, cert->source, cert->maxIdx, NULL);
1099    if (ParseCertRelative(c, CERT_TYPE, VERIFY, st->cm, NULL) != 0) {
1100        ret = ASN_OCSP_CONFIRM_E;
1101        goto err;
1102    }
1103#ifndef WOLFSSL_NO_OCSP_ISSUER_CHECK
1104    if ((flags & WOLFSSL_OCSP_NOCHECKS) == 0) {
1105        ret = CheckOcspResponder(resp, c->subjectHash, c->subjectKeyHash,
1106                c->extExtKeyUsage, c->issuerHash,
1107                (c->ca != NULL) ? c->ca->subjectKeyHash : NULL,
1108                st->cm);
1109    }
1110    else {
1111        ret = 0;
1112    }
1113#else
1114    (void)resp;
1115    (void)flags;
1116    ret = 0;
1117#endif
1118
1119err:
1120    FreeDecodedCert(c);
1121    WC_FREE_VAR_EX(c, NULL, DYNAMIC_TYPE_DCERT);
1122    return ret;
1123}
1124/* Signature verified in DecodeBasicOcspResponse.
1125 * But no store available to verify certificate. */
1126int wolfSSL_OCSP_basic_verify(WOLFSSL_OCSP_BASICRESP* bs,
1127    WOLF_STACK_OF(WOLFSSL_X509) * certs, WOLFSSL_X509_STORE* st,
1128    unsigned long flags)
1129{
1130    int         ret = WC_NO_ERR_TRACE(WOLFSSL_FAILURE);
1131    int embedded;
1132    DecodedCert *cert = NULL;
1133
1134    if (bs == NULL)
1135        return WOLFSSL_FAILURE;
1136
1137    ret = OcspFindSigner(bs, certs, &cert, &embedded, flags);
1138    if (ret != 0) {
1139        WOLFSSL_MSG("OCSP no signer found");
1140        return WOLFSSL_FAILURE;
1141    }
1142
1143    /* skip certificate verification if cert in certs and TRUST_OTHER is true */
1144    if (!embedded && (flags & WOLFSSL_OCSP_TRUSTOTHER) != 0)
1145        flags |= WOLFSSL_OCSP_NOVERIFY;
1146
1147    /* verify response signature */
1148    ret = ConfirmSignature(
1149        &cert->sigCtx,
1150        bs->response, bs->responseSz,
1151        cert->publicKey, cert->pubKeySize, cert->keyOID,
1152        bs->sig, bs->sigSz, bs->sigOID, bs->sigParams, bs->sigParamsSz,
1153        NULL);
1154
1155    if (ret != 0) {
1156        WOLFSSL_MSG("OCSP signature verification failed");
1157        ret = -1;
1158        goto err;
1159    }
1160
1161    if ((flags & WOLFSSL_OCSP_NOVERIFY) == 0) {
1162        ret = OcspVerifySigner(bs, cert, st, flags);
1163    }
1164
1165err:
1166    FreeDecodedCert(cert);
1167    XFREE(cert, NULL, DYNAMIC_TYPE_DCERT);
1168    return ret == 0 ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
1169}
1170
1171void wolfSSL_OCSP_RESPONSE_free(OcspResponse* response)
1172{
1173    OcspEntry *s, *sNext;
1174    if (response == NULL)
1175        return;
1176
1177
1178    s = response->single;
1179    while (s != NULL) {
1180        sNext = s->next;
1181        FreeOcspEntry(s, NULL);
1182        XFREE(s, NULL, DYNAMIC_TYPE_OCSP_ENTRY);
1183        s = sNext;
1184    }
1185
1186    XFREE(response->source, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1187
1188    XFREE(response, NULL, DYNAMIC_TYPE_OCSP_REQUEST);
1189}
1190
1191#ifndef NO_BIO
1192OcspResponse* wolfSSL_d2i_OCSP_RESPONSE_bio(WOLFSSL_BIO* bio,
1193    OcspResponse** response)
1194{
1195    byte*         data;
1196    byte*         p;
1197    int           len;
1198    int           dataAlloced = 0;
1199    OcspResponse* ret = NULL;
1200
1201    if (bio == NULL)
1202        return NULL;
1203
1204    if (bio->type == WOLFSSL_BIO_MEMORY) {
1205        len = wolfSSL_BIO_get_mem_data(bio, &data);
1206        if (len <= 0 || data == NULL) {
1207            return NULL;
1208        }
1209    }
1210#ifndef NO_FILESYSTEM
1211    else if (bio->type == WOLFSSL_BIO_FILE) {
1212        long fcur;
1213        long flen;
1214
1215        if (bio->ptr.fh == NULL)
1216            return NULL;
1217
1218        fcur = XFTELL(bio->ptr.fh);
1219        if (fcur < 0)
1220            return NULL;
1221        if(XFSEEK(bio->ptr.fh, 0, SEEK_END) != 0)
1222            return NULL;
1223        flen = XFTELL(bio->ptr.fh);
1224        if (flen < 0)
1225            return NULL;
1226        if (XFSEEK(bio->ptr.fh, fcur, SEEK_SET) != 0)
1227            return NULL;
1228
1229        /* check calculated length */
1230        fcur = flen - fcur;
1231        if (fcur > MAX_WOLFSSL_FILE_SIZE || fcur <= 0)
1232            return NULL;
1233
1234        data = (byte*)XMALLOC((size_t)fcur, 0, DYNAMIC_TYPE_TMP_BUFFER);
1235        if (data == NULL)
1236            return NULL;
1237        dataAlloced = 1;
1238
1239        len = wolfSSL_BIO_read(bio, (char *)data, (int)flen);
1240    }
1241#endif
1242    else
1243        return NULL;
1244
1245    if (len > 0) {
1246        p = data;
1247        ret = wolfSSL_d2i_OCSP_RESPONSE(response, (const unsigned char **)&p,
1248            len);
1249    }
1250
1251    if (dataAlloced)
1252        XFREE(data, 0, DYNAMIC_TYPE_TMP_BUFFER);
1253
1254    return ret;
1255}
1256#endif /* !NO_BIO */
1257
1258OcspResponse* wolfSSL_d2i_OCSP_RESPONSE(OcspResponse** response,
1259    const unsigned char** data, int len)
1260{
1261    OcspResponse *resp = NULL;
1262    word32 idx = 0;
1263    int length = 0;
1264    int ret;
1265
1266    if (data == NULL)
1267        return NULL;
1268
1269    if (response != NULL)
1270        resp = *response;
1271    if (resp == NULL) {
1272        resp = (OcspResponse*)XMALLOC(sizeof(OcspResponse), NULL,
1273                                      DYNAMIC_TYPE_OCSP_REQUEST);
1274        if (resp == NULL)
1275            return NULL;
1276        XMEMSET(resp, 0, sizeof(OcspResponse));
1277    }
1278
1279    resp->source = (byte*)XMALLOC((size_t)len, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1280    if (resp->source == NULL) {
1281        XFREE(resp, NULL, DYNAMIC_TYPE_OCSP_REQUEST);
1282        return NULL;
1283    }
1284    resp->single = (OcspEntry*)XMALLOC(sizeof(OcspEntry), NULL,
1285                                      DYNAMIC_TYPE_OCSP_ENTRY);
1286    if (resp->single == NULL) {
1287        XFREE(resp->source, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1288        XFREE(resp, NULL, DYNAMIC_TYPE_OCSP_REQUEST);
1289        return NULL;
1290    }
1291    XMEMSET(resp->single, 0, sizeof(OcspEntry));
1292    resp->single->status = (CertStatus*)XMALLOC(sizeof(CertStatus), NULL,
1293                                      DYNAMIC_TYPE_OCSP_STATUS);
1294    resp->single->ownStatus = 1;
1295    if (resp->single->status == NULL) {
1296        XFREE(resp->source, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1297        XFREE(resp->single, NULL, DYNAMIC_TYPE_OCSP_ENTRY);
1298        XFREE(resp, NULL, DYNAMIC_TYPE_OCSP_REQUEST);
1299        return NULL;
1300    }
1301    XMEMSET(resp->single->status, 0, sizeof(CertStatus));
1302
1303    XMEMCPY(resp->source, *data, (size_t)len);
1304    resp->maxIdx = (word32)len;
1305
1306    ret = OcspResponseDecode(resp, NULL, NULL, 1, 1);
1307    if (ret != 0 && ret != WC_NO_ERR_TRACE(ASN_OCSP_CONFIRM_E)) {
1308        /* for just converting from a DER to an internal structure the CA may
1309         * not yet be known to this function for signature verification */
1310        wolfSSL_OCSP_RESPONSE_free(resp);
1311        return NULL;
1312    }
1313
1314    if (GetSequence(*data, &idx, &length, (word32)len) >= 0)
1315        (*data) += idx + length;
1316
1317    if (response != NULL && *response == NULL)
1318        *response = resp;
1319
1320    return resp;
1321}
1322
1323int wolfSSL_i2d_OCSP_RESPONSE(OcspResponse* response,
1324    unsigned char** data)
1325{
1326    if (response == NULL)
1327        return BAD_FUNC_ARG;
1328
1329    if (response->source == NULL)
1330        return BAD_FUNC_ARG;
1331
1332    if (data == NULL)
1333        return (int)response->maxIdx;
1334
1335    if (*data == NULL) {
1336        *data = (unsigned char*)XMALLOC(response->maxIdx, NULL,
1337                                        DYNAMIC_TYPE_OPENSSL);
1338        if (*data == NULL)
1339            return -1;
1340        XMEMCPY(*data, response->source, response->maxIdx);
1341    }
1342    else {
1343        XMEMCPY(*data, response->source, response->maxIdx);
1344        *data += response->maxIdx;
1345    }
1346
1347    return (int)response->maxIdx;
1348}
1349
1350int wolfSSL_OCSP_response_status(OcspResponse *response)
1351{
1352    if (response == NULL)
1353        return -1;
1354    return response->responseStatus;
1355}
1356
1357const char *wolfSSL_OCSP_response_status_str(long s)
1358{
1359    switch (s) {
1360        case OCSP_SUCCESSFUL:
1361            return "successful";
1362        case OCSP_MALFORMED_REQUEST:
1363            return "malformedrequest";
1364        case OCSP_INTERNAL_ERROR:
1365            return "internalerror";
1366        case OCSP_TRY_LATER:
1367            return "trylater";
1368        case OCSP_SIG_REQUIRED:
1369            return "sigrequired";
1370        case OCSP_UNAUTHORIZED:
1371            return "unauthorized";
1372        default:
1373            return "(UNKNOWN)";
1374    }
1375}
1376
1377WOLFSSL_OCSP_BASICRESP* wolfSSL_OCSP_response_get1_basic(OcspResponse* response)
1378{
1379    WOLFSSL_OCSP_BASICRESP* bs;
1380    const unsigned char *ptr;
1381
1382    if (response == NULL || response->source == NULL)
1383        return NULL;
1384
1385    ptr = response->source;
1386    bs = wolfSSL_d2i_OCSP_RESPONSE(NULL, &ptr, response->maxIdx);
1387    return bs;
1388}
1389
1390OcspRequest* wolfSSL_OCSP_REQUEST_new(void)
1391{
1392    OcspRequest* request;
1393
1394    request = (OcspRequest*)XMALLOC(sizeof(OcspRequest), NULL,
1395                                    DYNAMIC_TYPE_OPENSSL);
1396    if (request != NULL)
1397        XMEMSET(request, 0, sizeof(OcspRequest));
1398
1399    return request;
1400}
1401
1402void wolfSSL_OCSP_REQUEST_free(OcspRequest* request)
1403{
1404    FreeOcspRequest(request);
1405    XFREE(request, NULL, DYNAMIC_TYPE_OPENSSL);
1406}
1407
1408int wolfSSL_i2d_OCSP_REQUEST(OcspRequest* request, unsigned char** data)
1409{
1410    int size;
1411
1412    if (request == NULL)
1413        return BAD_FUNC_ARG;
1414
1415    size = EncodeOcspRequest(request, NULL, 0);
1416    if (size <= 0 || data == NULL)
1417        return size;
1418
1419    size = EncodeOcspRequest(request, *data, (word32) size);
1420    if (size > 0)
1421        *data += size;
1422
1423    return size;
1424}
1425
1426WOLFSSL_OCSP_ONEREQ* wolfSSL_OCSP_request_add0_id(OcspRequest *req,
1427    WOLFSSL_OCSP_CERTID *cid)
1428{
1429    if (req == NULL || cid == NULL || cid->status == NULL)
1430        return NULL;
1431
1432    if (req->cid != NULL)
1433        wolfSSL_OCSP_CERTID_free((WOLFSSL_OCSP_CERTID*)req->cid);
1434    /* Keep to free */
1435    req->cid = (void*)cid;
1436
1437    XMEMCPY(req->issuerHash, cid->issuerHash, WC_MAX_DIGEST_SIZE);
1438    XMEMCPY(req->issuerKeyHash, cid->issuerKeyHash, WC_MAX_DIGEST_SIZE);
1439    req->hashAlg = (int)cid->hashAlgoOID;
1440    if (cid->status->serialSz > req->serialSz) {
1441        XFREE(req->serial, req->heap, DYNAMIC_TYPE_OCSP);
1442        req->serial = (byte*)XMALLOC((size_t)cid->status->serialSz,
1443                req->heap, DYNAMIC_TYPE_OCSP_REQUEST);
1444        if (req->serial == NULL)
1445            return NULL;
1446    }
1447    XMEMCPY(req->serial, cid->status->serial, (size_t)cid->status->serialSz);
1448    req->serialSz = cid->status->serialSz;
1449
1450    return req;
1451}
1452
1453WOLFSSL_OCSP_CERTID* wolfSSL_OCSP_CERTID_dup(WOLFSSL_OCSP_CERTID* id)
1454{
1455    WOLFSSL_OCSP_CERTID* certId;
1456
1457    if (id == NULL)
1458        return NULL;
1459
1460    certId = (WOLFSSL_OCSP_CERTID*)XMALLOC(sizeof(WOLFSSL_OCSP_CERTID),
1461        NULL, DYNAMIC_TYPE_OPENSSL);
1462    if (certId == NULL)
1463        return NULL;
1464
1465    XMEMCPY(certId, id, sizeof(WOLFSSL_OCSP_CERTID));
1466    certId->next = NULL;
1467    certId->rawCertId = NULL;
1468    certId->rawCertIdSize = 0;
1469
1470    /* Deep-copy the status to avoid double-free */
1471    if (id->status != NULL) {
1472        certId->status = (CertStatus*)XMALLOC(sizeof(CertStatus),
1473            NULL, DYNAMIC_TYPE_OCSP_STATUS);
1474        if (certId->status == NULL) {
1475            XFREE(certId, NULL, DYNAMIC_TYPE_OPENSSL);
1476            return NULL;
1477        }
1478        XMEMCPY(certId->status, id->status, sizeof(CertStatus));
1479        certId->status->next = NULL;
1480        /* Don't share dynamically allocated fields */
1481        certId->status->rawOcspResponse = NULL;
1482        certId->status->rawOcspResponseSz = 0;
1483        certId->status->serialInt = NULL;
1484#ifdef WOLFSSL_OCSP_PARSE_STATUS
1485        certId->status->thisDateAsn = NULL;
1486        certId->status->nextDateAsn = NULL;
1487#endif
1488    }
1489    certId->ownStatus = 1;
1490
1491    return certId;
1492}
1493
1494#ifndef NO_BIO
1495int wolfSSL_i2d_OCSP_REQUEST_bio(WOLFSSL_BIO* out,
1496        WOLFSSL_OCSP_REQUEST *req)
1497{
1498    int size = -1;
1499    unsigned char* data = NULL;
1500
1501    WOLFSSL_ENTER("wolfSSL_i2d_OCSP_REQUEST_bio");
1502    if (out == NULL || req == NULL)
1503        return WOLFSSL_FAILURE;
1504
1505    size = wolfSSL_i2d_OCSP_REQUEST(req, NULL);
1506    if (size > 0) {
1507        data = (unsigned char*) XMALLOC((size_t)size, out->heap,
1508                DYNAMIC_TYPE_TMP_BUFFER);
1509    }
1510
1511    if (data != NULL) {
1512        unsigned char* dataOrig = data;
1513        size = wolfSSL_i2d_OCSP_REQUEST(req, &data);
1514        data = dataOrig;
1515    }
1516
1517    if (size <= 0) {
1518        XFREE(data, out->heap, DYNAMIC_TYPE_TMP_BUFFER);
1519        return WOLFSSL_FAILURE;
1520    }
1521
1522    if (wolfSSL_BIO_write(out, data, size) == (int)size) {
1523        XFREE(data, out->heap, DYNAMIC_TYPE_TMP_BUFFER);
1524        return WOLFSSL_SUCCESS;
1525    }
1526
1527    XFREE(data, out->heap, DYNAMIC_TYPE_TMP_BUFFER);
1528    return WOLFSSL_FAILURE;
1529}
1530#endif /* !NO_BIO */
1531
1532int wolfSSL_i2d_OCSP_CERTID(WOLFSSL_OCSP_CERTID* id, unsigned char** data)
1533{
1534    int allocated = 0;
1535    word32 derSz = 0;
1536    word32 intSz = 0;
1537    int ret;
1538    WOLFSSL_ENTER("wolfSSL_i2d_OCSP_CERTID");
1539
1540    if (id == NULL)
1541        return -1;
1542
1543    if (id->rawCertId != NULL) {
1544        derSz = id->rawCertIdSize;
1545    }
1546    else {
1547        ret = OcspEncodeCertID(id, NULL, &derSz, &intSz);
1548        if (ret != 0) {
1549            WOLFSSL_MSG("Failed to calculate CertID size");
1550            return -1;
1551        }
1552    }
1553
1554    if (data == NULL) {
1555        return derSz;
1556    }
1557
1558    if (*data == NULL) {
1559        /* Allocate buffer for DER encoding */
1560        *data = (byte*)XMALLOC(derSz, NULL, DYNAMIC_TYPE_OPENSSL);
1561        if (*data == NULL) {
1562            WOLFSSL_MSG("Failed to allocate memory for CertID DER encoding");
1563            return -1;
1564        }
1565        allocated = 1;
1566    }
1567
1568    if (id->rawCertId != NULL) {
1569        XMEMCPY(*data, id->rawCertId, id->rawCertIdSize);
1570    }
1571    else {
1572        ret = OcspEncodeCertID(id, *data, &derSz, &intSz);
1573        if (ret < 0) {
1574            WOLFSSL_MSG("Failed to encode CertID");
1575            if (allocated) {
1576                XFREE(*data, NULL, DYNAMIC_TYPE_OPENSSL);
1577                *data = NULL;
1578            }
1579            return -1;
1580        }
1581    }
1582
1583    if (!allocated)
1584        *data += derSz;
1585
1586    return derSz;
1587}
1588
1589WOLFSSL_OCSP_CERTID* wolfSSL_d2i_OCSP_CERTID(WOLFSSL_OCSP_CERTID** cidOut,
1590                                             const unsigned char** derIn,
1591                                             int length)
1592{
1593    WOLFSSL_OCSP_CERTID *cid = NULL;
1594    int isAllocated = 0;
1595    word32 idx = 0;
1596    int ret;
1597
1598    if (derIn == NULL || *derIn == NULL || length <= 0)
1599        return NULL;
1600
1601    if (cidOut != NULL && *cidOut != NULL) {
1602        cid = *cidOut;
1603        FreeOcspEntry(cid, NULL);
1604    }
1605    else {
1606        cid = (WOLFSSL_OCSP_CERTID*)XMALLOC(sizeof(WOLFSSL_OCSP_CERTID), NULL,
1607            DYNAMIC_TYPE_OPENSSL);
1608        if (cid == NULL)
1609            return NULL;
1610        isAllocated = 1;
1611    }
1612
1613    XMEMSET(cid, 0, sizeof(WOLFSSL_OCSP_CERTID));
1614    cid->status = (CertStatus*)XMALLOC(sizeof(CertStatus), NULL,
1615        DYNAMIC_TYPE_OCSP_STATUS);
1616    if (cid->status == NULL) {
1617        XFREE(cid, NULL, DYNAMIC_TYPE_OPENSSL);
1618        return NULL;
1619    }
1620    XMEMSET(cid->status, 0, sizeof(CertStatus));
1621    cid->ownStatus = 1;
1622
1623    ret = OcspDecodeCertID(*derIn, &idx, length, cid);
1624    if (ret != 0) {
1625        FreeOcspEntry(cid, NULL);
1626        if (isAllocated) {
1627            XFREE(cid, NULL, DYNAMIC_TYPE_OPENSSL);
1628        }
1629        return NULL;
1630    }
1631
1632    *derIn += idx;
1633
1634    if (isAllocated && cidOut != NULL)
1635        *cidOut = cid;
1636
1637    return cid;
1638}
1639
1640const WOLFSSL_OCSP_CERTID* wolfSSL_OCSP_SINGLERESP_get0_id(
1641    const WOLFSSL_OCSP_SINGLERESP *single)
1642{
1643    return single;
1644}
1645
1646/**
1647 * Compare two WOLFSSL_OCSP_CERTID objects
1648 * @param a
1649 * @param b
1650 * @return 0 on success and when objects have the same id otherwise either
1651 *         the id's don't match or an error occurred
1652 */
1653int wolfSSL_OCSP_id_cmp(WOLFSSL_OCSP_CERTID *a, WOLFSSL_OCSP_CERTID *b)
1654{
1655    int ret = 0;
1656    if (a == NULL || b == NULL)
1657        return WOLFSSL_FATAL_ERROR;
1658
1659    ret = a->hashAlgoOID != b->hashAlgoOID;
1660    if (ret == 0)
1661        ret = XMEMCMP(a->issuerHash, b->issuerHash, OCSP_DIGEST_SIZE);
1662    if (ret == 0)
1663        ret = XMEMCMP(a->issuerKeyHash, b->issuerKeyHash, OCSP_DIGEST_SIZE);
1664    if (ret == 0) {
1665        if (a->status != NULL && b->status != NULL) {
1666            if (a->status->serialSz == b->status->serialSz)
1667                ret = XMEMCMP(a->status->serial, b->status->serial,
1668                        (size_t)a->status->serialSz);
1669            else
1670                ret = -1;
1671        }
1672        else if (a->status != b->status) {
1673            /* If either is not null then return non-zero */
1674            ret = -1;
1675        }
1676    }
1677    return ret;
1678}
1679
1680int wolfSSL_OCSP_single_get0_status(WOLFSSL_OCSP_SINGLERESP *single,
1681                                    int *reason,
1682                                    WOLFSSL_ASN1_TIME **revtime,
1683                                    WOLFSSL_ASN1_TIME **thisupd,
1684                                    WOLFSSL_ASN1_TIME **nextupd)
1685{
1686    if (single == NULL || single->status == NULL)
1687        return -1;
1688
1689#ifdef WOLFSSL_OCSP_PARSE_STATUS
1690    if (thisupd != NULL)
1691        *thisupd = &single->status->thisDateParsed;
1692    if (nextupd != NULL)
1693        *nextupd = &single->status->nextDateParsed;
1694#else
1695    if (thisupd != NULL)
1696        *thisupd = NULL;
1697    if (nextupd != NULL)
1698        *nextupd = NULL;
1699#endif
1700    if (reason != NULL)
1701        *reason = 0;
1702    if (revtime != NULL)
1703        *revtime = NULL;
1704
1705    return single->status->status;
1706}
1707
1708int wolfSSL_OCSP_resp_count(WOLFSSL_OCSP_BASICRESP *bs)
1709{
1710    WOLFSSL_OCSP_SINGLERESP* single;
1711    int count = 0;
1712
1713    if (bs == NULL)
1714        return WOLFSSL_FAILURE;
1715
1716    single = bs->single;
1717    while(single != NULL)
1718    {
1719        ++count;
1720        single = single->next;
1721    }
1722
1723    return count;
1724}
1725
1726WOLFSSL_OCSP_SINGLERESP* wolfSSL_OCSP_resp_get0(WOLFSSL_OCSP_BASICRESP *bs, int idx)
1727{
1728    WOLFSSL_OCSP_SINGLERESP* single;
1729    int currIdx = 0;
1730
1731    if (bs == NULL)
1732        return NULL;
1733
1734    single = bs->single;
1735    while(single != NULL && currIdx != idx)
1736    {
1737        single = single->next;
1738        ++currIdx;
1739    }
1740
1741    return single;
1742}
1743
1744#endif /* OPENSSL_EXTRA */
1745
1746#ifdef OPENSSL_ALL
1747
1748/*******************************************************************************
1749 * START OF WOLFSSL_OCSP_REQ_CTX API
1750 ******************************************************************************/
1751
1752enum ocspReqStates {
1753    ORS_INVALID = 0,
1754    ORS_HEADER_ADDED,
1755    ORS_REQ_DONE
1756};
1757
1758enum ocspReqIOStates {
1759    ORIOS_INVALID = 0,
1760    ORIOS_WRITE,
1761    ORIOS_READ
1762};
1763
1764WOLFSSL_OCSP_REQ_CTX* wolfSSL_OCSP_REQ_CTX_new(WOLFSSL_BIO *bio, int maxline)
1765{
1766    WOLFSSL_OCSP_REQ_CTX* ret = NULL;
1767
1768    WOLFSSL_ENTER("wolfSSL_OCSP_REQ_CTX_new");
1769
1770    if (maxline <= 0)
1771        maxline = OCSP_MAX_REQUEST_SZ;
1772
1773    ret = (WOLFSSL_OCSP_REQ_CTX*)XMALLOC(sizeof(*ret), NULL,
1774            DYNAMIC_TYPE_OPENSSL);
1775    if (ret != NULL) {
1776        XMEMSET(ret, 0, sizeof(*ret));
1777        ret->buf = (byte*)XMALLOC((word32)maxline, NULL, DYNAMIC_TYPE_OPENSSL);
1778        if (ret->buf == NULL)
1779            goto error;
1780        ret->reqResp = wolfSSL_BIO_new(wolfSSL_BIO_s_mem());
1781        ret->bufLen = maxline;
1782        ret->bio = bio;
1783        ret->ioState = ORIOS_WRITE;
1784    }
1785
1786    return ret;
1787error:
1788    wolfSSL_OCSP_REQ_CTX_free(ret);
1789    return NULL;
1790}
1791
1792void wolfSSL_OCSP_REQ_CTX_free(WOLFSSL_OCSP_REQ_CTX *ctx)
1793{
1794    WOLFSSL_ENTER("wolfSSL_OCSP_REQ_CTX_free");
1795    if (ctx != NULL) {
1796        if (ctx->buf != NULL)
1797            XFREE(ctx->buf, NULL, DYNAMIC_TYPE_OPENSSL);
1798        if (ctx->reqResp != NULL)
1799            wolfSSL_BIO_free(ctx->reqResp);
1800        XFREE(ctx, NULL, DYNAMIC_TYPE_OPENSSL);
1801    }
1802}
1803
1804WOLFSSL_OCSP_REQ_CTX* wolfSSL_OCSP_sendreq_new(WOLFSSL_BIO *bio,
1805        const char *path, OcspRequest *req, int maxline)
1806{
1807    WOLFSSL_OCSP_REQ_CTX* ret = NULL;
1808
1809    WOLFSSL_ENTER("wolfSSL_OCSP_sendreq_new");
1810
1811    ret = wolfSSL_OCSP_REQ_CTX_new(bio, maxline);
1812    if (ret == NULL)
1813        return NULL;
1814
1815    if (wolfSSL_OCSP_REQ_CTX_http(ret, "POST", path) != WOLFSSL_SUCCESS)
1816        goto error;
1817
1818    if (req != NULL &&
1819            wolfSSL_OCSP_REQ_CTX_set1_req(ret, req) != WOLFSSL_SUCCESS)
1820        goto error;
1821
1822    return ret;
1823error:
1824    wolfSSL_OCSP_REQ_CTX_free(ret);
1825    return NULL;
1826}
1827
1828int wolfSSL_OCSP_REQ_CTX_add1_header(WOLFSSL_OCSP_REQ_CTX *ctx,
1829                             const char *name, const char *value)
1830{
1831    WOLFSSL_ENTER("wolfSSL_OCSP_REQ_CTX_add1_header");
1832
1833    if (ctx == NULL || name == NULL) {
1834        WOLFSSL_MSG("Bad parameter");
1835        return WOLFSSL_FAILURE;
1836    }
1837    if (wolfSSL_BIO_puts(ctx->reqResp, name) <= 0) {
1838        WOLFSSL_MSG("wolfSSL_BIO_puts error");
1839        return WOLFSSL_FAILURE;
1840    }
1841    if (value != NULL) {
1842        if (wolfSSL_BIO_write(ctx->reqResp, ": ", 2) != 2) {
1843            WOLFSSL_MSG("wolfSSL_BIO_write error");
1844            return WOLFSSL_FAILURE;
1845        }
1846        if (wolfSSL_BIO_puts(ctx->reqResp, value) <= 0) {
1847            WOLFSSL_MSG("wolfSSL_BIO_puts error");
1848            return WOLFSSL_FAILURE;
1849        }
1850    }
1851    if (wolfSSL_BIO_write(ctx->reqResp, "\r\n", 2) != 2) {
1852        WOLFSSL_MSG("wolfSSL_BIO_write error");
1853        return WOLFSSL_FAILURE;
1854    }
1855
1856    ctx->state = ORS_HEADER_ADDED;
1857
1858    return WOLFSSL_SUCCESS;
1859}
1860
1861int wolfSSL_OCSP_REQ_CTX_http(WOLFSSL_OCSP_REQ_CTX *ctx, const char *op,
1862        const char *path)
1863{
1864    static const char http_hdr[] = "%s %s HTTP/1.0\r\n";
1865
1866    WOLFSSL_ENTER("wolfSSL_OCSP_REQ_CTX_http");
1867
1868    if (ctx == NULL || op == NULL) {
1869        WOLFSSL_MSG("Bad parameter");
1870        return WOLFSSL_FAILURE;
1871    }
1872
1873    if (path == NULL)
1874        path = "/";
1875
1876    if (wolfSSL_BIO_printf(ctx->reqResp, http_hdr, op, path) <= 0) {
1877        WOLFSSL_MSG("WOLFSSL_OCSP_REQ_CTX: wolfSSL_BIO_printf error");
1878        return WOLFSSL_FAILURE;
1879    }
1880
1881    ctx->state = ORS_HEADER_ADDED;
1882
1883    return WOLFSSL_SUCCESS;
1884}
1885
1886int wolfSSL_OCSP_REQ_CTX_set1_req(WOLFSSL_OCSP_REQ_CTX *ctx, OcspRequest *req)
1887{
1888    static const char req_hdr[] =
1889        "Content-Type: application/ocsp-request\r\n"
1890        "Content-Length: %d\r\n\r\n";
1891    /* Should be enough to hold Content-Length */
1892    char req_hdr_buf[sizeof(req_hdr) + 10];
1893    int req_hdr_buf_len;
1894    int req_len = wolfSSL_i2d_OCSP_REQUEST(req, NULL);
1895
1896    WOLFSSL_ENTER("wolfSSL_OCSP_REQ_CTX_set1_req");
1897
1898    if (ctx == NULL || req == NULL) {
1899        WOLFSSL_MSG("Bad parameters");
1900        return WOLFSSL_FAILURE;
1901    }
1902
1903    if (req_len <= 0) {
1904        WOLFSSL_MSG("wolfSSL_OCSP_REQ_CTX_set1_req: request len error");
1905        return WOLFSSL_FAILURE;
1906    }
1907
1908    req_hdr_buf_len =
1909            XSNPRINTF(req_hdr_buf, sizeof(req_hdr_buf), req_hdr, req_len);
1910    if (req_hdr_buf_len >= (int)sizeof(req_hdr_buf)) {
1911        WOLFSSL_MSG("wolfSSL_OCSP_REQ_CTX_set1_req: request too long");
1912        return WOLFSSL_FAILURE;
1913    }
1914
1915    if (wolfSSL_BIO_write(ctx->reqResp, req_hdr_buf, req_hdr_buf_len) <= 0) {
1916        WOLFSSL_MSG("wolfSSL_OCSP_REQ_CTX_set1_req: wolfSSL_BIO_write error");
1917        return WOLFSSL_FAILURE;
1918    }
1919
1920    if (wolfSSL_i2d_OCSP_REQUEST_bio(ctx->reqResp, req) <= 0) {
1921        WOLFSSL_MSG("wolfSSL_OCSP_REQ_CTX_set1_req: request i2d error");
1922        return WOLFSSL_FAILURE;
1923    }
1924
1925    ctx->state = ORS_REQ_DONE;
1926
1927    return WOLFSSL_SUCCESS;
1928}
1929
1930static int OCSP_REQ_CTX_bio_cb(char *buf, int sz, void *ctx)
1931{
1932    return BioReceiveInternal((WOLFSSL_BIO*)ctx, NULL, buf, sz);
1933}
1934
1935int wolfSSL_OCSP_REQ_CTX_nbio(WOLFSSL_OCSP_REQ_CTX *ctx)
1936{
1937    WOLFSSL_ENTER("wolfSSL_OCSP_REQ_CTX_nbio");
1938
1939    if (ctx == NULL) {
1940        WOLFSSL_MSG("Bad parameters");
1941        return WOLFSSL_FAILURE;
1942    }
1943
1944    switch ((enum ocspReqIOStates)ctx->ioState) {
1945        case ORIOS_WRITE:
1946        case ORIOS_READ:
1947            break;
1948        case ORIOS_INVALID:
1949        default:
1950            WOLFSSL_MSG("Invalid ctx->ioState state");
1951            return WOLFSSL_FAILURE;
1952    }
1953
1954    if (ctx->ioState == ORIOS_WRITE) {
1955        switch ((enum ocspReqStates)ctx->state) {
1956            case ORS_HEADER_ADDED:
1957                /* Write final new line to complete http header */
1958                if (wolfSSL_BIO_write(ctx->reqResp, "\r\n", 2) != 2) {
1959                    WOLFSSL_MSG("wolfSSL_BIO_write error");
1960                    return WOLFSSL_FAILURE;
1961                }
1962                break;
1963            case ORS_REQ_DONE:
1964                break;
1965            case ORS_INVALID:
1966            default:
1967                WOLFSSL_MSG("Invalid WOLFSSL_OCSP_REQ_CTX state");
1968                return WOLFSSL_FAILURE;
1969        }
1970    }
1971
1972    switch ((enum ocspReqIOStates)ctx->ioState) {
1973        case ORIOS_WRITE:
1974        {
1975            const unsigned char *req;
1976            int reqLen = wolfSSL_BIO_get_mem_data(ctx->reqResp, (void*)&req);
1977            if (reqLen <= 0) {
1978                WOLFSSL_MSG("wolfSSL_BIO_get_mem_data error");
1979                return WOLFSSL_FAILURE;
1980            }
1981            while (ctx->sent < reqLen) {
1982                int sent = wolfSSL_BIO_write(ctx->bio, req + ctx->sent,
1983                        reqLen - ctx->sent);
1984                if (sent <= 0) {
1985                    if (wolfSSL_BIO_should_retry(ctx->bio))
1986                        return WOLFSSL_FATAL_ERROR;
1987                    WOLFSSL_MSG("wolfSSL_BIO_write error");
1988                    ctx->ioState = ORIOS_INVALID;
1989                    return 0;
1990                }
1991                ctx->sent += sent;
1992            }
1993            ctx->sent = 0;
1994            ctx->ioState = ORIOS_READ;
1995            (void)wolfSSL_BIO_reset(ctx->reqResp);
1996            FALL_THROUGH;
1997        }
1998        case ORIOS_READ:
1999        {
2000            byte* resp = NULL;
2001            int respLen;
2002            int ret;
2003
2004            if (ctx->buf == NULL) /* Should be allocated in new call */
2005                return WOLFSSL_FAILURE;
2006
2007            ret = wolfIO_HttpProcessResponseOcspGenericIO(OCSP_REQ_CTX_bio_cb,
2008                    ctx->bio, &resp, ctx->buf, ctx->bufLen, NULL);
2009            if (ret <= 0) {
2010                if (resp != NULL)
2011                    XFREE(resp, NULL, DYNAMIC_TYPE_OCSP);
2012                if (ret == WC_NO_ERR_TRACE(WOLFSSL_CBIO_ERR_WANT_READ) ||
2013                    ret == WC_NO_ERR_TRACE(OCSP_WANT_READ))
2014                {
2015                    return WOLFSSL_FATAL_ERROR;
2016                }
2017                return WOLFSSL_FAILURE;
2018            }
2019            respLen = ret;
2020            ret = wolfSSL_BIO_write(ctx->reqResp, resp, respLen);
2021            XFREE(resp, NULL, DYNAMIC_TYPE_OCSP);
2022            if (ret != respLen) {
2023                WOLFSSL_MSG("wolfSSL_BIO_write error");
2024                return WOLFSSL_FAILURE;
2025            }
2026            break;
2027        }
2028        case ORIOS_INVALID:
2029        default:
2030            WOLFSSL_MSG("Invalid ctx->ioState state");
2031            return WOLFSSL_FAILURE;
2032    }
2033
2034    return WOLFSSL_SUCCESS;
2035}
2036
2037int wolfSSL_OCSP_sendreq_nbio(OcspResponse **presp, WOLFSSL_OCSP_REQ_CTX *ctx)
2038{
2039    int ret;
2040    int len;
2041    const unsigned char *resp = NULL;
2042
2043    WOLFSSL_ENTER("wolfSSL_OCSP_sendreq_nbio");
2044
2045    if (presp == NULL)
2046        return WOLFSSL_FAILURE;
2047
2048    ret = wolfSSL_OCSP_REQ_CTX_nbio(ctx);
2049    if (ret != WOLFSSL_SUCCESS)
2050        return ret;
2051
2052    len = wolfSSL_BIO_get_mem_data(ctx->reqResp, (void*)&resp);
2053    if (len <= 0)
2054        return WOLFSSL_FAILURE;
2055    return wolfSSL_d2i_OCSP_RESPONSE(presp, &resp, len) != NULL
2056            ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
2057}
2058
2059/*******************************************************************************
2060 * END OF WOLFSSL_OCSP_REQ_CTX API
2061 ******************************************************************************/
2062
2063#ifndef NO_WOLFSSL_STUB
2064int wolfSSL_OCSP_REQUEST_add_ext(OcspRequest* req, WOLFSSL_X509_EXTENSION* ext,
2065        int idx)
2066{
2067    WOLFSSL_STUB("wolfSSL_OCSP_REQUEST_add_ext");
2068    (void)req;
2069    (void)ext;
2070    (void)idx;
2071    return WOLFSSL_FATAL_ERROR;
2072}
2073#endif
2074
2075#ifndef NO_WOLFSSL_STUB
2076OcspResponse* wolfSSL_OCSP_response_create(int status,
2077    WOLFSSL_OCSP_BASICRESP* bs)
2078{
2079    WOLFSSL_STUB("wolfSSL_OCSP_response_create");
2080    (void)status;
2081    (void)bs;
2082    return NULL;
2083}
2084#endif
2085
2086#ifndef NO_WOLFSSL_STUB
2087const char* wolfSSL_OCSP_crl_reason_str(long s)
2088{
2089    WOLFSSL_STUB("wolfSSL_OCSP_crl_reason_str");
2090    (void)s;
2091    return NULL;
2092}
2093#endif
2094
2095/* Returns elements of an OCSP_CERTID struct. Currently only supports
2096 * returning the serial number, and returns an error if user requests
2097 * any of name, pmd, and/or keyHash.
2098 * Return 1 on success, 0 on failure */
2099int wolfSSL_OCSP_id_get0_info(WOLFSSL_ASN1_STRING **name,
2100  WOLFSSL_ASN1_OBJECT **pmd, WOLFSSL_ASN1_STRING **keyHash,
2101  WOLFSSL_ASN1_INTEGER **serial, WOLFSSL_OCSP_CERTID *cid)
2102{
2103    WOLFSSL_ENTER("wolfSSL_OCSP_id_get0_info");
2104
2105    if (cid == NULL)
2106        return 0;
2107
2108    /* build up ASN1_INTEGER for serial */
2109    if (serial != NULL) {
2110        int i = 0;
2111        WOLFSSL_ASN1_INTEGER* ser;
2112
2113        ser = wolfSSL_ASN1_INTEGER_new();
2114        if (ser == NULL)
2115            return 0;
2116
2117        if (cid->status->serialSz > (WOLFSSL_ASN1_INTEGER_MAX - 2)) {
2118            /* allocate data buffer, +2 for type and length */
2119            ser->data = (unsigned char*)XMALLOC((size_t)cid->status->serialSz + 2, NULL,
2120                DYNAMIC_TYPE_OPENSSL);
2121            if (ser->data == NULL) {
2122                wolfSSL_ASN1_INTEGER_free(ser);
2123                return 0;
2124            }
2125            ser->dataMax = (unsigned int)cid->status->serialSz + 2;
2126            ser->isDynamic = 1;
2127        } else {
2128            /* Use array instead of dynamic memory */
2129            ser->data    = ser->intData;
2130            ser->dataMax = WOLFSSL_ASN1_INTEGER_MAX;
2131        }
2132
2133        #if defined(WOLFSSL_QT) || defined(WOLFSSL_HAPROXY)
2134            /* Serial number starts at 0 index of ser->data */
2135            XMEMCPY(&ser->data[i], cid->status->serial,
2136                (size_t)cid->status->serialSz);
2137            ser->length = cid->status->serialSz;
2138        #else
2139            ser->data[i++] = ASN_INTEGER;
2140            i += SetLength(cid->status->serialSz, ser->data + i);
2141            XMEMCPY(&ser->data[i], cid->status->serial,
2142                (size_t)cid->status->serialSz);
2143            ser->length = i + cid->status->serialSz;
2144        #endif
2145
2146        cid->status->serialInt = ser;
2147        *serial = ser;
2148    }
2149
2150    /* Not needed for Apache, return error if user is requesting */
2151    if (name != NULL || pmd != NULL || keyHash != NULL) {
2152        if (name != NULL)
2153            *name = NULL;
2154
2155        if (pmd != NULL)
2156            *pmd = NULL;
2157
2158        if (keyHash != NULL)
2159            *keyHash = NULL;
2160        return 0;
2161    }
2162
2163    return 1;
2164}
2165
2166int wolfSSL_OCSP_request_add1_nonce(OcspRequest* req, unsigned char* val,
2167        int sz)
2168{
2169    WC_RNG rng;
2170
2171    WOLFSSL_ENTER("wolfSSL_OCSP_request_add1_nonce");
2172
2173    if (req == NULL || sz > MAX_OCSP_NONCE_SZ) {
2174        WOLFSSL_MSG("Bad parameter");
2175        return WOLFSSL_FAILURE;
2176    }
2177
2178    if (sz <= 0)
2179        sz = MAX_OCSP_NONCE_SZ;
2180
2181    if (val != NULL) {
2182        XMEMCPY(req->nonce, val, (size_t)sz);
2183    }
2184    else {
2185        if (
2186#ifndef HAVE_FIPS
2187            wc_InitRng_ex(&rng, req->heap, INVALID_DEVID)
2188#else
2189            wc_InitRng(&rng)
2190#endif
2191            != 0) {
2192            WOLFSSL_MSG("RNG init failed");
2193            return WOLFSSL_FAILURE;
2194        }
2195        if (wc_RNG_GenerateBlock(&rng, req->nonce, (word32)sz) != 0) {
2196            WOLFSSL_MSG("wc_RNG_GenerateBlock failed");
2197            wc_FreeRng(&rng);
2198            return WOLFSSL_FAILURE;
2199        }
2200        wc_FreeRng(&rng);
2201    }
2202    req->nonceSz = sz;
2203
2204    return WOLFSSL_SUCCESS;
2205}
2206
2207/* Returns result of OCSP nonce comparison. Return values:
2208 *  1 - nonces are both present and equal
2209 *  2 - both nonces are absent
2210 *  3 - nonce only present in response
2211 * -1 - nonce only present in request
2212 *  0 - both nonces present and equal
2213 */
2214int wolfSSL_OCSP_check_nonce(OcspRequest* req, WOLFSSL_OCSP_BASICRESP* bs)
2215{
2216    const byte* reqNonce = NULL;
2217    const byte* rspNonce = NULL;
2218    int reqNonceSz = 0;
2219    int rspNonceSz = 0;
2220
2221    WOLFSSL_ENTER("wolfSSL_OCSP_check_nonce");
2222
2223    if (req != NULL) {
2224        reqNonce = req->nonce;
2225        reqNonceSz = req->nonceSz;
2226    }
2227
2228    if (bs != NULL) {
2229        rspNonce = bs->nonce;
2230        rspNonceSz = bs->nonceSz;
2231    }
2232
2233    /* nonce absent in both req and rsp */
2234    if (reqNonce == NULL && rspNonce == NULL)
2235        return 2;
2236
2237    /* nonce present in rsp only */
2238    if (reqNonce == NULL && rspNonce != NULL)
2239        return 3;
2240
2241    /* nonce present in req only */
2242    if (reqNonce != NULL && rspNonce == NULL)
2243        return WOLFSSL_FATAL_ERROR;
2244
2245    /* nonces are present and equal, return 1. Extra NULL check for fixing
2246        scan-build warning. */
2247    if (reqNonceSz == rspNonceSz && reqNonce && rspNonce) {
2248        if (XMEMCMP(reqNonce, rspNonce, (size_t)reqNonceSz) == 0)
2249            return 1;
2250    }
2251
2252    /* nonces are present but not equal */
2253    return 0;
2254}
2255
2256#endif /* OPENSSL_ALL */
2257
2258#ifdef HAVE_OCSP_RESPONDER
2259
2260/* Free a CA entry and all its resources */
2261static void FreeOcspResponderCa(OcspResponderCa* ca, void* heap)
2262{
2263    OcspResponderCertStatus* status;
2264    OcspResponderCertStatus* nextStatus;
2265
2266    if (ca == NULL)
2267        return;
2268
2269    /* Free private key */
2270#ifndef NO_RSA
2271    if (ca->keyType == RSAk) {
2272        wc_FreeRsaKey(&ca->key.rsa);
2273    }
2274#endif
2275#ifdef HAVE_ECC
2276    if (ca->keyType == ECDSAk) {
2277        wc_ecc_free(&ca->key.ecc);
2278    }
2279#endif
2280
2281    /* Free certificate DER if allocated */
2282    if (ca->certDer != NULL) {
2283        XFREE(ca->certDer, heap, DYNAMIC_TYPE_OCSP);
2284    }
2285
2286    /* Free certificate status list */
2287    status = ca->statuses;
2288    while (status != NULL) {
2289        nextStatus = status->next;
2290        XFREE(status, heap, DYNAMIC_TYPE_OCSP);
2291        status = nextStatus;
2292    }
2293
2294    XFREE(ca, heap, DYNAMIC_TYPE_OCSP);
2295}
2296
2297/* Allocate and initialize an OCSP Responder */
2298OcspResponder* wc_OcspResponder_new(void* heap, int sendCerts)
2299{
2300    OcspResponder* responder;
2301
2302    WOLFSSL_ENTER("wc_OcspResponder_new");
2303
2304    responder = (OcspResponder*)XMALLOC(sizeof(OcspResponder), heap,
2305                                         DYNAMIC_TYPE_OCSP);
2306    if (responder != NULL) {
2307        XMEMSET(responder, 0, sizeof(OcspResponder));
2308        responder->heap = heap;
2309        responder->sendCerts = sendCerts ? 1 : 0;
2310        if (wc_InitRng(&responder->rng) != 0) {
2311            XFREE(responder, heap, DYNAMIC_TYPE_OCSP);
2312            responder = NULL;
2313        }
2314    }
2315    return responder;
2316}
2317
2318/* Free an OCSP Responder */
2319void wc_OcspResponder_free(OcspResponder* responder)
2320{
2321    WOLFSSL_ENTER("wc_OcspResponder_free");
2322    if (responder != NULL) {
2323        OcspResponderCa* ca;
2324        OcspResponderCa* nextCa;
2325        /* Free all CAs */
2326        ca = responder->caList;
2327        while (ca != NULL) {
2328            nextCa = ca->next;
2329            FreeOcspResponderCa(ca, responder->heap);
2330            ca = nextCa;
2331        }
2332        wc_FreeRng(&responder->rng);
2333        XFREE(responder, responder->heap, DYNAMIC_TYPE_OCSP);
2334    }
2335}
2336
2337int wc_OcspResponder_AddSigner(OcspResponder* responder,
2338    const byte* signerDer, word32 signerDerSz,
2339    const byte* keyDer, word32 keyDerSz,
2340    /* Necessary when adding an authorized responder */
2341    const byte* issuerCertDer, word32 issuerCertDerSz)
2342{
2343    int ret = -1;
2344    OcspResponderCa* ca = NULL;
2345    DecodedCert* decoded = NULL;
2346    word32 keyOID = 0;
2347
2348    WOLFSSL_ENTER("wc_OcspResponder_AddSigner");
2349
2350    if (responder == NULL || signerDer == NULL || signerDerSz == 0 ||
2351        keyDer == NULL || keyDerSz == 0 ||
2352        (issuerCertDerSz != 0 && issuerCertDer == NULL))
2353        return BAD_FUNC_ARG;
2354
2355    /* Allocate CA structure */
2356    ca = (OcspResponderCa*)XMALLOC(sizeof(OcspResponderCa), responder->heap,
2357                                   DYNAMIC_TYPE_OCSP);
2358    if (ca == NULL) {
2359        ret = MEMORY_E;
2360        goto out;
2361    }
2362    XMEMSET(ca, 0, sizeof(OcspResponderCa));
2363
2364    /* Parse certificate */
2365    decoded = (DecodedCert*)XMALLOC(sizeof(DecodedCert), responder->heap,
2366                                    DYNAMIC_TYPE_OCSP);
2367    if (decoded == NULL) {
2368        ret = MEMORY_E;
2369        goto out;
2370    }
2371
2372    wc_InitDecodedCert(decoded, signerDer, signerDerSz, responder->heap);
2373    ret = wc_ParseCert(decoded, CERT_TYPE, 0, NULL);
2374    if (ret != 0)
2375        goto out;
2376
2377    ret = wc_CheckPrivateKeyCert(keyDer, keyDerSz, decoded, 1, responder->heap);
2378    if (ret != 1) {
2379        ret = (ret == 0) ? BAD_FUNC_ARG : ret;
2380        goto out;
2381    }
2382    keyOID = decoded->keyOID;
2383
2384    ret = wc_ShaHash(decoded->publicKeyForHash, decoded->pubKeyForHashSize,
2385            ca->responderKeyHash);
2386    if (ret != 0)
2387        goto out;
2388
2389    /* Now place the real issuer into decoded and perform cert can actually
2390     * sign for issuer. */
2391    if (issuerCertDer != NULL && issuerCertDerSz > 0) {
2392        char issuer[WC_ASN_NAME_MAX];
2393
2394        if (signerDerSz == issuerCertDerSz &&
2395                XMEMCMP(signerDer, issuerCertDer, signerDerSz) == 0) {
2396            /* API misuse */
2397            ret = BAD_FUNC_ARG;
2398            goto out;
2399        }
2400        if ((decoded->extExtKeyUsage & EXTKEYUSE_OCSP_SIGN) == 0) {
2401            /* Cert is not authorized for OCSP signing */
2402            ret = BAD_FUNC_ARG;
2403            goto out;
2404        }
2405        XMEMCPY(issuer, decoded->issuer, WC_ASN_NAME_MAX);
2406
2407        /* Use allocated DecodedCert */
2408        wc_FreeDecodedCert(decoded);
2409        wc_InitDecodedCert(decoded, issuerCertDer, issuerCertDerSz,
2410                          responder->heap);
2411        ret = wc_ParseCert(decoded, CERT_TYPE, 0, NULL);
2412        if (ret != 0)
2413            goto out;
2414
2415        if (XSTRNCMP(issuer, decoded->subject, WC_ASN_NAME_MAX) != 0) {
2416            /* Issuer name in responder cert does not match subject of issuer cert */
2417            ret = BAD_FUNC_ARG;
2418            goto out;
2419        }
2420
2421        ca->authResp = 1;
2422    }
2423
2424    /* Use responder cert's subject and public key for hashes */
2425    if (decoded->subjectRawForHash == NULL ||
2426            decoded->subjectRawForHashLen <= 0) {
2427        ret = BAD_FUNC_ARG;
2428        goto out;
2429    }
2430    ret = AsnHashesHash(&ca->issuerHashes, decoded->subjectRawForHash,
2431            (word32)decoded->subjectRawForHashLen);
2432    if (ret != 0)
2433        goto out;
2434    if (decoded->publicKeyForHash == NULL || decoded->pubKeyForHashSize == 0) {
2435        ret = BAD_FUNC_ARG;
2436        goto out;
2437    }
2438    ret = AsnHashesHash(&ca->issuerKeyHashes, decoded->publicKeyForHash,
2439            decoded->pubKeyForHashSize);
2440    if (ret != 0)
2441        goto out;
2442
2443    /* Extract necessary info from decoded cert */
2444    XMEMCPY(ca->subject, decoded->subject, WC_ASN_NAME_MAX);
2445
2446    /* Store raw certificate DER if sendCerts is enabled */
2447    if (responder->sendCerts) {
2448        ca->certDer = (byte*)XMALLOC(signerDerSz, responder->heap, DYNAMIC_TYPE_OCSP);
2449        if (ca->certDer == NULL) {
2450            ret = MEMORY_E;
2451            goto out;
2452        }
2453        XMEMCPY(ca->certDer, signerDer, signerDerSz);
2454        ca->certDerSz = signerDerSz;
2455    }
2456
2457    /* Load the private key */
2458#ifndef NO_RSA
2459    if (keyOID == RSAk) {
2460        ret = wc_InitRsaKey(&ca->key.rsa, responder->heap);
2461        if (ret == 0) {
2462            word32 idx = 0;
2463            ca->keyType = RSAk;
2464            ret = wc_RsaPrivateKeyDecode(keyDer, &idx, &ca->key.rsa, keyDerSz);
2465        }
2466        if (ret != 0)
2467            goto out;
2468    }
2469    else
2470#endif
2471#ifdef HAVE_ECC
2472    if (keyOID == ECDSAk) {
2473        ret = wc_ecc_init_ex(&ca->key.ecc, responder->heap, INVALID_DEVID);
2474        if (ret == 0) {
2475            word32 idx = 0;
2476            ca->keyType = ECDSAk;
2477            ret = wc_EccPrivateKeyDecode(keyDer, &idx, &ca->key.ecc, keyDerSz);
2478        }
2479        if (ret != 0)
2480            goto out;
2481    }
2482    else
2483#endif
2484    {
2485        ret = NOT_COMPILED_IN;
2486        goto out;
2487    }
2488
2489    /* Check for duplicates before adding */
2490    {
2491        OcspResponderCa* existing = responder->caList;
2492        while (existing != NULL) {
2493            if (XMEMCMP(&existing->issuerHashes, &ca->issuerHashes,
2494                       sizeof(AsnHashes)) == 0 &&
2495                XMEMCMP(&existing->issuerKeyHashes, &ca->issuerKeyHashes,
2496                       sizeof(AsnHashes)) == 0) {
2497                ret = DUPE_ENTRY_E;
2498                goto out;
2499            }
2500            existing = existing->next;
2501        }
2502    }
2503
2504    /* Add CA to list */
2505    ca->next = responder->caList;
2506    responder->caList = ca;
2507    ca = NULL; /* Ownership transferred */
2508    ret = 0;
2509
2510out:
2511    if (decoded != NULL) {
2512        wc_FreeDecodedCert(decoded);
2513        XFREE(decoded, responder->heap, DYNAMIC_TYPE_OCSP);
2514    }
2515    if (ca != NULL)
2516        FreeOcspResponderCa(ca, responder->heap);
2517    return ret;
2518}
2519
2520/* Find Auth CA by issuer hashes from request */
2521static OcspResponderCa* FindCaByHashes(OcspResponder* responder,
2522    const byte* issuerHash, const byte* issuerKeyHash, int hashAlg)
2523{
2524    OcspResponderCa* ca = responder->caList;
2525
2526    while (ca != NULL) {
2527        int hashSz = 0;
2528        const byte* caIssuerHash = AsnHashesGetHash(&ca->issuerHashes,
2529            hashAlg, &hashSz);
2530        const byte* caKeyHash = AsnHashesGetHash(&ca->issuerKeyHashes,
2531            hashAlg, &hashSz);
2532
2533        if (caIssuerHash != NULL && caKeyHash != NULL && hashSz > 0 &&
2534            XMEMCMP(caIssuerHash, issuerHash, (size_t)hashSz) == 0 &&
2535            XMEMCMP(caKeyHash, issuerKeyHash, (size_t)hashSz) == 0) {
2536            return ca;
2537        }
2538        ca = ca->next;
2539    }
2540
2541    return NULL;
2542}
2543
2544/* Find certificate status in a CA */
2545static OcspResponderCertStatus* FindCertStatus(OcspResponderCa* ca,
2546    const byte* serial, word32 serialSz)
2547{
2548    OcspResponderCertStatus* status = ca->statuses;
2549
2550    while (status != NULL) {
2551        if (status->serialSz == (int)serialSz &&
2552            XMEMCMP(status->serial, serial, serialSz) == 0) {
2553            return status;
2554        }
2555        status = status->next;
2556    }
2557
2558    return NULL;
2559}
2560
2561/* Find Auth CA by subject string */
2562static OcspResponderCa* FindCaBySubject(OcspResponder* responder,
2563    const char* caSubject, word32 caSubjectSz)
2564{
2565    OcspResponderCa* ca = responder->caList;
2566
2567    while (ca != NULL) {
2568        word32 subjectLen = (word32)XSTRLEN(ca->subject);
2569        if (subjectLen == caSubjectSz &&
2570            XMEMCMP(ca->subject, caSubject, caSubjectSz) == 0) {
2571            return ca;
2572        }
2573        ca = ca->next;
2574    }
2575
2576    return NULL;
2577}
2578
2579/* Add a certificate status for a specific CA */
2580int wc_OcspResponder_SetCertStatus(OcspResponder* responder,
2581    const char* caSubject, word32 caSubjectSz,
2582    const byte* serial, word32 serialSz, enum Ocsp_Cert_Status status,
2583    time_t revocationTime, enum WC_CRL_Reason revocationReason,
2584    word32 validityPeriod)
2585{
2586    OcspResponderCa* ca = NULL;
2587    OcspResponderCertStatus* certStatus = NULL;
2588    int ret = WC_NO_ERR_TRACE(BAD_FUNC_ARG);
2589    int isNew = 0;
2590
2591    WOLFSSL_ENTER("wc_OcspResponder_SetCertStatus");
2592
2593    if (responder == NULL || caSubject == NULL || caSubjectSz == 0 ||
2594        serial == NULL || serialSz == 0 || serialSz > EXTERNAL_SERIAL_SIZE)
2595        goto out;
2596
2597    if (status != CERT_GOOD && status != CERT_REVOKED &&
2598        status != CERT_UNKNOWN)
2599        goto out;
2600
2601    /* Validate revocation parameters when status is REVOKED */
2602    if (status == CERT_REVOKED) {
2603        if (revocationTime <= 0)
2604            goto out;
2605        if (revocationReason < WC_CRL_REASON_UNSPECIFIED ||
2606            revocationReason > WC_CRL_REASON_AA_COMPROMISE)
2607            goto out;
2608        /* Skip value 7 which is not used */
2609        if (revocationReason == 7)
2610            goto out;
2611    }
2612
2613    if (status == CERT_GOOD && validityPeriod == 0)
2614        goto out;
2615    if (status != CERT_GOOD && validityPeriod != 0)
2616        goto out;
2617
2618    /* Find the CA */
2619    ca = FindCaBySubject(responder, caSubject, caSubjectSz);
2620    if (ca == NULL) {
2621        ret = ASN_NO_SIGNER_E;
2622        goto out;
2623    }
2624
2625    /* Check if status already exists for this serial */
2626    certStatus = FindCertStatus(ca, serial, serialSz);
2627    if (certStatus == NULL) {
2628        /* Allocate new status entry */
2629        certStatus = (OcspResponderCertStatus*)XMALLOC(
2630            sizeof(OcspResponderCertStatus), responder->heap, DYNAMIC_TYPE_OCSP);
2631        if (certStatus == NULL) {
2632            ret = MEMORY_E;
2633            goto out;
2634        }
2635        XMEMSET(certStatus, 0, sizeof(OcspResponderCertStatus));
2636        XMEMCPY(certStatus->serial, serial, serialSz);
2637        certStatus->serialSz = serialSz;
2638        isNew = 1;
2639    }
2640
2641    certStatus->status = status;
2642    certStatus->validityPeriod = 0;
2643    if (status == CERT_REVOKED) {
2644        ret = GetFormattedTime_ex(&revocationTime, certStatus->revocationDate,
2645            sizeof(certStatus->revocationDate), ASN_GENERALIZED_TIME);
2646        if (ret <= 0) {
2647            WOLFSSL_MSG("Failed to format revocation time");
2648            goto out;
2649        }
2650        certStatus->revocationDateSz = (word32)ret;
2651        certStatus->revocationReason = revocationReason;
2652    }
2653    else if (status == CERT_GOOD) {
2654        certStatus->validityPeriod = validityPeriod;
2655    }
2656
2657    if (isNew) {
2658        /* Add to CA's status list */
2659        certStatus->next = ca->statuses;
2660        ca->statuses = certStatus;
2661        certStatus = NULL; /* Ownership transferred */
2662    }
2663    ret = 0;
2664
2665out:
2666    if (isNew && certStatus != NULL)
2667        XFREE(certStatus, responder->heap, DYNAMIC_TYPE_OCSP);
2668
2669    return ret;
2670}
2671
2672static int OcspResponse_WriteResponse(OcspResponder* responder, byte* response,
2673        word32* responseSz, OcspResponderCa* ca,
2674        OcspResponderCertStatus* certStatus, OcspRequest* req)
2675{
2676    OcspResponse resp;
2677    CertStatus status;
2678    OcspEntry entry;
2679    int ret = 0;
2680    time_t now;
2681    RsaKey* rsaKey = NULL;
2682    ecc_key* eccKey = NULL;
2683    int respInited = 0;
2684    int hashSz = 0;
2685    const byte* caIssuerHash = NULL;
2686    const byte* caKeyHash = NULL;
2687    int hashAlg = -1;
2688
2689    WOLFSSL_ASSERT_SIZEOF_EQ(resp.responderId.keyHash, ca->responderKeyHash);
2690
2691    WOLFSSL_ENTER("OcspResponse_WriteResponse");
2692
2693    if (responseSz == NULL || ca == NULL || certStatus == NULL ||
2694            certStatus->serialSz > EXTERNAL_SERIAL_SIZE) {
2695        ret = BAD_FUNC_ARG;
2696        goto out;
2697    }
2698
2699    InitOcspResponse(&resp, &entry, &status, NULL, 0, responder->heap);
2700    respInited = 1;
2701
2702    resp.responseStatus = OCSP_SUCCESSFUL;
2703
2704    status.status = certStatus->status;
2705
2706    XMEMCPY(status.serial, certStatus->serial, certStatus->serialSz);
2707    status.serialSz = (byte)certStatus->serialSz;
2708
2709    /* Copy revocation information if status is REVOKED */
2710    if (certStatus->status == CERT_REVOKED) {
2711        XMEMCPY(status.revocationDate, certStatus->revocationDate,
2712                certStatus->revocationDateSz);
2713        status.revocationDateSz = certStatus->revocationDateSz;
2714        status.revocationReason = (byte)certStatus->revocationReason;
2715    }
2716
2717    now = wc_Time(NULL);
2718    ret = GetFormattedTime_ex(&now, status.thisDate, sizeof(status.thisDate),
2719            ASN_GENERALIZED_TIME);
2720    if (ret <= 0) {
2721        WOLFSSL_MSG("Failed to format thisUpdate time");
2722        goto out;
2723    }
2724    XMEMCPY(resp.producedDate, status.thisDate, ret);
2725    resp.producedDateSz = status.thisDateSz = (byte)(ret);
2726    resp.producedDateFormat = status.thisDateFormat = ASN_GENERALIZED_TIME;
2727
2728    /* Set nextUpdate if validity period is specified (for CERT_GOOD) */
2729    if (certStatus->status == CERT_GOOD && certStatus->validityPeriod > 0) {
2730        time_t nextTime = now + (time_t)certStatus->validityPeriod;
2731        ret = GetFormattedTime_ex(&nextTime, status.nextDate,
2732                sizeof(status.nextDate), ASN_GENERALIZED_TIME);
2733        if (ret <= 0) {
2734            WOLFSSL_MSG("Failed to format nextUpdate time");
2735            goto out;
2736        }
2737        status.nextDateSz = (byte)ret;
2738        status.nextDateFormat = ASN_GENERALIZED_TIME;
2739    }
2740
2741    /* Set certificate if sendCerts is enabled */
2742    if (responder->sendCerts && ca->certDer != NULL) {
2743        resp.cert = ca->certDer;
2744        resp.certSz = ca->certDerSz;
2745    }
2746
2747    /* Copy nonce from request to response if present */
2748    if (req != NULL && req->nonceSz > 0) {
2749        resp.nonce = req->nonce;
2750        resp.nonceSz = req->nonceSz;
2751    }
2752
2753    /* Echo the hash algorithm from the request */
2754    if (req == NULL) {
2755        hashAlg = SHAh; /* Fall back to SHA-1 as its required for OCSP */
2756    }
2757    else {
2758        hashAlg = req->hashAlg;
2759    }
2760    caIssuerHash = AsnHashesGetHash(&ca->issuerHashes, hashAlg, &hashSz);
2761    caKeyHash = AsnHashesGetHash(&ca->issuerKeyHashes, hashAlg, &hashSz);
2762    if (caIssuerHash == NULL || caKeyHash == NULL || hashSz <= 0) {
2763        ret = ASN_SIG_HASH_E;
2764        goto out;
2765    }
2766    entry.hashAlgoOID = (word32)hashAlg;
2767    XMEMCPY(entry.issuerHash, caIssuerHash, (size_t)hashSz);
2768    XMEMCPY(entry.issuerKeyHash, caKeyHash, (size_t)hashSz);
2769
2770    resp.responderIdType = OCSP_RESPONDER_ID_KEY;
2771    XMEMCPY(resp.responderId.keyHash, ca->responderKeyHash, WC_SHA_DIGEST_SIZE);
2772
2773    /* TODO allow user to set algo */
2774    if (ca->keyType == RSAk) {
2775        rsaKey = &ca->key.rsa;
2776        resp.sigOID = CTC_SHA256wRSA;
2777    }
2778    else if (ca->keyType == ECDSAk) {
2779        eccKey = &ca->key.ecc;
2780        resp.sigOID = CTC_SHA256wECDSA;
2781    }
2782    else {
2783        ret = NOT_COMPILED_IN;
2784        goto out;
2785    }
2786
2787    ret = OcspResponseEncode(&resp, response, responseSz, rsaKey, eccKey,
2788            &responder->rng);
2789    if (ret != 0) {
2790        WOLFSSL_MSG("Failed to encode OCSP response");
2791        goto out;
2792    }
2793
2794    ret = 0;
2795out:
2796    if (respInited)
2797        FreeOcspResponse(&resp);
2798    return ret;
2799}
2800
2801/* Generate OCSP response for a request */
2802int wc_OcspResponder_WriteResponse(OcspResponder* responder,
2803    const byte* request, word32 requestSz,
2804    byte* response, word32* responseSz)
2805{
2806    int ret = 0;
2807    OcspRequest req;
2808    OcspResponderCa* ca = NULL;
2809    OcspResponderCertStatus* certStatus = NULL;
2810    int reqInited = 0;
2811
2812    WOLFSSL_ENTER("wc_OcspResponder_WriteResponse");
2813
2814    if (responder == NULL || request == NULL || requestSz == 0) {
2815        ret = BAD_FUNC_ARG;
2816        goto out;
2817    }
2818
2819    XMEMSET(&req, 0, sizeof(OcspRequest));
2820
2821    /* Decode the OCSP request */
2822    ret = DecodeOcspRequest(&req, request, requestSz);
2823    if (ret != 0) {
2824        WOLFSSL_MSG("Failed to decode OCSP request");
2825        goto out;
2826    }
2827    reqInited = 1;
2828
2829    /* Find the CA by issuer hashes */
2830    ca = FindCaByHashes(responder, req.issuerHash, req.issuerKeyHash,
2831                        req.hashAlg);
2832    if (ca == NULL) {
2833        WOLFSSL_MSG("No matching CA found for request");
2834        ret = ASN_NO_SIGNER_E;
2835        goto out;
2836    }
2837
2838    /* Find the certificate status */
2839    certStatus = FindCertStatus(ca, req.serial, req.serialSz);
2840    if (certStatus == NULL) {
2841        /* RFC 6960: 'unknown' is a per-certificate status inside a successful
2842         * OCSPResponse, not an error response. Generate a successful response
2843         * with CERT_UNKNOWN so clients can distinguish it from UNAUTHORIZED. */
2844        OcspResponderCertStatus unknownStatus;
2845        WOLFSSL_MSG("No status for requested certificate, responding unknown");
2846        if (req.serialSz > EXTERNAL_SERIAL_SIZE) {
2847            ret = BUFFER_E;
2848            goto out;
2849        }
2850        XMEMSET(&unknownStatus, 0, sizeof(unknownStatus));
2851        XMEMCPY(unknownStatus.serial, req.serial, req.serialSz);
2852        unknownStatus.serialSz = req.serialSz;
2853        unknownStatus.status = CERT_UNKNOWN;
2854        ret = OcspResponse_WriteResponse(responder, response, responseSz, ca,
2855                &unknownStatus, &req);
2856    }
2857    else {
2858        WOLFSSL_MSG("Found CA and certificate status");
2859        ret = OcspResponse_WriteResponse(responder, response, responseSz, ca,
2860                certStatus, &req);
2861    }
2862
2863out:
2864    if (reqInited)
2865        FreeOcspRequest(&req);
2866    WOLFSSL_LEAVE("wc_OcspResponder_WriteResponse", ret);
2867    return ret;
2868}
2869
2870int wc_OcspResponder_WriteErrorResponse(enum Ocsp_Response_Status status,
2871    byte* response, word32* responseSz)
2872{
2873    int ret = 0;
2874    OcspResponse resp;
2875    int respInited = 0;
2876
2877    WOLFSSL_ENTER("wc_OcspResponder_WriteErrorResponse");
2878
2879    if (responseSz == NULL) {
2880        ret = BAD_FUNC_ARG;
2881        goto out;
2882    }
2883
2884    /* Validate status - OCSP_SUCCESSFUL is not allowed for error responses */
2885    if (status == OCSP_SUCCESSFUL) {
2886        WOLFSSL_MSG("OCSP_SUCCESSFUL is not a valid error status");
2887        ret = BAD_FUNC_ARG;
2888        goto out;
2889    }
2890
2891    /* Validate that status is a known enumeration value */
2892    if (status != OCSP_MALFORMED_REQUEST &&
2893        status != OCSP_INTERNAL_ERROR &&
2894        status != OCSP_TRY_LATER &&
2895        status != OCSP_SIG_REQUIRED &&
2896        status != OCSP_UNAUTHORIZED) {
2897        WOLFSSL_MSG("Invalid OCSP response status");
2898        ret = BAD_FUNC_ARG;
2899        goto out;
2900    }
2901
2902    /* Initialize a minimal OCSP response structure */
2903    InitOcspResponse(&resp, NULL, NULL, NULL, 0, NULL);
2904    respInited = 1;
2905
2906    /* Set the error status */
2907    resp.responseStatus = (byte)status;
2908
2909    /* Encode the error response (no responseBytes, just status) */
2910    ret = OcspResponseEncode(&resp, response, responseSz, NULL, NULL, NULL);
2911    if (ret != 0) {
2912        WOLFSSL_MSG("Failed to encode OCSP error response");
2913        goto out;
2914    }
2915
2916    ret = 0;
2917out:
2918    if (respInited)
2919        FreeOcspResponse(&resp);
2920    return ret;
2921}
2922
2923#endif /* HAVE_OCSP_RESPONDER */
2924
2925/* Helper functions for testing */
2926int wc_InitOcspRequest(OcspRequest* req, DecodedCert* cert,
2927                                    byte useNonce, void* heap)
2928{
2929    return InitOcspRequest(req, cert, useNonce, heap);
2930}
2931
2932int wc_EncodeOcspRequest(OcspRequest* req, byte* output,
2933                                      word32 size)
2934{
2935    return EncodeOcspRequest(req, output, size);
2936}
2937
2938#else /* HAVE_OCSP */
2939
2940
2941#ifdef _MSC_VER
2942    /* 4206 warning for blank file */
2943    #pragma warning(disable: 4206)
2944#endif
2945
2946
2947#endif /* HAVE_OCSP */
2948#endif /* WOLFCRYPT_ONLY */