luna - wolfssl/src/crl.c

   1/* crl.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/*
  25CRL Options:
  26 * CRL_STATIC_REVOKED_LIST:                                        default: off
  27 *                         Enables fixed static list of RevokedCerts to allow
  28 *                         for a binary search.
  29 * CRL_MAX_REVOKED_CERTS:                                          default: 4
  30 *                         Specifies the number of buffers to hold RevokedCerts.
  31 *                         The default value is set to 4.
  32 * CRL_REPORT_LOAD_ERRORS:                                         default: off
  33 *                         Return any errors encountered during loading CRL
  34 *                         from a directory.
  35*/
  36
  37#ifndef WOLFCRYPT_ONLY
  38#ifdef HAVE_CRL
  39
  40#include <wolfssl/internal.h>
  41#include <wolfssl/error-ssl.h>
  42#include <wolfssl/wolfcrypt/logging.h>
  43#include <wolfssl/wolfcrypt/ecc.h>
  44#include <wolfssl/wolfcrypt/rsa.h>
  45#if defined(OPENSSL_EXTRA)
  46#include <wolfssl/openssl/x509v3.h>
  47#endif
  48
  49#ifndef NO_STRING_H
  50    #include <string.h>
  51#endif
  52
  53#ifdef HAVE_CRL_MONITOR
  54    #if defined(__MACH__) || defined(__FreeBSD__) || defined(__linux__) || \
  55         defined(_MSC_VER)
  56        static int StopMonitor(wolfSSL_CRL_mfd_t mfd);
  57    #else
  58        #error "CRL monitor only currently supported on linux or mach or windows"
  59    #endif
  60#endif /* HAVE_CRL_MONITOR */
  61
  62
  63/* Initialize CRL members */
  64int InitCRL(WOLFSSL_CRL* crl, WOLFSSL_CERT_MANAGER* cm)
  65{
  66    WOLFSSL_ENTER("InitCRL");
  67    if(cm != NULL)
  68        crl->heap = cm->heap;
  69    else
  70        crl->heap = NULL;
  71    crl->cm = cm;
  72    crl->crlList  = NULL;
  73    crl->currentEntry = NULL;
  74#ifdef HAVE_CRL_MONITOR
  75    crl->monitors[0].path = NULL;
  76    crl->monitors[1].path = NULL;
  77    crl->tid = INVALID_THREAD_VAL;
  78    crl->mfd = WOLFSSL_CRL_MFD_INIT_VAL;
  79    crl->setup = 0; /* thread setup done predicate */
  80    if (wolfSSL_CondInit(&crl->cond) != 0) {
  81        WOLFSSL_MSG("thread condition init failed");
  82        return BAD_COND_E;
  83    }
  84#endif
  85#ifdef HAVE_CRL_IO
  86    crl->crlIOCb = NULL;
  87#endif
  88    if (wc_InitRwLock(&crl->crlLock) != 0) {
  89        WOLFSSL_MSG("Init Mutex failed");
  90        return BAD_MUTEX_E;
  91    }
  92#ifdef OPENSSL_ALL
  93    {
  94        int ret;
  95        wolfSSL_RefInit(&crl->ref, &ret);
  96    #ifdef WOLFSSL_REFCNT_ERROR_RETURN
  97        if (ret != 0) {
  98            WOLFSSL_MSG("wolfSSL_RefInit failed");
  99            wc_FreeRwLock(&crl->crlLock);
 100        #ifdef HAVE_CRL_MONITOR
 101            wolfSSL_CondFree(&crl->cond);
 102        #endif
 103            return ret;
 104        }
 105    #else
 106        (void)ret;
 107    #endif
 108    }
 109#endif
 110#if defined(OPENSSL_EXTRA)
 111    crl->revokedStack = NULL;
 112#endif
 113
 114    return 0;
 115}
 116
 117
 118#ifdef CRL_STATIC_REVOKED_LIST
 119/* Compare two RevokedCert entries by (serialSz, serialNumber) for sorting.
 120 * Returns < 0, 0, or > 0 like memcmp. */
 121static int CompareRevokedCert(const RevokedCert* a, const RevokedCert* b)
 122{
 123    if (a->serialSz != b->serialSz)
 124        return a->serialSz - b->serialSz;
 125    return XMEMCMP(a->serialNumber, b->serialNumber, (size_t)a->serialSz);
 126}
 127
 128/* Sort revoked cert array in-place using insertion sort. The array is bounded
 129 * by CRL_MAX_REVOKED_CERTS so O(n^2) is fine. */
 130static void SortCRL_CertList(RevokedCert* certs, int totalCerts)
 131{
 132    int i, j;
 133    RevokedCert tmp;
 134
 135    for (i = 1; i < totalCerts; i++) {
 136        XMEMCPY(&tmp, &certs[i], sizeof(RevokedCert));
 137        j = i - 1;
 138        while (j >= 0 && CompareRevokedCert(&certs[j], &tmp) > 0) {
 139            XMEMCPY(&certs[j + 1], &certs[j], sizeof(RevokedCert));
 140            j--;
 141        }
 142        XMEMCPY(&certs[j + 1], &tmp, sizeof(RevokedCert));
 143    }
 144}
 145#endif /* CRL_STATIC_REVOKED_LIST */
 146
 147/* Initialize CRL Entry */
 148static int InitCRL_Entry(CRL_Entry* crle, DecodedCRL* dcrl, const byte* buff,
 149                         int verified, void* heap)
 150{
 151    WOLFSSL_ENTER("InitCRL_Entry");
 152
 153    XMEMCPY(crle->issuerHash, dcrl->issuerHash, CRL_DIGEST_SIZE);
 154    /* XMEMCPY(crle->crlHash, dcrl->crlHash, CRL_DIGEST_SIZE);
 155     * copy the hash here if needed for optimized comparisons */
 156    XMEMCPY(crle->lastDate, dcrl->lastDate, MAX_DATE_SIZE);
 157    XMEMCPY(crle->nextDate, dcrl->nextDate, MAX_DATE_SIZE);
 158    crle->lastDateFormat = dcrl->lastDateFormat;
 159    crle->nextDateFormat = dcrl->nextDateFormat;
 160    crle->version = dcrl->version;
 161
 162#if defined(OPENSSL_EXTRA)
 163    crle->lastDateAsn1.length = MAX_DATE_SIZE;
 164    XMEMCPY (crle->lastDateAsn1.data, crle->lastDate,
 165             (size_t)crle->lastDateAsn1.length);
 166    crle->lastDateAsn1.type = crle->lastDateFormat;
 167    crle->nextDateAsn1.length = MAX_DATE_SIZE;
 168    XMEMCPY (crle->nextDateAsn1.data, crle->nextDate,
 169             (size_t)crle->nextDateAsn1.length);
 170    crle->nextDateAsn1.type = crle->nextDateFormat;
 171
 172    crle->issuer = NULL;
 173    wolfSSL_d2i_X509_NAME(&crle->issuer, (unsigned char**)&dcrl->issuer,
 174                          dcrl->issuerSz);
 175    if (crle->issuer == NULL) {
 176        return WOLFSSL_FATAL_ERROR;
 177    }
 178#endif
 179#ifdef CRL_STATIC_REVOKED_LIST
 180    /* ParseCRL_CertList() has already cached the Revoked certs into
 181       the crle->certs array. Sort it so binary search in
 182       FindRevokedSerial works correctly. */
 183    crle->totalCerts = dcrl->totalCerts;
 184    SortCRL_CertList(crle->certs, crle->totalCerts);
 185#else
 186    crle->certs = dcrl->certs;   /* take ownership */
 187    crle->totalCerts = dcrl->totalCerts;
 188#endif
 189    dcrl->certs = NULL;
 190    crle->crlNumberSet = dcrl->crlNumberSet;
 191    if (crle->crlNumberSet) {
 192        XMEMCPY(crle->crlNumber, dcrl->crlNumber, sizeof(crle->crlNumber));
 193    }
 194    crle->verified = verified;
 195    if (!verified) {
 196        crle->tbsSz = dcrl->sigIndex - dcrl->certBegin;
 197        crle->signatureSz = dcrl->sigLength;
 198        crle->signatureOID = dcrl->signatureOID;
 199        crle->toBeSigned = (byte*)XMALLOC(crle->tbsSz, heap,
 200                                          DYNAMIC_TYPE_CRL_ENTRY);
 201        if (crle->toBeSigned == NULL)
 202            return WOLFSSL_FATAL_ERROR;
 203        crle->signature = (byte*)XMALLOC(crle->signatureSz, heap,
 204                                         DYNAMIC_TYPE_CRL_ENTRY);
 205        if (crle->signature == NULL) {
 206            XFREE(crle->toBeSigned, heap, DYNAMIC_TYPE_CRL_ENTRY);
 207            crle->toBeSigned = NULL;
 208            return WOLFSSL_FATAL_ERROR;
 209        }
 210
 211    #ifdef WC_RSA_PSS
 212        crle->sigParamsSz = dcrl->sigParamsLength;
 213        if (dcrl->sigParamsLength > 0) {
 214            crle->sigParams = (byte*)XMALLOC(crle->sigParamsSz, heap,
 215                                             DYNAMIC_TYPE_CRL_ENTRY);
 216            if (crle->sigParams== NULL) {
 217                XFREE(crle->toBeSigned, heap, DYNAMIC_TYPE_CRL_ENTRY);
 218                crle->toBeSigned = NULL;
 219                XFREE(crle->signature, heap, DYNAMIC_TYPE_CRL_ENTRY);
 220                crle->signature = NULL;
 221                return WOLFSSL_FATAL_ERROR;
 222            }
 223            XMEMCPY(crle->sigParams, buff + dcrl->sigParamsIndex,
 224                crle->sigParamsSz);
 225        }
 226    #endif
 227        XMEMCPY(crle->toBeSigned, buff + dcrl->certBegin, crle->tbsSz);
 228        XMEMCPY(crle->signature, dcrl->signature, crle->signatureSz);
 229    #ifndef NO_SKID
 230        crle->extAuthKeyIdSet = dcrl->extAuthKeyIdSet;
 231        if (crle->extAuthKeyIdSet)
 232            XMEMCPY(crle->extAuthKeyId, dcrl->extAuthKeyId, KEYID_SIZE);
 233    #endif
 234    }
 235    else {
 236        crle->toBeSigned = NULL;
 237        crle->signature = NULL;
 238    }
 239
 240    (void)verified;
 241    (void)heap;
 242
 243    return 0;
 244}
 245
 246static CRL_Entry* CRL_Entry_new(void* heap)
 247{
 248    CRL_Entry* crle = (CRL_Entry*)XMALLOC(sizeof(CRL_Entry), heap,
 249                                          DYNAMIC_TYPE_CRL_ENTRY);
 250    if (crle != NULL) {
 251        XMEMSET(crle, 0, sizeof(CRL_Entry));
 252        if (wc_InitMutex(&crle->verifyMutex) != 0) {
 253            XFREE(crle, heap, DYNAMIC_TYPE_CRL_ENTRY);
 254            crle = NULL;
 255        }
 256    }
 257    (void)heap;
 258    return crle;
 259}
 260
 261/* Free all CRL Entry resources */
 262static void CRL_Entry_free(CRL_Entry* crle, void* heap)
 263{
 264    WOLFSSL_ENTER("CRL_Entry_free");
 265    if (crle == NULL) {
 266        WOLFSSL_MSG("CRL Entry is null");
 267        return;
 268    }
 269#ifdef CRL_STATIC_REVOKED_LIST
 270#if defined(OPENSSL_EXTRA)
 271    {
 272        int i;
 273        for (i = 0; i < CRL_MAX_REVOKED_CERTS; i++) {
 274            XFREE(crle->certs[i].extensions, heap, DYNAMIC_TYPE_REVOKED);
 275        }
 276    }
 277#endif
 278    XMEMSET(crle->certs, 0, CRL_MAX_REVOKED_CERTS*sizeof(RevokedCert));
 279#else
 280    {
 281        RevokedCert* tmp;
 282        RevokedCert* next;
 283
 284        for (tmp = crle->certs; tmp != NULL; tmp = next) {
 285            next = tmp->next;
 286#if defined(OPENSSL_EXTRA)
 287            XFREE(tmp->extensions, heap, DYNAMIC_TYPE_REVOKED);
 288#endif
 289            XFREE(tmp, heap, DYNAMIC_TYPE_REVOKED);
 290        }
 291
 292    }
 293#endif
 294    XFREE(crle->signature, heap, DYNAMIC_TYPE_CRL_ENTRY);
 295    XFREE(crle->toBeSigned, heap, DYNAMIC_TYPE_CRL_ENTRY);
 296#ifdef WC_RSA_PSS
 297    XFREE(crle->sigParams, heap, DYNAMIC_TYPE_CRL_ENTRY);
 298#endif
 299#if defined(OPENSSL_EXTRA)
 300    if (crle->issuer != NULL) {
 301        FreeX509Name(crle->issuer);
 302        XFREE(crle->issuer, heap, DYNAMIC_TYPE_X509);
 303    }
 304#endif
 305    wc_FreeMutex(&crle->verifyMutex);
 306    XFREE(crle, heap, DYNAMIC_TYPE_CRL_ENTRY);
 307    (void)heap;
 308}
 309
 310
 311/* Free all CRL resources */
 312void FreeCRL(WOLFSSL_CRL* crl, int dynamic)
 313{
 314    CRL_Entry* tmp;
 315
 316    WOLFSSL_ENTER("FreeCRL");
 317
 318    if (crl == NULL)
 319        return;
 320
 321#ifdef OPENSSL_ALL
 322    {
 323        int ret;
 324        int doFree = 0;
 325        wolfSSL_RefDec(&crl->ref, &doFree, &ret);
 326        if (ret != 0)
 327            WOLFSSL_MSG("Couldn't lock x509 mutex");
 328        if (!doFree)
 329            return;
 330    }
 331#endif
 332
 333#ifdef HAVE_CRL_MONITOR
 334    if (crl->tid != INVALID_THREAD_VAL) {
 335        WOLFSSL_MSG("stopping monitor thread");
 336        if (StopMonitor(crl->mfd) == 0) {
 337            if (wolfSSL_JoinThread(crl->tid) != 0)
 338                WOLFSSL_MSG("stop monitor failed in wolfSSL_JoinThread");
 339        }
 340        else {
 341            WOLFSSL_MSG("stop monitor failed");
 342        }
 343    }
 344    if (wolfSSL_CondFree(&crl->cond) != 0)
 345        WOLFSSL_MSG("wolfSSL_CondFree failed in FreeCRL");
 346#endif
 347
 348#ifdef OPENSSL_ALL
 349    wolfSSL_RefFree(&crl->ref);
 350#endif
 351
 352    tmp = crl->crlList;
 353#ifdef HAVE_CRL_MONITOR
 354    if (crl->monitors[0].path)
 355        XFREE(crl->monitors[0].path, crl->heap, DYNAMIC_TYPE_CRL_MONITOR);
 356
 357    if (crl->monitors[1].path)
 358        XFREE(crl->monitors[1].path, crl->heap, DYNAMIC_TYPE_CRL_MONITOR);
 359#endif
 360
 361#if defined(OPENSSL_EXTRA)
 362    if (crl->revokedStack != NULL) {
 363        wolfSSL_sk_pop_free(crl->revokedStack, NULL);
 364        crl->revokedStack = NULL;
 365    }
 366#endif
 367    XFREE(crl->currentEntry, crl->heap, DYNAMIC_TYPE_CRL_ENTRY);
 368    crl->currentEntry = NULL;
 369    while(tmp) {
 370        CRL_Entry* next = tmp->next;
 371        CRL_Entry_free(tmp, crl->heap);
 372        tmp = next;
 373    }
 374
 375    wc_FreeRwLock(&crl->crlLock);
 376    if (dynamic)   /* free self */
 377        XFREE(crl, crl->heap, DYNAMIC_TYPE_CRL);
 378}
 379
 380static int FindRevokedSerial(RevokedCert* rc, byte* serial, int serialSz,
 381        byte* serialHash, int totalCerts)
 382{
 383    int ret = 0;
 384    byte hash[SIGNER_DIGEST_SIZE];
 385#ifdef CRL_STATIC_REVOKED_LIST
 386    if (serialHash == NULL) {
 387        /* Binary search by (serialSz, serialNumber). The array was sorted in
 388         * InitCRL_Entry by the same comparison key. */
 389        int low = 0;
 390        int high = totalCerts - 1;
 391
 392        while (low <= high) {
 393            int mid = (low + high) / 2;
 394            int cmp;
 395
 396            /* Compare by serial size first, then by serial content. Shorter
 397             * serials sort before longer ones. */
 398            if (rc[mid].serialSz != serialSz) {
 399                cmp = rc[mid].serialSz - serialSz;
 400            }
 401            else {
 402                cmp = XMEMCMP(rc[mid].serialNumber, serial,
 403                              (size_t)rc[mid].serialSz);
 404            }
 405
 406            if (cmp < 0) {
 407                low = mid + 1;
 408            }
 409            else if (cmp > 0) {
 410                high = mid - 1;
 411            }
 412            else {
 413                WOLFSSL_MSG("Cert revoked");
 414                ret = CRL_CERT_REVOKED;
 415                break;
 416            }
 417        }
 418    }
 419    else {
 420        /* Hash-based lookup -- linear scan required since the array is sorted
 421         * by serial number, not by hash. */
 422        int i;
 423        for (i = 0; i < totalCerts; i++) {
 424            ret = CalcHashId(rc[i].serialNumber, (word32)rc[i].serialSz, hash);
 425            if (ret != 0)
 426                break;
 427            if (XMEMCMP(hash, serialHash, SIGNER_DIGEST_SIZE) == 0) {
 428                WOLFSSL_MSG("Cert revoked");
 429                ret = CRL_CERT_REVOKED;
 430                break;
 431            }
 432        }
 433    }
 434#else
 435    (void)totalCerts;
 436    /* search in the linked list*/
 437    while (rc) {
 438        if (serialHash == NULL) {
 439            if (rc->serialSz == serialSz &&
 440                   XMEMCMP(rc->serialNumber, serial, (size_t)rc->serialSz) == 0) {
 441                WOLFSSL_MSG("Cert revoked");
 442                ret = CRL_CERT_REVOKED;
 443                break;
 444            }
 445        }
 446        else {
 447            ret = CalcHashId(rc->serialNumber, (word32)rc->serialSz, hash);
 448            if (ret != 0)
 449                break;
 450            if (XMEMCMP(hash, serialHash, SIGNER_DIGEST_SIZE) == 0) {
 451                WOLFSSL_MSG("Cert revoked");
 452                ret = CRL_CERT_REVOKED;
 453                break;
 454            }
 455        }
 456        rc = rc->next;
 457    }
 458#endif
 459    return ret;
 460}
 461
 462static int VerifyCRLE(const WOLFSSL_CRL* crl, CRL_Entry* crle)
 463{
 464    Signer* ca = NULL;
 465    SignatureCtx sigCtx;
 466    int ret = 0;
 467
 468#ifndef NO_SKID
 469    if (crle->extAuthKeyIdSet)
 470        ca = GetCA(crl->cm, crle->extAuthKeyId);
 471    if (ca == NULL)
 472        ca = GetCAByName(crl->cm, crle->issuerHash);
 473#else /* NO_SKID */
 474    ca = GetCA(crl->cm, crle->issuerHash);
 475#endif /* NO_SKID */
 476    if (ca == NULL) {
 477        WOLFSSL_MSG("Did NOT find CRL issuer CA");
 478        return ASN_CRL_NO_SIGNER_E;
 479    }
 480
 481    ret = VerifyCRL_Signature(&sigCtx, crle->toBeSigned, crle->tbsSz,
 482            crle->signature, crle->signatureSz, crle->signatureOID,
 483        #ifdef WC_RSA_PSS
 484            crle->sigParams, (int)crle->sigParamsSz,
 485        #else
 486            NULL, 0,
 487        #endif
 488            ca, crl->heap);
 489
 490    if (ret == 0) {
 491        crle->verified = 1;
 492    }
 493    else {
 494        crle->verified = ret;
 495    }
 496
 497    return ret;
 498}
 499
 500static int CheckCertCRLList(WOLFSSL_CRL* crl, byte* issuerHash, byte* serial,
 501        int serialSz, byte* serialHash, int *pFoundEntry)
 502{
 503    CRL_Entry* crle;
 504    int        foundEntry = 0;
 505    int        ret = 0;
 506
 507    if (wc_LockRwLock_Rd(&crl->crlLock) != 0) {
 508        WOLFSSL_MSG("wc_LockRwLock_Rd failed");
 509        return BAD_MUTEX_E;
 510    }
 511
 512    for (crle = crl->crlList; crle != NULL; crle = crle->next) {
 513        if (XMEMCMP(crle->issuerHash, issuerHash, CRL_DIGEST_SIZE) == 0) {
 514            int nextDateValid = 1;
 515
 516            WOLFSSL_MSG("Found CRL Entry on list");
 517
 518            if (crle->verified == 0) {
 519                if (wc_LockMutex(&crle->verifyMutex) != 0) {
 520                    WOLFSSL_MSG("wc_LockMutex failed");
 521                    break;
 522                }
 523
 524                /* A different thread may have verified the entry while we were
 525                 * waiting for the mutex. */
 526                if (crle->verified == 0)
 527                    ret = VerifyCRLE(crl, crle);
 528
 529                wc_UnLockMutex(&crle->verifyMutex);
 530
 531                if (ret != 0)
 532                    break;
 533            }
 534
 535            if (crle->verified < 0) {
 536                WOLFSSL_MSG("Cannot use CRL as it didn't verify");
 537                ret = crle->verified;
 538                break;
 539            }
 540
 541            WOLFSSL_MSG("Checking next date validity");
 542
 543        #ifdef WOLFSSL_NO_CRL_NEXT_DATE
 544            if (crle->nextDateFormat != ASN_OTHER_TYPE)
 545        #endif
 546            {
 547            #if !defined(NO_ASN_TIME) && !defined(WOLFSSL_NO_CRL_DATE_CHECK)
 548                if (!XVALIDATE_DATE(crle->nextDate, crle->nextDateFormat,
 549                                   ASN_AFTER, MAX_DATE_SIZE)) {
 550                    WOLFSSL_MSG("CRL next date is no longer valid");
 551                    nextDateValid = 0;
 552                }
 553            #endif
 554            }
 555            if (nextDateValid) {
 556                foundEntry = 1;
 557                ret = FindRevokedSerial(crle->certs, serial, serialSz,
 558                        serialHash, crle->totalCerts);
 559                if (ret != 0)
 560                    break;
 561            }
 562            else if (foundEntry == 0) {
 563                ret = CRL_CERT_DATE_ERR;
 564            }
 565        }
 566    }
 567
 568    wc_UnLockRwLock(&crl->crlLock);
 569
 570    *pFoundEntry = foundEntry;
 571
 572    return ret;
 573}
 574
 575int CheckCertCRL_ex(WOLFSSL_CRL* crl, byte* issuerHash, byte* serial,
 576        int serialSz, byte* serialHash, const byte* extCrlInfo,
 577        int extCrlInfoSz, void* issuerName)
 578{
 579    int        foundEntry = 0;
 580    int        ret = 0;
 581
 582    WOLFSSL_ENTER("CheckCertCRL");
 583    (void)issuerName;
 584
 585    if ((serial == NULL || serialSz == 0) && serialHash == NULL) {
 586        WOLFSSL_MSG("Either serial or hash has to be provided");
 587        return BUFFER_ERROR;
 588    }
 589
 590#ifdef WOLFSSL_CRL_ALLOW_MISSING_CDP
 591    /* Skip CRL verification in case no CDP in peer cert */
 592    if (!extCrlInfo) {
 593        return ret;
 594    }
 595#endif
 596
 597    ret = CheckCertCRLList(crl, issuerHash, serial, serialSz, serialHash,
 598            &foundEntry);
 599
 600#ifdef HAVE_CRL_IO
 601    if (foundEntry == 0) {
 602        /* perform embedded lookup */
 603        if (crl->crlIOCb) {
 604            int cbRet = crl->crlIOCb(crl, (const char*)extCrlInfo,
 605                                     extCrlInfoSz);
 606            if (cbRet == WC_NO_ERR_TRACE(WOLFSSL_CBIO_ERR_WANT_READ)) {
 607                ret = OCSP_WANT_READ;
 608            }
 609            else if (cbRet >= 0) {
 610                /* try again */
 611                ret = CheckCertCRLList(crl, issuerHash, serial, serialSz,
 612                        serialHash, &foundEntry);
 613            }
 614        }
 615    }
 616#endif
 617
 618#if defined(OPENSSL_ALL) && defined(WOLFSSL_CERT_GEN) && \
 619    (defined(WOLFSSL_CERT_REQ) || defined(WOLFSSL_CERT_EXT)) && \
 620    !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR) && \
 621    !defined(NO_STDIO_FILESYSTEM) && \
 622    (!defined(NO_WOLFSSL_CLIENT) || !defined(WOLFSSL_NO_CLIENT_AUTH))
 623    /* if not find entry in the CRL list, it looks at the folder that sets  */
 624    /* by LOOKUP_ctrl because user would want to use hash_dir.              */
 625    /* Loading <issuer-hash>.rN form CRL file if find at the folder,        */
 626    /* and try again checking Cert in the CRL list.                         */
 627    /* When not set the folder or not use hash_dir, do nothing.             */
 628    if ((foundEntry == 0) && (ret != WC_NO_ERR_TRACE(OCSP_WANT_READ))) {
 629        if (crl->cm != NULL && crl->cm->x509_store_p != NULL) {
 630            int loadRet = LoadCertByIssuer(crl->cm->x509_store_p,
 631                          (WOLFSSL_X509_NAME*)issuerName, X509_LU_CRL);
 632            if (loadRet == WOLFSSL_SUCCESS) {
 633                /* try again */
 634                ret = CheckCertCRLList(crl, issuerHash, serial, serialSz,
 635                        serialHash, &foundEntry);
 636            }
 637        }
 638    }
 639#endif
 640    if (foundEntry == 0) {
 641        WOLFSSL_MSG("Couldn't find CRL for status check");
 642        if (ret != WC_NO_ERR_TRACE(CRL_CERT_DATE_ERR)) {
 643            ret = CRL_MISSING;
 644        }
 645
 646        if (crl->cm != NULL && crl->cm->cbMissingCRL) {
 647            char url[256];
 648
 649            WOLFSSL_MSG("Issuing missing CRL callback");
 650            url[0] = '\0';
 651            if (extCrlInfo) {
 652                if (extCrlInfoSz < (int)sizeof(url) -1 ) {
 653                    XMEMCPY(url, extCrlInfo, (size_t)extCrlInfoSz);
 654                    url[extCrlInfoSz] = '\0';
 655                }
 656                else  {
 657                    WOLFSSL_MSG("CRL url too long");
 658                }
 659            }
 660
 661            crl->cm->cbMissingCRL(url);
 662        }
 663
 664        if (crl->cm != NULL && crl->cm->crlCb &&
 665                crl->cm->crlCb(ret, crl, crl->cm, crl->cm->crlCbCtx)) {
 666            if (ret != 0)
 667                WOLFSSL_MSG("Overriding CRL error");
 668            ret = 0;
 669        }
 670    }
 671
 672    return ret;
 673}
 674
 675/* Is the cert ok with CRL, return 0 on success */
 676int CheckCertCRL(WOLFSSL_CRL* crl, DecodedCert* cert)
 677{
 678#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
 679    void* issuerName = cert->issuerName;
 680#else
 681    void* issuerName = NULL;
 682#endif
 683    return CheckCertCRL_ex(crl, cert->issuerHash, cert->serial, cert->serialSz,
 684            NULL, cert->extCrlInfo, cert->extCrlInfoSz, issuerName);
 685}
 686
 687#ifdef HAVE_CRL_UPDATE_CB
 688static void SetCrlInfo(CRL_Entry* entry, CrlInfo *info)
 689{
 690    info->issuerHash = (byte *)entry->issuerHash;
 691    info->issuerHashLen = CRL_DIGEST_SIZE;
 692    info->lastDate = (byte *)entry->lastDate;
 693    info->lastDateMaxLen = MAX_DATE_SIZE;
 694    info->lastDateFormat = entry->lastDateFormat;
 695    info->nextDate = (byte *)entry->nextDate;
 696    info->nextDateMaxLen = MAX_DATE_SIZE;
 697    info->nextDateFormat = entry->nextDateFormat;
 698    info->crlNumberSet = entry->crlNumberSet;
 699    if (info->crlNumberSet)
 700        XMEMCPY(info->crlNumber, entry->crlNumber, sizeof(entry->crlNumber));
 701}
 702
 703static void SetCrlInfoFromDecoded(DecodedCRL* entry, CrlInfo *info)
 704{
 705    info->issuerHash = (byte *)entry->issuerHash;
 706    info->issuerHashLen = SIGNER_DIGEST_SIZE;
 707    info->lastDate = (byte *)entry->lastDate;
 708    info->lastDateMaxLen = MAX_DATE_SIZE;
 709    info->lastDateFormat = entry->lastDateFormat;
 710    info->nextDate = (byte *)entry->nextDate;
 711    info->nextDateMaxLen = MAX_DATE_SIZE;
 712    info->nextDateFormat = entry->nextDateFormat;
 713    info->crlNumberSet = entry->crlNumberSet;
 714    if (info->crlNumberSet)
 715        XMEMCPY(info->crlNumber, entry->crlNumber, sizeof(entry->crlNumber));
 716}
 717#endif
 718
 719/* Returns MP_GT if prev crlNumber is smaller
 720 *         MP_EQ if equal
 721 *         MP_LT if prev crlNumber is larger */
 722static int CompareCRLnumber(CRL_Entry* prev, CRL_Entry* curr)
 723{
 724    int ret = 0;
 725    DECL_MP_INT_SIZE_DYN(prev_num, CRL_MAX_NUM_SZ_BITS,
 726                                   CRL_MAX_NUM_SZ_BITS);
 727    DECL_MP_INT_SIZE_DYN(curr_num, CRL_MAX_NUM_SZ_BITS,
 728                                   CRL_MAX_NUM_SZ_BITS);
 729
 730    NEW_MP_INT_SIZE(prev_num, CRL_MAX_NUM_SZ_BITS, NULL,
 731                                   DYNAMIC_TYPE_TMP_BUFFER);
 732    NEW_MP_INT_SIZE(curr_num, CRL_MAX_NUM_SZ_BITS, NULL,
 733                                   DYNAMIC_TYPE_TMP_BUFFER);
 734#ifdef MP_INT_SIZE_CHECK_NULL
 735    if ((prev_num == NULL) || (curr_num == NULL)) {
 736        ret = MEMORY_E;
 737    }
 738#endif
 739
 740    if (ret == 0 && ((INIT_MP_INT_SIZE(prev_num, CRL_MAX_NUM_SZ_BITS)
 741                != MP_OKAY) || (INIT_MP_INT_SIZE(curr_num,
 742                CRL_MAX_NUM_SZ_BITS)) != MP_OKAY)) {
 743        ret = MP_INIT_E;
 744    }
 745
 746    if (ret == 0 && (mp_read_radix(prev_num, (char*)prev->crlNumber,
 747                MP_RADIX_HEX) != MP_OKAY ||
 748                mp_read_radix(curr_num, (char*)curr->crlNumber,
 749                MP_RADIX_HEX) != MP_OKAY)) {
 750        ret = BAD_FUNC_ARG;
 751    }
 752
 753    if (ret == 0)
 754        ret = mp_cmp(prev_num, curr_num);
 755
 756    FREE_MP_INT_SIZE(prev_num, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 757    FREE_MP_INT_SIZE(curr_num, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 758
 759    return ret;
 760}
 761
 762/* Add or replace a decoded CRL, 0 on success */
 763static int AddCRL(WOLFSSL_CRL* crl, DecodedCRL* dcrl, CRL_Entry* crle,
 764                  const byte* buff, int verified)
 765{
 766    CRL_Entry* curr = NULL;
 767    CRL_Entry* prev = NULL;
 768#ifdef HAVE_CRL_UPDATE_CB
 769    CrlInfo old;
 770    CrlInfo cnew;
 771#endif
 772    int ret = 0;
 773
 774    WOLFSSL_ENTER("AddCRL");
 775
 776    if (crl == NULL)
 777        return WOLFSSL_FATAL_ERROR;
 778
 779    if (InitCRL_Entry(crle, dcrl, buff, verified, crl->heap) < 0) {
 780        WOLFSSL_MSG("Init CRL Entry failed");
 781        return WOLFSSL_FATAL_ERROR;
 782    }
 783
 784    if (wc_LockRwLock_Wr(&crl->crlLock) != 0) {
 785        WOLFSSL_MSG("wc_LockRwLock_Wr failed");
 786        return BAD_MUTEX_E;
 787    }
 788
 789    for (curr = crl->crlList; curr != NULL; curr = curr->next) {
 790        if (XMEMCMP(curr->issuerHash, crle->issuerHash, CRL_DIGEST_SIZE) == 0) {
 791            ret = CompareCRLnumber(crle, curr);
 792            /* Error out if the CRL we're attempting to add isn't more
 793             * authoritative than the existing entry */
 794            if (ret == MP_LT || ret == MP_EQ) {
 795                WOLFSSL_MSG("Same or newer CRL entry already exists");
 796                wc_UnLockRwLock(&crl->crlLock);
 797                return DUPE_ENTRY_E;
 798            }
 799            else if (ret < 0) {
 800                WOLFSSL_MSG("Error comparing CRL Numbers");
 801                wc_UnLockRwLock(&crl->crlLock);
 802                return ret;
 803            }
 804
 805            /* Insert the new entry after the current entry. */
 806            crle->next = curr->next;
 807            if (prev != NULL) {
 808                prev->next = crle;
 809            }
 810            else {
 811                crl->crlList = crle;
 812            }
 813
 814#ifdef HAVE_CRL_UPDATE_CB
 815            if (crl->cm && crl->cm->cbUpdateCRL != NULL) {
 816                SetCrlInfo(curr, &old);
 817                SetCrlInfo(crle, &cnew);
 818                crl->cm->cbUpdateCRL(&old, &cnew);
 819            }
 820#endif
 821
 822            /* Remove the current entry which was replaced */
 823            CRL_Entry_free(curr, crl->heap);
 824
 825            break;
 826        }
 827        prev = curr;
 828    }
 829
 830    if (curr == NULL) {
 831        /* No replacement occurred, prepend the new entry. */
 832        crle->next = crl->crlList;
 833        crl->crlList = crle;
 834    }
 835
 836    wc_UnLockRwLock(&crl->crlLock);
 837    return 0;
 838}
 839
 840
 841/* Load CRL File of type, WOLFSSL_SUCCESS on ok */
 842int BufferLoadCRL(WOLFSSL_CRL* crl, const byte* buff, long sz, int type,
 843                  int verify)
 844{
 845    int          ret = WOLFSSL_SUCCESS;
 846    const byte*  myBuffer = buff;    /* if DER ok, otherwise switch */
 847    DerBuffer*   der = NULL;
 848    WC_DECLARE_VAR(dcrl, DecodedCRL, 1, 0);
 849
 850    WOLFSSL_ENTER("BufferLoadCRL");
 851
 852    if (crl == NULL || buff == NULL || sz == 0)
 853        return BAD_FUNC_ARG;
 854
 855    if (type == WOLFSSL_FILETYPE_PEM) {
 856    #ifdef WOLFSSL_PEM_TO_DER
 857        ret = PemToDer(buff, sz, CRL_TYPE, &der, NULL, NULL, NULL);
 858        if (ret == 0) {
 859            myBuffer = der->buffer;
 860            sz = der->length;
 861        }
 862        else {
 863            WOLFSSL_MSG("Pem to Der failed");
 864            FreeDer(&der);
 865            return WOLFSSL_FATAL_ERROR;
 866        }
 867    #else
 868        ret = NOT_COMPILED_IN;
 869    #endif
 870    }
 871
 872#ifdef WOLFSSL_SMALL_STACK
 873    dcrl = (DecodedCRL*)XMALLOC(sizeof(DecodedCRL), NULL, DYNAMIC_TYPE_TMP_BUFFER);
 874    if (dcrl == NULL) {
 875        FreeDer(&der);
 876        return MEMORY_E;
 877    }
 878#endif
 879
 880    crl->currentEntry = CRL_Entry_new(crl->heap);
 881    if (crl->currentEntry == NULL) {
 882        WOLFSSL_MSG_CERT_LOG("alloc CRL Entry failed");
 883        WC_FREE_VAR_EX(dcrl, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 884        FreeDer(&der);
 885        return MEMORY_E;
 886    }
 887
 888    InitDecodedCRL(dcrl, crl->heap);
 889    ret = ParseCRL(crl->currentEntry->certs, dcrl, myBuffer, (word32)sz,
 890                   verify, crl->cm);
 891
 892    if (ret != 0 && !(ret == WC_NO_ERR_TRACE(ASN_CRL_NO_SIGNER_E)
 893                      && verify == NO_VERIFY)) {
 894        WOLFSSL_MSG_CERT_LOG("ParseCRL error");
 895        WOLFSSL_MSG_CERT_EX("ParseCRL verify = %d, ret = %d", verify, ret);
 896        CRL_Entry_free(crl->currentEntry, crl->heap);
 897        crl->currentEntry = NULL;
 898    }
 899    else {
 900        ret = AddCRL(crl, dcrl, crl->currentEntry, myBuffer,
 901                     ret != WC_NO_ERR_TRACE(ASN_CRL_NO_SIGNER_E));
 902        if (ret != 0) {
 903            WOLFSSL_MSG_CERT_LOG("AddCRL error");
 904            CRL_Entry_free(crl->currentEntry, crl->heap);
 905        }
 906        /* Entry now is in the list, or has been freed due to error */
 907        crl->currentEntry = NULL;
 908    }
 909
 910    FreeDecodedCRL(dcrl);
 911
 912    WC_FREE_VAR_EX(dcrl, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 913
 914    FreeDer(&der);
 915
 916    return ret ? ret : WOLFSSL_SUCCESS; /* convert 0 to WOLFSSL_SUCCESS */
 917}
 918
 919/* Store CRL into a buffer in DER or PEM format.
 920 * If buff is NULL, updates inOutSz with required size and returns success.
 921 * Returns WOLFSSL_SUCCESS on success, negative on failure.
 922 */
 923int BufferStoreCRL(WOLFSSL_CRL* crl, byte* buff, long* inOutSz, int type)
 924{
 925    int ret = 0;
 926    CRL_Entry* ent = NULL;
 927    const byte* tbs = NULL;
 928    word32 tbsSz = 0;
 929    const byte* sig = NULL;
 930    word32 sigSz = 0;
 931    word32 sigOID = 0;
 932#ifdef WC_RSA_PSS
 933    const byte* sigParams = NULL;
 934    word32 sigParamsSz = 0;
 935#endif
 936    word32 algoLen = 0;
 937    word32 bitHdrLen = 0;
 938    word32 totalContentLen = 0;
 939    word32 outerHdrLen = 0;
 940    word32 derNeeded = 0;
 941    long outSz = 0;
 942
 943    WOLFSSL_ENTER("BufferStoreCRL");
 944
 945    if (crl == NULL || inOutSz == NULL) {
 946        return BAD_FUNC_ARG;
 947    }
 948
 949    outSz = *inOutSz;
 950
 951    /* Access the first CRL entry. Lock is held until encoding is complete
 952     * to prevent the entry from being freed by another thread. */
 953    if (wc_LockRwLock_Rd(&crl->crlLock) != 0) {
 954        WOLFSSL_MSG("wc_LockRwLock_Rd failed");
 955        return BAD_MUTEX_E;
 956    }
 957    ent = crl->crlList;
 958    if (ent != NULL) {
 959        tbs = ent->toBeSigned;
 960        tbsSz = ent->tbsSz;
 961        sig = ent->signature;
 962        sigSz = ent->signatureSz;
 963        sigOID = ent->signatureOID;
 964#ifdef WC_RSA_PSS
 965        sigParams = ent->sigParams;
 966        sigParamsSz = ent->sigParamsSz;
 967#endif
 968    }
 969
 970    if (ent == NULL || tbs == NULL || tbsSz == 0 || sig == NULL || sigSz == 0) {
 971        WOLFSSL_MSG("CRL entry missing toBeSigned/signature data");
 972        ret = BAD_FUNC_ARG;
 973    }
 974
 975    /* Calculate encoded lengths for AlgorithmIdentifier. */
 976    if (ret == 0) {
 977#ifdef WC_RSA_PSS
 978        if (sigParams != NULL && sigParamsSz > 0) {
 979            /* OID + explicit parameters inside SEQUENCE */
 980            word32 oidSz = 0;
 981            word32 idLen;
 982            const byte* oid = OidFromId(sigOID, oidSigType, &oidSz);
 983            if (oid == NULL) {
 984                WOLFSSL_MSG("Unknown signature OID for CRL");
 985                ret = WOLFSSL_FATAL_ERROR;
 986            }
 987            else {
 988                /* OBJECT IDENTIFIER header */
 989                idLen = (word32)SetObjectId((int)oidSz, NULL);
 990                algoLen = SetSequence(idLen + oidSz + sigParamsSz, NULL)
 991                        + idLen + oidSz + sigParamsSz;
 992            }
 993        }
 994        else
 995#endif
 996        {
 997            algoLen = SetAlgoID((int)sigOID, NULL, oidSigType, 0);
 998            if (algoLen == 0) {
 999                WOLFSSL_MSG("SetAlgoID failed");
1000                ret = WOLFSSL_FATAL_ERROR;
1001            }
1002        }
1003    }
1004
1005    if (ret == 0) {
1006        /* BIT STRING header for signature */
1007        bitHdrLen = SetBitString(sigSz, 0, NULL);
1008
1009        /* Compute total DER size. */
1010        totalContentLen = tbsSz + algoLen + bitHdrLen + sigSz;
1011        outerHdrLen = SetSequence(totalContentLen, NULL);
1012        derNeeded = outerHdrLen + totalContentLen;
1013    }
1014
1015    if (ret == 0 && type == WOLFSSL_FILETYPE_ASN1) {
1016        if (buff == NULL) {
1017            *inOutSz = (long)derNeeded;
1018            ret = WOLFSSL_SUCCESS;
1019        }
1020        else if ((long)derNeeded > outSz) {
1021            WOLFSSL_MSG("Output buffer too small for DER CRL");
1022            ret = BUFFER_E;
1023        }
1024        else {
1025            /* Encode DER CRL directly into caller buffer. */
1026            word32 pos = 0;
1027#ifdef WC_RSA_PSS
1028            word32 oidSz = 0;
1029            const byte* oid = NULL;
1030#endif
1031            /* Outer SEQUENCE header */
1032            pos += SetSequence(totalContentLen, buff + pos);
1033            /* tbsCertList */
1034            XMEMCPY(buff + pos, tbs, tbsSz);
1035            pos += tbsSz;
1036
1037            /* signatureAlgorithm AlgorithmIdentifier */
1038#ifdef WC_RSA_PSS
1039            if (sigParams != NULL && sigParamsSz > 0) {
1040                /* Lookup OID bytes for signature algorithm. */
1041                oid = OidFromId(sigOID, oidSigType, &oidSz);
1042                if (oid == NULL) {
1043                    WOLFSSL_MSG("Unknown signature OID for CRL");
1044                    ret = WOLFSSL_FATAL_ERROR;
1045                }
1046                else {
1047                    /* SEQUENCE header for AlgorithmIdentifier */
1048                    pos += SetSequence((word32)SetObjectId((int)oidSz, NULL) +
1049                                       oidSz + sigParamsSz, buff + pos);
1050                    /* OBJECT IDENTIFIER header and content */
1051                    pos += (word32)SetObjectId((int)oidSz, buff + pos);
1052                    XMEMCPY(buff + pos, oid, oidSz);
1053                    pos += oidSz;
1054                    /* Parameters as captured (already DER encoded) */
1055                    XMEMCPY(buff + pos, sigParams, sigParamsSz);
1056                    pos += sigParamsSz;
1057                }
1058            }
1059            else
1060#endif
1061            {
1062                pos += SetAlgoID((int)sigOID, buff + pos, oidSigType, 0);
1063            }
1064
1065#ifdef WC_RSA_PSS
1066            if (ret == 0)
1067#endif
1068            {
1069                /* signature BIT STRING and bytes */
1070                pos += SetBitString(sigSz, 0, buff + pos);
1071                XMEMCPY(buff + pos, sig, sigSz);
1072
1073                *inOutSz = (long)derNeeded;
1074                ret = WOLFSSL_SUCCESS;
1075            }
1076            (void)pos; /* pos not used after this point */
1077        }
1078    }
1079#ifdef WOLFSSL_DER_TO_PEM
1080    else if (ret == 0 && type == WOLFSSL_FILETYPE_PEM) {
1081        byte* derTmp = NULL;
1082        int pemSz;
1083        /* Build DER first in a temporary buffer. */
1084        derTmp = (byte*)XMALLOC(derNeeded, crl->heap, DYNAMIC_TYPE_TMP_BUFFER);
1085        if (derTmp == NULL) {
1086            ret = MEMORY_E;
1087        }
1088
1089        if (ret == 0) {
1090            /* Encode DER CRL into temporary buffer. */
1091            word32 pos = 0;
1092#ifdef WC_RSA_PSS
1093            word32 oidSz = 0;
1094            const byte* oid = NULL;
1095#endif
1096            pos += SetSequence(totalContentLen, derTmp + pos);
1097            XMEMCPY(derTmp + pos, tbs, tbsSz);
1098            pos += tbsSz;
1099#ifdef WC_RSA_PSS
1100            if (sigParams != NULL && sigParamsSz > 0) {
1101                oid = OidFromId(sigOID, oidSigType, &oidSz);
1102                if (oid == NULL) {
1103                    ret = WOLFSSL_FATAL_ERROR;
1104                }
1105                else {
1106                    pos += SetSequence((word32)SetObjectId((int)oidSz, NULL) +
1107                                       oidSz + sigParamsSz, derTmp + pos);
1108                    pos += (word32)SetObjectId((int)oidSz, derTmp + pos);
1109                    XMEMCPY(derTmp + pos, oid, oidSz);
1110                    pos += oidSz;
1111                    XMEMCPY(derTmp + pos, sigParams, sigParamsSz);
1112                    pos += sigParamsSz;
1113                }
1114            }
1115            else
1116#endif
1117            {
1118                pos += SetAlgoID((int)sigOID, derTmp + pos, oidSigType, 0);
1119            }
1120#ifdef WC_RSA_PSS
1121            if (ret == 0)
1122#endif
1123            {
1124                pos += SetBitString(sigSz, 0, derTmp + pos);
1125                XMEMCPY(derTmp + pos, sig, sigSz);
1126            }
1127            (void)pos; /* pos not used after this point */
1128        }
1129
1130        /* Determine required PEM size. */
1131        if (ret == 0) {
1132            pemSz = wc_DerToPemEx(derTmp, derNeeded, NULL, 0, NULL, CRL_TYPE);
1133            if (pemSz < 0) {
1134                ret = WOLFSSL_FATAL_ERROR;
1135            }
1136            else if (buff == NULL) {
1137                *inOutSz = pemSz;
1138                ret = WOLFSSL_SUCCESS;
1139            }
1140            else if (outSz < pemSz) {
1141                WOLFSSL_MSG("Output buffer too small for PEM CRL");
1142                ret = BUFFER_E;
1143            }
1144            else if (wc_DerToPemEx(derTmp, derNeeded, buff, (word32)pemSz,
1145                                   NULL, CRL_TYPE) < 0) {
1146                ret = WOLFSSL_FATAL_ERROR;
1147            }
1148            else {
1149                *inOutSz = pemSz;
1150                ret = WOLFSSL_SUCCESS;
1151            }
1152        }
1153
1154        XFREE(derTmp, crl->heap, DYNAMIC_TYPE_TMP_BUFFER);
1155    }
1156#endif /* WOLFSSL_DER_TO_PEM */
1157    else if (ret == 0) {
1158        ret = BAD_FUNC_ARG;
1159    }
1160
1161    wc_UnLockRwLock(&crl->crlLock);
1162    return ret;
1163}
1164
1165#ifdef HAVE_CRL_UPDATE_CB
1166/* Fill out CRL info structure, WOLFSSL_SUCCESS on ok */
1167int GetCRLInfo(WOLFSSL_CRL* crl, CrlInfo* info, const byte* buff,
1168    long sz, int type)
1169{
1170    int          ret = WOLFSSL_SUCCESS;
1171    const byte*  myBuffer = buff;    /* if DER ok, otherwise switch */
1172    DerBuffer*   der = NULL;
1173    CRL_Entry*   crle = NULL;
1174    WC_DECLARE_VAR(dcrl, DecodedCRL, 1, 0);
1175
1176    WOLFSSL_ENTER("GetCRLInfo");
1177
1178    if (crl == NULL || info == NULL || buff == NULL || sz == 0)
1179        return BAD_FUNC_ARG;
1180
1181    if (type == WOLFSSL_FILETYPE_PEM) {
1182    #ifdef WOLFSSL_PEM_TO_DER
1183        ret = PemToDer(buff, sz, CRL_TYPE, &der, NULL, NULL, NULL);
1184        if (ret == 0) {
1185            myBuffer = der->buffer;
1186            sz = der->length;
1187        }
1188        else {
1189            WOLFSSL_MSG("Pem to Der failed");
1190            FreeDer(&der);
1191            return -1;
1192        }
1193    #else
1194        ret = NOT_COMPILED_IN;
1195    #endif
1196    }
1197
1198#ifdef WOLFSSL_SMALL_STACK
1199    dcrl = (DecodedCRL*)XMALLOC(sizeof(DecodedCRL), NULL,
1200        DYNAMIC_TYPE_TMP_BUFFER);
1201    if (dcrl == NULL) {
1202        FreeDer(&der);
1203        return MEMORY_E;
1204    }
1205#endif
1206
1207    crle = CRL_Entry_new(crl->heap);
1208    if (crle == NULL) {
1209        WOLFSSL_MSG("alloc CRL Entry failed");
1210        WC_FREE_VAR_EX(dcrl, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1211        FreeDer(&der);
1212        return MEMORY_E;
1213    }
1214
1215    InitDecodedCRL(dcrl, crl->heap);
1216    ret = ParseCRL(crle->certs, dcrl, myBuffer, (word32)sz,
1217                   0, crl->cm);
1218    if (ret != 0 && !(ret == WC_NO_ERR_TRACE(ASN_CRL_NO_SIGNER_E))) {
1219        WOLFSSL_MSG("ParseCRL error");
1220        CRL_Entry_free(crle, crl->heap);
1221        crle = NULL;
1222    }
1223    else {
1224        SetCrlInfoFromDecoded((DecodedCRL*)dcrl, info);
1225    }
1226
1227    FreeDecodedCRL(dcrl);
1228
1229    WC_FREE_VAR_EX(dcrl, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1230
1231    FreeDer(&der);
1232    CRL_Entry_free(crle, crl->heap);
1233
1234    return ret ? ret : WOLFSSL_SUCCESS; /* convert 0 to WOLFSSL_SUCCESS */
1235}
1236#endif
1237
1238#if defined(OPENSSL_EXTRA) && defined(HAVE_CRL)
1239/* helper function to create a new dynamic WOLFSSL_X509_CRL structure */
1240static WOLFSSL_X509_CRL* wolfSSL_X509_crl_new(WOLFSSL_CERT_MANAGER* cm)
1241{
1242    WOLFSSL_X509_CRL* ret;
1243    void* heap = NULL;
1244
1245    if (cm != NULL) {
1246        heap = cm->heap;
1247    }
1248
1249    ret = (WOLFSSL_X509_CRL*)XMALLOC(sizeof(WOLFSSL_X509_CRL), heap,
1250        DYNAMIC_TYPE_CRL);
1251    if (ret != NULL) {
1252        if (InitCRL(ret, cm) < 0) {
1253            WOLFSSL_MSG("Unable to initialize new CRL structure");
1254            XFREE(ret, heap, DYNAMIC_TYPE_CRL);
1255            ret = NULL;
1256        }
1257    }
1258    return ret;
1259}
1260
1261#ifndef CRL_STATIC_REVOKED_LIST
1262/* returns head of copied list that was alloc'd */
1263static RevokedCert *DupRevokedCertList(RevokedCert* in, void* heap)
1264{
1265    RevokedCert* head = NULL;
1266    RevokedCert* current = in;
1267    RevokedCert* prev = NULL;
1268    while (current) {
1269        RevokedCert* tmp = (RevokedCert*)XMALLOC(sizeof(RevokedCert), heap,
1270                DYNAMIC_TYPE_REVOKED);
1271        if (tmp != NULL) {
1272            XMEMCPY(tmp->serialNumber, current->serialNumber,
1273                    EXTERNAL_SERIAL_SIZE);
1274            tmp->serialSz = current->serialSz;
1275            XMEMCPY(tmp->revDate, current->revDate,
1276                    MAX_DATE_SIZE);
1277            tmp->revDateFormat = current->revDateFormat;
1278            tmp->reasonCode = current->reasonCode;
1279#if defined(OPENSSL_EXTRA)
1280            tmp->extensions = NULL;
1281            tmp->extensionsSz = 0;
1282            if (current->extensions != NULL && current->extensionsSz > 0) {
1283                tmp->extensions = (byte*)XMALLOC(current->extensionsSz, heap,
1284                                                 DYNAMIC_TYPE_REVOKED);
1285                if (tmp->extensions != NULL) {
1286                    XMEMCPY(tmp->extensions, current->extensions,
1287                            current->extensionsSz);
1288                    tmp->extensionsSz = current->extensionsSz;
1289                }
1290            }
1291#endif
1292            tmp->next = NULL;
1293            if (prev != NULL)
1294                prev->next = tmp;
1295            if (head == NULL)
1296                head = tmp;
1297            prev = tmp;
1298        }
1299        else {
1300            WOLFSSL_MSG("Failed to allocate new RevokedCert structure");
1301            /* free up any existing list */
1302            while (head != NULL) {
1303                current = head;
1304                head = head->next;
1305#if defined(OPENSSL_EXTRA)
1306                XFREE(current->extensions, heap, DYNAMIC_TYPE_REVOKED);
1307#endif
1308                XFREE(current, heap, DYNAMIC_TYPE_REVOKED);
1309            }
1310            return NULL;
1311        }
1312        current = current->next;
1313    }
1314
1315    (void)heap;
1316    return head;
1317}
1318
1319#endif /* CRL_STATIC_REVOKED_LIST */
1320/* returns a deep copy of ent on success and null on fail */
1321static CRL_Entry* DupCRL_Entry(const CRL_Entry* ent, void* heap)
1322{
1323    CRL_Entry *dupl;
1324    const size_t copyOffset = WC_OFFSETOF(CRL_Entry, verifyMutex) +
1325            sizeof(ent->verifyMutex);
1326#ifdef CRL_STATIC_REVOKED_LIST
1327    if (ent->totalCerts > CRL_MAX_REVOKED_CERTS) {
1328        return NULL;
1329    }
1330#endif
1331    dupl = CRL_Entry_new(heap);
1332    if (dupl == NULL) {
1333        WOLFSSL_MSG("alloc CRL Entry failed");
1334        return NULL;
1335    }
1336
1337    XMEMCPY((byte*)dupl + copyOffset, (byte*)ent + copyOffset,
1338            sizeof(CRL_Entry) - copyOffset);
1339
1340#ifndef CRL_STATIC_REVOKED_LIST
1341    dupl->certs = DupRevokedCertList(ent->certs, heap);
1342    if (ent->certs != NULL && dupl->certs == NULL) {
1343        CRL_Entry_free(dupl, heap);
1344        return NULL;
1345    }
1346#endif
1347#ifdef OPENSSL_EXTRA
1348    dupl->issuer = wolfSSL_X509_NAME_dup(ent->issuer);
1349    if (ent->issuer != NULL && dupl->issuer == NULL) {
1350        CRL_Entry_free(dupl, heap);
1351        return NULL;
1352    }
1353#endif
1354
1355    if (!ent->verified) {
1356        dupl->toBeSigned = (byte*)XMALLOC(dupl->tbsSz, heap,
1357                                          DYNAMIC_TYPE_CRL_ENTRY);
1358        dupl->signature = (byte*)XMALLOC(dupl->signatureSz, heap,
1359                                         DYNAMIC_TYPE_CRL_ENTRY);
1360    #ifdef WC_RSA_PSS
1361        dupl->sigParams = (byte*)XMALLOC(dupl->sigParamsSz, heap,
1362                                         DYNAMIC_TYPE_CRL_ENTRY);
1363    #endif
1364        if (dupl->toBeSigned == NULL || dupl->signature == NULL
1365        #ifdef WC_RSA_PSS
1366            /* allow sigParamsSz is zero and XMALLOC(0) to return NULL */
1367            || (dupl->sigParams == NULL && dupl->sigParamsSz != 0)
1368        #endif
1369        ) {
1370            CRL_Entry_free(dupl, heap);
1371            return NULL;
1372        }
1373        XMEMCPY(dupl->toBeSigned, ent->toBeSigned, dupl->tbsSz);
1374        XMEMCPY(dupl->signature, ent->signature, dupl->signatureSz);
1375    #ifdef WC_RSA_PSS
1376        if (dupl->sigParamsSz > 0) {
1377            XMEMCPY(dupl->sigParams, ent->sigParams, dupl->sigParamsSz);
1378        }
1379    #endif
1380    }
1381    else {
1382        dupl->toBeSigned = NULL;
1383        dupl->tbsSz = 0;
1384        dupl->signature = NULL;
1385        dupl->signatureSz = 0;
1386#ifdef WC_RSA_PSS
1387        dupl->sigParams = NULL;
1388        dupl->sigParamsSz = 0;
1389#endif
1390#if !defined(NO_SKID) && !defined(NO_ASN)
1391        dupl->extAuthKeyIdSet = 0;
1392#endif
1393    }
1394
1395    return dupl;
1396}
1397
1398
1399/* returns the head of a deep copy of the list on success and null on fail */
1400static CRL_Entry* DupCRL_list(CRL_Entry* crl, void* heap)
1401{
1402    CRL_Entry* current;
1403    CRL_Entry* head = NULL;
1404    CRL_Entry** prev = &head;
1405
1406    for (current = crl; current != NULL; current = current->next) {
1407        CRL_Entry* tmp = DupCRL_Entry(current, heap);
1408        if (tmp != NULL) {
1409            *prev = tmp;
1410            prev = &tmp->next;
1411        }
1412        else {
1413            WOLFSSL_MSG("Failed to allocate new CRL_Entry structure");
1414            /* free up any existing list */
1415            while (head != NULL) {
1416                CRL_Entry* next = head->next;
1417                CRL_Entry_free(head, heap);
1418                head = next;
1419            }
1420            return NULL;
1421        }
1422    }
1423
1424    return head;
1425}
1426
1427
1428/* Duplicates everything except the parent cm pointed to.
1429 * Expects that Init has already been done to 'dupl'
1430 * return 0 on success */
1431static int DupX509_CRL(WOLFSSL_X509_CRL *dupl, const WOLFSSL_X509_CRL* crl)
1432{
1433    if (dupl == NULL || crl == NULL) {
1434        return BAD_FUNC_ARG;
1435    }
1436
1437#ifdef HAVE_CRL_MONITOR
1438    if (crl->monitors[0].path) {
1439        size_t pathSz = XSTRLEN(crl->monitors[0].path) + 1;
1440        dupl->monitors[0].path = (char*)XMALLOC(pathSz, dupl->heap,
1441                DYNAMIC_TYPE_CRL_MONITOR);
1442        if (dupl->monitors[0].path != NULL) {
1443            XSTRNCPY(dupl->monitors[0].path, crl->monitors[0].path, pathSz);
1444        }
1445        else {
1446            return MEMORY_E;
1447        }
1448    }
1449
1450    if (crl->monitors[1].path) {
1451        size_t pathSz = XSTRLEN(crl->monitors[1].path) + 1;
1452        dupl->monitors[1].path = (char*)XMALLOC(pathSz, dupl->heap,
1453                DYNAMIC_TYPE_CRL_MONITOR);
1454        if (dupl->monitors[1].path != NULL) {
1455            XSTRNCPY(dupl->monitors[1].path, crl->monitors[1].path, pathSz);
1456        }
1457        else {
1458            if (dupl->monitors[0].path != NULL) {
1459                XFREE(dupl->monitors[0].path, dupl->heap,
1460                        DYNAMIC_TYPE_CRL_MONITOR);
1461                dupl->monitors[0].path = NULL;
1462            }
1463            return MEMORY_E;
1464        }
1465    }
1466#endif
1467
1468    dupl->crlList = DupCRL_list(crl->crlList, dupl->heap);
1469    if (crl->crlList != NULL && dupl->crlList == NULL)
1470        return MEMORY_E;
1471#ifdef HAVE_CRL_IO
1472    dupl->crlIOCb = crl->crlIOCb;
1473#endif
1474
1475    return 0;
1476}
1477
1478WOLFSSL_X509_CRL* wolfSSL_X509_CRL_dup(const WOLFSSL_X509_CRL* crl)
1479{
1480    WOLFSSL_X509_CRL* ret;
1481
1482    WOLFSSL_ENTER("wolfSSL_X509_CRL_dup");
1483
1484    if (crl == NULL)
1485        return NULL;
1486
1487    ret = wolfSSL_X509_crl_new(crl->cm);
1488    if (ret != NULL && DupX509_CRL(ret, crl) != 0) {
1489        FreeCRL(ret, 1);
1490        ret = NULL;
1491    }
1492    return ret;
1493}
1494
1495#ifdef OPENSSL_ALL
1496int wolfSSL_X509_CRL_up_ref(WOLFSSL_X509_CRL* crl)
1497{
1498    int ret;
1499
1500    if (crl == NULL)
1501        return WOLFSSL_FAILURE;
1502
1503    wolfSSL_RefInc(&crl->ref, &ret);
1504#ifdef WOLFSSL_REFCNT_ERROR_RETURN
1505    if (ret != 0) {
1506        WOLFSSL_MSG("Failed to lock x509 mutex");
1507        return WOLFSSL_FAILURE;
1508    }
1509#else
1510    (void)ret;
1511#endif
1512
1513    return WOLFSSL_SUCCESS;
1514}
1515#endif
1516
1517/* returns WOLFSSL_SUCCESS on success. Does not take ownership of newcrl */
1518int wolfSSL_X509_STORE_add_crl(WOLFSSL_X509_STORE *store, WOLFSSL_X509_CRL *newcrl)
1519{
1520    WOLFSSL_X509_CRL *crl;
1521    int ret = 0;
1522
1523    WOLFSSL_ENTER("wolfSSL_X509_STORE_add_crl");
1524    if (store == NULL || newcrl == NULL || store->cm == NULL)
1525        return BAD_FUNC_ARG;
1526
1527    if (store->cm->crl == NULL) {
1528        crl = wolfSSL_X509_crl_new(store->cm);
1529        if (crl == NULL) {
1530            WOLFSSL_MSG("wolfSSL_X509_crl_new failed");
1531            return WOLFSSL_FAILURE;
1532        }
1533        if (wc_LockRwLock_Rd(&newcrl->crlLock) != 0) {
1534            WOLFSSL_MSG("wc_LockRwLock_Rd failed");
1535            FreeCRL(crl, 1);
1536            return BAD_MUTEX_E;
1537        }
1538        ret = DupX509_CRL(crl, newcrl);
1539        wc_UnLockRwLock(&newcrl->crlLock);
1540        if (ret != 0) {
1541            FreeCRL(crl, 1);
1542            return WOLFSSL_FAILURE;
1543        }
1544        store->crl = store->cm->crl = crl;
1545        if (wolfSSL_CertManagerEnableCRL(store->cm, WOLFSSL_CRL_CHECKALL)
1546                != WOLFSSL_SUCCESS) {
1547            WOLFSSL_MSG("wolfSSL_CertManagerEnableCRL error");
1548            return WOLFSSL_FAILURE;
1549        }
1550        return WOLFSSL_SUCCESS;
1551    }
1552
1553    /* find tail of current list and add new list */
1554    crl  = store->cm->crl;
1555    if (newcrl->crlList != NULL) {
1556        CRL_Entry **tail;
1557        CRL_Entry *toAdd;
1558
1559        if (wc_LockRwLock_Wr(&crl->crlLock) != 0) {
1560            WOLFSSL_MSG("wc_LockRwLock_Wr failed");
1561            return BAD_MUTEX_E;
1562        }
1563
1564        if (crl != newcrl && wc_LockRwLock_Rd(&newcrl->crlLock) != 0) {
1565            WOLFSSL_MSG("wc_LockRwLock_Rd failed");
1566            wc_UnLockRwLock(&crl->crlLock);
1567            return BAD_MUTEX_E;
1568        }
1569        toAdd = DupCRL_list(newcrl->crlList, crl->heap);
1570        if (crl != newcrl)
1571            wc_UnLockRwLock(&newcrl->crlLock);
1572
1573        tail = &crl->crlList;
1574        while (*tail != NULL)
1575            tail = &(*tail)->next;
1576        *tail = toAdd;
1577        wc_UnLockRwLock(&crl->crlLock);
1578    }
1579
1580    if (wolfSSL_CertManagerEnableCRL(store->cm, WOLFSSL_CRL_CHECKALL)
1581            != WOLFSSL_SUCCESS) {
1582        WOLFSSL_MSG("wolfSSL_CertManagerEnableCRL error");
1583        return WOLFSSL_FAILURE;
1584    }
1585
1586    WOLFSSL_LEAVE("wolfSSL_X509_STORE_add_crl", WOLFSSL_SUCCESS);
1587
1588    return WOLFSSL_SUCCESS;
1589}
1590#endif
1591
1592#ifdef HAVE_CRL_MONITOR
1593
1594
1595/* Signal Monitor thread is setup, save status to setup flag, 0 on success */
1596static int SignalSetup(WOLFSSL_CRL* crl, int status)
1597{
1598    int ret, condRet;
1599
1600    ret = wolfSSL_CondStart(&crl->cond);
1601    if (ret != 0)
1602        return ret;
1603
1604    crl->setup = status;
1605
1606    condRet = wolfSSL_CondSignal(&crl->cond);
1607    ret = wolfSSL_CondEnd(&crl->cond);
1608    if (ret != 0)
1609        return ret;
1610
1611    return condRet;
1612}
1613
1614
1615/* read in new CRL entries and save new list */
1616static int SwapLists(WOLFSSL_CRL* crl)
1617{
1618    int        ret;
1619    CRL_Entry* newList;
1620    WC_DECLARE_VAR(tmp, WOLFSSL_CRL, 1, 0);
1621
1622    WC_ALLOC_VAR_EX(tmp, WOLFSSL_CRL, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
1623        return MEMORY_E);
1624
1625    if (InitCRL(tmp, crl->cm) < 0) {
1626        WOLFSSL_MSG("Init tmp CRL failed");
1627        WC_FREE_VAR_EX(tmp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1628        return WOLFSSL_FATAL_ERROR;
1629    }
1630
1631    if (crl->monitors[0].path) {
1632        ret = LoadCRL(tmp, crl->monitors[0].path, WOLFSSL_FILETYPE_PEM, 0);
1633        if (ret != WOLFSSL_SUCCESS) {
1634            WOLFSSL_MSG("PEM LoadCRL on dir change failed");
1635            FreeCRL(tmp, 0);
1636            WC_FREE_VAR_EX(tmp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1637            return WOLFSSL_FATAL_ERROR;
1638        }
1639    }
1640
1641    if (crl->monitors[1].path) {
1642        ret = LoadCRL(tmp, crl->monitors[1].path, WOLFSSL_FILETYPE_ASN1, 0);
1643        if (ret != WOLFSSL_SUCCESS) {
1644            WOLFSSL_MSG("DER LoadCRL on dir change failed");
1645            FreeCRL(tmp, 0);
1646            WC_FREE_VAR_EX(tmp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1647            return WOLFSSL_FATAL_ERROR;
1648        }
1649    }
1650
1651    if (wc_LockRwLock_Wr(&crl->crlLock) != 0) {
1652        WOLFSSL_MSG("wc_LockRwLock_Wr failed");
1653        FreeCRL(tmp, 0);
1654        WC_FREE_VAR_EX(tmp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1655        return WOLFSSL_FATAL_ERROR;
1656    }
1657
1658    newList = tmp->crlList;
1659
1660    /* swap lists */
1661    tmp->crlList  = crl->crlList;
1662    crl->crlList = newList;
1663
1664    wc_UnLockRwLock(&crl->crlLock);
1665
1666    FreeCRL(tmp, 0);
1667
1668    WC_FREE_VAR_EX(tmp, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1669
1670    return 0;
1671}
1672
1673
1674#if (defined(__MACH__) || defined(__FreeBSD__))
1675
1676#include <sys/types.h>
1677#include <sys/event.h>
1678#include <sys/time.h>
1679#include <fcntl.h>
1680#include <unistd.h>
1681#include <errno.h>
1682
1683#ifdef __MACH__
1684    #define XEVENT_MODE O_EVTONLY
1685#elif defined(__FreeBSD__)
1686    #define XEVENT_MODE O_RDONLY
1687#endif
1688
1689
1690
1691/* we need a unique kqueue user filter fd for crl in case user is doing custom
1692 * events too */
1693#ifndef CRL_CUSTOM_FD
1694    #define CRL_CUSTOM_FD 123456
1695#endif
1696
1697
1698/* shutdown monitor thread, 0 on success */
1699static int StopMonitor(wolfSSL_CRL_mfd_t mfd)
1700{
1701    struct kevent change;
1702
1703    /* trigger custom shutdown */
1704#if defined(NOTE_TRIGGER)
1705    EV_SET(&change, CRL_CUSTOM_FD, EVFILT_USER, 0, NOTE_TRIGGER, 0, NULL);
1706#elif defined(EV_TRIGGER)
1707    EV_SET(&change, CRL_CUSTOM_FD, EVFILT_USER, EV_TRIGGER, 0, 0, NULL);
1708#endif
1709    if (kevent(mfd, &change, 1, NULL, 0, NULL) < 0) {
1710        WOLFSSL_MSG("kevent trigger customer event failed");
1711        return WOLFSSL_FATAL_ERROR;
1712    }
1713
1714    return 0;
1715}
1716
1717
1718/* OS X  monitoring */
1719static THREAD_RETURN WOLFSSL_THREAD DoMonitor(void* arg)
1720{
1721    int fPEM, fDER;
1722    struct kevent change;
1723
1724    WOLFSSL_CRL* crl = (WOLFSSL_CRL*)arg;
1725
1726    WOLFSSL_ENTER("DoMonitor");
1727
1728    crl->mfd = kqueue();
1729    if (crl->mfd == -1) {
1730        WOLFSSL_MSG("kqueue failed");
1731        SignalSetup(crl, MONITOR_SETUP_E);
1732        return NULL;
1733    }
1734    wc_set_cloexec(crl->mfd);
1735
1736    /* listen for custom shutdown event */
1737    EV_SET(&change, CRL_CUSTOM_FD, EVFILT_USER, EV_ADD, 0, 0, NULL);
1738    if (kevent(crl->mfd, &change, 1, NULL, 0, NULL) < 0) {
1739        WOLFSSL_MSG("kevent monitor customer event failed");
1740        SignalSetup(crl, MONITOR_SETUP_E);
1741        (void)close(crl->mfd);
1742        return NULL;
1743    }
1744
1745    fPEM = -1;
1746    fDER = -1;
1747
1748    if (crl->monitors[0].path) {
1749        fPEM = wc_open_cloexec(crl->monitors[0].path, XEVENT_MODE);
1750        if (fPEM == -1) {
1751            WOLFSSL_MSG("PEM event dir open failed");
1752            SignalSetup(crl, MONITOR_SETUP_E);
1753            (void)close(crl->mfd);
1754            return NULL;
1755        }
1756    }
1757
1758    if (crl->monitors[1].path) {
1759        fDER = wc_open_cloexec(crl->monitors[1].path, XEVENT_MODE);
1760        if (fDER == -1) {
1761            WOLFSSL_MSG("DER event dir open failed");
1762            if (fPEM != -1)
1763                (void)close(fPEM);
1764            (void)close(crl->mfd);
1765            SignalSetup(crl, MONITOR_SETUP_E);
1766            return NULL;
1767        }
1768    }
1769
1770    if (fPEM != -1)
1771        EV_SET(&change, fPEM, EVFILT_VNODE, EV_ADD | EV_ENABLE | EV_CLEAR,
1772                NOTE_DELETE | NOTE_EXTEND | NOTE_WRITE | NOTE_ATTRIB, 0, 0);
1773
1774    if (fDER != -1)
1775        EV_SET(&change, fDER, EVFILT_VNODE, EV_ADD | EV_ENABLE | EV_CLEAR,
1776                NOTE_DELETE | NOTE_EXTEND | NOTE_WRITE | NOTE_ATTRIB, 0, 0);
1777
1778    /* signal to calling thread we're setup */
1779    if (SignalSetup(crl, 1) != 0) {
1780        if (fPEM != -1)
1781            (void)close(fPEM);
1782        if (fDER != -1)
1783            (void)close(fDER);
1784        (void)close(crl->mfd);
1785        return NULL;
1786    }
1787
1788    for (;;) {
1789        struct kevent event;
1790        int           numEvents = kevent(crl->mfd, &change, 1, &event, 1, NULL);
1791
1792        WOLFSSL_MSG("Got kevent");
1793
1794        if (numEvents == -1) {
1795            WOLFSSL_MSG("kevent problem, continue");
1796            continue;
1797        }
1798
1799        if (event.filter == EVFILT_USER) {
1800            WOLFSSL_MSG("Got user shutdown event, breaking out");
1801            break;
1802        }
1803
1804        if (SwapLists(crl) < 0) {
1805            WOLFSSL_MSG("SwapLists problem, continue");
1806        }
1807    }
1808
1809    if (fPEM != -1)
1810        (void)close(fPEM);
1811    if (fDER != -1)
1812        (void)close(fDER);
1813
1814    (void)close(crl->mfd);
1815
1816    return NULL;
1817}
1818
1819
1820#elif defined(__linux__)
1821
1822#include <sys/types.h>
1823#include <sys/inotify.h>
1824#include <sys/eventfd.h>
1825#include <unistd.h>
1826#include <fcntl.h>
1827#include <errno.h>
1828
1829#ifndef max
1830    static WC_INLINE int max(int a, int b)
1831    {
1832        return a > b ? a : b;
1833    }
1834#endif /* max */
1835
1836
1837/* shutdown monitor thread, 0 on success */
1838static int StopMonitor(wolfSSL_CRL_mfd_t mfd)
1839{
1840    word64 w64 = 1;
1841
1842    /* write to our custom event */
1843    if (write(mfd, &w64, sizeof(w64)) < 0) {
1844        WOLFSSL_MSG("StopMonitor write failed");
1845        return WOLFSSL_FATAL_ERROR;
1846    }
1847
1848    return 0;
1849}
1850
1851
1852/* linux monitoring */
1853static THREAD_RETURN WOLFSSL_THREAD DoMonitor(void* arg)
1854{
1855    int         notifyFd;
1856    int         wd  = -1;
1857    WOLFSSL_CRL* crl = (WOLFSSL_CRL*)arg;
1858    WC_DECLARE_VAR(buff, char, 8192, 0);
1859
1860    WOLFSSL_ENTER("DoMonitor");
1861
1862#ifdef EFD_CLOEXEC
1863    crl->mfd = eventfd(0, EFD_CLOEXEC);  /* our custom shutdown event */
1864    if (crl->mfd < 0 && (errno == ENOSYS || errno == EINVAL)) {
1865        crl->mfd = eventfd(0, 0);
1866        wc_set_cloexec(crl->mfd);
1867    }
1868#else
1869    crl->mfd = eventfd(0, 0);  /* our custom shutdown event */
1870    wc_set_cloexec(crl->mfd);
1871#endif
1872    if (crl->mfd < 0) {
1873        WOLFSSL_MSG("eventfd failed");
1874        SignalSetup(crl, MONITOR_SETUP_E);
1875        return NULL;
1876    }
1877
1878#ifdef IN_CLOEXEC
1879    notifyFd = inotify_init1(IN_CLOEXEC);
1880    if (notifyFd < 0 && (errno == ENOSYS || errno == EINVAL)) {
1881        notifyFd = inotify_init();
1882        wc_set_cloexec(notifyFd);
1883    }
1884#else
1885    notifyFd = inotify_init();
1886    wc_set_cloexec(notifyFd);
1887#endif
1888    if (notifyFd < 0) {
1889        WOLFSSL_MSG("inotify failed");
1890        (void)close(crl->mfd);
1891        SignalSetup(crl, MONITOR_SETUP_E);
1892        return NULL;
1893    }
1894
1895    if (crl->monitors[0].path) {
1896        wd = inotify_add_watch(notifyFd, crl->monitors[0].path, IN_CLOSE_WRITE |
1897                                                                IN_DELETE);
1898        if (wd < 0) {
1899            WOLFSSL_MSG("PEM notify add watch failed");
1900            (void)close(crl->mfd);
1901            (void)close(notifyFd);
1902            SignalSetup(crl, MONITOR_SETUP_E);
1903            return NULL;
1904        }
1905    }
1906
1907    if (crl->monitors[1].path) {
1908        wd = inotify_add_watch(notifyFd, crl->monitors[1].path, IN_CLOSE_WRITE |
1909                                                                IN_DELETE);
1910        if (wd < 0) {
1911            WOLFSSL_MSG("DER notify add watch failed");
1912            (void)close(crl->mfd);
1913            (void)close(notifyFd);
1914            SignalSetup(crl, MONITOR_SETUP_E);
1915            return NULL;
1916        }
1917    }
1918
1919
1920    /* signal to calling thread we're setup */
1921    if (SignalSetup(crl, 1) != 0) {
1922        if (wd > 0) {
1923            if (inotify_rm_watch(notifyFd, wd) < 0)
1924                WOLFSSL_MSG("inotify_rm_watch #1 failed in DoMonitor");
1925        }
1926        (void)close(crl->mfd);
1927        (void)close(notifyFd);
1928        return NULL;
1929    }
1930
1931#ifdef WOLFSSL_SMALL_STACK
1932    buff = (char*)XMALLOC(8192, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1933    if (buff == NULL)
1934        return NULL;
1935#endif
1936
1937    for (;;) {
1938        fd_set readfds;
1939        int    result;
1940        int    length;
1941
1942        FD_ZERO(&readfds);
1943        FD_SET(notifyFd, &readfds);
1944        FD_SET(crl->mfd, &readfds);
1945
1946        result = select(max(notifyFd, crl->mfd) + 1, &readfds, NULL, NULL,NULL);
1947
1948        WOLFSSL_MSG("Got notify event");
1949
1950        if (result < 0) {
1951            WOLFSSL_MSG("select problem, continue");
1952            continue;
1953        }
1954
1955        if (FD_ISSET(crl->mfd, &readfds)) {
1956            word64 r64;
1957            int    rlen;
1958
1959            WOLFSSL_MSG("got custom shutdown event, breaking out");
1960
1961            /* read out the bytes written to the event to clean up */
1962            rlen = (int) read(crl->mfd, &r64, sizeof(r64));
1963            if (rlen < 0) {
1964                WOLFSSL_MSG("read custom event failure");
1965            }
1966
1967            break;
1968        }
1969
1970        length = (int) read(notifyFd, buff, 8192);
1971        if (length < 0) {
1972            WOLFSSL_MSG("notify read problem, continue");
1973            continue;
1974        }
1975
1976        if (SwapLists(crl) < 0) {
1977            WOLFSSL_MSG("SwapLists problem, continue");
1978        }
1979    }
1980
1981    WC_FREE_VAR_EX(buff, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1982
1983    if (wd > 0) {
1984        if (inotify_rm_watch(notifyFd, wd) < 0)
1985            WOLFSSL_MSG("inotify_rm_watch #2 failed in DoMonitor");
1986    }
1987    (void)close(crl->mfd);
1988    (void)close(notifyFd);
1989
1990    return NULL;
1991}
1992
1993#elif defined(_MSC_VER)
1994
1995/* shutdown monitor thread, 0 on success */
1996static int StopMonitor(wolfSSL_CRL_mfd_t mfd)
1997{
1998    if (SetEvent(mfd) == 0) {
1999        WOLFSSL_MSG("SetEvent custom event trigger failed");
2000        return WOLFSSL_FATAL_ERROR;
2001    }
2002    return 0;
2003}
2004
2005#ifdef DEBUG_WOLFSSL
2006#define SHOW_WINDOWS_ERROR() do {                               \
2007    LPVOID lpMsgBuf = NULL;                                     \
2008    DWORD dw = GetLastError();                                  \
2009    FormatMessageA(                                             \
2010        FORMAT_MESSAGE_ALLOCATE_BUFFER |                        \
2011        FORMAT_MESSAGE_FROM_SYSTEM |                            \
2012        FORMAT_MESSAGE_IGNORE_INSERTS,                          \
2013        NULL,                                                   \
2014        dw,                                                     \
2015        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),              \
2016        (LPSTR) &lpMsgBuf,                                      \
2017        0, NULL );                                              \
2018    WOLFSSL_MSG_EX("DoMonitor failed with error %d: %s\n",      \
2019        dw, lpMsgBuf);                                          \
2020    LocalFree(lpMsgBuf);                                        \
2021} while(0)
2022#else
2023#define SHOW_WINDOWS_ERROR() WC_DO_NOTHING
2024#endif
2025
2026#define DM_ERROR() do {                                         \
2027    SHOW_WINDOWS_ERROR();                                       \
2028    status = MONITOR_SETUP_E;                                   \
2029    goto cleanup;                                               \
2030} while(0)
2031
2032/* windows monitoring
2033 * Tested initially by hand by running
2034 * .\server.exe -A certs/ca-cert.pem -i -x
2035 * and connecting to with
2036 * .\client.exe -C -c certs/server-cert.pem -k certs/server-key.pem
2037 * This connection succeeds by default. By deleting all files from certs/crl
2038 * except for crl.revoked we disallow the client to connect. Deleting files
2039 * is done while the server is running to show that the monitor reacts to
2040 * changes in the crl directory. */
2041static THREAD_RETURN WOLFSSL_THREAD DoMonitor(void* arg)
2042{
2043    WOLFSSL_CRL* crl = (WOLFSSL_CRL*)arg;
2044    int status = 0;
2045    HANDLE handles[WOLFSSL_CRL_MONITORS_LEN + 1];
2046    DWORD handlesLen = 0;
2047    int i;
2048
2049    WOLFSSL_ENTER("DoMonitor");
2050
2051    handles[0] = crl->mfd = CreateEventA(NULL, FALSE, FALSE, NULL);
2052    if (crl->mfd == NULL) {
2053        WOLFSSL_MSG("CreateEventA failed");
2054        DM_ERROR();
2055    }
2056    handlesLen++;
2057
2058    for (i = 0; i < WOLFSSL_CRL_MONITORS_LEN; i++) {
2059        if (crl->monitors[i].path) {
2060            handles[handlesLen] = FindFirstChangeNotificationA(
2061                crl->monitors[i].path, TRUE,
2062                /* Watch for any changes that may affect what CRL's we load.
2063                 * This may trigger on the same file multiple times but this
2064                 * way we are certain that we have the most up to date and
2065                 * accurate set of CRL's. We don't expect this to trigger
2066                 * often enough for it to be a bottleneck. */
2067                FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES |
2068                FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE |
2069                FILE_NOTIFY_CHANGE_SECURITY);
2070            if (handles[handlesLen] == INVALID_HANDLE_VALUE) {
2071                WOLFSSL_MSG("FindFirstChangeNotificationA failed");
2072                DM_ERROR();
2073            }
2074            handlesLen++;
2075        }
2076    }
2077
2078    if (handlesLen == 1) {
2079        WOLFSSL_MSG("Nothing to watch. Only custom event handle set.");
2080        DM_ERROR();
2081    }
2082
2083    if (SignalSetup(crl, 1) != 0) {
2084        WOLFSSL_MSG("Call to SignalSetup failed");
2085        DM_ERROR();
2086    }
2087
2088    for (;;) {
2089        DWORD waitRet = WaitForMultipleObjects(handlesLen, handles, FALSE,
2090                                               INFINITE);
2091        WOLFSSL_MSG("Got notify event");
2092
2093        if (waitRet >= WAIT_OBJECT_0 && waitRet < WAIT_OBJECT_0 + handlesLen) {
2094            if (waitRet == WAIT_OBJECT_0) {
2095                WOLFSSL_MSG("got custom shutdown event, breaking out");
2096                break;
2097            }
2098            else if (SwapLists(crl) < 0) {
2099                WOLFSSL_MSG("SwapLists problem, continue");
2100            }
2101        }
2102        else {
2103            WOLFSSL_MSG("Unexpected WaitForMultipleObjects return. Continue.");
2104        }
2105
2106        for (i = 1; i < (int)handlesLen; i++) {
2107            if (FindNextChangeNotification(handles[i]) == 0) {
2108                WOLFSSL_MSG("FindNextChangeNotification failed");
2109                DM_ERROR();
2110            }
2111        }
2112    }
2113
2114cleanup:
2115    if (status != 0)
2116        SignalSetup(crl, status);
2117    for (i = 0; i < (int)handlesLen; i++) {
2118        BOOL closeRet;
2119        if (i == 0) /* First handle is our custom event */
2120            closeRet = CloseHandle(handles[i]);
2121        else
2122            closeRet = FindCloseChangeNotification(handles[i]);
2123        if (closeRet == 0) {
2124            WOLFSSL_MSG("Failed to close handle");
2125        }
2126    }
2127    crl->mfd = INVALID_HANDLE_VALUE;
2128    return 0;
2129}
2130
2131#endif /* MACH or linux or windows */
2132
2133
2134/* Start Monitoring the CRL path(s) in a thread */
2135static int StartMonitorCRL(WOLFSSL_CRL* crl)
2136{
2137    int ret = WOLFSSL_SUCCESS;
2138
2139    WOLFSSL_ENTER("StartMonitorCRL");
2140
2141    if (crl == NULL)
2142        return BAD_FUNC_ARG;
2143
2144    if (crl->tid != INVALID_THREAD_VAL) {
2145        WOLFSSL_MSG("Monitor thread already running");
2146        return ret;  /* that's ok, someone already started */
2147    }
2148
2149    if (wolfSSL_NewThread(&crl->tid, DoMonitor, crl) != 0) {
2150        WOLFSSL_MSG("Thread creation error");
2151        return THREAD_CREATE_E;
2152    }
2153
2154    /* wait for setup to complete */
2155    if (wolfSSL_CondStart(&crl->cond) != 0) {
2156        WOLFSSL_MSG("wolfSSL_CondStart failed");
2157        return BAD_MUTEX_E;
2158    }
2159    while (crl->setup == 0) {
2160        int condRet;
2161        condRet = wolfSSL_CondWait(&crl->cond);
2162        if (condRet != 0) {
2163            ret = BAD_COND_E;
2164            break;
2165        }
2166    }
2167    if (ret >= 0 && crl->setup < 0)
2168        ret = crl->setup;  /* store setup error */
2169
2170    if (ret < 0) {
2171        WOLFSSL_MSG("DoMonitor setup failure");
2172        crl->tid = INVALID_THREAD_VAL;  /* thread already done */
2173    }
2174    if (wolfSSL_CondEnd(&crl->cond) != 0) {
2175        WOLFSSL_MSG("wolfSSL_CondEnd failed");
2176        return BAD_MUTEX_E;
2177    }
2178
2179    return ret;
2180}
2181
2182#endif  /* HAVE_CRL_MONITOR */
2183
2184#if !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR)
2185
2186/* Load CRL path files of type, WOLFSSL_SUCCESS on ok */
2187int LoadCRL(WOLFSSL_CRL* crl, const char* path, int type, int monitor)
2188{
2189    int         ret = WOLFSSL_SUCCESS;
2190    char*       name = NULL;
2191    WC_DECLARE_VAR(readCtx, ReadDirCtx, 1, 0);
2192
2193    WOLFSSL_ENTER("LoadCRL");
2194    if (crl == NULL)
2195        return BAD_FUNC_ARG;
2196
2197    WC_ALLOC_VAR_EX(readCtx, ReadDirCtx, 1, crl->heap,
2198        DYNAMIC_TYPE_TMP_BUFFER, return MEMORY_E);
2199
2200    /* try to load each regular file in path */
2201    ret = wc_ReadDirFirst(readCtx, path, &name);
2202    while (ret == 0 && name) {
2203        int skip = 0;
2204        if (type == WOLFSSL_FILETYPE_PEM) {
2205            if (XSTRSTR(name, ".pem") == NULL) {
2206                WOLFSSL_MSG("not .pem file, skipping");
2207                skip = 1;
2208            }
2209        }
2210        else {
2211            if (XSTRSTR(name, ".der") == NULL &&
2212                XSTRSTR(name, ".crl") == NULL)
2213            {
2214                WOLFSSL_MSG("not .der or .crl file, skipping");
2215                skip = 1;
2216            }
2217        }
2218
2219#ifndef CRL_REPORT_LOAD_ERRORS
2220        if (!skip && ProcessFile(NULL, name, type, CRL_TYPE, NULL, 0, crl,
2221                                 VERIFY) != WOLFSSL_SUCCESS) {
2222            WOLFSSL_MSG("CRL file load failed, continuing");
2223        }
2224#else
2225        if (!skip) {
2226            ret = ProcessFile(NULL, name, type, CRL_TYPE, NULL, 0, crl, VERIFY);
2227            if (ret != WOLFSSL_SUCCESS) {
2228                WOLFSSL_MSG("CRL file load failed");
2229                wc_ReadDirClose(readCtx);
2230                WC_FREE_VAR_EX(readCtx, crl->heap, DYNAMIC_TYPE_TMP_BUFFER);
2231                return ret;
2232            }
2233        }
2234#endif
2235
2236        ret = wc_ReadDirNext(readCtx, path, &name);
2237    }
2238    wc_ReadDirClose(readCtx);
2239
2240    /* load failures not reported, for backwards compat */
2241    ret = WOLFSSL_SUCCESS;
2242
2243    WC_FREE_VAR_EX(readCtx, crl->heap, DYNAMIC_TYPE_TMP_BUFFER);
2244
2245    if (monitor & WOLFSSL_CRL_MONITOR) {
2246#ifdef HAVE_CRL_MONITOR
2247        word32 pathLen;
2248        char* pathBuf;
2249
2250        WOLFSSL_MSG("monitor path requested");
2251
2252        pathLen = (word32)XSTRLEN(path);
2253        pathBuf = (char*)XMALLOC(pathLen+1, crl->heap, DYNAMIC_TYPE_CRL_MONITOR);
2254        if (pathBuf) {
2255            XMEMCPY(pathBuf, path, pathLen+1);
2256
2257            if (type == WOLFSSL_FILETYPE_PEM) {
2258                /* free old path before setting a new one */
2259                if (crl->monitors[0].path) {
2260                    XFREE(crl->monitors[0].path, crl->heap,
2261                            DYNAMIC_TYPE_CRL_MONITOR);
2262                }
2263                crl->monitors[0].path = pathBuf;
2264                crl->monitors[0].type = WOLFSSL_FILETYPE_PEM;
2265            } else {
2266                /* free old path before setting a new one */
2267                if (crl->monitors[1].path) {
2268                    XFREE(crl->monitors[1].path, crl->heap,
2269                            DYNAMIC_TYPE_CRL_MONITOR);
2270                }
2271                crl->monitors[1].path = pathBuf;
2272                crl->monitors[1].type = WOLFSSL_FILETYPE_ASN1;
2273            }
2274
2275            if (monitor & WOLFSSL_CRL_START_MON) {
2276                WOLFSSL_MSG("start monitoring requested");
2277
2278                ret = StartMonitorCRL(crl);
2279            }
2280        }
2281        else {
2282            ret = MEMORY_E;
2283        }
2284#else
2285        WOLFSSL_MSG("CRL monitoring requested but not compiled in");
2286        ret = NOT_COMPILED_IN;
2287#endif
2288    }
2289
2290    return ret;
2291}
2292
2293#else
2294int LoadCRL(WOLFSSL_CRL* crl, const char* path, int type, int monitor)
2295{
2296    (void)crl;
2297    (void)path;
2298    (void)type;
2299    (void)monitor;
2300
2301    /* stub for scenario where file system is not supported */
2302    return NOT_COMPILED_IN;
2303}
2304#endif /* !NO_FILESYSTEM && !NO_WOLFSSL_DIR */
2305
2306#ifndef NO_FILESYSTEM
2307/* Store CRL to a file in DER or PEM format.
2308 * Returns WOLFSSL_SUCCESS on success, negative on failure.
2309 * @param [in] crl    CRL object.
2310 * @param [in] path   Path to the file to store the CRL.
2311 * @param [in] type   Format of encoding. Valid values:
2312 *                      WOLFSSL_FILETYPE_ASN1, WOLFSSL_FILETYPE_PEM.
2313 * @return  WOLFSSL_SUCCESS on success, or negative on failure.
2314 */
2315int StoreCRL(WOLFSSL_CRL* crl, const char* path, int type)
2316{
2317    XFILE fp = XBADFILE;
2318    int ret = WOLFSSL_SUCCESS;
2319    long sz = 0;
2320    byte* mem = NULL;
2321
2322    WOLFSSL_ENTER("StoreCRL");
2323
2324    if (crl == NULL || path == NULL)
2325        return BAD_FUNC_ARG;
2326
2327    /* Determine required size. */
2328    ret = BufferStoreCRL(crl, NULL, &sz, type);
2329    if (ret != WOLFSSL_SUCCESS) {
2330        return ret;
2331    }
2332
2333    /* Allocate temporary buffer. */
2334    mem = (byte*)XMALLOC((size_t)sz, crl->heap, DYNAMIC_TYPE_TMP_BUFFER);
2335    if (mem == NULL) {
2336        return MEMORY_E;
2337    }
2338
2339    /* Encode CRL into buffer. */
2340    ret = BufferStoreCRL(crl, mem, &sz, type);
2341    if (ret == WOLFSSL_SUCCESS) {
2342        /* Open destination file for writing. */
2343        fp = XFOPEN(path, "wb");
2344        if (fp == XBADFILE) {
2345            ret = WOLFSSL_BAD_FILE;
2346        }
2347        else {
2348            size_t wrote = XFWRITE(mem, 1, (size_t)sz, fp);
2349            if (wrote != (size_t)sz) {
2350                WOLFSSL_MSG("CRL file write failed");
2351                ret = FWRITE_ERROR;
2352            }
2353            XFCLOSE(fp);
2354        }
2355    }
2356
2357    XFREE(mem, crl->heap, DYNAMIC_TYPE_TMP_BUFFER);
2358    return ret;
2359}
2360#else
2361int StoreCRL(WOLFSSL_CRL* crl, const char* file, int type)
2362{
2363    (void)crl;
2364    (void)file;
2365    (void)type;
2366    return NOT_COMPILED_IN;
2367}
2368#endif /* NO_FILESYSTEM */
2369
2370#if defined(OPENSSL_EXTRA) && !defined(NO_ASN_TIME)
2371/* Create a new empty CRL object for generation.
2372 * Version is set to 2 by default. Use wolfSSL_X509_CRL_set_version() to
2373 * change it.
2374 * lastUpdate set to current time, nextUpdate set to 500 days from now.
2375 * Returns a new CRL or NULL on failure.
2376 */
2377WOLFSSL_X509_CRL* wolfSSL_X509_CRL_new(void)
2378{
2379    WOLFSSL_X509_CRL* crl;
2380    CRL_Entry* entry;
2381    WOLFSSL_ASN1_TIME asnTime;
2382
2383    WOLFSSL_ENTER("wolfSSL_X509_CRL_new");
2384
2385    crl = (WOLFSSL_X509_CRL*)XMALLOC(sizeof(WOLFSSL_X509_CRL), NULL,
2386                                      DYNAMIC_TYPE_CRL);
2387    if (crl == NULL) {
2388        WOLFSSL_MSG("Memory allocation failed for CRL");
2389        return NULL;
2390    }
2391
2392    if (InitCRL(crl, NULL) < 0) {
2393        WOLFSSL_MSG("Init CRL failed");
2394        XFREE(crl, NULL, DYNAMIC_TYPE_CRL);
2395        return NULL;
2396    }
2397
2398    /* Allocate empty CRL entry for setting fields */
2399    entry = (CRL_Entry*)XMALLOC(sizeof(CRL_Entry), NULL,
2400                                DYNAMIC_TYPE_CRL_ENTRY);
2401    if (entry == NULL) {
2402        WOLFSSL_MSG("Memory allocation failed for CRL entry");
2403        FreeCRL(crl, 1);
2404        return NULL;
2405    }
2406    XMEMSET(entry, 0, sizeof(CRL_Entry));
2407
2408    if (wc_InitMutex(&entry->verifyMutex) != 0) {
2409        XFREE(entry, NULL, DYNAMIC_TYPE_CRL_ENTRY);
2410        FreeCRL(crl, 1);
2411        return NULL;
2412    }
2413
2414    crl->crlList = entry;
2415
2416    /* Set thisUpdate to current time */
2417    if (wolfSSL_ASN1_TIME_adj(&asnTime, XTIME(NULL), 0, 0) == NULL) {
2418        WOLFSSL_MSG("Failed to get current time");
2419        FreeCRL(crl, 1);
2420        return NULL;
2421    }
2422    if (wolfSSL_X509_CRL_set_lastUpdate(crl, &asnTime) != WOLFSSL_SUCCESS) {
2423        WOLFSSL_MSG("Failed to set last update");
2424        FreeCRL(crl, 1);
2425        return NULL;
2426    }
2427
2428    /* Set next update date to 500 days from now,
2429     * following convention from wc_InitCert() */
2430    if (wolfSSL_ASN1_TIME_adj(&asnTime, XTIME(NULL), 500, 0) == NULL) {
2431        WOLFSSL_MSG("Failed to get next update time");
2432        FreeCRL(crl, 1);
2433        return NULL;
2434    }
2435    if (wolfSSL_X509_CRL_set_nextUpdate(crl, &asnTime) != WOLFSSL_SUCCESS) {
2436        WOLFSSL_MSG("Failed to set next update");
2437        FreeCRL(crl, 1);
2438        return NULL;
2439    }
2440
2441    /* Set default version to v2 (required for extensions) */
2442    entry->version = 2;
2443
2444    return crl;
2445}
2446
2447#ifdef WOLFSSL_CERT_GEN
2448/* Add a revoked certificate entry to CRL.
2449 * crl: target CRL
2450 * rev: revoked certificate entry (serial, date, reason, etc.)
2451 * Returns WOLFSSL_SUCCESS on success.
2452 */
2453int wolfSSL_X509_CRL_add_revoked(WOLFSSL_X509_CRL* crl,
2454                                 WOLFSSL_X509_REVOKED* rev)
2455{
2456    CRL_Entry* entry;
2457    RevokedCert* rc;
2458    RevokedCert* curr;
2459
2460    WOLFSSL_ENTER("wolfSSL_X509_CRL_add_revoked");
2461
2462    if (crl == NULL || rev == NULL || rev->serialNumber == NULL) {
2463        return BAD_FUNC_ARG;
2464    }
2465
2466    if (rev->revocationDate != NULL && (rev->revocationDate->length <= 0 ||
2467        (unsigned)rev->revocationDate->length > sizeof(rc->revDate))) {
2468        return BAD_FUNC_ARG;
2469    }
2470
2471    entry = crl->crlList;
2472    if (entry == NULL) {
2473        return BAD_FUNC_ARG;
2474    }
2475
2476    {
2477        const byte* serial = rev->serialNumber->data;
2478        int serialSz = rev->serialNumber->length;
2479        int i;
2480        int allZero = 1;
2481
2482        if (serial == NULL || serialSz <= 0) {
2483            return BAD_FUNC_ARG;
2484        }
2485
2486        if (serialSz > EXTERNAL_SERIAL_SIZE) {
2487            return BAD_FUNC_ARG;
2488        }
2489
2490        /* All zero serial numbers are invalid per rfc5280 and not supported */
2491        for (i = 0; i < serialSz; i++) {
2492            if (serial[i] != 0) {
2493                allZero = 0;
2494                break;
2495            }
2496        }
2497        if (allZero) {
2498            return BAD_FUNC_ARG;
2499        }
2500
2501        rc = (RevokedCert*)XMALLOC(sizeof(RevokedCert), crl->heap,
2502                                   DYNAMIC_TYPE_REVOKED);
2503        if (rc == NULL) {
2504            return MEMORY_E;
2505        }
2506        XMEMSET(rc, 0, sizeof(RevokedCert));
2507
2508        XMEMCPY(rc->serialNumber, serial, (size_t)serialSz);
2509        rc->serialSz = serialSz;
2510    }
2511
2512    /* Use caller-provided revocation date, or fall back to current time */
2513    if (rev->revocationDate != NULL && rev->revocationDate->length > 0) {
2514        XMEMCPY(rc->revDate, rev->revocationDate->data,
2515                 (size_t)rev->revocationDate->length);
2516        rc->revDateFormat = (byte)rev->revocationDate->type;
2517    }
2518    else {
2519        WOLFSSL_ASN1_TIME revDate;
2520        XMEMSET(&revDate, 0, sizeof(revDate));
2521        if (wolfSSL_ASN1_TIME_adj(&revDate, XTIME(NULL), 0, 0) == NULL) {
2522            WOLFSSL_MSG("Failed to get current time");
2523            XFREE(rc, crl->heap, DYNAMIC_TYPE_REVOKED);
2524            return BAD_STATE_E;
2525        }
2526        XMEMCPY(rc->revDate, revDate.data, revDate.length);
2527        rc->revDateFormat = (byte)revDate.type;
2528    }
2529
2530    rc->reasonCode = rev->reason;
2531    rc->next = NULL;
2532
2533    /* Add to end of list */
2534    if (entry->certs == NULL) {
2535        entry->certs = rc;
2536    }
2537    else {
2538        for (curr = entry->certs; curr->next != NULL; curr = curr->next)
2539            ;
2540        curr->next = rc;
2541    }
2542    entry->totalCerts++;
2543
2544    /* Invalidate cached STACK_OF(X509_REVOKED) since list changed */
2545    if (crl->revokedStack != NULL) {
2546        wolfSSL_sk_pop_free(crl->revokedStack, NULL);
2547        crl->revokedStack = NULL;
2548    }
2549
2550    WOLFSSL_LEAVE("wolfSSL_X509_CRL_add_revoked", WOLFSSL_SUCCESS);
2551    return WOLFSSL_SUCCESS;
2552}
2553
2554/* Add a revoked certificate entry to CRL by parsing a certificate buffer.
2555 * crl: target CRL
2556 * certBuf: DER-encoded certificate buffer
2557 * certSz: size of certificate buffer
2558 * revDate: revocation date (ASN.1 format), or NULL for
2559 *          current time
2560 * revDateFmt: date format (ASN_UTC_TIME or ASN_GENERALIZED_TIME), ignored if
2561 *             revDate is NULL
2562 * Returns WOLFSSL_SUCCESS on success.
2563 * Note: this function is only available when WOLFSSL_CERT_GEN is defined.
2564 */
2565int wolfSSL_X509_CRL_add_revoked_cert(WOLFSSL_X509_CRL* crl,
2566                                      const unsigned char* certBuf, int certSz)
2567{
2568    int ret;
2569    DecodedCert* cert = NULL;
2570    WOLFSSL_X509_REVOKED revoked;
2571    WOLFSSL_ASN1_INTEGER* serialInt = NULL;
2572
2573    WOLFSSL_ENTER("wolfSSL_X509_CRL_add_revoked_cert");
2574
2575    if (crl == NULL || certBuf == NULL || certSz <= 0) {
2576        return BAD_FUNC_ARG;
2577    }
2578
2579    cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL, DYNAMIC_TYPE_DCERT);
2580    if (cert == NULL) {
2581        return MEMORY_E;
2582    }
2583
2584    /* Initialize and parse the certificate */
2585    InitDecodedCert(cert, certBuf, (word32)certSz, NULL);
2586    ret = ParseCertRelative(cert, CERT_TYPE, NO_VERIFY, NULL, NULL);
2587    if (ret != 0) {
2588        WOLFSSL_MSG("Failed to parse certificate");
2589        FreeDecodedCert(cert);
2590        XFREE(cert, NULL, DYNAMIC_TYPE_DCERT);
2591        return ret;
2592    }
2593
2594    serialInt = wolfSSL_ASN1_INTEGER_new();
2595    if (serialInt == NULL) {
2596        FreeDecodedCert(cert);
2597        XFREE(cert, NULL, DYNAMIC_TYPE_DCERT);
2598        return MEMORY_E;
2599    }
2600
2601    if (cert->serialSz > WOLFSSL_ASN1_INTEGER_MAX) {
2602        serialInt->data = (unsigned char*)XMALLOC(cert->serialSz, NULL,
2603            DYNAMIC_TYPE_OPENSSL);
2604        if (serialInt->data == NULL) {
2605            wolfSSL_ASN1_INTEGER_free(serialInt);
2606            FreeDecodedCert(cert);
2607            XFREE(cert, NULL, DYNAMIC_TYPE_DCERT);
2608            return MEMORY_E;
2609        }
2610        serialInt->dataMax = (unsigned int)cert->serialSz;
2611        serialInt->isDynamic = 1;
2612    }
2613    else {
2614        serialInt->data = serialInt->intData;
2615        serialInt->dataMax = WOLFSSL_ASN1_INTEGER_MAX;
2616    }
2617
2618    XMEMCPY(serialInt->data, cert->serial, cert->serialSz);
2619    serialInt->length = cert->serialSz;
2620
2621    XMEMSET(&revoked, 0, sizeof(revoked));
2622    revoked.serialNumber = serialInt;
2623    revoked.reason = CRL_REASON_NONE;
2624
2625    /* Add the revoked certificate entry */
2626    ret = wolfSSL_X509_CRL_add_revoked(crl, &revoked);
2627
2628    FreeDecodedCert(cert);
2629    XFREE(cert, NULL, DYNAMIC_TYPE_DCERT);
2630    wolfSSL_ASN1_INTEGER_free(serialInt);
2631
2632    return ret;
2633}
2634
2635static int GetCrlSignBufSz(int tbsSz, int sigType, RsaKey* rsaKey,
2636    ecc_key* eccKey)
2637{
2638    int sigSz = 0;
2639    int ret;
2640    byte sigDummy = 0;
2641
2642    if (tbsSz <= 0)
2643        return BAD_FUNC_ARG;
2644
2645    (void)rsaKey;
2646    (void)eccKey;
2647#ifndef NO_RSA
2648    if (rsaKey != NULL) {
2649        sigSz = wc_RsaEncryptSize(rsaKey);
2650    }
2651#endif
2652#ifdef HAVE_ECC
2653    if (sigSz <= 0 && eccKey != NULL) {
2654        sigSz = wc_ecc_sig_size(eccKey);
2655    }
2656#endif
2657    if (sigSz <= 0) {
2658        /* Fallback for unexpected key sizes */
2659        sigSz = 1024;
2660    }
2661
2662    /* Estimate total CRL size by asking AddSignature for the DER wrapper
2663     * size (sequence + algo OID + BIT STRING headers). If it fails (e.g.,
2664     * unknown sigType), fall back to a conservative headroom of 64 bytes for
2665     * those headers. This is defensive (size-estimate only); the real sign
2666     * path will still report any unsupported sigType. */
2667    ret = AddSignature(NULL, tbsSz, &sigDummy, sigSz, sigType);
2668    if (ret < 0) {
2669        ret = tbsSz + sigSz + 64;
2670    }
2671    return ret;
2672}
2673
2674/* Sign a CRL with a private key, rebuilding TBS from fields.
2675 * crl: CRL with fields set via setter functions
2676 * pkey: private key for signing
2677 * md: digest algorithm (e.g., EVP_sha256())
2678 * Note: only one entry is supported in the CRL list.
2679 * Returns WOLFSSL_SUCCESS on success.
2680 */
2681int wolfSSL_X509_CRL_sign(WOLFSSL_X509_CRL* crl, WOLFSSL_EVP_PKEY* pkey,
2682                          const WOLFSSL_EVP_MD* md)
2683{
2684    int ret = WOLFSSL_SUCCESS;
2685    CRL_Entry* entry;
2686    byte* issuerDer = NULL;
2687    int issuerSz = 0;
2688    int sigType = 0;
2689    int tbsSz = 0;
2690    int totalSz = 0;
2691    byte* buf = NULL;
2692    int bufSz = 0;
2693    RsaKey* rsaKey = NULL;
2694    ecc_key* eccKey = NULL;
2695    WC_RNG rng;
2696    int rngInit = 0;
2697
2698    WOLFSSL_ENTER("wolfSSL_X509_CRL_sign");
2699
2700    if (crl == NULL || pkey == NULL || md == NULL) {
2701        return BAD_FUNC_ARG;
2702    }
2703
2704    /* Fetch only the first entry in the CRL list */
2705    entry = crl->crlList;
2706    if (entry == NULL) {
2707        WOLFSSL_MSG("CRL has no entry");
2708        return BAD_FUNC_ARG;
2709    }
2710
2711    /* Determine signature type from digest and key type */
2712    if (ret == WOLFSSL_SUCCESS) {
2713#ifndef NO_RSA
2714        if (pkey->type == WC_EVP_PKEY_RSA) {
2715            if (md == wolfSSL_EVP_sha256()) {
2716                sigType = CTC_SHA256wRSA;
2717            }
2718            #ifdef WOLFSSL_SHA384
2719            else if (md == wolfSSL_EVP_sha384()) {
2720                sigType = CTC_SHA384wRSA;
2721            }
2722            #endif
2723            #ifdef WOLFSSL_SHA512
2724            else if (md == wolfSSL_EVP_sha512()) {
2725                sigType = CTC_SHA512wRSA;
2726            }
2727            #endif
2728            else if (md == wolfSSL_EVP_sha1()) {
2729                sigType = CTC_SHAwRSA;
2730            }
2731            else {
2732                WOLFSSL_MSG("Unsupported digest for RSA");
2733                return BAD_FUNC_ARG;
2734            }
2735            rsaKey = (RsaKey*)pkey->rsa->internal;
2736        }
2737        else
2738#endif
2739#ifdef HAVE_ECC
2740        if (pkey->type == WC_EVP_PKEY_EC) {
2741            if (md == wolfSSL_EVP_sha256()) {
2742                sigType = CTC_SHA256wECDSA;
2743            }
2744            #ifdef WOLFSSL_SHA384
2745            else if (md == wolfSSL_EVP_sha384()) {
2746                sigType = CTC_SHA384wECDSA;
2747            }
2748            #endif
2749            #ifdef WOLFSSL_SHA512
2750            else if (md == wolfSSL_EVP_sha512()) {
2751                sigType = CTC_SHA512wECDSA;
2752            }
2753            #endif
2754            else if (md == wolfSSL_EVP_sha1()) {
2755                sigType = CTC_SHAwECDSA;
2756            }
2757            else {
2758                WOLFSSL_MSG("Unsupported digest for ECDSA");
2759                return BAD_FUNC_ARG;
2760            }
2761            eccKey = (ecc_key*)pkey->ecc->internal;
2762        }
2763        else
2764#endif
2765        {
2766            WOLFSSL_MSG("Unsupported key type");
2767            return BAD_FUNC_ARG;
2768        }
2769    }
2770
2771    /* Get issuer name DER */
2772    if (ret == WOLFSSL_SUCCESS) {
2773        if (entry->issuer != NULL) {
2774            /* Retrieve the issuer in two passes so we can avoid making
2775             * assumptions about the heap that is used, as we must free
2776             * this buffer later. */
2777            issuerSz = wolfSSL_i2d_X509_NAME(entry->issuer, NULL);
2778            if (issuerSz <= 0) {
2779                WOLFSSL_MSG("Failed to encode issuer name");
2780                ret = WOLFSSL_FAILURE;
2781            }
2782            else {
2783                issuerDer = (byte*)XMALLOC((size_t)issuerSz, crl->heap,
2784                                           DYNAMIC_TYPE_TMP_BUFFER);
2785                if (issuerDer == NULL) {
2786                    WOLFSSL_MSG("Memory allocation failed for issuer DER");
2787                    ret = MEMORY_E;
2788                }
2789                else {
2790                    /* i2d moves the pointer, so use a temp */
2791                    byte* tempPtr = issuerDer;
2792                    if (wolfSSL_i2d_X509_NAME(entry->issuer, &tempPtr) <= 0) {
2793                        WOLFSSL_MSG("Failed to encode issuer name");
2794                        ret = WOLFSSL_FAILURE;
2795                    }
2796                }
2797            }
2798        }
2799        else {
2800            WOLFSSL_MSG("CRL has no issuer set");
2801            ret = BAD_FUNC_ARG;
2802        }
2803    }
2804
2805    /* Copy dates from ASN1 time structures to raw fields if needed */
2806    if (ret == WOLFSSL_SUCCESS) {
2807        if (entry->lastDateAsn1.length > 0 && entry->lastDateFormat == 0) {
2808            XMEMCPY(entry->lastDate, entry->lastDateAsn1.data,
2809                    (size_t)entry->lastDateAsn1.length);
2810            entry->lastDateFormat = (byte)entry->lastDateAsn1.type;
2811        }
2812        if (entry->nextDateAsn1.length > 0 && entry->nextDateFormat == 0) {
2813            XMEMCPY(entry->nextDate, entry->nextDateAsn1.data,
2814                    (size_t)entry->nextDateAsn1.length);
2815            entry->nextDateFormat = (byte)entry->nextDateAsn1.type;
2816        }
2817    }
2818
2819    /* Verify we have valid dates */
2820    if (ret == WOLFSSL_SUCCESS) {
2821        if (entry->lastDateFormat == 0) {
2822            WOLFSSL_MSG("CRL has no lastUpdate date set");
2823            ret = BAD_FUNC_ARG;
2824        }
2825    }
2826
2827    /* Initialize RNG */
2828    if (ret == WOLFSSL_SUCCESS) {
2829        if (wc_InitRng(&rng) != 0) {
2830            WOLFSSL_MSG("RNG init failed");
2831            ret = WOLFSSL_FAILURE;
2832        }
2833        else {
2834            rngInit = 1;
2835        }
2836    }
2837
2838    if (ret == WOLFSSL_SUCCESS) {
2839        const byte* crlNumber = NULL;
2840        word32 crlNumberSz = 0;
2841
2842        if (entry->crlNumberSet) {
2843            crlNumber = (const byte*)entry->crlNumber;
2844            crlNumberSz = CRL_MAX_NUM_SZ;
2845        }
2846
2847        /* Determine TBS size, but this does not include the outer signature
2848         * wrapper (AlgorithmIdentifier,  BIT STRING and outer SEQUENCE) */
2849        bufSz = wc_MakeCRL_ex(issuerDer, (word32)issuerSz,
2850                              entry->lastDate, entry->lastDateFormat,
2851                              entry->nextDate, entry->nextDateFormat,
2852                              entry->certs, crlNumber, crlNumberSz,
2853                              sigType, entry->version, NULL, 0);
2854        if (bufSz < 0) {
2855            WOLFSSL_MSG("wc_MakeCRL_ex size check failed");
2856            ret = bufSz;
2857        }
2858    }
2859
2860    if (ret == WOLFSSL_SUCCESS) {
2861        bufSz = GetCrlSignBufSz(bufSz, sigType, rsaKey, eccKey);
2862        if (bufSz <= 0) {
2863            WOLFSSL_MSG("CRL buffer size calc failed");
2864            ret = bufSz;
2865        }
2866    }
2867
2868    /* Allocate working buffer for TBS + signature */
2869    if (ret == WOLFSSL_SUCCESS) {
2870        buf = (byte*)XMALLOC(bufSz, crl->heap, DYNAMIC_TYPE_TMP_BUFFER);
2871        if (buf == NULL) {
2872            ret = MEMORY_E;
2873        }
2874    }
2875
2876    /* Build to-be-signed (TBS) portion of the CRL buffer.
2877     * Note that we pass the fields rather than the CRL_entry struct so
2878     * wolfcrypt need not know about the openSSL-compatible CRL_entry struct.
2879     */
2880    if (ret == WOLFSSL_SUCCESS) {
2881        const byte* crlNumber = NULL;
2882        word32 crlNumberSz = 0;
2883
2884        if (entry->crlNumberSet) {
2885            crlNumber = (const byte*)entry->crlNumber;
2886            crlNumberSz = CRL_MAX_NUM_SZ;
2887        }
2888
2889        tbsSz = wc_MakeCRL_ex(issuerDer, (word32)issuerSz,
2890                              entry->lastDate, entry->lastDateFormat,
2891                              entry->nextDate, entry->nextDateFormat,
2892                              entry->certs, crlNumber, crlNumberSz,
2893                              sigType,
2894                              entry->version, buf, bufSz);
2895        if (tbsSz < 0) {
2896            WOLFSSL_MSG("wc_MakeCRL_ex failed");
2897            ret = tbsSz;
2898        }
2899    }
2900
2901    /* Sign and complete CRL. Note that the output buffer is the same as the
2902     * input buffer. The signature is added to the end of the buffer.
2903     */
2904    if (ret == WOLFSSL_SUCCESS) {
2905        totalSz = wc_SignCRL_ex(buf, tbsSz, sigType, buf, bufSz,
2906                                rsaKey, eccKey, &rng);
2907        if (totalSz < 0) {
2908            WOLFSSL_MSG("wc_SignCRL_ex failed");
2909            ret = totalSz;
2910        }
2911    }
2912
2913    /* Update CRL entry with new toBeSigned and signature. Build the new
2914     * buffers first and only commit to entry on full success. */
2915    if (ret == WOLFSSL_SUCCESS) {
2916        byte* newToBeSigned = NULL;
2917        byte* newSignature = NULL;
2918        word32 newTbsSz = 0;
2919        word32 newSignatureSz = 0;
2920        word32 newSignatureOid = 0;
2921
2922        /* Extract TBS and signature from the complete CRL buffer.
2923         * After AddSignature, the buffer layout is:
2924         * [outer SEQUENCE header][TBS][AlgorithmIdentifier][BIT STRING sig]
2925         */
2926        {
2927            word32 idx = 0;
2928            int len = 0;
2929            word32 tbsStart = 0;
2930            word32 tbsLen = 0;
2931            int sigLen = 0;
2932
2933            /* Parse outer SEQUENCE */
2934            if (GetSequence(buf, &idx, &len, (word32)totalSz) < 0) {
2935                ret = ASN_PARSE_E;
2936            }
2937
2938            /* TBS starts here */
2939            if (ret == WOLFSSL_SUCCESS) {
2940                tbsStart = idx;
2941            }
2942
2943            /* Parse TBS SEQUENCE to get its length */
2944            if (ret == WOLFSSL_SUCCESS) {
2945                if (GetSequence(buf, &idx, &len, (word32)totalSz) < 0) {
2946                    ret = ASN_PARSE_E;
2947                }
2948            }
2949            if (ret == WOLFSSL_SUCCESS) {
2950                tbsLen = idx + (word32)len - tbsStart;
2951                idx = tbsStart + tbsLen; /* Move past TBS */
2952            }
2953
2954            /* Allocate and copy TBS */
2955            if (ret == WOLFSSL_SUCCESS) {
2956                newToBeSigned = (byte*)XMALLOC(tbsLen, crl->heap,
2957                                               DYNAMIC_TYPE_CRL_ENTRY);
2958                if (newToBeSigned == NULL) {
2959                    ret = MEMORY_E;
2960                }
2961            }
2962            if (ret == WOLFSSL_SUCCESS) {
2963                XMEMCPY(newToBeSigned, buf + tbsStart, tbsLen);
2964                newTbsSz = tbsLen;
2965            }
2966
2967            /* Skip AlgorithmIdentifier */
2968            if (ret == WOLFSSL_SUCCESS) {
2969                if (GetAlgoId(buf, &idx, (word32*)&len, oidSigType,
2970                        (word32)totalSz) < 0) {
2971                    ret = ASN_PARSE_E;
2972                }
2973            }
2974
2975            /* Get BIT STRING */
2976            if (ret == WOLFSSL_SUCCESS) {
2977                if (GetASNHeader(buf, ASN_BIT_STRING, &idx, &sigLen,
2978                        (word32)totalSz) < 0) {
2979                    ret = ASN_PARSE_E;
2980                }
2981            }
2982
2983            /* Skip unused bits byte */
2984            if (ret == WOLFSSL_SUCCESS) {
2985                if (idx >= (word32)totalSz || sigLen <= 0 || buf[idx] != 0) {
2986                    ret = ASN_PARSE_E;
2987                }
2988            }
2989            if (ret == WOLFSSL_SUCCESS) {
2990                idx++;
2991                sigLen--;
2992            }
2993
2994            if (ret == WOLFSSL_SUCCESS) {
2995                newSignature = (byte*)XMALLOC((word32)sigLen, crl->heap,
2996                                              DYNAMIC_TYPE_CRL_ENTRY);
2997                if (newSignature == NULL) {
2998                    ret = MEMORY_E;
2999                }
3000            }
3001            if (ret == WOLFSSL_SUCCESS) {
3002                XMEMCPY(newSignature, buf + idx, (size_t)sigLen);
3003                newSignatureSz = (word32)sigLen;
3004                newSignatureOid = (word32)sigType;
3005            }
3006        }
3007
3008        if (ret == WOLFSSL_SUCCESS) {
3009            if (entry->toBeSigned != NULL) {
3010                XFREE(entry->toBeSigned, crl->heap, DYNAMIC_TYPE_CRL_ENTRY);
3011                entry->toBeSigned = NULL;
3012            }
3013            if (entry->signature != NULL) {
3014                XFREE(entry->signature, crl->heap, DYNAMIC_TYPE_CRL_ENTRY);
3015                entry->signature = NULL;
3016            }
3017
3018            entry->toBeSigned = newToBeSigned;
3019            entry->tbsSz = newTbsSz;
3020            entry->signature = newSignature;
3021            entry->signatureSz = newSignatureSz;
3022            entry->signatureOID = newSignatureOid;
3023        }
3024        else {
3025            if (newToBeSigned != NULL) {
3026                XFREE(newToBeSigned, crl->heap, DYNAMIC_TYPE_CRL_ENTRY);
3027            }
3028            if (newSignature != NULL) {
3029                XFREE(newSignature, crl->heap, DYNAMIC_TYPE_CRL_ENTRY);
3030            }
3031        }
3032    }
3033
3034    /* Mark the CRL as verified/signed for future reference. */
3035    if (ret == WOLFSSL_SUCCESS) {
3036        entry->verified = 1;
3037    }
3038
3039    if (issuerDer) {
3040        XFREE(issuerDer, crl->heap, DYNAMIC_TYPE_TMP_BUFFER);
3041    }
3042    if (buf) {
3043        XFREE(buf, crl->heap, DYNAMIC_TYPE_TMP_BUFFER);
3044    }
3045    if (rngInit) {
3046        wc_FreeRng(&rng);
3047    }
3048
3049    return ret;
3050}
3051#endif /* WOLFSSL_CERT_GEN */
3052
3053#endif /* OPENSSL_EXTRA */
3054
3055#endif /* HAVE_CRL */
3056#endif /* !WOLFCRYPT_ONLY */