Ignore:
Timestamp:
Feb 7, 2019, 8:36:33 AM (5 years ago)
Author:
coas-nagasima
Message:

wolfsslを3.15.7にバージョンアップ

File:
1 edited

Legend:

Unmodified
Added
Removed

  • asp3_tinet_ecnl_arm/trunk/wolfssl-3.12.2/src/internal.c

    r364 r372  
    2828#include <wolfssl/wolfcrypt/settings.h>
    2929
     30/*
     31 * WOLFSSL_SMALL_CERT_VERIFY:
     32 *     Verify the certificate signature without using DecodedCert. Doubles up
     33 *     on some code but allows smaller dynamic memory usage.
     34 */
     35
    3036#ifndef WOLFCRYPT_ONLY
    3137
    … …  
    3945    #define WOLFSSL_MISC_INCLUDED
    4046    #include <wolfcrypt/src/misc.c>
     47#endif
     48#if defined(OPENSSL_EXTRA) && defined(WOLFCRYPT_HAVE_SRP) && !defined(NO_SHA)
     49    #include <wolfssl/wolfcrypt/srp.h>
    4150#endif
    4251
    … …  
    8291    #error Cannot use both secure-renegotiation and renegotiation-indication
    8392#endif
     93
     94#ifndef WOLFSSL_NO_TLS12
    8495
    8596#ifndef NO_WOLFSSL_CLIENT
    … …  
    101112#ifndef NO_WOLFSSL_SERVER
    102113    static int DoClientKeyExchange(WOLFSSL* ssl, byte* input, word32*, word32);
    103     #if !defined(NO_RSA) || defined(HAVE_ECC)
     114    #if (!defined(NO_RSA) || defined(HAVE_ECC) || defined(HAVE_ED25519)) && \
     115                                                !defined(WOLFSSL_NO_CLIENT_AUTH)
    104116        static int DoCertificateVerify(WOLFSSL* ssl, byte*, word32*, word32);
    105117    #endif
    … …  
    109121#endif
    110122
     123#endif /* !WOLFSSL_NO_TLS12 */
    111124
    112125#ifdef WOLFSSL_DTLS
    113     static INLINE int DtlsCheckWindow(WOLFSSL* ssl);
    114     static INLINE int DtlsUpdateWindow(WOLFSSL* ssl);
     126    static WC_INLINE int DtlsCheckWindow(WOLFSSL* ssl);
     127    static WC_INLINE int DtlsUpdateWindow(WOLFSSL* ssl);
    115128#endif
    116129
    … …  
    129142
    130143
     144#ifndef WOLFSSL_NO_TLS12
     145#if !defined(NO_WOLFSSL_SERVER) || !defined(NO_WOLFSSL_CLIENT)
     146
    131147/* Server random bytes for TLS v1.3 described downgrade protection mechanism. */
    132148static const byte tls13Downgrade[7] = {
    … …  
    135151#define TLS13_DOWNGRADE_SZ  sizeof(tls13Downgrade)
    136152
    137 
    138 #ifndef NO_OLD_TLS
     153#endif /* !NO_WOLFSSL_SERVER || !NO_WOLFSSL_CLIENT */
     154
     155#if !defined(NO_OLD_TLS) && !defined(WOLFSSL_AEAD_ONLY)
    139156static int SSL_hmac(WOLFSSL* ssl, byte* digest, const byte* in, word32 sz,
    140                     int content, int verify);
    141 
    142 #endif
     157                    int padSz, int content, int verify);
     158
     159#endif
     160
     161#endif /* !WOLFSSL_NO_TLS12 */
    143162
    144163#ifdef HAVE_QSH
    … …  
    160179    if (ssl->version.major == SSLv3_MAJOR && ssl->version.minor >=TLSv1_2_MINOR)
    161180        return 1;
     181#ifdef WOLFSSL_DTLS
    162182    if (ssl->version.major == DTLS_MAJOR && ssl->version.minor <= DTLSv1_2_MINOR)
    163183        return 1;
     184#endif
    164185
    165186    return 0;
    … …  
    171192}
    172193
    173 
    174 static INLINE int IsEncryptionOn(WOLFSSL* ssl, int isSend)
     194static WC_INLINE int IsEncryptionOn(WOLFSSL* ssl, int isSend)
    175195{
    176196    (void)isSend;
    … …  
    186206
    187207
     208#if defined(WOLFSSL_DTLS) || !defined(WOLFSSL_NO_TLS12)
    188209/* If SCTP is not enabled returns the state of the dtls option.
    189210 * If SCTP is enabled returns dtls && !sctp. */
    190 static INLINE int IsDtlsNotSctpMode(WOLFSSL* ssl)
     211static WC_INLINE int IsDtlsNotSctpMode(WOLFSSL* ssl)
    191212{
    192213    int result = ssl->options.dtls;
    … …  
    200221    return result;
    201222}
     223#endif /* DTLS || !WOLFSSL_NO_TLS12 */
    202224
    203225
    … …  
    524546#endif
    525547    exp[idx++] = sz;
     548#ifndef WOLFSSL_AEAD_ONLY
    526549    XMEMCPY(exp + idx, keys->client_write_MAC_secret, sz); idx += sz;
    527550    XMEMCPY(exp + idx, keys->server_write_MAC_secret, sz); idx += sz;
     551#else
     552    XMEMSET(exp + idx, 0, sz); idx += sz;
     553    XMEMSET(exp + idx, 0, sz); idx += sz;
     554#endif
    528555
    529556    sz         = ssl->specs.key_size;
    … …  
    682709#endif
    683710    sz = exp[idx++];
    684     if (sz > MAX_DIGEST_SIZE || sz + idx > len) {
     711#ifndef WOLFSSL_AEAD_ONLY
     712    if (sz > sizeof(keys->client_write_MAC_secret) || sz + idx > len) {
    685713        return BUFFER_E;
    686714    }
    687715    XMEMCPY(keys->client_write_MAC_secret, exp + idx, sz); idx += sz;
    688716    XMEMCPY(keys->server_write_MAC_secret, exp + idx, sz); idx += sz;
     717#else
     718    if (sz + idx > len) {
     719        return BUFFER_E;
     720    }
     721    idx += sz; idx += sz;
     722#endif
    689723
    690724    sz = exp[idx++];
    691     if (sz > AES_256_KEY_SIZE || sz + idx > len) {
     725    if (sz > sizeof(keys->client_write_key) || sz + idx > len) {
    692726        return BUFFER_E;
    693727    }
    … …  
    696730
    697731    sz = exp[idx++];
    698     if (sz > MAX_WRITE_IV_SZ || sz + idx > len) {
     732    if (sz > sizeof(keys->client_write_IV) || sz + idx > len) {
    699733        return BUFFER_E;
    700734    }
    … …  
    705739
    706740    sz = exp[idx++];
    707     if (sz > AEAD_MAX_IMP_SZ || sz + idx > len) {
     741    if (sz > sizeof(keys->aead_enc_imp_IV) || sz + idx > len) {
    708742        return BUFFER_E;
    709743    }
    … …  
    741775#ifndef NO_DH
    742776    c16toa(options->minDhKeySz, exp + idx); idx += OPAQUE16_LEN;
     777    c16toa(options->maxDhKeySz, exp + idx); idx += OPAQUE16_LEN;
    743778    c16toa(options->dhKeySz, exp + idx);    idx += OPAQUE16_LEN;
    744779#else
     780    c16toa(zero, exp + idx); idx += OPAQUE16_LEN;
    745781    c16toa(zero, exp + idx); idx += OPAQUE16_LEN;
    746782    c16toa(zero, exp + idx); idx += OPAQUE16_LEN;
    … …  
    904940#ifndef NO_DH
    905941    ato16(exp + idx, &(options->minDhKeySz)); idx += OPAQUE16_LEN;
     942    ato16(exp + idx, &(options->maxDhKeySz)); idx += OPAQUE16_LEN;
    906943    ato16(exp + idx, &(options->dhKeySz));    idx += OPAQUE16_LEN;
    907944#else
     945    idx += OPAQUE16_LEN;
    908946    idx += OPAQUE16_LEN;
    909947    idx += OPAQUE16_LEN;
    … …  
    13121350    }
    13131351
    1314     /* do not allow stream ciphers with DTLS */
    1315     if (ssl->specs.cipher_type == stream) {
     1352    /* do not allow stream ciphers with DTLS, except for NULL cipher */
     1353    if (ssl->specs.cipher_type == stream &&
     1354        ssl->specs.bulk_cipher_algorithm != wolfssl_cipher_null) {
    13161355        WOLFSSL_MSG("Can not import stream ciphers for DTLS");
    13171356        return SANITY_CIPHER_E;
    … …  
    13311370}
    13321371
     1372#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_EITHER_SIDE)
     1373int InitSSL_Side(WOLFSSL* ssl, word16 side)
     1374{
     1375    if (ssl == NULL)
     1376        return BAD_FUNC_ARG;
     1377
     1378    /* set side */
     1379    ssl->options.side = side;
     1380
     1381    /* reset options that are side specific */
     1382#ifdef HAVE_NTRU
     1383    if (ssl->options.side == WOLFSSL_CLIENT_END) {
     1384        ssl->options.haveNTRU = 1;      /* always on client side */
     1385                                        /* server can turn on by loading key */
     1386    }
     1387#endif
     1388#ifdef HAVE_ECC
     1389    if (ssl->options.side == WOLFSSL_CLIENT_END) {
     1390        ssl->options.haveECDSAsig  = 1; /* always on client side */
     1391        ssl->options.haveECC = 1;       /* server turns on with ECC key cert */
     1392        ssl->options.haveStaticECC = 1; /* server can turn on by loading key */
     1393    }
     1394#elif defined(HAVE_ED25519)
     1395    if (ssl->options.side == WOLFSSL_CLIENT_END) {
     1396        ssl->options.haveECDSAsig  = 1; /* always on client side */
     1397        ssl->options.haveECC  = 1;      /* server turns on with ECC key cert */
     1398    }
     1399#endif
     1400
     1401#if defined(HAVE_EXTENDED_MASTER) && !defined(NO_WOLFSSL_CLIENT)
     1402    if (ssl->options.side == WOLFSSL_CLIENT_END) {
     1403        if ((ssl->ctx->method->version.major == SSLv3_MAJOR) &&
     1404             (ssl->ctx->method->version.minor >= TLSv1_MINOR)) {
     1405            ssl->options.haveEMS = 1;
     1406        }
     1407    #ifdef WOLFSSL_DTLS
     1408        if (ssl->ctx->method->version.major == DTLS_MAJOR)
     1409            ssl->options.haveEMS = 1;
     1410    #endif /* WOLFSSL_DTLS */
     1411    }
     1412#endif /* HAVE_EXTENDED_MASTER && !NO_WOLFSSL_CLIENT */
     1413
     1414    return InitSSL_Suites(ssl);
     1415}
     1416#endif /* OPENSSL_EXTRA || WOLFSSL_EITHER_SIDE */
    13331417
    13341418/* Initialize SSL context, return 0 on success */
    … …  
    13431427    ctx->heap     = ctx;        /* defaults to self */
    13441428    ctx->timeout  = WOLFSSL_SESSION_TIMEOUT;
    1345     ctx->minDowngrade = TLSv1_MINOR;     /* current default */
     1429    ctx->minDowngrade = WOLFSSL_MIN_DOWNGRADE; /* current default: TLSv1_MINOR */
    13461430
    13471431    if (wc_InitMutex(&ctx->countMutex) < 0) {
    … …  
    13531437#ifndef NO_DH
    13541438    ctx->minDhKeySz  = MIN_DHKEY_SZ;
     1439    ctx->maxDhKeySz  = MAX_DHKEY_SZ;
    13551440#endif
    13561441#ifndef NO_RSA
    … …  
    13631448#ifdef OPENSSL_EXTRA
    13641449    ctx->verifyDepth = MAX_CHAIN_DEPTH;
     1450    ctx->cbioFlag = WOLFSSL_CBIO_NONE;
    13651451#endif
    13661452
    … …  
    13781464            #endif
    13791465        #endif
     1466    #elif defined WOLFSSL_UIP
     1467        ctx->CBIORecv = uIPReceive;
     1468        ctx->CBIOSend = uIPSend;
     1469        #ifdef WOLFSSL_DTLS
     1470        if (method->version.major == DTLS_MAJOR) {
     1471            ctx->CBIOSendTo = uIPSendTo;
     1472            ctx->CBIORecvFrom = uIPRecvFrom;
     1473        }
     1474        #endif
    13801475    #else
    13811476        ctx->CBIORecv = EmbedReceive;
    … …  
    13971492    ctx->CBIORecv = NetX_Receive;
    13981493    ctx->CBIOSend = NetX_Send;
     1494#elif defined(WOLFSSL_APACHE_MYNEWT) && !defined(WOLFSSL_LWIP)
     1495    ctx->CBIORecv = Mynewt_Receive;
     1496    ctx->CBIOSend = Mynewt_Send;
    13991497#endif
    14001498
    14011499#ifdef HAVE_NTRU
    14021500    if (method->side == WOLFSSL_CLIENT_END)
    1403         ctx->haveNTRU = 1;           /* always on cliet side */
     1501        ctx->haveNTRU = 1;           /* always on client side */
    14041502                                     /* server can turn on by loading key */
    14051503#endif
    14061504#ifdef HAVE_ECC
    14071505    if (method->side == WOLFSSL_CLIENT_END) {
    1408         ctx->haveECDSAsig  = 1;        /* always on cliet side */
     1506        ctx->haveECDSAsig  = 1;        /* always on client side */
    14091507        ctx->haveECC  = 1;             /* server turns on with ECC key cert */
    14101508        ctx->haveStaticECC = 1;        /* server can turn on by loading key */
     1509    }
     1510#elif defined(HAVE_ED25519)
     1511    if (method->side == WOLFSSL_CLIENT_END) {
     1512        ctx->haveECDSAsig  = 1;        /* always on client side */
     1513        ctx->haveECC  = 1;             /* server turns on with ECC key cert */
    14111514    }
    14121515#endif
    … …  
    14571560
    14581561    ctx->heap = heap; /* wolfSSL_CTX_load_static_memory sets */
     1562    ctx->verifyDepth = MAX_CHAIN_DEPTH;
    14591563
    14601564    return ret;
    … …  
    14741578
    14751579    XFREE(ctx->method, ctx->heap, DYNAMIC_TYPE_METHOD);
    1476     if (ctx->suites)
     1580    ctx->method = NULL;
     1581    if (ctx->suites) {
    14771582        XFREE(ctx->suites, ctx->heap, DYNAMIC_TYPE_SUITES);
     1583        ctx->suites = NULL;
     1584    }
    14781585
    14791586#ifndef NO_DH
    14801587    XFREE(ctx->serverDH_G.buffer, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY);
     1588    ctx->serverDH_G.buffer = NULL;
    14811589    XFREE(ctx->serverDH_P.buffer, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY);
     1590    ctx->serverDH_P.buffer = NULL;
    14821591#endif /* !NO_DH */
    14831592
    … …  
    14861595        wc_FreeRng(ctx->rng);
    14871596        XFREE(ctx->rng, ctx->heap, DYNAMIC_TYPE_RNG);
     1597        ctx->rng = NULL;
    14881598    }
    14891599#endif /* SINGLE_THREADED */
    … …  
    14961606            FreeX509(ctx->ourCert);
    14971607            XFREE(ctx->ourCert, ctx->heap, DYNAMIC_TYPE_X509);
     1608            ctx->ourCert = NULL;
    14981609        }
    14991610    #endif /* KEEP_OUR_CERT */
    15001611    FreeDer(&ctx->certChain);
    15011612    wolfSSL_CertManagerFree(ctx->cm);
     1613    ctx->cm = NULL;
    15021614    #ifdef OPENSSL_EXTRA
     1615        /* ctx->cm was free'd so cm of x509 store should now be NULL */
     1616        if (ctx->x509_store_pt != NULL) {
     1617            ctx->x509_store_pt->cm = NULL;
     1618        }
     1619        wolfSSL_X509_STORE_free(ctx->x509_store_pt);
    15031620        while (ctx->ca_names != NULL) {
    15041621            WOLFSSL_STACK *next = ctx->ca_names->next;
    15051622            wolfSSL_X509_NAME_free(ctx->ca_names->data.name);
    1506             XFREE(ctx->ca_names->data.name, NULL, DYNAMIC_TYPE_OPENSSL);
    15071623            XFREE(ctx->ca_names, NULL, DYNAMIC_TYPE_OPENSSL);
    15081624            ctx->ca_names = next;
    15091625        }
    15101626    #endif
    1511     #if defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY)
     1627    #if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY)
    15121628        while (ctx->x509Chain != NULL) {
    15131629            WOLFSSL_STACK *next = ctx->x509Chain->next;
    … …  
    15361652            FreeOcspRequest(ctx->chainOcspRequest[i]);
    15371653            XFREE(ctx->chainOcspRequest[i], ctx->heap, DYNAMIC_TYPE_OCSP_REQUEST);
     1654            ctx->chainOcspRequest[i] = NULL;
    15381655        }
    15391656    }
    … …  
    15421659
    15431660#endif /* HAVE_TLS_EXTENSIONS */
    1544 
     1661#ifdef OPENSSL_EXTRA
     1662    if(ctx->alpn_cli_protos) {
     1663        XFREE((void *)ctx->alpn_cli_protos, NULL, DYNAMIC_TYPE_OPENSSL);
     1664        ctx->alpn_cli_protos = NULL;
     1665    }
     1666#endif
    15451667#ifdef WOLFSSL_STATIC_MEMORY
    15461668    if (ctx->heap != NULL) {
    … …  
    16221744    ssl->decrypt.chacha = NULL;
    16231745#endif
    1624 #ifdef HAVE_POLY1305
     1746#if defined(HAVE_POLY1305) && defined(HAVE_ONE_TIME_AUTH)
    16251747    ssl->auth.poly1305 = NULL;
    16261748#endif
    … …  
    16811803    XFREE(ssl->decrypt.chacha, ssl->heap, DYNAMIC_TYPE_CIPHER);
    16821804#endif
    1683 #ifdef HAVE_POLY1305
     1805#if defined(HAVE_POLY1305) && defined(HAVE_ONE_TIME_AUTH)
    16841806    XFREE(ssl->auth.poly1305, ssl->heap, DYNAMIC_TYPE_CIPHER);
    16851807#endif
    … …  
    16931815void InitCipherSpecs(CipherSpecs* cs)
    16941816{
     1817    XMEMSET(cs, 0, sizeof(CipherSpecs));
     1818
    16951819    cs->bulk_cipher_algorithm = INVALID_BYTE;
    16961820    cs->cipher_type           = INVALID_BYTE;
    … …  
    16981822    cs->kea                   = INVALID_BYTE;
    16991823    cs->sig_algo              = INVALID_BYTE;
    1700 
    1701     cs->hash_size   = 0;
    1702     cs->static_ecdh = 0;
    1703     cs->key_size    = 0;
    1704     cs->iv_size     = 0;
    1705     cs->block_size  = 0;
    17061824}
    17071825
    … …  
    17141832    (void)keySz;
    17151833
     1834#if defined(HAVE_ECC) || defined(HAVE_ED25519)
    17161835    if (haveECDSAsig) {
     1836    #ifdef HAVE_ECC
    17171837        #ifdef WOLFSSL_SHA512
    17181838            suites->hashSigAlgo[idx++] = sha512_mac;
    … …  
    17321852            suites->hashSigAlgo[idx++] = ecc_dsa_sa_algo;
    17331853        #endif
     1854    #endif
    17341855        #ifdef HAVE_ED25519
    17351856            suites->hashSigAlgo[idx++] = ED25519_SA_MAJOR;
    … …  
    17371858        #endif
    17381859    }
     1860#endif /* HAVE_ECC || HAVE_ED25519 */
    17391861
    17401862    if (haveRSAsig) {
    … …  
    17421864            if (tls1_2) {
    17431865            #ifdef WOLFSSL_SHA512
    1744                 if (keySz >= MIN_RSA_SHA512_PSS_BITS) {
    17451866                    suites->hashSigAlgo[idx++] = rsa_pss_sa_algo;
    17461867                    suites->hashSigAlgo[idx++] = sha512_mac;
    1747                 }
    17481868            #endif
    17491869            #ifdef WOLFSSL_SHA384
    1750                 if (keySz >= MIN_RSA_SHA384_PSS_BITS) {
    17511870                  suites->hashSigAlgo[idx++] = rsa_pss_sa_algo;
    17521871                  suites->hashSigAlgo[idx++] = sha384_mac;
    1753                 }
    17541872            #endif
    17551873            #ifndef NO_SHA256
    … …  
    17781896    }
    17791897
     1898        #ifdef HAVE_ANON
    17801899    if (haveAnon) {
    1781         #ifdef HAVE_ANON
    17821900            suites->hashSigAlgo[idx++] = sha_mac;
    17831901            suites->hashSigAlgo[idx++] = anonymous_sa_algo;
    1784         #endif
    1785     }
    1786 
     1902    }
     1903#endif
     1904
     1905    (void)haveAnon;
     1906    (void)haveECDSAsig;
    17871907    suites->hashSigAlgoSz = (word16)idx;
    17881908}
    … …  
    18101930    (void)haveStaticECC;
    18111931    (void)haveECC;
     1932    (void)side;
     1933    (void)haveRSA;    /* some builds won't read */
     1934    (void)haveRSAsig; /* non ecc builds won't read */
    18121935
    18131936    if (suites == NULL) {
    … …  
    18191942        return;      /* trust user settings, don't override */
    18201943
     1944#ifdef WOLFSSL_TLS13
     1945#ifdef BUILD_TLS_AES_128_GCM_SHA256
     1946    if (tls1_3) {
     1947        suites->suites[idx++] = TLS13_BYTE;
     1948        suites->suites[idx++] = TLS_AES_128_GCM_SHA256;
     1949    }
     1950#endif
     1951
     1952#ifdef BUILD_TLS_AES_256_GCM_SHA384
     1953    if (tls1_3) {
     1954        suites->suites[idx++] = TLS13_BYTE;
     1955        suites->suites[idx++] = TLS_AES_256_GCM_SHA384;
     1956    }
     1957#endif
     1958
     1959#ifdef BUILD_TLS_CHACHA20_POLY1305_SHA256
     1960    if (tls1_3) {
     1961        suites->suites[idx++] = TLS13_BYTE;
     1962        suites->suites[idx++] = TLS_CHACHA20_POLY1305_SHA256;
     1963    }
     1964#endif
     1965
     1966#ifdef BUILD_TLS_AES_128_CCM_SHA256
     1967    if (tls1_3) {
     1968        suites->suites[idx++] = TLS13_BYTE;
     1969        suites->suites[idx++] = TLS_AES_128_CCM_SHA256;
     1970    }
     1971#endif
     1972
     1973#ifdef BUILD_TLS_AES_128_CCM_8_SHA256
     1974    if (tls1_3) {
     1975        suites->suites[idx++] = TLS13_BYTE;
     1976        suites->suites[idx++] = TLS_AES_128_CCM_8_SHA256;
     1977    }
     1978#endif
     1979#endif /* WOLFSSL_TLS13 */
     1980
     1981#ifndef WOLFSSL_NO_TLS12
     1982
     1983#if !defined(NO_WOLFSSL_SERVER) && !defined(NO_RSA)
    18211984    if (side == WOLFSSL_SERVER_END && haveStaticECC) {
    18221985        haveRSA = 0;   /* can't do RSA with ECDSA key */
    1823         (void)haveRSA; /* some builds won't read */
    18241986    }
    18251987
    18261988    if (side == WOLFSSL_SERVER_END && haveECDSAsig) {
    18271989        haveRSAsig = 0;     /* can't have RSA sig if signed by ECDSA */
    1828         (void)haveRSAsig;   /* non ecc builds won't read */
    1829     }
     1990    }
     1991#endif /* !NO_WOLFSSL_SERVER */
    18301992
    18311993#ifdef WOLFSSL_DTLS
    … …  
    18422004#ifdef HAVE_RENEGOTIATION_INDICATION
    18432005    if (side == WOLFSSL_CLIENT_END) {
    1844         suites->suites[idx++] = 0;
     2006        suites->suites[idx++] = CIPHER_BYTE;
    18452007        suites->suites[idx++] = TLS_EMPTY_RENEGOTIATION_INFO_SCSV;
    18462008    }
    … …  
    18562018#ifdef BUILD_TLS_NTRU_RSA_WITH_AES_256_CBC_SHA
    18572019   if (tls && haveNTRU && haveRSA) {
    1858         suites->suites[idx++] = 0;
     2020        suites->suites[idx++] = CIPHER_BYTE;
    18592021        suites->suites[idx++] = TLS_NTRU_RSA_WITH_AES_256_CBC_SHA;
    18602022   }
    … …  
    18632025#ifdef BUILD_TLS_NTRU_RSA_WITH_AES_128_CBC_SHA
    18642026    if (tls && haveNTRU && haveRSA) {
    1865         suites->suites[idx++] = 0;
     2027        suites->suites[idx++] = CIPHER_BYTE;
    18662028        suites->suites[idx++] = TLS_NTRU_RSA_WITH_AES_128_CBC_SHA;
    18672029    }
    … …  
    18702032#ifdef BUILD_TLS_NTRU_RSA_WITH_RC4_128_SHA
    18712033    if (!dtls && tls && haveNTRU && haveRSA) {
    1872         suites->suites[idx++] = 0;
     2034        suites->suites[idx++] = CIPHER_BYTE;
    18732035        suites->suites[idx++] = TLS_NTRU_RSA_WITH_RC4_128_SHA;
    18742036    }
    … …  
    18772039#ifdef BUILD_TLS_NTRU_RSA_WITH_3DES_EDE_CBC_SHA
    18782040    if (tls && haveNTRU && haveRSA) {
    1879         suites->suites[idx++] = 0;
     2041        suites->suites[idx++] = CIPHER_BYTE;
    18802042        suites->suites[idx++] = TLS_NTRU_RSA_WITH_3DES_EDE_CBC_SHA;
    18812043    }
    18822044#endif
    1883 
    1884 #ifdef WOLFSSL_TLS13
    1885 #ifdef BUILD_TLS_AES_128_GCM_SHA256
    1886     if (tls1_3) {
    1887         suites->suites[idx++] = TLS13_BYTE;
    1888         suites->suites[idx++] = TLS_AES_128_GCM_SHA256;
    1889     }
    1890 #endif
    1891 
    1892 #ifdef BUILD_TLS_AES_256_GCM_SHA384
    1893     if (tls1_3) {
    1894         suites->suites[idx++] = TLS13_BYTE;
    1895         suites->suites[idx++] = TLS_AES_256_GCM_SHA384;
    1896     }
    1897 #endif
    1898 
    1899 #ifdef BUILD_TLS_CHACHA20_POLY1305_SHA256
    1900     if (tls1_3) {
    1901         suites->suites[idx++] = TLS13_BYTE;
    1902         suites->suites[idx++] = TLS_CHACHA20_POLY1305_SHA256;
    1903     }
    1904 #endif
    1905 
    1906 #ifdef BUILD_TLS_AES_128_CCM_SHA256
    1907     if (tls1_3) {
    1908         suites->suites[idx++] = TLS13_BYTE;
    1909         suites->suites[idx++] = TLS_AES_128_CCM_SHA256;
    1910     }
    1911 #endif
    1912 
    1913 #ifdef BUILD_TLS_AES_128_CCM_8_SHA256
    1914     if (tls1_3) {
    1915         suites->suites[idx++] = TLS13_BYTE;
    1916         suites->suites[idx++] = TLS_AES_128_CCM_8_SHA256;
    1917     }
    1918 #endif
    1919 #endif /* WOLFSSL_TLS13 */
    19202045
    19212046#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
    … …  
    19492074#ifdef BUILD_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
    19502075    if (tls1_2 && haveDH && haveRSA) {
    1951         suites->suites[idx++] = 0;
     2076        suites->suites[idx++] = CIPHER_BYTE;
    19522077        suites->suites[idx++] = TLS_DHE_RSA_WITH_AES_256_GCM_SHA384;
    19532078    }
    … …  
    19562081#ifdef BUILD_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
    19572082    if (tls1_2 && haveDH && haveRSA) {
    1958         suites->suites[idx++] = 0;
     2083        suites->suites[idx++] = CIPHER_BYTE;
    19592084        suites->suites[idx++] = TLS_DHE_RSA_WITH_AES_128_GCM_SHA256;
    19602085    }
    … …  
    19632088#ifdef BUILD_TLS_RSA_WITH_AES_256_GCM_SHA384
    19642089    if (tls1_2 && haveRSA) {
    1965         suites->suites[idx++] = 0;
     2090        suites->suites[idx++] = CIPHER_BYTE;
    19662091        suites->suites[idx++] = TLS_RSA_WITH_AES_256_GCM_SHA384;
    19672092    }
    … …  
    19702095#ifdef BUILD_TLS_RSA_WITH_AES_128_GCM_SHA256
    19712096    if (tls1_2 && haveRSA) {
    1972         suites->suites[idx++] = 0;
     2097        suites->suites[idx++] = CIPHER_BYTE;
    19732098        suites->suites[idx++] = TLS_RSA_WITH_AES_128_GCM_SHA256;
    19742099    }
    … …  
    20052130#ifdef BUILD_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384
    20062131    if (tls1_2 && haveDH && havePSK) {
    2007         suites->suites[idx++] = 0;
     2132        suites->suites[idx++] = CIPHER_BYTE;
    20082133        suites->suites[idx++] = TLS_DHE_PSK_WITH_AES_256_GCM_SHA384;
     2134    }
     2135#endif
     2136
     2137#ifdef BUILD_TLS_DH_anon_WITH_AES_128_CBC_SHA
     2138    if (tls1_2 && haveDH) {
     2139      suites->suites[idx++] = CIPHER_BYTE;
     2140      suites->suites[idx++] = TLS_DH_anon_WITH_AES_128_CBC_SHA;
     2141    }
     2142#endif
     2143
     2144#ifdef BUILD_TLS_DH_anon_WITH_AES_256_GCM_SHA384
     2145    if (tls1_2 && haveDH) {
     2146      suites->suites[idx++] = CIPHER_BYTE;
     2147      suites->suites[idx++] = TLS_DH_anon_WITH_AES_256_GCM_SHA384;
    20092148    }
    20102149#endif
    … …  
    20122151#ifdef BUILD_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256
    20132152    if (tls1_2 && haveDH && havePSK) {
    2014         suites->suites[idx++] = 0;
     2153        suites->suites[idx++] = CIPHER_BYTE;
    20152154        suites->suites[idx++] = TLS_DHE_PSK_WITH_AES_128_GCM_SHA256;
    20162155    }
    … …  
    20192158#ifdef BUILD_TLS_PSK_WITH_AES_256_GCM_SHA384
    20202159    if (tls1_2 && havePSK) {
    2021         suites->suites[idx++] = 0;
     2160        suites->suites[idx++] = CIPHER_BYTE;
    20222161        suites->suites[idx++] = TLS_PSK_WITH_AES_256_GCM_SHA384;
    20232162    }
    … …  
    20262165#ifdef BUILD_TLS_PSK_WITH_AES_128_GCM_SHA256
    20272166    if (tls1_2 && havePSK) {
    2028         suites->suites[idx++] = 0;
     2167        suites->suites[idx++] = CIPHER_BYTE;
    20292168        suites->suites[idx++] = TLS_PSK_WITH_AES_128_GCM_SHA256;
    20302169    }
    … …  
    20562195#ifdef BUILD_TLS_DHE_RSA_WITH_AES_256_CBC_SHA
    20572196    if (tls && haveDH && haveRSA) {
    2058         suites->suites[idx++] = 0;
     2197        suites->suites[idx++] = CIPHER_BYTE;
    20592198        suites->suites[idx++] = TLS_DHE_RSA_WITH_AES_256_CBC_SHA;
    20602199    }
    … …  
    22672406#ifdef BUILD_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
    22682407    if (tls && haveDH && haveRSA) {
    2269         suites->suites[idx++] = 0;
     2408        suites->suites[idx++] = CIPHER_BYTE;
    22702409        suites->suites[idx++] = TLS_DHE_RSA_WITH_AES_256_CBC_SHA256;
    22712410    }
    … …  
    22742413#ifdef BUILD_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
    22752414    if (tls && haveDH && haveRSA) {
    2276         suites->suites[idx++] = 0;
     2415        suites->suites[idx++] = CIPHER_BYTE;
    22772416        suites->suites[idx++] = TLS_DHE_RSA_WITH_AES_128_CBC_SHA256;
    22782417    }
    … …  
    22832422#ifdef BUILD_TLS_DHE_RSA_WITH_AES_256_CBC_SHA
    22842423    if (tls && haveDH && haveRSA) {
    2285         suites->suites[idx++] = 0;
     2424        suites->suites[idx++] = CIPHER_BYTE;
    22862425        suites->suites[idx++] = TLS_DHE_RSA_WITH_AES_256_CBC_SHA;
    22872426    }
    … …  
    22912430#ifdef BUILD_TLS_DHE_RSA_WITH_AES_128_CBC_SHA
    22922431    if (tls && haveDH && haveRSA) {
    2293         suites->suites[idx++] = 0;
     2432        suites->suites[idx++] = CIPHER_BYTE;
    22942433        suites->suites[idx++] = TLS_DHE_RSA_WITH_AES_128_CBC_SHA;
    22952434    }
    … …  
    22982437#ifdef BUILD_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA
    22992438    if (tls && haveDH && haveRSA) {
    2300         suites->suites[idx++] = 0;
     2439        suites->suites[idx++] = CIPHER_BYTE;
    23012440        suites->suites[idx++] = TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA;
    23022441    }
    … …  
    23052444#ifdef BUILD_TLS_RSA_WITH_AES_256_CBC_SHA256
    23062445    if (tls && haveRSA) {
    2307         suites->suites[idx++] = 0;
     2446        suites->suites[idx++] = CIPHER_BYTE;
    23082447        suites->suites[idx++] = TLS_RSA_WITH_AES_256_CBC_SHA256;
    23092448    }
    … …  
    23122451#ifdef BUILD_TLS_RSA_WITH_AES_128_CBC_SHA256
    23132452    if (tls && haveRSA) {
    2314         suites->suites[idx++] = 0;
     2453        suites->suites[idx++] = CIPHER_BYTE;
    23152454        suites->suites[idx++] = TLS_RSA_WITH_AES_128_CBC_SHA256;
    23162455    }
    … …  
    23192458#ifdef BUILD_TLS_RSA_WITH_AES_256_CBC_SHA
    23202459    if (tls && haveRSA) {
    2321         suites->suites[idx++] = 0;
     2460        suites->suites[idx++] = CIPHER_BYTE;
    23222461        suites->suites[idx++] = TLS_RSA_WITH_AES_256_CBC_SHA;
    23232462    }
    … …  
    23262465#ifdef BUILD_TLS_RSA_WITH_AES_128_CBC_SHA
    23272466    if (tls && haveRSA) {
    2328         suites->suites[idx++] = 0;
     2467        suites->suites[idx++] = CIPHER_BYTE;
    23292468        suites->suites[idx++] = TLS_RSA_WITH_AES_128_CBC_SHA;
    23302469    }
    … …  
    23622501#ifdef BUILD_TLS_RSA_WITH_NULL_SHA
    23632502    if (tls && haveRSA) {
    2364         suites->suites[idx++] = 0;
     2503        suites->suites[idx++] = CIPHER_BYTE;
    23652504        suites->suites[idx++] = TLS_RSA_WITH_NULL_SHA;
    23662505    }
    … …  
    23692508#ifdef BUILD_TLS_RSA_WITH_NULL_SHA256
    23702509    if (tls && haveRSA) {
    2371         suites->suites[idx++] = 0;
     2510        suites->suites[idx++] = CIPHER_BYTE;
    23722511        suites->suites[idx++] = TLS_RSA_WITH_NULL_SHA256;
    23732512    }
    … …  
    23762515#ifdef BUILD_TLS_PSK_WITH_AES_256_CBC_SHA
    23772516    if (tls && havePSK) {
    2378         suites->suites[idx++] = 0;
     2517        suites->suites[idx++] = CIPHER_BYTE;
    23792518        suites->suites[idx++] = TLS_PSK_WITH_AES_256_CBC_SHA;
    23802519    }
    … …  
    23832522#ifdef BUILD_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384
    23842523    if (tls && haveDH && havePSK) {
    2385         suites->suites[idx++] = 0;
     2524        suites->suites[idx++] = CIPHER_BYTE;
    23862525        suites->suites[idx++] = TLS_DHE_PSK_WITH_AES_256_CBC_SHA384;
    23872526    }
    … …  
    23902529#ifdef BUILD_TLS_PSK_WITH_AES_256_CBC_SHA384
    23912530    if (tls && havePSK) {
    2392         suites->suites[idx++] = 0;
     2531        suites->suites[idx++] = CIPHER_BYTE;
    23932532        suites->suites[idx++] = TLS_PSK_WITH_AES_256_CBC_SHA384;
    23942533    }
    … …  
    23972536#ifdef BUILD_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256
    23982537    if (tls && haveDH && havePSK) {
    2399         suites->suites[idx++] = 0;
     2538        suites->suites[idx++] = CIPHER_BYTE;
    24002539        suites->suites[idx++] = TLS_DHE_PSK_WITH_AES_128_CBC_SHA256;
    24012540    }
    … …  
    24042543#ifdef BUILD_TLS_PSK_WITH_AES_128_CBC_SHA256
    24052544    if (tls && havePSK) {
    2406         suites->suites[idx++] = 0;
     2545        suites->suites[idx++] = CIPHER_BYTE;
    24072546        suites->suites[idx++] = TLS_PSK_WITH_AES_128_CBC_SHA256;
    24082547    }
    … …  
    24112550#ifdef BUILD_TLS_PSK_WITH_AES_128_CBC_SHA
    24122551    if (tls && havePSK) {
    2413         suites->suites[idx++] = 0;
     2552        suites->suites[idx++] = CIPHER_BYTE;
    24142553        suites->suites[idx++] = TLS_PSK_WITH_AES_128_CBC_SHA;
    24152554    }
    … …  
    24882627#ifdef BUILD_TLS_DHE_PSK_WITH_NULL_SHA384
    24892628    if (tls && haveDH && havePSK) {
    2490         suites->suites[idx++] = 0;
     2629        suites->suites[idx++] = CIPHER_BYTE;
    24912630        suites->suites[idx++] = TLS_DHE_PSK_WITH_NULL_SHA384;
    24922631    }
    … …  
    24952634#ifdef BUILD_TLS_PSK_WITH_NULL_SHA384
    24962635    if (tls && havePSK) {
    2497         suites->suites[idx++] = 0;
     2636        suites->suites[idx++] = CIPHER_BYTE;
    24982637        suites->suites[idx++] = TLS_PSK_WITH_NULL_SHA384;
    24992638    }
    … …  
    25092648#ifdef BUILD_TLS_DHE_PSK_WITH_NULL_SHA256
    25102649    if (tls && haveDH && havePSK) {
    2511         suites->suites[idx++] = 0;
     2650        suites->suites[idx++] = CIPHER_BYTE;
    25122651        suites->suites[idx++] = TLS_DHE_PSK_WITH_NULL_SHA256;
    25132652    }
    … …  
    25162655#ifdef BUILD_TLS_PSK_WITH_NULL_SHA256
    25172656    if (tls && havePSK) {
    2518         suites->suites[idx++] = 0;
     2657        suites->suites[idx++] = CIPHER_BYTE;
    25192658        suites->suites[idx++] = TLS_PSK_WITH_NULL_SHA256;
    25202659    }
    … …  
    25232662#ifdef BUILD_TLS_PSK_WITH_NULL_SHA
    25242663    if (tls && havePSK) {
    2525         suites->suites[idx++] = 0;
     2664        suites->suites[idx++] = CIPHER_BYTE;
    25262665        suites->suites[idx++] = TLS_PSK_WITH_NULL_SHA;
    25272666    }
    … …  
    25302669#ifdef BUILD_SSL_RSA_WITH_RC4_128_SHA
    25312670    if (!dtls && haveRSA) {
    2532         suites->suites[idx++] = 0;
     2671        suites->suites[idx++] = CIPHER_BYTE;
    25332672        suites->suites[idx++] = SSL_RSA_WITH_RC4_128_SHA;
    25342673    }
    … …  
    25372676#ifdef BUILD_SSL_RSA_WITH_RC4_128_MD5
    25382677    if (!dtls && haveRSA) {
    2539         suites->suites[idx++] = 0;
     2678        suites->suites[idx++] = CIPHER_BYTE;
    25402679        suites->suites[idx++] = SSL_RSA_WITH_RC4_128_MD5;
    25412680    }
    … …  
    25442683#ifdef BUILD_SSL_RSA_WITH_3DES_EDE_CBC_SHA
    25452684    if (haveRSA ) {
    2546         suites->suites[idx++] = 0;
     2685        suites->suites[idx++] = CIPHER_BYTE;
    25472686        suites->suites[idx++] = SSL_RSA_WITH_3DES_EDE_CBC_SHA;
    25482687    }
    … …  
    25512690#ifdef BUILD_TLS_RSA_WITH_HC_128_MD5
    25522691    if (!dtls && tls && haveRSA) {
    2553         suites->suites[idx++] = 0;
     2692        suites->suites[idx++] = CIPHER_BYTE;
    25542693        suites->suites[idx++] = TLS_RSA_WITH_HC_128_MD5;
    25552694    }
    … …  
    25582697#ifdef BUILD_TLS_RSA_WITH_HC_128_SHA
    25592698    if (!dtls && tls && haveRSA) {
    2560         suites->suites[idx++] = 0;
     2699        suites->suites[idx++] = CIPHER_BYTE;
    25612700        suites->suites[idx++] = TLS_RSA_WITH_HC_128_SHA;
    25622701    }
    … …  
    25652704#ifdef BUILD_TLS_RSA_WITH_HC_128_B2B256
    25662705    if (!dtls && tls && haveRSA) {
    2567         suites->suites[idx++] = 0;
     2706        suites->suites[idx++] = CIPHER_BYTE;
    25682707        suites->suites[idx++] = TLS_RSA_WITH_HC_128_B2B256;
    25692708    }
    … …  
    25722711#ifdef BUILD_TLS_RSA_WITH_AES_128_CBC_B2B256
    25732712    if (tls && haveRSA) {
    2574         suites->suites[idx++] = 0;
     2713        suites->suites[idx++] = CIPHER_BYTE;
    25752714        suites->suites[idx++] = TLS_RSA_WITH_AES_128_CBC_B2B256;
    25762715    }
    … …  
    25792718#ifdef BUILD_TLS_RSA_WITH_AES_256_CBC_B2B256
    25802719    if (tls && haveRSA) {
    2581         suites->suites[idx++] = 0;
     2720        suites->suites[idx++] = CIPHER_BYTE;
    25822721        suites->suites[idx++] = TLS_RSA_WITH_AES_256_CBC_B2B256;
    25832722    }
    … …  
    25862725#ifdef BUILD_TLS_RSA_WITH_RABBIT_SHA
    25872726    if (!dtls && tls && haveRSA) {
    2588         suites->suites[idx++] = 0;
     2727        suites->suites[idx++] = CIPHER_BYTE;
    25892728        suites->suites[idx++] = TLS_RSA_WITH_RABBIT_SHA;
    25902729    }
    … …  
    25932732#ifdef BUILD_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA
    25942733    if (tls && haveRSA) {
    2595         suites->suites[idx++] = 0;
     2734        suites->suites[idx++] = CIPHER_BYTE;
    25962735        suites->suites[idx++] = TLS_RSA_WITH_CAMELLIA_128_CBC_SHA;
    25972736    }
    … …  
    26002739#ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA
    26012740    if (tls && haveDH && haveRSA) {
    2602         suites->suites[idx++] = 0;
     2741        suites->suites[idx++] = CIPHER_BYTE;
    26032742        suites->suites[idx++] = TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA;
    26042743    }
    … …  
    26072746#ifdef BUILD_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA
    26082747    if (tls && haveRSA) {
    2609         suites->suites[idx++] = 0;
     2748        suites->suites[idx++] = CIPHER_BYTE;
    26102749        suites->suites[idx++] = TLS_RSA_WITH_CAMELLIA_256_CBC_SHA;
    26112750    }
    … …  
    26142753#ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA
    26152754    if (tls && haveDH && haveRSA) {
    2616         suites->suites[idx++] = 0;
     2755        suites->suites[idx++] = CIPHER_BYTE;
    26172756        suites->suites[idx++] = TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA;
    26182757    }
    … …  
    26212760#ifdef BUILD_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256
    26222761    if (tls && haveRSA) {
    2623         suites->suites[idx++] = 0;
     2762        suites->suites[idx++] = CIPHER_BYTE;
    26242763        suites->suites[idx++] = TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256;
    26252764    }
    … …  
    26282767#ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256
    26292768    if (tls && haveDH && haveRSA) {
    2630         suites->suites[idx++] = 0;
     2769        suites->suites[idx++] = CIPHER_BYTE;
    26312770        suites->suites[idx++] = TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256;
    26322771    }
    … …  
    26352774#ifdef BUILD_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256
    26362775    if (tls && haveRSA) {
    2637         suites->suites[idx++] = 0;
     2776        suites->suites[idx++] = CIPHER_BYTE;
    26382777        suites->suites[idx++] = TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256;
    26392778    }
    … …  
    26422781#ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256
    26432782    if (tls && haveDH && haveRSA) {
    2644         suites->suites[idx++] = 0;
     2783        suites->suites[idx++] = CIPHER_BYTE;
    26452784        suites->suites[idx++] = TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256;
    26462785    }
    … …  
    26492788#ifdef BUILD_SSL_RSA_WITH_IDEA_CBC_SHA
    26502789    if (haveRSA) {
    2651         suites->suites[idx++] = 0;
     2790        suites->suites[idx++] = CIPHER_BYTE;
    26522791        suites->suites[idx++] = SSL_RSA_WITH_IDEA_CBC_SHA;
    26532792    }
    26542793#endif
     2794
     2795#endif /* !WOLFSSL_NO_TLS12 */
    26552796
    26562797    suites->suiteSz = idx;
    … …  
    26682809 * hsType   The signature type.
    26692810 */
    2670 static INLINE void DecodeSigAlg(const byte* input, byte* hashAlgo, byte* hsType)
     2811static WC_INLINE void DecodeSigAlg(const byte* input, byte* hashAlgo, byte* hsType)
    26712812{
    26722813    switch (input[0]) {
    … …  
    26972838#endif /* !NO_WOLFSSL_SERVER || !NO_CERTS */
    26982839
    2699 #if !defined(NO_DH) || defined(HAVE_ECC)
     2840#ifndef WOLFSSL_NO_TLS12
     2841#if !defined(NO_WOLFSSL_SERVER) || !defined(NO_WOLFSSL_CLIENT)
     2842#if !defined(NO_DH) || defined(HAVE_ECC) || defined(HAVE_CURVE25519) || \
     2843                                       (!defined(NO_RSA) && defined(WC_RSA_PSS))
    27002844
    27012845static enum wc_HashType HashAlgoToType(int hashAlgo)
    … …  
    27262870    return WC_HASH_TYPE_NONE;
    27272871}
     2872#endif /* !NO_DH || HAVE_ECC || (!NO_RSA && WC_RSA_PSS) */
     2873#endif /* !NO_WOLFSSL_SERVER || !NO_WOLFSSL_CLIENT */
     2874#endif /* !WOLFSSL_NO_TLS12 */
    27282875
    27292876#ifndef NO_CERTS
    2730 
    27312877
    27322878void InitX509Name(WOLFSSL_X509_NAME* name, int dynamicFlag)
    … …  
    27372883        name->name        = name->staticName;
    27382884        name->dynamicName = 0;
    2739 #ifdef OPENSSL_EXTRA
     2885        name->sz = 0;
     2886#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
    27402887        XMEMSET(&name->fullName, 0, sizeof(DecodedName));
    27412888        XMEMSET(&name->cnEntry,  0, sizeof(WOLFSSL_X509_NAME_ENTRY));
     2889        XMEMSET(&name->extra,    0, sizeof(name->extra));
    27422890        name->cnEntry.value = &(name->cnEntry.data); /* point to internal data*/
     2891        name->cnEntry.nid = ASN_COMMON_NAME;
    27432892        name->x509 = NULL;
    27442893#endif /* OPENSSL_EXTRA */
    … …  
    27522901        if (name->dynamicName)
    27532902            XFREE(name->name, heap, DYNAMIC_TYPE_SUBJECT_CN);
    2754 #ifdef OPENSSL_EXTRA
    2755         if (name->fullName.fullName != NULL)
     2903#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
     2904        {
     2905            int i;
     2906            if (name->fullName.fullName != NULL) {
    27562907            XFREE(name->fullName.fullName, heap, DYNAMIC_TYPE_X509);
    2757 #endif /* OPENSSL_EXTRA */
     2908                name->fullName.fullName = NULL;
     2909            }
     2910            for (i = 0; i < MAX_NAME_ENTRIES; i++) {
     2911                /* free ASN1 string data */
     2912                if (name->extra[i].set && name->extra[i].data.data != NULL) {
     2913                    XFREE(name->extra[i].data.data, heap, DYNAMIC_TYPE_OPENSSL);
     2914                }
     2915            }
     2916            wolfSSL_ASN1_OBJECT_free(&name->cnEntry.object);
     2917        }
     2918#endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL */
    27582919    }
    27592920    (void)heap;
    … …  
    27742935    InitX509Name(&x509->issuer, 0);
    27752936    InitX509Name(&x509->subject, 0);
    2776     x509->version        = 0;
    2777     x509->pubKey.buffer  = NULL;
    2778     x509->sig.buffer     = NULL;
    2779     x509->derCert        = NULL;
    2780     x509->altNames       = NULL;
    2781     x509->altNamesNext   = NULL;
    27822937    x509->dynamicMemory  = (byte)dynamicFlag;
    2783     x509->isCa           = 0;
    2784 #ifdef HAVE_ECC
    2785     x509->pkCurveOID = 0;
    2786 #endif /* HAVE_ECC */
    2787 #ifdef OPENSSL_EXTRA
    2788     x509->pathLength     = 0;
    2789     x509->basicConstSet  = 0;
    2790     x509->basicConstCrit = 0;
    2791     x509->basicConstPlSet = 0;
    2792     x509->subjAltNameSet = 0;
    2793     x509->subjAltNameCrit = 0;
    2794     x509->authKeyIdSet   = 0;
    2795     x509->authKeyIdCrit  = 0;
    2796     x509->authKeyId      = NULL;
    2797     x509->authKeyIdSz    = 0;
    2798     x509->subjKeyIdSet   = 0;
    2799     x509->subjKeyIdCrit  = 0;
    2800     x509->subjKeyId      = NULL;
    2801     x509->subjKeyIdSz    = 0;
    2802     x509->keyUsageSet    = 0;
    2803     x509->keyUsageCrit   = 0;
    2804     x509->keyUsage       = 0;
    2805     #ifdef WOLFSSL_SEP
    2806         x509->certPolicySet  = 0;
    2807         x509->certPolicyCrit = 0;
    2808     #endif /* WOLFSSL_SEP */
    2809 #endif /* OPENSSL_EXTRA */
    28102938}
    28112939
    … …  
    28232951    FreeDer(&x509->derCert);
    28242952    XFREE(x509->sig.buffer, x509->heap, DYNAMIC_TYPE_SIGNATURE);
    2825     #ifdef OPENSSL_EXTRA
     2953    #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
    28262954        XFREE(x509->authKeyId, x509->heap, DYNAMIC_TYPE_X509_EXT);
    28272955        XFREE(x509->subjKeyId, x509->heap, DYNAMIC_TYPE_X509_EXT);
    … …  
    28322960            XFREE(x509->extKeyUsageSrc, x509->heap, DYNAMIC_TYPE_X509_EXT);
    28332961        }
    2834     #endif /* OPENSSL_EXTRA */
     2962    #endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL */
    28352963    if (x509->altNames)
    2836         FreeAltNames(x509->altNames, NULL);
     2964        FreeAltNames(x509->altNames, x509->heap);
    28372965}
    28382966
    2839 #endif /* !NO_DH || HAVE_ECC */
    2840 
    2841 #if !defined(NO_RSA) || defined(HAVE_ECC) || defined(HAVE_ED25519)
     2967
     2968#if !defined(NO_WOLFSSL_SERVER) || !defined(NO_WOLFSSL_CLIENT)
     2969#if !defined(WOLFSSL_NO_TLS12) && !defined(WOLFSSL_NO_CLIENT_AUTH)
    28422970/* Encode the signature algorithm into buffer.
    28432971 *
    … …  
    28462974 * output    The buffer to encode into.
    28472975 */
    2848 static INLINE void EncodeSigAlg(byte hashAlgo, byte hsType, byte* output)
     2976static WC_INLINE void EncodeSigAlg(byte hashAlgo, byte hsType, byte* output)
    28492977{
    28502978    switch (hsType) {
    … …  
    28773005        /* ED448: 0x0808 */
    28783006    }
     3007    (void)hashAlgo;
     3008    (void)output;
    28793009}
     3010
    28803011static void SetDigest(WOLFSSL* ssl, int hashAlgo)
    28813012{
    … …  
    29073038    } /* switch */
    29083039}
    2909 #endif
     3040#endif /* !WOLFSSL_NO_TLS12 && !WOLFSSL_NO_CLIENT_AUTH */
     3041#endif /* !NO_WOLFSSL_SERVER || !NO_WOLFSSL_CLIENT */
     3042#endif /* !NO_CERTS */
    29103043
    29113044#ifndef NO_RSA
     3045#ifndef WOLFSSL_NO_TLS12
     3046#if !defined(NO_WOLFSSL_SERVER) || !defined(NO_WOLFSSL_CLIENT)
    29123047static int TypeHash(int hashAlgo)
    29133048{
    … …  
    29333068    return 0;
    29343069}
     3070#endif /* !NO_WOLFSSL_SERVER && !NO_WOLFSSL_CLIENT */
     3071#endif /* !WOLFSSL_NO_TLS12 */
    29353072
    29363073#if defined(WC_RSA_PSS)
    … …  
    29693106int RsaSign(WOLFSSL* ssl, const byte* in, word32 inSz, byte* out,
    29703107            word32* outSz, int sigAlgo, int hashAlgo, RsaKey* key,
    2971             const byte* keyBuf, word32 keySz, void* ctx)
     3108            DerBuffer* keyBufInfo)
    29723109{
    29733110    int ret;
     3111#ifdef HAVE_PK_CALLBACKS
     3112    const byte* keyBuf = NULL;
     3113    word32 keySz = 0;
     3114
     3115    if (keyBufInfo) {
     3116        keyBuf = keyBufInfo->buffer;
     3117        keySz = keyBufInfo->length;
     3118    }
     3119#endif
    29743120
    29753121    (void)ssl;
    2976     (void)keyBuf;
    2977     (void)keySz;
    2978     (void)ctx;
     3122    (void)keyBufInfo;
    29793123    (void)sigAlgo;
    29803124    (void)hashAlgo;
    … …  
    29833127
    29843128#ifdef WOLFSSL_ASYNC_CRYPT
    2985     /* intialize event */
     3129    /* initialize event */
    29863130    ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
    29873131    if (ret != 0)
    … …  
    30003144    #if defined(HAVE_PK_CALLBACKS)
    30013145        if (ssl->ctx->RsaPssSignCb) {
     3146            void* ctx = wolfSSL_GetRsaPssSignCtx(ssl);
    30023147            ret = ssl->ctx->RsaPssSignCb(ssl, in, inSz, out, outSz,
    30033148                                         TypeHash(hashAlgo), mgf,
    … …  
    30153160#if defined(HAVE_PK_CALLBACKS)
    30163161    if (ssl->ctx->RsaSignCb) {
     3162        void* ctx = wolfSSL_GetRsaSignCtx(ssl);
    30173163        ret = ssl->ctx->RsaSignCb(ssl, in, inSz, out, outSz, keyBuf, keySz,
    30183164                                                                          ctx);
    … …  
    30413187
    30423188int RsaVerify(WOLFSSL* ssl, byte* in, word32 inSz, byte** out, int sigAlgo,
    3043               int hashAlgo, RsaKey* key, const byte* keyBuf, word32 keySz,
    3044               void* ctx)
     3189              int hashAlgo, RsaKey* key, buffer* keyBufInfo)
    30453190{
    30463191    int ret;
     3192#ifdef HAVE_PK_CALLBACKS
     3193    const byte* keyBuf = NULL;
     3194    word32 keySz = 0;
     3195
     3196    if (keyBufInfo) {
     3197        keyBuf = keyBufInfo->buffer;
     3198        keySz = keyBufInfo->length;
     3199    }
     3200#endif
    30473201
    30483202    (void)ssl;
    3049     (void)keyBuf;
    3050     (void)keySz;
    3051     (void)ctx;
     3203    (void)keyBufInfo;
    30523204    (void)sigAlgo;
    30533205    (void)hashAlgo;
    … …  
    30563208
    30573209#ifdef WOLFSSL_ASYNC_CRYPT
    3058     /* intialize event */
     3210    /* initialize event */
    30593211    ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
    30603212    if (ret != 0)
    … …  
    30723224#ifdef HAVE_PK_CALLBACKS
    30733225        if (ssl->ctx->RsaPssVerifyCb) {
     3226            void* ctx = wolfSSL_GetRsaPssVerifyCtx(ssl);
    30743227            ret = ssl->ctx->RsaPssVerifyCb(ssl, in, inSz, out,
    30753228                                           TypeHash(hashAlgo), mgf,
    … …  
    30843237#ifdef HAVE_PK_CALLBACKS
    30853238    if (ssl->ctx->RsaVerifyCb) {
     3239        void* ctx = wolfSSL_GetRsaVerifyCtx(ssl);
    30863240        ret = ssl->ctx->RsaVerifyCb(ssl, in, inSz, out, keyBuf, keySz, ctx);
    30873241    }
    … …  
    31053259
    31063260/* Verify RSA signature, 0 on success */
     3261/* This function is used to check the sign result */
    31073262int VerifyRsaSign(WOLFSSL* ssl, byte* verifySig, word32 sigSz,
    3108     const byte* plain, word32 plainSz, int sigAlgo, int hashAlgo, RsaKey* key)
     3263    const byte* plain, word32 plainSz, int sigAlgo, int hashAlgo, RsaKey* key,
     3264    DerBuffer* keyBufInfo)
    31093265{
    31103266    byte* out = NULL;  /* inline result */
    31113267    int   ret;
     3268#ifdef HAVE_PK_CALLBACKS
     3269    const byte* keyBuf = NULL;
     3270    word32 keySz = 0;
     3271
     3272    if (keyBufInfo) {
     3273        keyBuf = keyBufInfo->buffer;
     3274        keySz = keyBufInfo->length;
     3275    }
     3276#endif
    31123277
    31133278    (void)ssl;
     3279    (void)keyBufInfo;
    31143280    (void)sigAlgo;
    31153281    (void)hashAlgo;
    … …  
    31173283    WOLFSSL_ENTER("VerifyRsaSign");
    31183284
    3119     if (verifySig == NULL || plain == NULL || key == NULL) {
     3285    if (verifySig == NULL || plain == NULL) {
    31203286        return BAD_FUNC_ARG;
    31213287    }
    … …  
    31273293
    31283294#ifdef WOLFSSL_ASYNC_CRYPT
    3129     /* intialize event */
     3295    /* initialize event */
     3296    if (key) {
    31303297    ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
    31313298    if (ret != 0)
    31323299        return ret;
     3300    }
    31333301#endif
    31343302
    … …  
    31413309        if (ret != 0)
    31423310            return ret;
     3311    #ifdef HAVE_PK_CALLBACKS
     3312        if (ssl->ctx->RsaPssSignCheckCb) {
     3313            /* The key buffer includes private/public portion,
     3314                but only public is used */
     3315            /* If HSM hardware is checking the signature result you can
     3316                optionally skip the sign check and return 0 */
     3317            /* The ctx here is the RsaSignCtx set using wolfSSL_SetRsaSignCtx */
     3318            void* ctx = wolfSSL_GetRsaPssSignCtx(ssl);
     3319            ret = ssl->ctx->RsaPssSignCheckCb(ssl, verifySig, sigSz, &out,
     3320                                           TypeHash(hashAlgo), mgf,
     3321                                           keyBuf, keySz, ctx);
     3322        }
     3323        else
     3324    #endif /* HAVE_PK_CALLBACKS */
     3325        {
    31433326        ret = wc_RsaPSS_VerifyInline(verifySig, sigSz, &out, hashType, mgf,
    31443327                                                                           key);
     3328        }
     3329
    31453330        if (ret > 0) {
    31463331            ret = wc_RsaPSS_CheckPadding(plain, plainSz, out, ret, hashType);
    … …  
    31503335    }
    31513336    else
    3152 #endif
     3337#endif /* WC_RSA_PSS */
     3338    {
     3339    #ifdef HAVE_PK_CALLBACKS
     3340        if (ssl->ctx->RsaSignCheckCb) {
     3341            /* The key buffer includes private/public portion,
     3342                but only public is used */
     3343            /* If HSM hardware is checking the signature result you can
     3344                optionally skip the sign check and return 0 */
     3345            /* The ctx here is the RsaSignCtx set using wolfSSL_SetRsaSignCtx */
     3346            void* ctx = wolfSSL_GetRsaSignCtx(ssl);
     3347            ret = ssl->ctx->RsaSignCheckCb(ssl, verifySig, sigSz, &out,
     3348                keyBuf, keySz, ctx);
     3349        }
     3350        else
     3351    #endif /* HAVE_PK_CALLBACKS */
    31533352    {
    31543353        ret = wc_RsaSSL_VerifyInline(verifySig, sigSz, &out, key);
     3354        }
     3355
    31553356        if (ret > 0) {
    31563357            if (ret != (int)plainSz || !out ||
    … …  
    31663367    /* Handle async pending response */
    31673368#ifdef WOLFSSL_ASYNC_CRYPT
    3168     if (ret == WC_PENDING_E) {
     3369    if (key && ret == WC_PENDING_E) {
    31693370        ret = wolfSSL_AsyncPush(ssl, &key->asyncDev);
    31703371    }
    … …  
    31763377}
    31773378
     3379#ifndef WOLFSSL_NO_TLS12
     3380
    31783381int RsaDec(WOLFSSL* ssl, byte* in, word32 inSz, byte** out, word32* outSz,
    3179     RsaKey* key, const byte* keyBuf, word32 keySz, void* ctx)
     3382    RsaKey* key, DerBuffer* keyBufInfo)
    31803383{
    31813384    int ret;
     3385#ifdef HAVE_PK_CALLBACKS
     3386    const byte* keyBuf = NULL;
     3387    word32 keySz = 0;
     3388
     3389    if (keyBufInfo) {
     3390        keyBuf = keyBufInfo->buffer;
     3391        keySz = keyBufInfo->length;
     3392    }
     3393#endif
    31823394
    31833395    (void)ssl;
    3184     (void)keyBuf;
    3185     (void)keySz;
    3186     (void)ctx;
     3396    (void)keyBufInfo;
    31873397
    31883398    WOLFSSL_ENTER("RsaDec");
    31893399
    31903400#ifdef WOLFSSL_ASYNC_CRYPT
    3191     /* intialize event */
     3401    /* initialize event */
    31923402    ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
    31933403    if (ret != 0)
    … …  
    31973407#ifdef HAVE_PK_CALLBACKS
    31983408    if (ssl->ctx->RsaDecCb) {
    3199             ret = ssl->ctx->RsaDecCb(ssl, in, inSz, out, keyBuf, keySz,
    3200                                                                     ctx);
     3409        void* ctx = wolfSSL_GetRsaDecCtx(ssl);
     3410        ret = ssl->ctx->RsaDecCb(ssl, in, inSz, out, keyBuf, keySz, ctx);
    32013411    }
    32023412    else
    … …  
    32303440
    32313441int RsaEnc(WOLFSSL* ssl, const byte* in, word32 inSz, byte* out, word32* outSz,
    3232     RsaKey* key, const byte* keyBuf, word32 keySz, void* ctx)
     3442    RsaKey* key, buffer* keyBufInfo)
    32333443{
    32343444    int ret;
     3445#ifdef HAVE_PK_CALLBACKS
     3446    const byte* keyBuf = NULL;
     3447    word32 keySz = 0;
     3448
     3449    if (keyBufInfo) {
     3450        keyBuf = keyBufInfo->buffer;
     3451        keySz = keyBufInfo->length;
     3452    }
     3453#endif
    32353454
    32363455    (void)ssl;
    3237     (void)keyBuf;
    3238     (void)keySz;
    3239     (void)ctx;
     3456    (void)keyBufInfo;
    32403457
    32413458    WOLFSSL_ENTER("RsaEnc");
    32423459
    32433460#ifdef WOLFSSL_ASYNC_CRYPT
    3244     /* intialize event */
     3461    /* initialize event */
    32453462    ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
    32463463    if (ret != 0)
    … …  
    32503467#ifdef HAVE_PK_CALLBACKS
    32513468    if (ssl->ctx->RsaEncCb) {
    3252             ret = ssl->ctx->RsaEncCb(ssl, in, inSz, out, outSz, keyBuf, keySz,
    3253                                                                         ctx);
     3469        void* ctx = wolfSSL_GetRsaEncCtx(ssl);
     3470        ret = ssl->ctx->RsaEncCb(ssl, in, inSz, out, outSz, keyBuf, keySz, ctx);
    32543471    }
    32553472    else
    … …  
    32773494}
    32783495
     3496#endif /* !WOLFSSL_NO_TLS12 */
     3497
    32793498#endif /* NO_RSA */
    32803499
    … …  
    32823501
    32833502int EccSign(WOLFSSL* ssl, const byte* in, word32 inSz, byte* out,
    3284     word32* outSz, ecc_key* key, byte* keyBuf, word32 keySz, void* ctx)
     3503    word32* outSz, ecc_key* key, DerBuffer* keyBufInfo)
    32853504{
    32863505    int ret;
     3506#ifdef HAVE_PK_CALLBACKS
     3507    const byte* keyBuf = NULL;
     3508    word32 keySz = 0;
     3509
     3510    if (keyBufInfo) {
     3511        keyBuf = keyBufInfo->buffer;
     3512        keySz = keyBufInfo->length;
     3513    }
     3514#endif
    32873515
    32883516    (void)ssl;
    3289     (void)keyBuf;
    3290     (void)keySz;
    3291     (void)ctx;
     3517    (void)keyBufInfo;
    32923518
    32933519    WOLFSSL_ENTER("EccSign");
    32943520
    32953521#ifdef WOLFSSL_ASYNC_CRYPT
    3296     /* intialize event */
     3522    /* initialize event */
    32973523    ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
    32983524    if (ret != 0)
    … …  
    33023528#if defined(HAVE_PK_CALLBACKS)
    33033529    if (ssl->ctx->EccSignCb) {
     3530        void* ctx = wolfSSL_GetEccSignCtx(ssl);
    33043531        ret = ssl->ctx->EccSignCb(ssl, in, inSz, out, outSz, keyBuf,
    33053532            keySz, ctx);
    … …  
    33243551
    33253552int EccVerify(WOLFSSL* ssl, const byte* in, word32 inSz, const byte* out,
    3326     word32 outSz, ecc_key* key, byte* keyBuf, word32 keySz,
    3327     void* ctx)
     3553    word32 outSz, ecc_key* key, buffer* keyBufInfo)
    33283554{
    33293555    int ret;
     3556#ifdef HAVE_PK_CALLBACKS
     3557    const byte* keyBuf = NULL;
     3558    word32 keySz = 0;
     3559
     3560    if (keyBufInfo) {
     3561        keyBuf = keyBufInfo->buffer;
     3562        keySz = keyBufInfo->length;
     3563    }
     3564#endif
    33303565
    33313566    (void)ssl;
    3332     (void)keyBuf;
    3333     (void)keySz;
    3334     (void)ctx;
     3567    (void)keyBufInfo;
    33353568
    33363569    WOLFSSL_ENTER("EccVerify");
    33373570
    33383571#ifdef WOLFSSL_ASYNC_CRYPT
    3339     /* intialize event */
     3572    /* initialize event */
    33403573    ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
    33413574    if (ret != 0)
    … …  
    33453578#ifdef HAVE_PK_CALLBACKS
    33463579    if (ssl->ctx->EccVerifyCb) {
     3580        void* ctx = wolfSSL_GetEccVerifyCtx(ssl);
    33473581        ret = ssl->ctx->EccVerifyCb(ssl, in, inSz, out, outSz, keyBuf, keySz,
    33483582            &ssl->eccVerifyRes, ctx);
    … …  
    34263660int EccSharedSecret(WOLFSSL* ssl, ecc_key* priv_key, ecc_key* pub_key,
    34273661        byte* pubKeyDer, word32* pubKeySz, byte* out, word32* outlen,
    3428         int side, void* ctx)
     3662        int side)
    34293663{
    34303664    int ret;
    … …  
    34403674    (void)pubKeySz;
    34413675    (void)side;
    3442     (void)ctx;
    34433676
    34443677    WOLFSSL_ENTER("EccSharedSecret");
    … …  
    34563689
    34573690#ifdef WOLFSSL_ASYNC_CRYPT
    3458     /* intialize event */
     3691    /* initialize event */
    34593692    ret = wolfSSL_AsyncInit(ssl, asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
    34603693    if (ret != 0)
    … …  
    34643697#ifdef HAVE_PK_CALLBACKS
    34653698    if (ssl->ctx->EccSharedSecretCb) {
     3699        void* ctx = wolfSSL_GetEccSharedSecretCtx(ssl);
    34663700        ret = ssl->ctx->EccSharedSecretCb(ssl, otherKey, pubKeyDer,
    34673701            pubKeySz, out, outlen, side, ctx);
    … …  
    34893723    int ret = 0;
    34903724    int keySz = 0;
     3725    int ecc_curve = ECC_CURVE_DEF;
    34913726
    34923727    WOLFSSL_ENTER("EccMakeKey");
    34933728
    34943729#ifdef WOLFSSL_ASYNC_CRYPT
    3495     /* intialize event */
     3730    /* initialize event */
    34963731    ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_NONE);
    34973732    if (ret != 0)
    … …  
    34993734#endif
    35003735
     3736    /* get key size */
    35013737    if (peer == NULL) {
    35023738        keySz = ssl->eccTempKeySz;
    … …  
    35063742    }
    35073743
     3744    /* get curve type */
    35083745    if (ssl->ecdhCurveOID > 0) {
    3509         ret = wc_ecc_make_key_ex(ssl->rng, keySz, key,
    3510                  wc_ecc_get_oid(ssl->ecdhCurveOID, NULL, NULL));
    3511     }
    3512     else {
    3513         ret = wc_ecc_make_key(ssl->rng, keySz, key);
    3514         if (ret == 0)
     3746        ecc_curve = wc_ecc_get_oid(ssl->ecdhCurveOID, NULL, NULL);
     3747    }
     3748
     3749#ifdef HAVE_PK_CALLBACKS
     3750    if (ssl->ctx->EccKeyGenCb) {
     3751        void* ctx = wolfSSL_GetEccKeyGenCtx(ssl);
     3752        ret = ssl->ctx->EccKeyGenCb(ssl, key, keySz, ecc_curve, ctx);
     3753    }
     3754    else
     3755#endif
     3756    {
     3757        ret = wc_ecc_make_key_ex(ssl->rng, keySz, key, ecc_curve);
     3758    }
     3759
     3760    /* make sure the curve is set for TLS */
     3761    if (ret == 0 && key->dp) {
    35153762            ssl->ecdhCurveOID = key->dp->oidSum;
    35163763    }
    … …  
    35303777
    35313778#ifdef HAVE_ED25519
     3779/* Check whether the key contains a public key.
     3780 * If not then pull it out of the leaf certificate.
     3781 *
     3782 * ssl  SSL/TLS object.
     3783 * returns MEMORY_E when unable to allocate memory, a parsing error, otherwise
     3784 * 0 on success.
     3785 */
     3786int Ed25519CheckPubKey(WOLFSSL* ssl)
     3787{
     3788    ed25519_key* key = (ed25519_key*)ssl->hsKey;
     3789    int ret = 0;
     3790
     3791    /* Public key required for signing. */
     3792    if (!key->pubKeySet) {
     3793        DerBuffer* leaf = ssl->buffers.certificate;
     3794        DecodedCert* cert = (DecodedCert*)XMALLOC(sizeof(*cert),
     3795                                     ssl->heap, DYNAMIC_TYPE_DCERT);
     3796        if (cert == NULL)
     3797            ret = MEMORY_E;
     3798
     3799        if (ret == 0) {
     3800            InitDecodedCert(cert, leaf->buffer, leaf->length, ssl->heap);
     3801            ret = DecodeToKey(cert, 0);
     3802        }
     3803        if (ret == 0) {
     3804            ret = wc_ed25519_import_public(cert->publicKey, cert->pubKeySize,
     3805                                                                           key);
     3806        }
     3807        if (cert != NULL) {
     3808            FreeDecodedCert(cert);
     3809            XFREE(cert, ssl->heap, DYNAMIC_TYPE_DCERT);
     3810        }
     3811    }
     3812
     3813    return ret;
     3814}
     3815
    35323816/* Sign the data using EdDSA and key using X25519.
    35333817 *
    … …  
    35403824 * keySz  The length of the private key data in bytes.
    35413825 * ctx    The callback context.
    3542  * returns 0 on succes, otherwise the valus is an error.
     3826 * returns 0 on success, otherwise the value is an error.
    35433827 */
    35443828int Ed25519Sign(WOLFSSL* ssl, const byte* in, word32 inSz, byte* out,
    3545                 word32* outSz, ed25519_key* key, byte* keyBuf, word32 keySz,
    3546                 void* ctx)
     3829                word32* outSz, ed25519_key* key, DerBuffer* keyBufInfo)
    35473830{
    35483831    int ret;
     3832#ifdef HAVE_PK_CALLBACKS
     3833    const byte* keyBuf = NULL;
     3834    word32 keySz = 0;
     3835
     3836    if (keyBufInfo) {
     3837        keyBuf = keyBufInfo->buffer;
     3838        keySz = keyBufInfo->length;
     3839    }
     3840#endif
    35493841
    35503842    (void)ssl;
    3551     (void)keyBuf;
    3552     (void)keySz;
    3553     (void)ctx;
     3843    (void)keyBufInfo;
    35543844
    35553845    WOLFSSL_ENTER("Ed25519Sign");
    35563846
    35573847#ifdef WOLFSSL_ASYNC_CRYPT
    3558     /* intialize event */
     3848    /* initialize event */
    35593849    ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
    35603850    if (ret != 0)
    … …  
    35643854#if defined(HAVE_PK_CALLBACKS)
    35653855    if (ssl->ctx->Ed25519SignCb) {
     3856        void* ctx = wolfSSL_GetEd25519SignCtx(ssl);
    35663857        ret = ssl->ctx->Ed25519SignCb(ssl, in, inSz, out, outSz, keyBuf,
    35673858            keySz, ctx);
    … …  
    35953886 * keySz  The length of the private key data in bytes.
    35963887 * ctx    The callback context.
    3597  * returns 0 on succes, otherwise the valus is an error.
     3888 * returns 0 on success, otherwise the value is an error.
    35983889 */
    35993890int Ed25519Verify(WOLFSSL* ssl, const byte* in, word32 inSz, const byte* msg,
    3600                   word32 msgSz, ed25519_key* key, byte* keyBuf, word32 keySz,
    3601                   void* ctx)
     3891                  word32 msgSz, ed25519_key* key, buffer* keyBufInfo)
    36023892{
    36033893    int ret;
     3894#ifdef HAVE_PK_CALLBACKS
     3895    const byte* keyBuf = NULL;
     3896    word32 keySz = 0;
     3897
     3898    if (keyBufInfo) {
     3899        keyBuf = keyBufInfo->buffer;
     3900        keySz = keyBufInfo->length;
     3901    }
     3902#endif
    36043903
    36053904    (void)ssl;
    3606     (void)keyBuf;
    3607     (void)keySz;
    3608     (void)ctx;
     3905    (void)keyBufInfo;
    36093906
    36103907    WOLFSSL_ENTER("Ed25519Verify");
    36113908
    36123909#ifdef WOLFSSL_ASYNC_CRYPT
    3613     /* intialize event */
     3910    /* initialize event */
    36143911    ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
    36153912    if (ret != 0)
    … …  
    36193916#ifdef HAVE_PK_CALLBACKS
    36203917    if (ssl->ctx->Ed25519VerifyCb) {
     3918        void* ctx = wolfSSL_GetEd25519VerifyCtx(ssl);
    36213919        ret = ssl->ctx->Ed25519VerifyCb(ssl, in, inSz, msg, msgSz, keyBuf,
    36223920                                        keySz, &ssl->eccVerifyRes, ctx);
    … …  
    36453943}
    36463944#endif /* HAVE_ED25519 */
     3945
     3946#ifndef WOLFSSL_NO_TLS12
    36473947
    36483948#ifdef HAVE_CURVE25519
    … …  
    36863986static int X25519SharedSecret(WOLFSSL* ssl, curve25519_key* priv_key,
    36873987        curve25519_key* pub_key, byte* pubKeyDer, word32* pubKeySz,
    3688         byte* out, word32* outlen, int side, void* ctx)
     3988        byte* out, word32* outlen, int side)
    36893989{
    36903990    int ret;
    … …  
    36943994    (void)pubKeySz;
    36953995    (void)side;
    3696     (void)ctx;
    36973996
    36983997    WOLFSSL_ENTER("X25519SharedSecret");
    36993998
    37003999#ifdef WOLFSSL_ASYNC_CRYPT
    3701     /* intialize event */
     4000    /* initialize event */
    37024001    ret = wolfSSL_AsyncInit(ssl, &priv_key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
    37034002    if (ret != 0)
    … …  
    37114010        ret = X25519GetKey(ssl, &otherKey);
    37124011        if (ret == 0) {
     4012            void* ctx = wolfSSL_GetX25519SharedSecretCtx(ssl);
    37134013            ret = ssl->ctx->X25519SharedSecretCb(ssl, otherKey, pubKeyDer,
    37144014                pubKeySz, out, outlen, side, ctx);
    … …  
    37444044
    37454045#ifdef WOLFSSL_ASYNC_CRYPT
    3746     /* intialize event */
     4046    /* initialize event */
    37474047    ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_NONE);
    37484048    if (ret != 0)
    … …  
    37504050#endif
    37514051
     4052#ifdef HAVE_PK_CALLBACKS
     4053    if (ssl->ctx->X25519KeyGenCb) {
     4054        void* ctx = wolfSSL_GetX25519KeyGenCtx(ssl);
     4055        ret = ssl->ctx->X25519KeyGenCb(ssl, key, CURVE25519_KEYSIZE, ctx);
     4056    }
     4057    else
     4058#endif
     4059    {
    37524060    ret = wc_curve25519_make_key(ssl->rng, CURVE25519_KEYSIZE, key);
    3753     if (ret == 0)
     4061    }
     4062
     4063    if (ret == 0) {
    37544064        ssl->ecdhCurveOID = ECC_X25519_OID;
     4065    }
    37554066
    37564067    /* Handle async pending response */
    … …  
    37664077}
    37674078#endif /* HAVE_CURVE25519 */
    3768 
    3769 #endif /* !NO_CERTS */
    37704079
    37714080#if !defined(NO_CERTS) || !defined(NO_PSK)
    … …  
    37814090
    37824091#ifdef WOLFSSL_ASYNC_CRYPT
    3783     /* intialize event */
     4092    /* initialize event */
    37844093    ret = wolfSSL_AsyncInit(ssl, &dhKey->asyncDev, WC_ASYNC_FLAG_NONE);
    37854094    if (ret != 0)
    … …  
    38134122
    38144123#ifdef WOLFSSL_ASYNC_CRYPT
    3815     /* intialize event */
     4124    /* initialize event */
    38164125    ret = wolfSSL_AsyncInit(ssl, &dhKey->asyncDev, WC_ASYNC_FLAG_NONE);
    38174126    if (ret != 0)
    … …  
    38194128#endif
    38204129
    3821     ret = wc_DhAgree(dhKey, agree, agreeSz, priv, privSz, otherPub, otherPubSz);
     4130#ifdef HAVE_PK_CALLBACKS
     4131    if (ssl->ctx->DhAgreeCb) {
     4132        void* ctx = wolfSSL_GetDhAgreeCtx(ssl);
     4133
     4134        WOLFSSL_MSG("Calling DhAgree Callback Function");
     4135        ret = ssl->ctx->DhAgreeCb(ssl, dhKey, priv, privSz,
     4136                    otherPub, otherPubSz, agree, agreeSz, ctx);
     4137    }
     4138    else
     4139#endif
     4140    {
     4141        ret = wc_DhAgree(dhKey, agree, agreeSz, priv, privSz, otherPub,
     4142                otherPubSz);
     4143    }
    38224144
    38234145    /* Handle async pending response */
    … …  
    38354157#endif /* !NO_CERTS || !NO_PSK */
    38364158
     4159#endif /* !WOLFSSL_NO_TLS12 */
     4160
     4161
     4162#ifdef HAVE_PK_CALLBACKS
     4163int wolfSSL_CTX_IsPrivatePkSet(WOLFSSL_CTX* ctx)
     4164{
     4165    int pkcbset = 0;
     4166    (void)ctx;
     4167#if defined(HAVE_ECC) || defined(HAVE_ED25519) || !defined(NO_RSA)
     4168    if (0
     4169    #ifdef HAVE_ECC
     4170        || ctx->EccSignCb != NULL
     4171    #endif
     4172    #ifdef HAVE_ED25519
     4173        || ctx->Ed25519SignCb != NULL
     4174    #endif
     4175    #ifndef NO_RSA
     4176        || ctx->RsaSignCb != NULL
     4177        || ctx->RsaDecCb != NULL
     4178        #ifdef WC_RSA_PSS
     4179        || ctx->RsaPssSignCb != NULL
     4180        #endif
     4181    #endif
     4182    ) {
     4183        pkcbset = 1;
     4184    }
     4185#endif
     4186    return pkcbset;
     4187}
     4188#endif /* HAVE_PK_CALLBACKS */
     4189
     4190
     4191int InitSSL_Suites(WOLFSSL* ssl)
     4192{
     4193    int keySz = 0;
     4194    byte havePSK = 0;
     4195    byte haveAnon = 0;
     4196    byte haveRSA = 0;
     4197    byte haveMcast = 0;
     4198
     4199    (void)haveAnon; /* Squash unused var warnings */
     4200    (void)haveMcast;
     4201
     4202    if (!ssl)
     4203        return BAD_FUNC_ARG;
     4204
     4205#ifndef NO_RSA
     4206    haveRSA = 1;
     4207#endif
     4208#ifndef NO_PSK
     4209    havePSK = (byte)ssl->options.havePSK;
     4210#endif /* NO_PSK */
     4211#ifdef HAVE_ANON
     4212    haveAnon = ssl->options.haveAnon;
     4213#endif /* HAVE_ANON*/
     4214#ifdef WOLFSSL_MULTICAST
     4215    haveMcast = ssl->options.haveMcast;
     4216#endif /* WOLFSSL_MULTICAST */
     4217
     4218#ifdef WOLFSSL_EARLY_DATA
     4219    if (ssl->options.side == WOLFSSL_SERVER_END)
     4220        ssl->options.maxEarlyDataSz = ssl->ctx->maxEarlyDataSz;
     4221#endif
     4222#if !defined(WOLFSSL_NO_CLIENT_AUTH) && defined(HAVE_ED25519) && \
     4223                                        !defined(NO_ED25519_CLIENT_AUTH)
     4224    ssl->options.cacheMessages = ssl->options.side == WOLFSSL_SERVER_END ||
     4225                                        ssl->buffers.keyType == ed25519_sa_algo;
     4226#endif
     4227
     4228#ifndef NO_CERTS
     4229    keySz = ssl->buffers.keySz;
     4230#endif
     4231
     4232    /* make sure server has DH parms, and add PSK if there, add NTRU too */
     4233    if (ssl->options.side == WOLFSSL_SERVER_END) {
     4234        InitSuites(ssl->suites, ssl->version, keySz, haveRSA, havePSK,
     4235                   ssl->options.haveDH, ssl->options.haveNTRU,
     4236                   ssl->options.haveECDSAsig, ssl->options.haveECC,
     4237                   ssl->options.haveStaticECC, ssl->options.side);
     4238    }
     4239    else {
     4240        InitSuites(ssl->suites, ssl->version, keySz, haveRSA, havePSK,
     4241                   TRUE, ssl->options.haveNTRU,
     4242                   ssl->options.haveECDSAsig, ssl->options.haveECC,
     4243                   ssl->options.haveStaticECC, ssl->options.side);
     4244    }
     4245
     4246#if !defined(NO_CERTS) && !defined(WOLFSSL_SESSION_EXPORT)
     4247    /* make sure server has cert and key unless using PSK, Anon, or
     4248     * Multicast. This should be true even if just switching ssl ctx */
     4249    if (ssl->options.side == WOLFSSL_SERVER_END &&
     4250            !havePSK && !haveAnon && !haveMcast) {
     4251
     4252        /* server certificate must be loaded */
     4253        if (!ssl->buffers.certificate || !ssl->buffers.certificate->buffer) {
     4254            WOLFSSL_MSG("Server missing certificate");
     4255            return NO_PRIVATE_KEY;
     4256        }
     4257
     4258        /* allow no private key if using PK callbacks and CB is set */
     4259    #ifdef HAVE_PK_CALLBACKS
     4260        if (wolfSSL_CTX_IsPrivatePkSet(ssl->ctx)) {
     4261            WOLFSSL_MSG("Using PK for server private key");
     4262        }
     4263        else
     4264    #endif
     4265        if (!ssl->buffers.key || !ssl->buffers.key->buffer) {
     4266            WOLFSSL_MSG("Server missing private key");
     4267            return NO_PRIVATE_KEY;
     4268        }
     4269    }
     4270#endif
     4271
     4272    return WOLFSSL_SUCCESS;
     4273}
    38374274
    38384275/* This function inherits a WOLFSSL_CTX's fields into an SSL object.
    … …  
    38484285int SetSSL_CTX(WOLFSSL* ssl, WOLFSSL_CTX* ctx, int writeDup)
    38494286{
    3850     byte havePSK = 0;
    3851     byte haveAnon = 0;
     4287    int ret = WOLFSSL_SUCCESS;
    38524288    byte newSSL;
    3853     byte haveRSA = 0;
    3854     byte haveMcast = 0;
    3855 
    3856     (void)haveAnon; /* Squash unused var warnings */
    3857     (void)haveMcast;
    38584289
    38594290    if (!ssl || !ctx)
    38604291        return BAD_FUNC_ARG;
    38614292
     4293#ifndef SINGLE_THREADED
    38624294    if (ssl->suites == NULL && !writeDup)
    38634295        return BAD_FUNC_ARG;
     4296#endif
    38644297
    38654298    newSSL = ssl->ctx == NULL; /* Assign after null check */
    … …  
    38704303    }
    38714304#endif
    3872 
    3873 
    3874 #ifndef NO_RSA
    3875     haveRSA = 1;
    3876 #endif
    3877 #ifndef NO_PSK
    3878     havePSK = ctx->havePSK;
    3879 #endif /* NO_PSK */
    3880 #ifdef HAVE_ANON
    3881     haveAnon = ctx->haveAnon;
    3882 #endif /* HAVE_ANON*/
    3883 #ifdef WOLFSSL_MULTICAST
    3884     haveMcast = ctx->haveMcast;
    3885 #endif /* WOLFSSL_MULTICAST */
    38864305
    38874306    /* decrement previous CTX reference count if exists.
    … …  
    39044323#ifdef HAVE_ECC
    39054324    ssl->eccTempKeySz = ctx->eccTempKeySz;
     4325    ssl->ecdhCurveOID = ctx->ecdhCurveOID;
     4326#endif
     4327#if defined(HAVE_ECC) || defined(HAVE_ED25519)
    39064328    ssl->pkCurveOID = ctx->pkCurveOID;
    3907     ssl->ecdhCurveOID = ctx->ecdhCurveOID;
    39084329#endif
    39094330
    39104331#ifdef OPENSSL_EXTRA
    39114332    ssl->options.mask = ctx->mask;
     4333    ssl->CBIS         = ctx->CBIS;
    39124334#endif
    39134335    ssl->timeout = ctx->timeout;
    … …  
    39274349    ssl->options.client_psk_cb = ctx->client_psk_cb;
    39284350    ssl->options.server_psk_cb = ctx->server_psk_cb;
     4351#ifdef WOLFSSL_TLS13
     4352    ssl->options.client_psk_tls13_cb = ctx->client_psk_tls13_cb;
     4353    ssl->options.server_psk_tls13_cb = ctx->server_psk_tls13_cb;
     4354#endif
    39294355#endif /* NO_PSK */
    39304356#ifdef WOLFSSL_EARLY_DATA
    … …  
    39384364#ifndef NO_DH
    39394365    ssl->options.minDhKeySz = ctx->minDhKeySz;
     4366    ssl->options.maxDhKeySz = ctx->maxDhKeySz;
    39404367#endif
    39414368#ifndef NO_RSA
    … …  
    39664393
    39674394#ifndef NO_DH
     4395    #if !defined(WOLFSSL_OLD_PRIME_CHECK) && !defined(HAVE_FIPS) && \
     4396        !defined(HAVE_SELFTEST)
     4397        ssl->options.dhKeyTested = ctx->dhKeyTested;
     4398    #endif
    39684399    ssl->buffers.serverDH_P = ctx->serverDH_P;
    39694400    ssl->buffers.serverDH_G = ctx->serverDH_G;
    … …  
    39814412    ssl->buffers.keySz   = ctx->privateKeySz;
    39824413#endif
     4414#if !defined(WOLFSSL_NO_CLIENT_AUTH) && defined(HAVE_ED25519) && \
     4415                                        !defined(NO_ED25519_CLIENT_AUTH)
     4416    ssl->options.cacheMessages = ssl->options.side == WOLFSSL_SERVER_END ||
     4417                                        ssl->buffers.keyType == ed25519_sa_algo;
     4418#endif
     4419
    39834420
    39844421#ifdef WOLFSSL_ASYNC_CRYPT
    … …  
    39874424
    39884425    if (writeDup == 0) {
    3989         int keySz = 0;
    3990 #ifndef NO_CERTS
    3991         keySz = ssl->buffers.keySz;
    3992 #endif
    3993 
    39944426#ifndef NO_PSK
    39954427        if (ctx->server_hint[0]) {   /* set in CTX */
    … …  
    40004432#endif /* NO_PSK */
    40014433
    4002         if (ctx->suites)
     4434        if (ctx->suites) {
     4435#ifndef SINGLE_THREADED
    40034436            *ssl->suites = *ctx->suites;
    4004         else
     4437#else
     4438            ssl->suites = ctx->suites;
     4439#endif
     4440        }
     4441        else {
    40054442            XMEMSET(ssl->suites, 0, sizeof(Suites));
    4006 
    4007         /* make sure server has DH parms, and add PSK if there, add NTRU too */
    4008         if (ssl->options.side == WOLFSSL_SERVER_END)
    4009             InitSuites(ssl->suites, ssl->version, keySz, haveRSA, havePSK,
    4010                        ssl->options.haveDH, ssl->options.haveNTRU,
    4011                        ssl->options.haveECDSAsig, ssl->options.haveECC,
    4012                        ssl->options.haveStaticECC, ssl->options.side);
    4013         else
    4014             InitSuites(ssl->suites, ssl->version, keySz, haveRSA, havePSK,
    4015                        TRUE, ssl->options.haveNTRU,
    4016                        ssl->options.haveECDSAsig, ssl->options.haveECC,
    4017                        ssl->options.haveStaticECC, ssl->options.side);
    4018 
    4019 #if !defined(NO_CERTS) && !defined(WOLFSSL_SESSION_EXPORT)
    4020         /* make sure server has cert and key unless using PSK, Anon, or
    4021          * Multicast. This should be true even if just switching ssl ctx */
    4022         if (ssl->options.side == WOLFSSL_SERVER_END &&
    4023                 !havePSK && !haveAnon && !haveMcast)
    4024             if (!ssl->buffers.certificate || !ssl->buffers.certificate->buffer
    4025                 || !ssl->buffers.key || !ssl->buffers.key->buffer) {
    4026                 WOLFSSL_MSG("Server missing certificate and/or private key");
    4027                 return NO_PRIVATE_KEY;
    4028             }
    4029 #endif
    4030 
     4443            }
     4444
     4445        if (ssl->options.side != WOLFSSL_NEITHER_END) {
     4446            /* Defer initializing suites until accept or connect */
     4447            ret = InitSSL_Suites(ssl);
     4448        }
    40314449    }  /* writeDup check */
    40324450
    … …  
    40374455#endif
    40384456
     4457    ssl->CBIORecv = ctx->CBIORecv;
     4458    ssl->CBIOSend = ctx->CBIOSend;
    40394459#ifdef OPENSSL_EXTRA
    40404460    ssl->readAhead = ctx->readAhead;
    40414461#endif
    4042 
    4043     return WOLFSSL_SUCCESS;
     4462    ssl->verifyDepth = ctx->verifyDepth;
     4463
     4464    return ret;
    40444465}
    40454466
    … …  
    41134534        wc_Sha512Free(&ssl->hsHashes->hashSha512);
    41144535    #endif
     4536    #if defined(HAVE_ED25519) && !defined(WOLFSSL_NO_CLIENT_AUTH)
     4537        if (ssl->hsHashes->messages != NULL) {
     4538            XFREE(ssl->hsHashes->messages, ssl->heap, DYNAMIC_TYPE_HASHES);
     4539            ssl->hsHashes->messages = NULL;
     4540         }
     4541    #endif
    41154542
    41164543        XFREE(ssl->hsHashes, ssl->heap, DYNAMIC_TYPE_HASHES);
    … …  
    42334660    ssl->buffers.outputBuffer.bufferSize  = STATIC_BUFFER_LEN;
    42344661
    4235 #if defined(KEEP_PEER_CERT) || defined(GOAHEAD_WS)
     4662#ifdef KEEP_PEER_CERT
    42364663    InitX509(&ssl->peerCert, 0, ssl->heap);
    42374664#endif
    … …  
    42474674    ssl->IOCB_ReadCtx  = &ssl->nxCtx;  /* default NetX IO ctx, same for read */
    42484675    ssl->IOCB_WriteCtx = &ssl->nxCtx;  /* and write */
     4676#elif defined(WOLFSSL_APACHE_MYNEWT) && !defined(WOLFSSL_LWIP)
     4677    ssl->mnCtx = mynewt_ctx_new();
     4678    if(!ssl->mnCtx) {
     4679        return MEMORY_E;
     4680    }
     4681    ssl->IOCB_ReadCtx  = ssl->mnCtx;  /* default Mynewt IO ctx, same for read */
     4682    ssl->IOCB_WriteCtx = ssl->mnCtx;  /* and write */
    42494683#endif
    42504684
    … …  
    42604694    ssl->encrypt.state = CIPHER_STATE_BEGIN;
    42614695    ssl->decrypt.state = CIPHER_STATE_BEGIN;
     4696#ifndef NO_DH
     4697    #if !defined(WOLFSSL_OLD_PRIME_CHECK) && !defined(HAVE_FIPS) && \
     4698        !defined(HAVE_SELFTEST)
     4699        ssl->options.dhDoKeyTest = 1;
     4700    #endif
     4701#endif
    42624702
    42634703#ifdef WOLFSSL_DTLS
    … …  
    42764716#endif
    42774717
     4718#ifndef WOLFSSL_AEAD_ONLY
    42784719    #ifndef NO_OLD_TLS
    42794720        ssl->hmac = SSL_hmac; /* default to SSLv3 */
    4280     #else
     4721    #elif !defined(WOLFSSL_NO_TLS12)
    42814722        ssl->hmac = TLS_hmac;
    42824723    #endif
     4724#endif
    42834725
    42844726
    … …  
    42984740        ssl->options.postHandshakeAuth = ctx->postHandshakeAuth;
    42994741    #endif
     4742
     4743    if (ctx->numGroups > 0) {
     4744        XMEMCPY(ssl->group, ctx->group, sizeof(*ctx->group) * ctx->numGroups);
     4745        ssl->numGroups = ctx->numGroups;
     4746    }
    43004747#endif
    43014748
    … …  
    43064753#ifdef HAVE_ALPN
    43074754    ssl->alpn_client_list = NULL;
    4308     #if defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY)
     4755    #if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY)
    43094756        ssl->alpnSelect    = ctx->alpnSelect;
    43104757        ssl->alpnSelectArg = ctx->alpnSelectArg;
    … …  
    43214768    ssl->alert_history.last_tx.code  = -1;
    43224769    ssl->alert_history.last_tx.level = -1;
     4770
     4771#ifdef OPENSSL_EXTRA
     4772    /* copy over application session context ID */
     4773    ssl->sessionCtxSz = ctx->sessionCtxSz;
     4774    XMEMCPY(ssl->sessionCtx, ctx->sessionCtx, ctx->sessionCtxSz);
     4775    ssl->cbioFlag = ctx->cbioFlag;
     4776#endif
    43234777
    43244778    InitCiphers(ssl);
    … …  
    43364790        }
    43374791        XMEMSET(ssl->arrays, 0, sizeof(Arrays));
     4792#if defined(WOLFSSL_TLS13) || defined(WOLFSSL_SNIFFER)
    43384793        ssl->arrays->preMasterSecret = (byte*)XMALLOC(ENCRYPT_LEN, ssl->heap,
    43394794            DYNAMIC_TYPE_SECRET);
    … …  
    43424797        }
    43434798        XMEMSET(ssl->arrays->preMasterSecret, 0, ENCRYPT_LEN);
    4344 
     4799#endif
     4800
     4801#ifdef SINGLE_THREADED
     4802        if (ctx->suites == NULL)
     4803#endif
     4804        {
    43454805        /* suites */
    43464806        ssl->suites = (Suites*)XMALLOC(sizeof(Suites), ssl->heap,
    … …  
    43514811        }
    43524812    }
     4813    }
    43534814
    43544815    /* Initialize SSL with the appropriate fields from it's ctx */
    … …  
    43874848    }
    43884849
     4850#ifdef HAVE_WRITE_DUP
    43894851    if (writeDup) {
    43904852        /* all done */
    43914853        return 0;
    43924854    }
     4855#endif
    43934856
    43944857    /* hsHashes */
    … …  
    44344897        for (i = 0; i < WOLFSSL_DTLS_PEERSEQ_SZ; i++)
    44354898            ssl->keys.peerSeq[i].peerId = INVALID_PEER_ID;
     4899    }
     4900#endif
     4901
     4902#ifdef HAVE_SECURE_RENEGOTIATION
     4903    if (ssl->options.side == WOLFSSL_CLIENT_END) {
     4904    /* use secure renegotiation by default (not recommend) */
     4905    #ifdef WOLFSSL_SECURE_RENEGOTIATION_ON_BY_DEFAULT
     4906        ret = wolfSSL_UseSecureRenegotiation(ssl);
     4907        if (ret != WOLFSSL_SUCCESS)
     4908            return ret;
     4909    #endif
    44364910    }
    44374911#endif
    … …  
    45985072}
    45995073
    4600 #if !defined(NO_RSA) || defined(HAVE_ECC) || defined(HAVE_CURVE25519)
     5074#if !defined(NO_RSA) || defined(HAVE_ECC) || defined(HAVE_ED25519) || \
     5075    defined(HAVE_CURVE25519)
    46015076static int ReuseKey(WOLFSSL* ssl, int type, void* pKey)
    46025077{
    46035078    int ret = 0;
     5079
     5080    (void)ssl;
    46045081
    46055082    switch (type) {
    … …  
    46915168        XFREE(ssl->rng, ssl->heap, DYNAMIC_TYPE_RNG);
    46925169    }
     5170#ifdef SINGLE_THREADED
     5171    if (ssl->suites != ssl->ctx->suites)
     5172#endif
    46935173    XFREE(ssl->suites, ssl->heap, DYNAMIC_TYPE_SUITES);
    46945174    FreeHandshakeHashes(ssl);
    … …  
    46975177    /* clear keys struct after session */
    46985178    ForceZero(&ssl->keys, sizeof(Keys));
     5179
     5180#ifdef WOLFSSL_TLS13
     5181    if (ssl->options.tls1_3) {
     5182        ForceZero(&ssl->clientSecret, sizeof(ssl->clientSecret));
     5183        ForceZero(&ssl->serverSecret, sizeof(ssl->serverSecret));
     5184    }
     5185#endif
    46995186
    47005187#ifndef NO_DH
    … …  
    47065193    XFREE(ssl->buffers.serverDH_Pub.buffer, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY);
    47075194    /* parameters (p,g) may be owned by ctx */
    4708     if (ssl->buffers.weOwnDH || ssl->options.side == WOLFSSL_CLIENT_END) {
     5195    if (ssl->buffers.weOwnDH) {
    47095196        XFREE(ssl->buffers.serverDH_G.buffer, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY);
    47105197        XFREE(ssl->buffers.serverDH_P.buffer, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY);
    … …  
    47415228#endif
    47425229#endif /* WOLFSSL_DTLS */
    4743 #if defined(OPENSSL_EXTRA) || defined(GOAHEAD_WS)
     5230#ifdef OPENSSL_EXTRA
    47445231    if (ssl->biord != ssl->biowr)        /* only free write if different */
    47455232        wolfSSL_BIO_free(ssl->biowr);
    … …  
    47545241    FreeKey(ssl, DYNAMIC_TYPE_ECC, (void**)&ssl->peerEccDsaKey);
    47555242    ssl->peerEccDsaKeyPresent = 0;
     5243#endif
     5244#if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
     5245    {
     5246        int dtype;
     5247    #ifdef HAVE_ECC
     5248        dtype = DYNAMIC_TYPE_ECC;
     5249    #endif
    47565250#ifdef HAVE_CURVE25519
    4757     if (!ssl->peerX25519KeyPresent &&
    4758             ssl->eccTempKeyPresent != DYNAMIC_TYPE_CURVE25519)
    4759 #endif /* HAVE_CURVE25519 */
     5251    #ifdef HAVE_ECC
     5252        if (ssl->peerX25519KeyPresent ||
     5253                              ssl->eccTempKeyPresent == DYNAMIC_TYPE_CURVE25519)
     5254    #endif /* HAVE_ECC */
    47605255    {
    4761         FreeKey(ssl, DYNAMIC_TYPE_ECC, (void**)&ssl->eccTempKey);
     5256            dtype = DYNAMIC_TYPE_CURVE25519;
     5257    }
     5258    #endif /* HAVE_CURVE25519 */
     5259        FreeKey(ssl, dtype, (void**)&ssl->eccTempKey);
    47625260        ssl->eccTempKeyPresent = 0;
    47635261    }
     5262#endif /* HAVE_ECC || HAVE_CURVE25519 */
    47645263#ifdef HAVE_CURVE25519
    4765     else {
    4766         FreeKey(ssl, DYNAMIC_TYPE_CURVE25519, (void**)&ssl->eccTempKey);
    4767         ssl->eccTempKeyPresent = 0;
    4768     }
    47695264    FreeKey(ssl, DYNAMIC_TYPE_CURVE25519, (void**)&ssl->peerX25519Key);
    47705265    ssl->peerX25519KeyPresent = 0;
    47715266#endif
    4772 #endif /* HAVE_ECC */
    47735267#ifdef HAVE_ED25519
    47745268    FreeKey(ssl, DYNAMIC_TYPE_ED25519, (void**)&ssl->peerEd25519Key);
    … …  
    48005294#endif
    48015295#endif /* HAVE_TLS_EXTENSIONS */
     5296#if defined(WOLFSSL_APACHE_MYNEWT) && !defined(WOLFSSL_LWIP)
     5297    if (ssl->mnCtx) {
     5298        mynewt_ctx_clear(ssl->mnCtx);
     5299        ssl->mnCtx = NULL;
     5300    }
     5301#endif
    48025302#ifdef HAVE_NETX
    48035303    if (ssl->nxCtx.nxPacket)
    48045304        nx_packet_release(ssl->nxCtx.nxPacket);
    48055305#endif
    4806 #if defined(KEEP_PEER_CERT) || defined(GOAHEAD_WS)
     5306#ifdef KEEP_PEER_CERT
    48075307    FreeX509(&ssl->peerCert);
    48085308#endif
    … …  
    48425342        WOLFSSL_HEAP_HINT* ssl_hint = (WOLFSSL_HEAP_HINT*)ssl->heap;
    48435343        WOLFSSL_HEAP*      ctx_heap;
     5344        void* heap = ssl->ctx ? ssl->ctx->heap : ssl->heap;
    48445345
    48455346        ctx_heap = ssl_hint->memory;
    … …  
    48615362        /* check if tracking stats */
    48625363        if (ctx_heap->flag & WOLFMEM_TRACK_STATS) {
    4863             XFREE(ssl_hint->stats, ssl->ctx->heap, DYNAMIC_TYPE_SSL);
    4864         }
    4865         XFREE(ssl->heap, ssl->ctx->heap, DYNAMIC_TYPE_SSL);
     5364            XFREE(ssl_hint->stats, heap, DYNAMIC_TYPE_SSL);
     5365        }
     5366        XFREE(ssl->heap, heap, DYNAMIC_TYPE_SSL);
    48665367    #ifdef WOLFSSL_HEAP_TEST
    48675368    }
    … …  
    48865387        ShrinkInputBuffer(ssl, NO_FORCED_FREE);
    48875388
     5389#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_POST_HANDSHAKE_AUTH)
     5390    if (!ssl->options.tls1_3)
     5391#endif
     5392    {
    48885393    /* suites */
     5394#ifdef SINGLE_THREADED
     5395        if (ssl->suites != ssl->ctx->suites)
     5396#endif
    48895397    XFREE(ssl->suites, ssl->heap, DYNAMIC_TYPE_SUITES);
    48905398    ssl->suites = NULL;
    … …  
    48925400    /* hsHashes */
    48935401    FreeHandshakeHashes(ssl);
     5402    }
    48945403
    48955404    /* RNG */
    4896     if (ssl->specs.cipher_type == stream || ssl->options.tls1_1 == 0) {
     5405    if (ssl->options.tls1_1 == 0
     5406#ifndef WOLFSSL_AEAD_ONLY
     5407        || ssl->specs.cipher_type == stream
     5408#endif
     5409#if defined(WOLFSSL_TLS13)
     5410    #if !defined(WOLFSSL_POST_HANDSHAKE_AUTH)
     5411        || ssl->options.tls1_3
     5412    #elif !defined(HAVE_SESSION_TICKET)
     5413        || (ssl->options.tls1_3 && ssl->options.side == WOLFSSL_SERVER_END)
     5414    #endif
     5415#endif
     5416    ) {
    48975417        if (ssl->options.weOwnRng) {
    48985418            wc_FreeRng(ssl->rng);
    … …  
    49135433#endif
    49145434
     5435#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_POST_HANDSHAKE_AUTH) && \
     5436                                                    defined(HAVE_SESSION_TICKET)
     5437    if (!ssl->options.tls1_3)
     5438#endif
    49155439    /* arrays */
    49165440    if (ssl->options.saveArrays == 0)
    49175441        FreeArrays(ssl, 1);
    49185442
     5443#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_POST_HANDSHAKE_AUTH)
     5444    if (!ssl->options.tls1_3 || ssl->options.side == WOLFSSL_CLIENT_END)
     5445#endif
     5446    {
    49195447#ifndef NO_RSA
    49205448    /* peerRsaKey */
    … …  
    49225450    ssl->peerRsaKeyPresent = 0;
    49235451#endif
     5452#ifdef HAVE_ECC
     5453        FreeKey(ssl, DYNAMIC_TYPE_ECC, (void**)&ssl->peerEccDsaKey);
     5454        ssl->peerEccDsaKeyPresent = 0;
     5455#endif /* HAVE_ECC */
     5456#ifdef HAVE_ED25519
     5457        FreeKey(ssl, DYNAMIC_TYPE_ED25519, (void**)&ssl->peerEd25519Key);
     5458        ssl->peerEd25519KeyPresent = 0;
     5459#endif /* HAVE_ED25519 */
     5460    }
    49245461
    49255462#ifdef HAVE_ECC
    49265463    FreeKey(ssl, DYNAMIC_TYPE_ECC, (void**)&ssl->peerEccKey);
    49275464    ssl->peerEccKeyPresent = 0;
    4928     FreeKey(ssl, DYNAMIC_TYPE_ECC, (void**)&ssl->peerEccDsaKey);
    4929     ssl->peerEccDsaKeyPresent = 0;
     5465#endif
     5466#if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
     5467    {
     5468        int dtype;
     5469    #ifdef HAVE_ECC
     5470        dtype = DYNAMIC_TYPE_ECC;
     5471    #endif
    49305472#ifdef HAVE_CURVE25519
    4931     if (ssl->ecdhCurveOID != ECC_X25519_OID)
    4932 #endif /* HAVE_CURVE25519 */
     5473    #ifdef HAVE_ECC
     5474        if (ssl->peerX25519KeyPresent ||
     5475                              ssl->eccTempKeyPresent == DYNAMIC_TYPE_CURVE25519)
     5476    #endif /* HAVE_ECC */
    49335477    {
    4934         FreeKey(ssl, DYNAMIC_TYPE_ECC, (void**)&ssl->eccTempKey);
     5478            dtype = DYNAMIC_TYPE_CURVE25519;
     5479    }
     5480    #endif /* HAVE_CURVE25519 */
     5481        FreeKey(ssl, dtype, (void**)&ssl->eccTempKey);
    49355482        ssl->eccTempKeyPresent = 0;
    49365483    }
     5484#endif /* HAVE_ECC || HAVE_CURVE25519 */
    49375485#ifdef HAVE_CURVE25519
    4938     else {
    4939         FreeKey(ssl, DYNAMIC_TYPE_CURVE25519, (void**)&ssl->eccTempKey);
    4940         ssl->eccTempKeyPresent = 0;
    4941     }
    49425486    FreeKey(ssl, DYNAMIC_TYPE_CURVE25519, (void**)&ssl->peerX25519Key);
    49435487    ssl->peerX25519KeyPresent = 0;
    4944 #endif /* HAVE_CURVE25519 */
    4945 #endif /* HAVE_ECC */
     5488#endif
     5489
    49465490#ifndef NO_DH
    49475491    if (ssl->buffers.serverDH_Priv.buffer) {
    … …  
    49545498    ssl->buffers.serverDH_Pub.buffer = NULL;
    49555499    /* parameters (p,g) may be owned by ctx */
    4956     if (ssl->buffers.weOwnDH || ssl->options.side == WOLFSSL_CLIENT_END) {
     5500    if (ssl->buffers.weOwnDH) {
    49575501        XFREE(ssl->buffers.serverDH_G.buffer, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY);
    49585502        ssl->buffers.serverDH_G.buffer = NULL;
    … …  
    49615505    }
    49625506#endif /* !NO_DH */
     5507
    49635508#ifndef NO_CERTS
    49645509    wolfSSL_UnloadCertsKeys(ssl);
    49655510#endif
    49665511#ifdef HAVE_PK_CALLBACKS
     5512#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_POST_HANDSHAKE_AUTH)
     5513    if (!ssl->options.tls1_3 || ssl->options.side == WOLFSSL_CLIENT_END)
     5514#endif
     5515    {
    49675516    #ifdef HAVE_ECC
    49685517        XFREE(ssl->buffers.peerEccDsaKey.buffer, ssl->heap, DYNAMIC_TYPE_ECC);
    … …  
    49785527        ssl->buffers.peerEd25519Key.buffer = NULL;
    49795528    #endif
     5529    }
    49805530#endif /* HAVE_PK_CALLBACKS */
    49815531
    … …  
    49915541        ssl->session.ticketLen = 0;
    49925542    }
     5543#endif
     5544
     5545#if defined(HAVE_TLS_EXTENSIONS) && !defined(HAVE_SNI) && \
     5546                    !defined(HAVE_ALPN) && !defined(WOLFSSL_POST_HANDSHAKE_AUTH)
     5547    /* Some extensions need to be kept for post-handshake querying. */
     5548    TLSX_FreeAll(ssl->extensions, ssl->heap);
     5549    ssl->extensions = NULL;
    49935550#endif
    49945551
    … …  
    50225579{
    50235580    if (ssl->ctx) {
    5024         FreeSSL_Ctx(ssl->ctx); /* will decrement and free underyling CTX if 0 */
     5581        FreeSSL_Ctx(ssl->ctx); /* will decrement and free underlying CTX if 0 */
    50255582    }
    50265583    SSL_ResourceFree(ssl);
    … …  
    50295586}
    50305587
    5031 
    5032 #if !defined(NO_OLD_TLS) || defined(HAVE_CHACHA) || defined(HAVE_AESCCM) \
    5033     || defined(HAVE_AESGCM) || defined(WOLFSSL_DTLS)
    5034 static INLINE void GetSEQIncrement(WOLFSSL* ssl, int verify, word32 seq[2])
     5588#if !defined(NO_OLD_TLS) || defined(WOLFSSL_DTLS) || \
     5589    ((defined(HAVE_CHACHA) || defined(HAVE_AESCCM) || defined(HAVE_AESGCM)) \
     5590     && defined(HAVE_AEAD))
     5591
     5592#if defined(WOLFSSL_DTLS) || !defined(WOLFSSL_NO_TLS12)
     5593static WC_INLINE void GetSEQIncrement(WOLFSSL* ssl, int verify, word32 seq[2])
    50355594{
    50365595    if (verify) {
    … …  
    50515610    }
    50525611}
     5612#endif /* WOLFSSL_DTLS || !WOLFSSL_NO_TLS12 */
    50535613
    50545614
    50555615#ifdef WOLFSSL_DTLS
    5056 static INLINE void DtlsGetSEQ(WOLFSSL* ssl, int order, word32 seq[2])
     5616static WC_INLINE void DtlsGetSEQ(WOLFSSL* ssl, int order, word32 seq[2])
    50575617{
    50585618    if (order == PREV_ORDER) {
    … …  
    50985658}
    50995659
    5100 static INLINE void DtlsSEQIncrement(WOLFSSL* ssl, int order)
     5660static WC_INLINE void DtlsSEQIncrement(WOLFSSL* ssl, int order)
    51015661{
    51025662    word32 seq;
    … …  
    51265686#endif /* WOLFSSL_DTLS */
    51275687
    5128 
    5129 static INLINE void WriteSEQ(WOLFSSL* ssl, int verifyOrder, byte* out)
     5688#if defined(WOLFSSL_DTLS) || !defined(WOLFSSL_NO_TLS12)
     5689static WC_INLINE void WriteSEQ(WOLFSSL* ssl, int verifyOrder, byte* out)
    51305690{
    51315691    word32 seq[2] = {0, 0};
    … …  
    51435703    c32toa(seq[1], out + OPAQUE32_LEN);
    51445704}
    5145 #endif
    5146 
     5705#endif /* WOLFSSL_DTLS || !WOLFSSL_NO_TLS12 */
     5706#endif /* !NO_OLD_TLS || WOLFSSL_DTLS ||
     5707        *     ((HAVE_CHACHA || HAVE_AESCCM || HAVE_AESGCM) && HAVE_AEAD) */
    51475708
    51485709#ifdef WOLFSSL_DTLS
    … …  
    52545815        }
    52555816
    5256         /* if no mesage data, just return */
     5817        /* if no message data, just return */
    52575818        if (fragSz == 0)
    52585819            return 0;
    … …  
    56156176}
    56166177
     6178#ifndef WOLFSSL_NO_TLS12
     6179
    56176180ProtocolVersion MakeDTLSv1_2(void)
    56186181{
    … …  
    56236186    return pv;
    56246187}
     6188
     6189#endif /* !WOLFSSL_NO_TLS12 */
    56256190
    56266191#endif /* WOLFSSL_DTLS */
    … …  
    57866351    }
    57876352
     6353#elif defined(WOLFSSL_NUCLEUS_1_2)
     6354
     6355    #define NU_TICKS_PER_SECOND 100
     6356
     6357    word32 LowResTimer(void)
     6358    {
     6359        /* returns number of 10ms ticks, so 100 ticks/sec */
     6360        return NU_Retrieve_Clock() / NU_TICKS_PER_SECOND;
     6361    }
     6362#elif defined(WOLFSSL_APACHE_MYNEWT)
     6363
     6364    #include "os/os_time.h"
     6365    word32 LowResTimer(void)
     6366    {
     6367        word32 now;
     6368        struct os_timeval tv;
     6369        os_gettimeofday(&tv, NULL);
     6370        now = (word32)tv.tv_sec;
     6371        return now;
     6372    }
     6373
    57886374#else
    57896375    /* Posix style time */
     6376    #ifndef USER_TIME
    57906377    #include <time.h>
     6378    #endif
    57916379
    57926380    word32 LowResTimer(void)
    57936381    {
    5794         return (word32)time(0);
    5795     }
    5796 
    5797 
    5798 #endif
    5799 
     6382        return (word32)XTIME(0);
     6383    }
     6384#endif
     6385#if !defined(WOLFSSL_NO_CLIENT_AUTH) && defined(HAVE_ED25519) && \
     6386                                                !defined(NO_ED25519_CLIENT_AUTH)
     6387/* Store the message for use with CertificateVerify using Ed25519.
     6388 *
     6389 * ssl   SSL/TLS object.
     6390 * data  Message to store.
     6391 * sz    Size of message to store.
     6392 * returns MEMORY_E if not able to reallocate, otherwise 0.
     6393 */
     6394static int Ed25519Update(WOLFSSL* ssl, const byte* data, int sz)
     6395{
     6396    int   ret = 0;
     6397    byte* msgs;
     6398
     6399    if (ssl->options.cacheMessages) {
     6400        msgs = (byte*)XREALLOC(ssl->hsHashes->messages,
     6401                                                ssl->hsHashes->length + sz,
     6402                                                ssl->heap, DYNAMIC_TYPE_HASHES);
     6403        if (msgs == NULL)
     6404            ret = MEMORY_E;
     6405        if (ret == 0) {
     6406            ssl->hsHashes->messages = msgs;
     6407            XMEMCPY(msgs + ssl->hsHashes->length, data, sz);
     6408            ssl->hsHashes->prevLen = ssl->hsHashes->length;
     6409            ssl->hsHashes->length += sz;
     6410        }
     6411    }
     6412
     6413    return ret;
     6414}
     6415#endif /* HAVE_ED25519 && !WOLFSSL_NO_CLIENT_AUTH */
    58006416
    58016417#ifndef NO_CERTS
    … …  
    58396455            return ret;
    58406456#endif
     6457    #if !defined(WOLFSSL_NO_CLIENT_AUTH) && defined(HAVE_ED25519) && \
     6458                                                !defined(NO_ED25519_CLIENT_AUTH)
     6459        ret = Ed25519Update(ssl, output, sz);
     6460        if (ret != 0)
     6461            return ret;
     6462    #endif
    58416463    }
    58426464
    … …  
    58906512            return ret;
    58916513#endif
     6514    #if !defined(WOLFSSL_NO_CLIENT_AUTH) && defined(HAVE_ED25519) && \
     6515                                                !defined(NO_ED25519_CLIENT_AUTH)
     6516        ret = Ed25519Update(ssl, adj, sz);
     6517        if (ret != 0)
     6518            return ret;
     6519    #endif
    58926520    }
    58936521
    … …  
    59436571            return ret;
    59446572#endif
     6573    #if !defined(WOLFSSL_NO_CLIENT_AUTH) && defined(HAVE_ED25519) && \
     6574                                                !defined(NO_ED25519_CLIENT_AUTH)
     6575        ret = Ed25519Update(ssl, adj, sz);
     6576        if (ret != 0)
     6577            return ret;
     6578    #endif
    59456579    }
    59466580
    … …  
    59626596    rl->pvMajor = ssl->version.major;       /* type and version same in each */
    59636597#ifdef WOLFSSL_TLS13
    5964     if (IsAtLeastTLSv1_3(ssl->version))
     6598    if (IsAtLeastTLSv1_3(ssl->version)) {
     6599#ifdef WOLFSSL_TLS13_DRAFT_18
    59656600        rl->pvMinor = TLSv1_MINOR;
     6601#else
     6602        rl->pvMinor = TLSv1_2_MINOR;
     6603#endif
     6604    }
    59666605    else
    59676606#endif
    … …  
    59936632
    59946633
     6634#if !defined(WOLFSSL_NO_TLS12) || (defined(HAVE_SESSION_TICKET) && \
     6635                                                    !defined(NO_WOLFSSL_SERVER))
    59956636/* add handshake header for message */
    59966637static void AddHandShakeHeader(byte* output, word32 length,
    … …  
    60056646    /* handshake header */
    60066647    hs = (HandShakeHeader*)output;
     6648    if (hs == NULL)
     6649        return;
     6650
    60076651    hs->type = type;
    60086652    c32to24(length, hs->length);         /* type and length same for each */
    … …  
    60206664}
    60216665
    6022 
    60236666/* add both headers for handshake message */
    60246667static void AddHeaders(byte* output, word32 length, byte type, WOLFSSL* ssl)
    … …  
    60376680    AddHandShakeHeader(output + outputAdj, length, 0, length, type, ssl);
    60386681}
    6039 
    6040 
     6682#endif /* !WOLFSSL_NO_TLS12 || (HAVE_SESSION_TICKET && !NO_WOLFSSL_SERVER) */
     6683
     6684
     6685#ifndef WOLFSSL_NO_TLS12
    60416686#ifndef NO_CERTS
    60426687static void AddFragHeaders(byte* output, word32 fragSz, word32 fragOffset,
    … …  
    60586703}
    60596704#endif /* NO_CERTS */
     6705#endif /* !WOLFSSL_NO_TLS12 */
    60606706
    60616707
    60626708/* return bytes received, -1 on error */
    6063 static int Receive(WOLFSSL* ssl, byte* buf, word32 sz)
     6709static int wolfSSLReceive(WOLFSSL* ssl, byte* buf, word32 sz)
    60646710{
    60656711    int recvd;
    60666712
    6067     if (ssl->ctx->CBIORecv == NULL) {
     6713    if (ssl->CBIORecv == NULL) {
    60686714        WOLFSSL_MSG("Your IO Recv callback is null, please set");
    60696715        return -1;
    … …  
    60716717
    60726718retry:
    6073     recvd = ssl->ctx->CBIORecv(ssl, (char *)buf, (int)sz, ssl->IOCB_ReadCtx);
     6719    recvd = ssl->CBIORecv(ssl, (char *)buf, (int)sz, ssl->IOCB_ReadCtx);
    60746720    if (recvd < 0)
    60756721        switch (recvd) {
    … …  
    60996745                            XSTRNCPY(ssl->timeoutInfo.timeoutName,
    61006746                                    "recv() timeout", MAX_TIMEOUT_NAME_SZ);
     6747                            ssl->timeoutInfo.timeoutName[
     6748                                MAX_TIMEOUT_NAME_SZ] = '\0';
     6749
    61016750                            WOLFSSL_MSG("Got our timeout");
    61026751                            return WANT_READ;
    … …  
    61106759                return -1;
    61116760
     6761                #ifdef WOLFSSL_DTLS
    61126762            case WOLFSSL_CBIO_ERR_TIMEOUT:
    6113                 #ifdef WOLFSSL_DTLS
    61146763                if (IsDtlsNotSctpMode(ssl) &&
    61156764                    !ssl->options.handShakeDone &&
    … …  
    61196768                    goto retry;
    61206769                }
    6121                 #endif
    61226770                return -1;
     6771            #endif
    61236772
    61246773            default:
    … …  
    61716820int SendBuffered(WOLFSSL* ssl)
    61726821{
    6173     if (ssl->ctx->CBIOSend == NULL) {
     6822    if (ssl->CBIOSend == NULL) {
    61746823        WOLFSSL_MSG("Your IO Send callback is null, please set");
    61756824        return SOCKET_ERROR_E;
    … …  
    61856834
    61866835    while (ssl->buffers.outputBuffer.length > 0) {
    6187         int sent = ssl->ctx->CBIOSend(ssl,
     6836        int sent = ssl->CBIOSend(ssl,
    61886837                                      (char*)ssl->buffers.outputBuffer.buffer +
    61896838                                      ssl->buffers.outputBuffer.idx,
    … …  
    62106859                                XSTRNCPY(ssl->timeoutInfo.timeoutName,
    62116860                                        "send() timeout", MAX_TIMEOUT_NAME_SZ);
     6861                                ssl->timeoutInfo.timeoutName[
     6862                                    MAX_TIMEOUT_NAME_SZ] = '\0';
     6863
    62126864                                WOLFSSL_MSG("Got our timeout");
    62136865                                return WANT_WRITE;
    … …  
    62476899
    62486900/* Grow the output buffer */
    6249 static INLINE int GrowOutputBuffer(WOLFSSL* ssl, int size)
     6901static WC_INLINE int GrowOutputBuffer(WOLFSSL* ssl, int size)
    62506902{
    62516903    byte* tmp;
    … …  
    64447096    if (rh->pvMajor != ssl->version.major ||
    64457097        (rh->pvMinor != ssl->version.minor &&
    6446          (!IsAtLeastTLSv1_3(ssl->version) || rh->pvMinor != TLSv1_MINOR)))
     7098#ifdef WOLFSSL_TLS13_DRAFT_18
     7099         (!IsAtLeastTLSv1_3(ssl->version) || rh->pvMinor != TLSv1_MINOR)
     7100#else
     7101         (!IsAtLeastTLSv1_3(ssl->version) || rh->pvMinor != TLSv1_2_MINOR)
     7102#endif
     7103        ))
    64477104#endif
    64487105    {
    … …  
    64947151}
    64957152
    6496 
     7153#ifndef WOLFSSL_NO_TLS12
    64977154static int GetHandShakeHeader(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
    64987155                              byte *type, word32 *size, word32 totalSz)
    … …  
    65107167    return 0;
    65117168}
    6512 
     7169#endif
    65137170
    65147171#ifdef WOLFSSL_DTLS
    … …  
    66697326#endif
    66707327
     7328#ifndef WOLFSSL_NO_TLS12
     7329
    66717330/* Finished doesn't support SHA512, not SHA512 cipher suites yet */
    66727331static int BuildFinished(WOLFSSL* ssl, Hashes* hashes, const byte* sender)
    66737332{
    66747333    int ret = 0;
    6675 #ifdef WOLFSSL_SHA384
    6676 #ifdef WOLFSSL_SMALL_STACK
    6677     wc_Sha384* sha384;
    6678 #else
    6679     wc_Sha384 sha384[1];
    6680 #endif /* WOLFSSL_SMALL_STACK */
    6681 #endif /* WOLFSSL_SHA384 */
    66827334
    66837335    if (ssl == NULL)
    66847336        return BAD_FUNC_ARG;
    6685 
    6686 #ifdef WOLFSSL_SHA384
    6687 #ifdef WOLFSSL_SMALL_STACK
    6688     sha384 = (wc_Sha384*)XMALLOC(sizeof(wc_Sha384), ssl->heap, DYNAMIC_TYPE_HASHCTX);
    6689     if (sha384 == NULL)
    6690         return MEMORY_E;
    6691 #endif /* WOLFSSL_SMALL_STACK */
    6692 #endif /* WOLFSSL_SHA384 */
    6693 
    6694     /* store current states, building requires get_digest which resets state */
    6695 #ifdef WOLFSSL_SHA384
    6696     sha384[0] = ssl->hsHashes->hashSha384;
    6697 #endif
    66987337
    66997338#ifndef NO_TLS
    … …  
    67117350#endif
    67127351
    6713     /* restore */
    6714     if (IsAtLeastTLSv1_2(ssl)) {
    6715     #ifdef WOLFSSL_SHA384
    6716         ssl->hsHashes->hashSha384 = sha384[0];
    6717     #endif
    6718     }
    6719 
    6720 #ifdef WOLFSSL_SHA384
    6721 #ifdef WOLFSSL_SMALL_STACK
    6722     XFREE(sha384, ssl->heap, DYNAMIC_TYPE_HASHCTX);
    6723 #endif
    6724 #endif
    6725 
    67267352    return ret;
    67277353}
    67287354
    6729 
     7355#endif /* WOLFSSL_NO_TLS12 */
     7356
     7357#if !defined(NO_WOLFSSL_SERVER) || !defined(NO_WOLFSSL_CLIENT)
    67307358    /* cipher requirements */
    67317359    enum {
    … …  
    67477375    {
    67487376
     7377        (void)requirement;
     7378
     7379#ifndef WOLFSSL_NO_TLS12
     7380
     7381#ifdef HAVE_CHACHA
    67497382        if (first == CHACHA_BYTE) {
    67507383
    67517384        switch (second) {
    6752 
    67537385        case TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 :
    67547386            if (requirement == REQUIRES_RSA)
    … …  
    68047436            }
    68057437        }
     7438#endif /* HAVE_CHACHA */
    68067439
    68077440        /* ECC extensions */
    … …  
    68097442
    68107443        switch (second) {
    6811 
     7444#ifdef HAVE_ECC
    68127445#ifndef NO_RSA
    68137446        case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA :
    … …  
    68357468                return 1;
    68367469            break;
    6837 #endif
     7470    #endif /* !NO_DES3 */
    68387471
    68397472#ifndef NO_RC4
    … …  
    68497482                return 1;
    68507483            break;
    6851 #endif
     7484    #endif /* !NO_RC4 */
    68527485#endif /* NO_RSA */
    68537486
    … …  
    68627495                return 1;
    68637496            break;
    6864 #endif
     7497    #endif /* !NO_DES3  */
    68657498#ifndef NO_RC4
    68667499        case TLS_ECDHE_ECDSA_WITH_RC4_128_SHA :
    … …  
    68737506                return 1;
    68747507            break;
    6875 #endif
     7508    #endif /* !NO_RC4 */
    68767509#ifndef NO_RSA
    68777510        case TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA :
    … …  
    68867519                return 1;
    68877520            break;
    6888 #endif
     7521    #endif /* !NO_RSA */
    68897522
    68907523        case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA :
    … …  
    69277560                return 1;
    69287561            break;
     7562#endif /* HAVE_ECC */
    69297563
    69307564#ifndef NO_RSA
     7565    #ifdef HAVE_ECC
    69317566        case TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 :
    69327567            if (requirement == REQUIRES_RSA)
    … …  
    69527587                return 1;
    69537588            break;
    6954 
     7589    #endif /* HAVE_ECC */
     7590    #ifdef HAVE_AESCCM
    69557591        case TLS_RSA_WITH_AES_128_CCM_8 :
    69567592        case TLS_RSA_WITH_AES_256_CCM_8 :
    … …  
    69607596                return 1;
    69617597            break;
     7598    #endif /* HAVE_AESCCM */
     7599    #ifdef HAVE_ECC
    69627600
    69637601        case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 :
    … …  
    69747612                return 1;
    69757613            break;
    6976 #endif
    6977 
     7614    #endif /* HAVE_ECC */
     7615#endif /* !NO_RSA */
     7616
     7617#ifdef HAVE_ECC
    69787618        case TLS_ECDHE_ECDSA_WITH_AES_128_CCM :
    69797619        case TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 :
    … …  
    69967636                return 1;
    69977637            break;
    6998 
     7638#endif /* HAVE_ECC */
     7639
     7640#ifndef NO_PSK
    69997641        case TLS_PSK_WITH_AES_128_CCM:
    70007642        case TLS_PSK_WITH_AES_256_CCM:
    … …  
    70127654                return 1;
    70137655            break;
    7014 
     7656#endif /* !NO_PSK */
     7657#ifdef HAVE_ECC
    70157658        case TLS_ECDHE_ECDSA_WITH_NULL_SHA :
    70167659            if (requirement == REQUIRES_ECC)
    … …  
    70277670                return 1;
    70287671            break;
    7029 
     7672#endif /* HAVE_ECC */
    70307673        default:
    70317674            WOLFSSL_MSG("Unsupported cipher suite, CipherRequires ECC");
    … …  
    70337676        }   /* switch */
    70347677        }   /* if     */
     7678
     7679#endif /* !WOLFSSL_NO_TLS12 */
    70357680
    70367681        /* Distinct TLS v1.3 cipher suites with cipher and digest only. */
    … …  
    70547699        }
    70557700
     7701#ifndef WOLFSSL_NO_TLS12
     7702
    70567703        if (first != ECC_BYTE && first != CHACHA_BYTE &&
    70577704            first != TLS13_BYTE) {   /* normal suites */
    … …  
    70597706
    70607707#ifndef NO_RSA
     7708    #ifndef NO_RC4
    70617709        case SSL_RSA_WITH_RC4_128_SHA :
    70627710            if (requirement == REQUIRES_RSA)
    … …  
    70687716                return 1;
    70697717            break;
     7718    #endif /* NO_RC4 */
    70707719
    70717720        case SSL_RSA_WITH_3DES_EDE_CBC_SHA :
    … …  
    70747723            break;
    70757724
     7725    #ifdef HAVE_NTRU
    70767726        case TLS_NTRU_RSA_WITH_RC4_128_SHA :
    70777727            if (requirement == REQUIRES_NTRU)
    70787728                return 1;
    70797729            break;
     7730    #endif /* HAVE_NTRU */
    70807731
    70817732        case TLS_RSA_WITH_AES_128_CBC_SHA :
    … …  
    70897740            break;
    70907741
     7742    #ifdef HAVE_NTRU
    70917743        case TLS_NTRU_RSA_WITH_3DES_EDE_CBC_SHA :
    70927744            if (requirement == REQUIRES_NTRU)
    70937745                return 1;
    70947746            break;
     7747    #endif /* HAVE_NTRU */
    70957748
    70967749        case TLS_RSA_WITH_AES_256_CBC_SHA :
    … …  
    70997752            break;
    71007753
     7754    #ifdef HAVE_NTRU
    71017755        case TLS_NTRU_RSA_WITH_AES_128_CBC_SHA :
    71027756            if (requirement == REQUIRES_NTRU)
    71037757                return 1;
    71047758            break;
     7759    #endif /* HAVE_NTRU */
    71057760
    71067761        case TLS_RSA_WITH_AES_256_CBC_SHA256 :
    … …  
    71157770            break;
    71167771
     7772    #ifdef HAVE_NTRU
    71177773        case TLS_NTRU_RSA_WITH_AES_256_CBC_SHA :
    71187774            if (requirement == REQUIRES_NTRU)
    71197775                return 1;
    71207776            break;
    7121 
     7777    #endif /* HAVE_NTRU */
     7778
     7779    #ifdef HAVE_IDEA
    71227780        case SSL_RSA_WITH_IDEA_CBC_SHA :
    71237781            if (requirement == REQUIRES_RSA)
    71247782                return 1;
    71257783            break;
    7126 #endif
    7127 
     7784    #endif /* HAVE_IDEA */
     7785#endif /* !NO_RSA */
     7786
     7787#ifndef NO_PSK
    71287788        case TLS_PSK_WITH_AES_128_GCM_SHA256 :
    71297789        case TLS_PSK_WITH_AES_256_GCM_SHA384 :
    … …  
    71507810                return 1;
    71517811            break;
     7812#endif /* NO_PSK */
    71527813
    71537814#ifndef NO_RSA
    … …  
    71807841            break;
    71817842
     7843#ifndef NO_HC128
    71827844        case TLS_RSA_WITH_HC_128_MD5 :
    71837845            if (requirement == REQUIRES_RSA)
    … …  
    71947856                return 1;
    71957857            break;
    7196 
     7858#endif /* NO_HC128 */
     7859
     7860#ifdef HAVE_BLAKE2
    71977861        case TLS_RSA_WITH_AES_128_CBC_B2B256:
    71987862        case TLS_RSA_WITH_AES_256_CBC_B2B256:
    … …  
    72007864                return 1;
    72017865            break;
    7202 
     7866#endif /* HAVE_BLAKE2 */
     7867
     7868#ifndef NO_RABBIT
    72037869        case TLS_RSA_WITH_RABBIT_SHA :
    72047870            if (requirement == REQUIRES_RSA)
    72057871                return 1;
    72067872            break;
     7873#endif /* !NO_RABBIT */
    72077874
    72087875        case TLS_RSA_WITH_AES_128_GCM_SHA256 :
    … …  
    72207887            break;
    72217888
     7889#ifdef HAVE_CAMELLIA
    72227890        case TLS_RSA_WITH_CAMELLIA_128_CBC_SHA :
    72237891        case TLS_RSA_WITH_CAMELLIA_256_CBC_SHA :
    … …  
    72397907                return 1;
    72407908            break;
     7909#endif /* HAVE_CAMELLIA */
    72417910
    72427911        case TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA:
    … …  
    72547923                return 1;
    72557924            break;
     7925        case TLS_DH_anon_WITH_AES_256_GCM_SHA384:
     7926            if (requirement == REQUIRES_DHE)
     7927                return 1;
     7928            break;
    72567929#endif
    72577930#ifdef WOLFSSL_MULTICAST
    … …  
    72667939        }  /* if ECC / Normal suites else */
    72677940
     7941#endif /* !WOLFSSL_NO_TLS12 */
     7942
    72687943        return 0;
    72697944    }
     7945
     7946#endif /* !NO_WOLFSSL_SERVER && !NO_WOLFSSL_CLIENT */
    72707947
    72717948
    … …  
    72807957int MatchDomainName(const char* pattern, int len, const char* str)
    72817958{
     7959    int ret = 0;
    72827960    char p, s;
    72837961
    … …  
    72887966
    72897967        p = (char)XTOLOWER((unsigned char)*pattern++);
    7290         if (p == 0)
     7968        if (p == '\0')
    72917969            break;
    72927970
    … …  
    73127990        }
    73137991
    7314         if (*str != '\0')
     7992
     7993        if (len > 0) {
    73157994            str++;
    7316 
    7317         if (len > 0)
    73187995            len--;
    73197996    }
    7320 
    7321     return *str == '\0';
     7997    }
     7998
     7999    if (*str == '\0' && len == 0) {
     8000        ret = 1; /* success */
     8001    }
     8002
     8003    return ret;
    73228004}
    73238005
    … …  
    73378019        WOLFSSL_MSG("\tindividual AltName check");
    73388020
    7339         if (MatchDomainName(altName->name,(int)XSTRLEN(altName->name), domain)){
     8021        if (MatchDomainName(altName->name, altName->len, domain)){
    73408022            match = 1;
    73418023            break;
    … …  
    73748056        WOLFSSL_MSG("\tindividual AltName check");
    73758057
    7376         if (MatchDomainName(altName->name, (int)XSTRLEN(altName->name),
    7377                             domain)) {
     8058        if (MatchDomainName(altName->name, altName->len, domain)) {
    73788059            match = 1;
    73798060            *checkCN = 0;
    … …  
    74378118#endif
    74388119
    7439 #if defined(KEEP_PEER_CERT) || defined(SESSION_CERTS)
     8120#if defined(KEEP_PEER_CERT) || defined(SESSION_CERTS) || \
     8121    defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
    74408122/* Copy parts X509 needs from Decoded cert, 0 on success */
     8123/* The same DecodedCert cannot be copied to WOLFSSL_X509 twice otherwise the
     8124 * altNames pointers could be free'd by second x509 still active by first */
    74418125int CopyDecodedToX509(WOLFSSL_X509* x509, DecodedCert* dCert)
    74428126{
    … …  
    74528136    x509->issuer.name[ASN_NAME_MAX - 1] = '\0';
    74538137    x509->issuer.sz = (int)XSTRLEN(x509->issuer.name) + 1;
    7454 #ifdef OPENSSL_EXTRA
     8138#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
    74558139    if (dCert->issuerName.fullName != NULL) {
    74568140        XMEMCPY(&x509->issuer.fullName,
    … …  
    74648148    }
    74658149    x509->issuer.x509 = x509;
    7466 #endif /* OPENSSL_EXTRA */
     8150#endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL */
    74678151
    74688152    XSTRNCPY(x509->subject.name, dCert->subject, ASN_NAME_MAX);
    74698153    x509->subject.name[ASN_NAME_MAX - 1] = '\0';
    74708154    x509->subject.sz = (int)XSTRLEN(x509->subject.name) + 1;
    7471 #ifdef OPENSSL_EXTRA
     8155#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
    74728156    if (dCert->subjectName.fullName != NULL) {
    74738157        XMEMCPY(&x509->subject.fullName,
    … …  
    74808164    }
    74818165    x509->subject.x509 = x509;
    7482 #endif /* OPENSSL_EXTRA */
    7483 #ifdef WOLFSSL_NGINX
    7484     XMEMCPY(x509->subject.raw, dCert->subjectRaw, dCert->subjectRawLen);
    7485     x509->subject.rawLen = dCert->subjectRawLen;
     8166#endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL */
     8167#if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX)
     8168    x509->subject.rawLen = min(dCert->subjectRawLen, sizeof(x509->subject.raw));
     8169    XMEMCPY(x509->subject.raw, dCert->subjectRaw, x509->subject.rawLen);
     8170#ifdef WOLFSSL_CERT_EXT
     8171    x509->issuer.rawLen = min(dCert->issuerRawLen, sizeof(x509->issuer.raw));
     8172    XMEMCPY(x509->issuer.raw, dCert->issuerRaw, x509->issuer.rawLen);
     8173#endif
    74868174#endif
    74878175
    74888176    XMEMCPY(x509->serial, dCert->serial, EXTERNAL_SERIAL_SIZE);
    74898177    x509->serialSz = dCert->serialSz;
    7490     if (dCert->subjectCNLen < ASN_NAME_MAX) {
     8178    if (dCert->subjectCN && dCert->subjectCNLen < ASN_NAME_MAX) {
    74918179        XMEMCPY(x509->subjectCN, dCert->subjectCN, dCert->subjectCNLen);
    74928180        x509->subjectCN[dCert->subjectCNLen] = '\0';
    … …  
    75758263    x509->altNamesNext   = x509->altNames;  /* index hint */
    75768264
     8265#if (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)) && \
     8266    !defined(IGNORE_NAME_CONSTRAINTS)
     8267    /* add copies of alternate emails from dCert to X509 */
     8268    if (dCert->altEmailNames != NULL) {
     8269        DNS_entry* cur = dCert->altEmailNames;
     8270
     8271        while (cur != NULL) {
     8272            if (cur->type == ASN_RFC822_TYPE) {
     8273                DNS_entry* dnsEntry;
     8274                int strLen = cur->len;
     8275
     8276                dnsEntry = (DNS_entry*)XMALLOC(sizeof(DNS_entry), x509->heap,
     8277                                        DYNAMIC_TYPE_ALTNAME);
     8278                if (dnsEntry == NULL) {
     8279                    WOLFSSL_MSG("\tOut of Memory");
     8280                    return MEMORY_E;
     8281                }
     8282
     8283                dnsEntry->type = ASN_RFC822_TYPE;
     8284                dnsEntry->name = (char*)XMALLOC(strLen + 1, x509->heap,
     8285                                         DYNAMIC_TYPE_ALTNAME);
     8286                if (dnsEntry->name == NULL) {
     8287                    WOLFSSL_MSG("\tOut of Memory");
     8288                    XFREE(dnsEntry, x509->heap, DYNAMIC_TYPE_ALTNAME);
     8289                    return MEMORY_E;
     8290                }
     8291                dnsEntry->len = strLen;
     8292                XMEMCPY(dnsEntry->name, cur->name, strLen);
     8293                dnsEntry->name[strLen] = '\0';
     8294
     8295                dnsEntry->next = x509->altNames;
     8296                x509->altNames = dnsEntry;
     8297            }
     8298            cur = cur->next;
     8299        }
     8300    }
     8301#endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL */
     8302
    75778303    x509->isCa = dCert->isCA;
    7578 #ifdef OPENSSL_EXTRA
     8304#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
    75798305    x509->pathLength = dCert->pathLength;
    75808306    x509->keyUsage = dCert->extKeyUsage;
    … …  
    76578383        }
    76588384    #endif /* WOLFSSL_CERT_EXT */
    7659 #endif /* OPENSSL_EXTRA */
    7660 #ifdef HAVE_ECC
     8385#endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL */
     8386#if defined(HAVE_ECC) || defined(HAVE_ED25519)
    76618387    x509->pkCurveOID = dCert->pkCurveOID;
    76628388#endif /* HAVE_ECC */
    … …  
    76668392
    76678393#endif /* KEEP_PEER_CERT || SESSION_CERTS */
     8394
     8395#if defined(HAVE_CERTIFICATE_STATUS_REQUEST) || \
     8396     (defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2) && !defined(WOLFSSL_NO_TLS12))
     8397static int ProcessCSR(WOLFSSL* ssl, byte* input, word32* inOutIdx,
     8398                      word32 status_length)
     8399{
     8400    int ret = 0;
     8401    OcspRequest* request;
     8402
     8403    #ifdef WOLFSSL_SMALL_STACK
     8404        CertStatus* status;
     8405        OcspResponse* response;
     8406    #else
     8407        CertStatus status[1];
     8408        OcspResponse response[1];
     8409    #endif
     8410
     8411    do {
     8412        #ifdef HAVE_CERTIFICATE_STATUS_REQUEST
     8413            if (ssl->status_request) {
     8414                request = (OcspRequest*)TLSX_CSR_GetRequest(ssl->extensions);
     8415                ssl->status_request = 0;
     8416                break;
     8417            }
     8418        #endif
     8419
     8420        #ifdef HAVE_CERTIFICATE_STATUS_REQUEST_V2
     8421            if (ssl->status_request_v2) {
     8422                request = (OcspRequest*)TLSX_CSR2_GetRequest(ssl->extensions,
     8423                                                          WOLFSSL_CSR2_OCSP, 0);
     8424                ssl->status_request_v2 = 0;
     8425                break;
     8426            }
     8427        #endif
     8428
     8429        return BUFFER_ERROR;
     8430    } while(0);
     8431
     8432    if (request == NULL)
     8433        return BAD_CERTIFICATE_STATUS_ERROR; /* not expected */
     8434
     8435    #ifdef WOLFSSL_SMALL_STACK
     8436        status = (CertStatus*)XMALLOC(sizeof(CertStatus), ssl->heap,
     8437                                                      DYNAMIC_TYPE_OCSP_STATUS);
     8438        response = (OcspResponse*)XMALLOC(sizeof(OcspResponse), ssl->heap,
     8439                                                     DYNAMIC_TYPE_OCSP_REQUEST);
     8440
     8441        if (status == NULL || response == NULL) {
     8442            if (status)
     8443                XFREE(status, NULL, DYNAMIC_TYPE_OCSP_STATUS);
     8444            if (response)
     8445                XFREE(response, NULL, DYNAMIC_TYPE_OCSP_REQUEST);
     8446
     8447            return MEMORY_ERROR;
     8448        }
     8449    #endif
     8450
     8451    InitOcspResponse(response, status, input +*inOutIdx, status_length);
     8452
     8453    if (OcspResponseDecode(response, ssl->ctx->cm, ssl->heap, 0) != 0)
     8454        ret = BAD_CERTIFICATE_STATUS_ERROR;
     8455    else if (CompareOcspReqResp(request, response) != 0)
     8456        ret = BAD_CERTIFICATE_STATUS_ERROR;
     8457    else if (response->responseStatus != OCSP_SUCCESSFUL)
     8458        ret = BAD_CERTIFICATE_STATUS_ERROR;
     8459    else if (response->status->status == CERT_REVOKED)
     8460        ret = OCSP_CERT_REVOKED;
     8461    else if (response->status->status != CERT_GOOD)
     8462        ret = BAD_CERTIFICATE_STATUS_ERROR;
     8463
     8464    *inOutIdx += status_length;
     8465
     8466    #ifdef WOLFSSL_SMALL_STACK
     8467        XFREE(status,   ssl->heap, DYNAMIC_TYPE_OCSP_STATUS);
     8468        XFREE(response, ssl->heap, DYNAMIC_TYPE_OCSP_REQUEST);
     8469    #endif
     8470
     8471    return ret;
     8472}
     8473#endif
     8474
     8475
     8476
     8477#ifdef HAVE_PK_CALLBACKS
     8478
     8479#ifdef HAVE_ECC
     8480    static int SigPkCbEccVerify(const unsigned char* sig, unsigned int sigSz,
     8481       const unsigned char* hash, unsigned int hashSz,
     8482       const unsigned char* keyDer, unsigned int keySz,
     8483       int* result, void* ctx)
     8484    {
     8485        int ret = NOT_COMPILED_IN;
     8486        WOLFSSL* ssl = (WOLFSSL*)ctx;
     8487
     8488        if (ssl && ssl->ctx->EccVerifyCb) {
     8489            ret = ssl->ctx->EccVerifyCb(ssl, sig, sigSz, hash, hashSz,
     8490                keyDer, keySz, result, ssl->EccVerifyCtx);
     8491        }
     8492        return ret;
     8493    }
     8494#endif
     8495#ifndef NO_RSA
     8496    static int SigPkCbRsaVerify(unsigned char* sig, unsigned int sigSz,
     8497       unsigned char** out, const unsigned char* keyDer, unsigned int keySz,
     8498       void* ctx)
     8499    {
     8500        int ret = NOT_COMPILED_IN;
     8501        WOLFSSL* ssl = (WOLFSSL*)ctx;
     8502
     8503        if (ssl && ssl->ctx->RsaVerifyCb) {
     8504            ret = ssl->ctx->RsaVerifyCb(ssl, sig, sigSz, out, keyDer, keySz,
     8505                ssl->RsaVerifyCtx);
     8506        }
     8507        return ret;
     8508    }
     8509#endif
     8510
     8511int InitSigPkCb(WOLFSSL* ssl, SignatureCtx* sigCtx)
     8512{
     8513    if (ssl == NULL || sigCtx == NULL)
     8514        return BAD_FUNC_ARG;
     8515
     8516    /* only setup the verify callback if a PK is set */
     8517#ifdef HAVE_ECC
     8518    if (ssl->ctx->EccVerifyCb) {
     8519        sigCtx->pkCbEcc = SigPkCbEccVerify;
     8520        sigCtx->pkCtxEcc = ssl;
     8521    }
     8522#endif
     8523#ifndef NO_RSA
     8524    /* only setup the verify callback if a PK is set */
     8525    if (ssl->ctx->RsaVerifyCb) {
     8526        sigCtx->pkCbRsa = SigPkCbRsaVerify;
     8527        sigCtx->pkCtxRsa = ssl;
     8528    }
     8529#endif
     8530
     8531    return 0;
     8532}
     8533
     8534#endif /* HAVE_PK_CALLBACKS */
     8535
    76688536
    76698537typedef struct ProcPeerCertArgs {
    76708538    buffer*      certs;
    76718539#ifdef WOLFSSL_TLS13
    7672     buffer*      exts; /* extentions */
     8540    buffer*      exts; /* extensions */
    76738541#endif
    76748542    DecodedCert* dCert;
    7675     char*  domain;
    76768543    word32 idx;
    76778544    word32 begin;
    76788545    int    totalCerts; /* number of certs in certs buffer */
    76798546    int    count;
    7680     int    dCertInit;
    76818547    int    certIdx;
    7682     int    fatal;
    76838548    int    lastErr;
    76848549#ifdef WOLFSSL_ALT_CERT_CHAINS
    … …  
    76888553    byte   ctxSz;
    76898554#endif
     8555#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
     8556    char   untrustedDepth;
     8557#endif
     8558    word16 fatal:1;
     8559    word16 verifyErr:1;
     8560    word16 dCertInit:1;
    76908561#ifdef WOLFSSL_TRUST_PEER_CERT
    7691     byte haveTrustPeer; /* was cert verified by loaded trusted peer cert */
    7692 #endif
    7693 #ifdef OPENSSL_EXTRA
    7694     char   untrustedDepth;
     8562    word16 haveTrustPeer:1; /* was cert verified by loaded trusted peer cert */
    76958563#endif
    76968564} ProcPeerCertArgs;
     8565
     8566/* WOLFSSL_ALWAYS_VERIFY_CB: Use verify callback for success or failure cases */
     8567/* WOLFSSL_VERIFY_CB_ALL_CERTS: Issue callback for all intermediate certificates */
     8568
     8569/* Callback is issued for certificate presented in TLS Certificate (11) packet.
     8570 * The intermediates are done first then peer leaf cert last. Use the
     8571 * store->error_depth member to determine index (0=peer, >1 intermediates)
     8572 */
     8573
     8574static int DoVerifyCallback(WOLFSSL* ssl, int ret, ProcPeerCertArgs* args)
     8575{
     8576    int verify_ok = 0, alertWhy = 0, use_cb = 0;
     8577
     8578    /* Determine return code and alert reason */
     8579    if (ret != 0) {
     8580        alertWhy = bad_certificate;
     8581        if (ret == ASN_AFTER_DATE_E ||
     8582            ret == ASN_BEFORE_DATE_E) {
     8583            alertWhy = certificate_expired;
     8584    }
     8585    }
     8586    else {
     8587        verify_ok = 1;
     8588    }
     8589
     8590    /* Determine if verify callback should be used */
     8591    if (ret != 0) {
     8592        if (!ssl->options.verifyNone) {
     8593            use_cb = 1; /* always report errors */
     8594        }
     8595    }
     8596#ifdef WOLFSSL_ALWAYS_VERIFY_CB
     8597    /* always use verify callback on peer leaf cert */
     8598    if (args->certIdx == 0) {
     8599        use_cb = 1;
     8600    }
     8601#endif
     8602#ifdef WOLFSSL_VERIFY_CB_ALL_CERTS
     8603    /* perform verify callback on other intermediate certs (not just peer) */
     8604    if (args->certIdx > 0) {
     8605        use_cb = 1;
     8606}
     8607#endif
     8608
     8609    /* if verify callback has been set */
     8610    if (use_cb && ssl->verifyCallback) {
     8611    #ifdef WOLFSSL_SMALL_STACK
     8612        WOLFSSL_X509_STORE_CTX* store;
     8613        #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
     8614        WOLFSSL_X509* x509;
     8615        #endif
     8616        char* domain = NULL;
     8617#else
     8618        WOLFSSL_X509_STORE_CTX store[1];
     8619        #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
     8620        WOLFSSL_X509           x509[1];
     8621#endif
     8622        char domain[ASN_NAME_MAX];
     8623#endif
     8624
     8625    #ifdef WOLFSSL_SMALL_STACK
     8626        store = (WOLFSSL_X509_STORE_CTX*)XMALLOC(
     8627            sizeof(WOLFSSL_X509_STORE_CTX), ssl->heap, DYNAMIC_TYPE_X509_STORE);
     8628        if (store == NULL) {
     8629            return MEMORY_E;
     8630        }
     8631        #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
     8632        x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), ssl->heap,
     8633            DYNAMIC_TYPE_X509);
     8634        if (x509 == NULL) {
     8635            XFREE(store, ssl->heap, DYNAMIC_TYPE_X509);
     8636            return MEMORY_E;
     8637    }
     8638#endif
     8639        domain = (char*)XMALLOC(ASN_NAME_MAX, ssl->heap, DYNAMIC_TYPE_STRING);
     8640        if (domain == NULL) {
     8641            XFREE(store, ssl->heap, DYNAMIC_TYPE_X509);
     8642            #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
     8643            XFREE(x509, ssl->heap, DYNAMIC_TYPE_X509);
     8644    #endif
     8645            return MEMORY_E;
     8646    }
     8647    #endif /* WOLFSSL_SMALL_STACK */
     8648
     8649        XMEMSET(store, 0, sizeof(WOLFSSL_X509_STORE_CTX));
     8650    #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
     8651        XMEMSET(x509, 0, sizeof(WOLFSSL_X509));
     8652        #endif
     8653        domain[0] = '\0';
     8654
     8655        /* build subject CN as string to return in store */
     8656        if (args->dCertInit && args->dCert && args->dCert->subjectCN) {
     8657            int subjectCNLen = args->dCert->subjectCNLen;
     8658            if (subjectCNLen > ASN_NAME_MAX-1)
     8659                subjectCNLen = ASN_NAME_MAX-1;
     8660            if (subjectCNLen > 0) {
     8661                XMEMCPY(domain, args->dCert->subjectCN, subjectCNLen);
     8662                domain[subjectCNLen] = '\0';
     8663            }
     8664        }
     8665
     8666        store->error = ret;
     8667        store->error_depth = args->certIdx;
     8668        store->discardSessionCerts = 0;
     8669        store->domain = domain;
     8670        store->userCtx = ssl->verifyCbCtx;
     8671        store->certs = args->certs;
     8672        store->totalCerts = args->totalCerts;
     8673        store->ex_data = ssl;
     8674
     8675    #if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER)
     8676        if (ssl->ctx->x509_store_pt != NULL) {
     8677            store->store = ssl->ctx->x509_store_pt;
     8678        }
     8679        else {
     8680            store->store = &ssl->ctx->x509_store;
     8681        }
     8682    #endif
     8683    #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
     8684        #ifdef KEEP_PEER_CERT
     8685        if (args->certIdx == 0) {
     8686            store->current_cert = &ssl->peerCert; /* use existing X509 */
     8687        }
     8688        else
     8689        #endif
     8690        {
     8691            InitX509(x509, 0, ssl->heap);
     8692            if (CopyDecodedToX509(x509, args->dCert) == 0) {
     8693                store->current_cert = x509;
     8694            }
     8695        }
     8696    #endif
     8697    #ifdef SESSION_CERTS
     8698        store->sesChain = &ssl->session.chain;
     8699    #endif
     8700        /* non-zero return code indicates failure override */
     8701        if (ssl->verifyCallback(verify_ok, store)) {
     8702            if (ret != 0) {
     8703                WOLFSSL_MSG("Verify callback overriding error!");
     8704                ret = 0;
     8705            }
     8706        }
     8707        else {
     8708            /* induce error if one not present */
     8709            if (ret == 0) {
     8710                ret = VERIFY_CERT_ERROR;
     8711            }
     8712
     8713            /* mark as verify error */
     8714            args->verifyErr = 1;
     8715        }
     8716    #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
     8717        if (args->certIdx > 0)
     8718            FreeX509(x509);
     8719    #endif
     8720    #if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA)
     8721        wolfSSL_sk_X509_free(store->chain);
     8722        store->chain = NULL;
     8723    #endif
     8724    #ifdef SESSION_CERTS
     8725        if (store->discardSessionCerts) {
     8726            WOLFSSL_MSG("Verify callback requested discard sess certs");
     8727            ssl->session.chain.count = 0;
     8728        #ifdef WOLFSSL_ALT_CERT_CHAINS
     8729            ssl->session.altChain.count = 0;
     8730        #endif
     8731        }
     8732    #endif /* SESSION_CERTS */
     8733    #ifdef WOLFSSL_SMALL_STACK
     8734        XFREE(domain, ssl->heap, DYNAMIC_TYPE_STRING);
     8735        #if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
     8736        XFREE(x509, ssl->heap, DYNAMIC_TYPE_X509);
     8737        #endif
     8738        XFREE(store, ssl->heap, DYNAMIC_TYPE_X509_STORE);
     8739    #endif
     8740    }
     8741
     8742    if (ret != 0) {
     8743        if (!ssl->options.verifyNone) {
     8744            /* handle failure */
     8745            SendAlert(ssl, alert_fatal, alertWhy); /* try to send */
     8746            ssl->options.isClosed = 1;
     8747        }
     8748
     8749        /* Report SSL error */
     8750        ssl->error = ret;
     8751    }
     8752
     8753    return ret;
     8754}
    76978755
    76988756static void FreeProcPeerCertArgs(WOLFSSL* ssl, void* pArgs)
    … …  
    77028760    (void)ssl;
    77038761
    7704     if (args->domain) {
    7705         XFREE(args->domain, ssl->heap, DYNAMIC_TYPE_STRING);
    7706         args->domain = NULL;
    7707     }
    77088762    if (args->certs) {
    77098763        XFREE(args->certs, ssl->heap, DYNAMIC_TYPE_DER);
    … …  
    77298783                     word32 totalSz)
    77308784{
    7731     int ret = 0;
     8785    int ret = 0, sigRet = 0;
    77328786#ifdef WOLFSSL_ASYNC_CRYPT
    77338787    ProcPeerCertArgs* args = (ProcPeerCertArgs*)ssl->async.args;
    77348788    typedef char args_test[sizeof(ssl->async.args) >= sizeof(*args) ? 1 : -1];
    77358789    (void)sizeof(args_test);
     8790#elif defined(WOLFSSL_NONBLOCK_OCSP)
     8791    ProcPeerCertArgs* args = ssl->nonblockarg;
     8792#elif defined(WOLFSSL_SMALL_STACK)
     8793    ProcPeerCertArgs* args = NULL;
    77368794#else
    77378795    ProcPeerCertArgs  args[1];
    … …  
    77538811    }
    77548812    else
     8813#elif defined(WOLFSSL_NONBLOCK_OCSP)
     8814    if (args == NULL) {
     8815        args = (ProcPeerCertArgs*)XMALLOC(
     8816            sizeof(ProcPeerCertArgs), ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
     8817        if (args == NULL) {
     8818            ERROR_OUT(MEMORY_E, exit_ppc);
     8819        }
     8820    }
     8821    if (ssl->nonblockarg == NULL) /* new args */
     8822#elif defined(WOLFSSL_SMALL_STACK)
     8823    args = (ProcPeerCertArgs*)XMALLOC(
     8824        sizeof(ProcPeerCertArgs), ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
     8825    if (args == NULL) {
     8826        ERROR_OUT(MEMORY_E, exit_ppc);
     8827    }
    77558828#endif
    77568829    {
    … …  
    77638836    #ifdef WOLFSSL_ASYNC_CRYPT
    77648837        ssl->async.freeArgs = FreeProcPeerCertArgs;
     8838    #elif defined(WOLFSSL_NONBLOCK_OCSP)
     8839        ssl->nonblockarg = args;
    77658840    #endif
    77668841    }
    … …  
    77748849        #ifdef WOLFSSL_CALLBACKS
    77758850            if (ssl->hsInfoOn)
    7776                 AddPacketName("Certificate", &ssl->handShakeInfo);
     8851                AddPacketName(ssl, "Certificate");
    77778852            if (ssl->toInfoOn)
    77788853                AddLateName("Certificate", &ssl->timeoutInfo);
    … …  
    78428917
    78438918            /* allocate buffer for certs */
     8919        #ifdef OPENSSL_EXTRA
     8920            args->certs = (buffer*)XMALLOC(sizeof(buffer) *
     8921                    (ssl->verifyDepth + 1), ssl->heap, DYNAMIC_TYPE_DER);
     8922            if (args->certs == NULL) {
     8923                ERROR_OUT(MEMORY_E, exit_ppc);
     8924            }
     8925            XMEMSET(args->certs, 0, sizeof(buffer) * (ssl->verifyDepth + 1));
     8926        #else
    78448927            args->certs = (buffer*)XMALLOC(sizeof(buffer) * MAX_CHAIN_DEPTH,
    78458928                                            ssl->heap, DYNAMIC_TYPE_DER);
    … …  
    78488931            }
    78498932            XMEMSET(args->certs, 0, sizeof(buffer) * MAX_CHAIN_DEPTH);
    7850 
     8933        #endif /* OPENSSL_EXTRA */
    78518934            /* Certificate List */
    78528935            if ((args->idx - args->begin) + OPAQUE24_LEN > totalSz) {
    … …  
    78558938            c24to32(input + args->idx, &listSz);
    78568939            args->idx += OPAQUE24_LEN;
    7857             if (listSz > MAX_RECORD_SIZE) {
     8940            if (listSz > MAX_CERTIFICATE_SZ) {
    78588941                ERROR_OUT(BUFFER_ERROR, exit_ppc);
    78598942            }
    … …  
    78688951                word32 certSz;
    78698952
    7870                 if (args->totalCerts >= MAX_CHAIN_DEPTH) {
    78718953                #ifdef OPENSSL_EXTRA
     8954                if (args->totalCerts > ssl->verifyDepth) {
    78728955                    ssl->peerVerifyRet = X509_V_ERR_CERT_CHAIN_TOO_LONG;
    7873                 #endif
    78748956                    ERROR_OUT(MAX_CHAIN_ERROR, exit_ppc);
    78758957                }
     8958            #else
     8959                if (args->totalCerts >= ssl->verifyDepth ||
     8960                        args->totalCerts >= MAX_CHAIN_DEPTH) {
     8961                    ERROR_OUT(MAX_CHAIN_ERROR, exit_ppc);
     8962                }
     8963            #endif
    78768964
    78778965                if ((args->idx - args->begin) + OPAQUE24_LEN > totalSz) {
    … …  
    79139001                    args->idx += extSz;
    79149002                    listSz -= extSz + OPAQUE16_LEN;
     9003                    ret = TLSX_Parse(ssl, args->exts[args->totalCerts].buffer,
     9004                        args->exts[args->totalCerts].length, certificate, NULL);
     9005                    if (ret < 0)
     9006                        return ret;
    79159007                }
    79169008            #endif
    … …  
    79249016
    79259017            args->dCertInit = 0;
     9018#ifndef WOLFSSL_SMALL_CERT_VERIFY
    79269019            args->dCert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), ssl->heap,
    79279020                                                       DYNAMIC_TYPE_DCERT);
    … …  
    79299022                ERROR_OUT(MEMORY_E, exit_ppc);
    79309023            }
     9024#endif
    79319025
    79329026            /* Advance state and proceed */
    … …  
    79479041
    79489042                    if (!args->dCertInit) {
     9043#ifdef WOLFSSL_SMALL_CERT_VERIFY
     9044                        if (args->dCert == NULL) {
     9045                            args->dCert = (DecodedCert*)XMALLOC(
     9046                                                 sizeof(DecodedCert), ssl->heap,
     9047                                                 DYNAMIC_TYPE_DCERT);
     9048                            if (args->dCert == NULL) {
     9049                                ERROR_OUT(MEMORY_E, exit_ppc);
     9050                            }
     9051                        }
     9052#endif
     9053
    79499054                        InitDecodedCert(args->dCert,
    79509055                            cert->buffer, cert->length, ssl->heap);
    … …  
    79549059                    #endif
    79559060                        args->dCertInit = 1;
     9061                    #ifdef HAVE_PK_CALLBACKS
     9062                        ret = InitSigPkCb(ssl, &args->dCert->sigCtx);
     9063                        if (ret != 0)
     9064                            goto exit_ppc;
     9065                    #endif
    79569066                    }
    79579067
    79589068                    ret = ParseCertRelative(args->dCert, CERT_TYPE, 0,
    79599069                                                            ssl->ctx->cm);
    7960                     if (ret != 0 && ret != WC_PENDING_E)
    7961                         goto exit_ppc;
    7962 
    79639070                #ifdef WOLFSSL_ASYNC_CRYPT
    79649071                    if (ret == WC_PENDING_E) {
    … …  
    79689075                    }
    79699076                #endif
     9077                    if (ret != 0)
     9078                        goto exit_ppc;
    79709079
    79719080                #ifndef NO_SKID
    … …  
    80159124
    80169125                    if (!args->dCertInit) {
     9126#ifdef WOLFSSL_SMALL_CERT_VERIFY
     9127                        if (args->dCert == NULL) {
     9128                            args->dCert = (DecodedCert*)XMALLOC(
     9129                                                 sizeof(DecodedCert), ssl->heap,
     9130                                                 DYNAMIC_TYPE_DCERT);
     9131                            if (args->dCert == NULL) {
     9132                                ERROR_OUT(MEMORY_E, exit_ppc);
     9133                            }
     9134                        }
     9135#endif
     9136
    80179137                        InitDecodedCert(args->dCert,
    80189138                            cert->buffer, cert->length, ssl->heap);
    … …  
    80229142                    #endif
    80239143                        args->dCertInit = 1;
     9144                    #ifdef HAVE_PK_CALLBACKS
     9145                        ret = InitSigPkCb(ssl, &args->dCert->sigCtx);
     9146                        if (ret != 0)
     9147                            goto exit_ppc;
     9148                    #endif
    80249149                    }
    80259150
    80269151                    ret = ParseCertRelative(args->dCert, CERT_TYPE, 0,
    80279152                                                                  ssl->ctx->cm);
    8028                     if (ret != 0 && ret != WC_PENDING_E) {
    8029                         goto exit_ppc;
    8030                     }
    80319153                #ifdef WOLFSSL_ASYNC_CRYPT
    80329154                    if (ret == WC_PENDING_E) {
    … …  
    80369158                    }
    80379159                #endif
     9160                    if (ret != 0) {
     9161                        goto exit_ppc;
     9162                    }
    80389163
    80399164                #ifndef NO_SKID
    … …  
    80449169                    if (!AlreadySigner(ssl->ctx->cm, subjectHash))
    80459170                        args->untrustedDepth = 1;
     9171
    80469172                    FreeDecodedCert(args->dCert);
    80479173                    args->dCertInit = 0;
    … …  
    80619187                    cert = &args->certs[args->certIdx];
    80629188
     9189#ifdef WOLFSSL_SMALL_CERT_VERIFY
     9190                    sigRet = 0;
     9191
     9192                    if (!ssl->options.verifyNone) {
     9193                        if (args->dCert != NULL) {
     9194                            if (args->dCertInit) {
     9195                                FreeDecodedCert(args->dCert);
     9196                                args->dCertInit = 0;
     9197                            }
     9198                            XFREE(args->dCert, ssl->heap, DYNAMIC_TYPE_DCERT);
     9199                            args->dCert = NULL;
     9200                        }
     9201                        sigRet = CheckCertSignature(cert->buffer, cert->length,
     9202                                                       ssl->heap, ssl->ctx->cm);
     9203                    }
     9204#endif
    80639205                    if (!args->dCertInit) {
     9206#ifdef WOLFSSL_SMALL_CERT_VERIFY
     9207                        if (args->dCert == NULL) {
     9208                            args->dCert = (DecodedCert*)XMALLOC(
     9209                                                 sizeof(DecodedCert), ssl->heap,
     9210                                                 DYNAMIC_TYPE_DCERT);
     9211                            if (args->dCert == NULL) {
     9212                                ERROR_OUT(MEMORY_E, exit_ppc);
     9213                            }
     9214                        }
     9215#endif
     9216
    80649217                        InitDecodedCert(args->dCert,
    80659218                            cert->buffer, cert->length, ssl->heap);
    … …  
    80699222                    #endif
    80709223                        args->dCertInit = 1;
     9224                    #ifdef HAVE_PK_CALLBACKS
     9225                        ret = InitSigPkCb(ssl, &args->dCert->sigCtx);
     9226                        if (ret != 0)
     9227                            goto exit_ppc;
     9228                    #endif
    80719229                    }
    80729230
     9231                    /* check if returning from non-blocking OCSP */
     9232                #ifdef WOLFSSL_NONBLOCK_OCSP
     9233                    if (args->lastErr != OCSP_WANT_READ)
     9234                    {
     9235                #endif
     9236
     9237#ifndef WOLFSSL_SMALL_CERT_VERIFY
     9238                    sigRet = ParseCertRelative(args->dCert, CERT_TYPE,
     9239                                    !ssl->options.verifyNone, ssl->ctx->cm);
     9240#else
    80739241                    ret = ParseCertRelative(args->dCert, CERT_TYPE,
    8074                                     !ssl->options.verifyNone, ssl->ctx->cm);
     9242                             !ssl->options.verifyNone ? VERIFY_NAME : NO_VERIFY,
     9243                             ssl->ctx->cm);
     9244                    if (ret != 0) {
     9245                        sigRet = ret;
     9246                        ret = 0;
     9247                    }
     9248#endif
    80759249                #ifdef WOLFSSL_ASYNC_CRYPT
    8076                     if (ret == WC_PENDING_E) {
     9250                    if (sigRet == WC_PENDING_E) {
    80779251                        ret = wolfSSL_AsyncPush(ssl,
    80789252                            args->dCert->sigCtx.asyncDev);
    … …  
    80989272                                    WOLFSSL_MSG(
    80999273                                        "RSA key size in cert chain error");
    8100                                     ret = RSA_KEY_SIZE_E;
     9274                                    sigRet = RSA_KEY_SIZE_E;
    81019275                                }
    81029276                                break;
    … …  
    81099283                                    WOLFSSL_MSG(
    81109284                                        "ECC key size in cert chain error");
    8111                                     ret = ECC_KEY_SIZE_E;
     9285                                    sigRet = ECC_KEY_SIZE_E;
    81129286                                }
    81139287                                break;
    … …  
    81209294                                    WOLFSSL_MSG(
    81219295                                        "ECC key size in cert chain error");
    8122                                     ret = ECC_KEY_SIZE_E;
     9296                                    sigRet = ECC_KEY_SIZE_E;
    81239297                                }
    81249298                                break;
    … …  
    81329306                    } /* if (!ssl->options.verifyNone) */
    81339307
    8134                     if (ret == 0 && args->dCert->isCA == 0) {
     9308                    if (sigRet == 0 && args->dCert->isCA == 0) {
    81359309                        WOLFSSL_MSG("Chain cert is not a CA, not adding as one");
    81369310                    }
    8137                     else if (ret == 0 && ssl->options.verifyNone) {
     9311                    else if (sigRet == 0 && ssl->options.verifyNone) {
    81389312                        WOLFSSL_MSG("Chain cert not verified by option, not adding as CA");
    81399313                    }
    8140                     else if (ret == 0 && !AlreadySigner(ssl->ctx->cm, subjectHash)) {
     9314                    else if (sigRet == 0 && !AlreadySigner(ssl->ctx->cm, subjectHash)) {
    81419315                        DerBuffer* add = NULL;
    81429316                        ret = AllocDer(&add, cert->length, CA_TYPE, ssl->heap);
    … …  
    81489322                        XMEMCPY(add->buffer, cert->buffer, cert->length);
    81499323
    8150                     #ifdef WOLFSSL_NGINX
     9324                    #if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX)
    81519325                        if (args->certIdx > args->untrustedDepth)
    8152                             args->untrustedDepth = args->certIdx + 1;
     9326                            args->untrustedDepth = (char)args->certIdx + 1;
    81539327                    #endif
    81549328
    … …  
    81669340
    81679341                            /* clear last CA fail since CA cert was validated */
     9342                            if (!args->verifyErr)
    81689343                            args->lastCaErr = 0;
    81699344
    … …  
    81759350                    #endif
    81769351                    }
    8177                     else if (ret != 0) {
     9352                    else if (sigRet != 0) {
    81789353                        WOLFSSL_MSG("Failed to verify CA from chain");
    8179                     #ifdef WOLFSSL_ALT_CERT_CHAINS
    8180                         if (args->lastCaErr == 0) {
    8181                             /* store CA error and proceed to next cert */
    8182                             args->lastCaErr = ret;
    8183                             ret = 0;
    8184                         }
    8185                         else {
    8186                             args->lastErr = args->lastCaErr;
    8187                         }
    8188                     #endif
    81899354                    #ifdef OPENSSL_EXTRA
    81909355                        ssl->peerVerifyRet = X509_V_ERR_INVALID_CA;
    … …  
    81959360                    }
    81969361
     9362                #ifdef WOLFSSL_NONBLOCK_OCSP
     9363                    }
     9364                    else {
     9365                        args->lastErr = 0; /* clear last error */
     9366                    }
     9367                #endif
     9368
    81979369            #if defined(HAVE_OCSP) || defined(HAVE_CRL)
    8198                     if (ret == 0) {
     9370                    if (ret == 0 && sigRet == 0) {
    81999371                        int doCrlLookup = 1;
    82009372                #ifdef HAVE_OCSP
    … …  
    82119383                            ret = CheckCertOCSP_ex(ssl->ctx->cm->ocsp,
    82129384                                                    args->dCert, NULL, ssl);
    8213                         #ifdef WOLFSSL_ASYNC_CRYPT
    8214                             /* non-blocking socket re-entry requires async */
    8215                             if (ret == WANT_READ) {
     9385                        #ifdef WOLFSSL_NONBLOCK_OCSP
     9386                            if (ret == OCSP_WANT_READ) {
     9387                                args->lastErr = ret;
    82169388                                goto exit_ppc;
    82179389                            }
    … …  
    82319403                            WOLFSSL_MSG("Doing Non Leaf CRL check");
    82329404                            ret = CheckCertCRL(ssl->ctx->cm->crl, args->dCert);
    8233                         #ifdef WOLFSSL_ASYNC_CRYPT
    8234                             /* non-blocking socket re-entry requires async */
    8235                             if (ret == WANT_READ) {
     9405                        #ifdef WOLFSSL_NONBLOCK_OCSP
     9406                            if (ret == OCSP_WANT_READ) {
     9407                                args->lastErr = ret;
    82369408                                goto exit_ppc;
    82379409                            }
    … …  
    82439415                #endif /* HAVE_CRL */
    82449416                        (void)doCrlLookup;
     9417
     9418                        if (ret != 0)
     9419                            sigRet = ret;
    82459420                    }
    82469421            #endif /* HAVE_OCSP || HAVE_CRL */
    82479422
    8248                     if (ret != 0 && args->lastErr == 0) {
    8249                         args->lastErr = ret;   /* save error from last time */
    8250                         ret = 0; /* reset error */
     9423                    /* Do verify callback */
     9424                    sigRet = DoVerifyCallback(ssl, sigRet, args);
     9425
     9426                    /* Handle error codes */
     9427                #ifdef WOLFSSL_ALT_CERT_CHAINS
     9428                    if (args->lastCaErr == 0) {
     9429                        /* capture CA error and proceed to next cert */
     9430                        args->lastCaErr = sigRet;
     9431                        sigRet = 0;
     9432                    }
     9433                    else {
     9434                        args->lastErr = args->lastCaErr;
     9435                    }
     9436                #endif
     9437                    if (sigRet != 0 && args->lastErr == 0) {
     9438                        args->lastErr = sigRet;  /* save error from last time */
     9439                        sigRet = 0; /* reset error */
    82519440                    }
    82529441
    … …  
    82579446            } /* if (count > 0) */
    82589447
     9448            if (sigRet != 0)
     9449                ret = sigRet;
    82599450            /* Check for error */
    82609451            if (ret != 0) {
    … …  
    82769467                cert = &args->certs[args->certIdx];
    82779468
     9469#ifdef WOLFSSL_SMALL_CERT_VERIFY
     9470                sigRet = 0;
     9471
     9472                if (!ssl->options.verifyNone) {
     9473                    if (args->dCert != NULL) {
     9474                        if (args->dCertInit) {
     9475                            FreeDecodedCert(args->dCert);
     9476                            args->dCertInit = 0;
     9477                        }
     9478                        XFREE(args->dCert, ssl->heap, DYNAMIC_TYPE_DCERT);
     9479                        args->dCert = NULL;
     9480                    }
     9481                    sigRet = CheckCertSignature(cert->buffer, cert->length,
     9482                                                       ssl->heap, ssl->ctx->cm);
     9483                }
     9484#endif
    82789485                if (!args->dCertInit) {
     9486                    if (args->dCert == NULL) {
     9487                        args->dCert = (DecodedCert*)XMALLOC(sizeof(DecodedCert),
     9488                                                 ssl->heap, DYNAMIC_TYPE_DCERT);
     9489                        if (args->dCert == NULL) {
     9490                            ERROR_OUT(MEMORY_E, exit_ppc);
     9491                        }
     9492                    }
     9493
    82799494                    InitDecodedCert(args->dCert,
    82809495                        cert->buffer, cert->length, ssl->heap);
    … …  
    82849499                #endif
    82859500                    args->dCertInit = 1;
     9501                #ifdef HAVE_PK_CALLBACKS
     9502                    ret = InitSigPkCb(ssl, &args->dCert->sigCtx);
     9503                    if (ret != 0)
     9504                        goto exit_ppc;
     9505                #endif
    82869506                }
    82879507
    … …  
    82919511                {
    82929512                    /* only parse if not already present in dCert from above */
     9513#ifndef WOLFSSL_SMALL_CERT_VERIFY
     9514                    sigRet = ParseCertRelative(args->dCert, CERT_TYPE,
     9515                                    !ssl->options.verifyNone, ssl->ctx->cm);
     9516#else
    82939517                    ret = ParseCertRelative(args->dCert, CERT_TYPE,
    8294                                     !ssl->options.verifyNone, ssl->ctx->cm);
     9518                             !ssl->options.verifyNone ? VERIFY_NAME : NO_VERIFY,
     9519                             ssl->ctx->cm);
     9520                    if (ret != 0) {
     9521                        sigRet = ret;
     9522                        ret = 0;
     9523                    }
     9524#endif
    82959525                #ifdef WOLFSSL_ASYNC_CRYPT
    8296                     if (ret == WC_PENDING_E) {
     9526                    if (sigRet == WC_PENDING_E) {
    82979527                        ret = wolfSSL_AsyncPush(ssl,
    82989528                            args->dCert->sigCtx.asyncDev);
    … …  
    83029532                }
    83039533
    8304                 if (ret == 0) {
     9534                if (sigRet == 0) {
    83059535                    WOLFSSL_MSG("Verified Peer's cert");
    83069536                #ifdef OPENSSL_EXTRA
    … …  
    83139543                    }
    83149544                #endif /* SESSION_CERTS && WOLFSSL_ALT_CERT_CHAINS */
     9545
     9546                    /* check if fatal error */
     9547                    if (args->verifyErr) {
     9548                        args->fatal = 1;
     9549                        if (sigRet == 0) {
     9550                            sigRet = args->lastErr;
     9551                        }
     9552                    #ifdef WOLFSSL_ALT_CERT_CHAINS
     9553                        if (sigRet == 0) {
     9554                            sigRet = args->lastCaErr;
     9555                        }
     9556                    #endif
     9557                    }
     9558                    else {
    83159559                    args->fatal = 0;
    83169560                }
    8317                 else if (ret == ASN_PARSE_E || ret == BUFFER_E) {
     9561                }
     9562                else if (sigRet == ASN_PARSE_E || sigRet == BUFFER_E) {
    83189563                    WOLFSSL_MSG("Got Peer cert ASN PARSE or BUFFER ERROR");
    83199564                #ifdef OPENSSL_EXTRA
     9565                    SendAlert(ssl, alert_fatal, bad_certificate);
    83209566                    ssl->peerVerifyRet = X509_V_ERR_CERT_REJECTED;
    83219567                #endif
    … …  
    83309576                        WOLFSSL_MSG(
    83319577                            "\tCallback override available, will continue");
    8332                         args->fatal = 0;
     9578                        /* check if fatal error */
     9579                        args->fatal = (args->verifyErr) ? 1 : 0;
    83339580                    }
    83349581                    else {
    83359582                        WOLFSSL_MSG("\tNo callback override available, fatal");
    83369583                        args->fatal = 1;
     9584                    #ifdef OPENSSL_EXTRA
     9585                        SendAlert(ssl, alert_fatal, bad_certificate);
     9586                    #endif
    83379587                    }
    83389588                }
    … …  
    83509600                                "Peer sent different cert during scr, fatal");
    83519601                            args->fatal = 1;
    8352                             ret   = SCR_DIFFERENT_CERT_E;
     9602                            sigRet   = SCR_DIFFERENT_CERT_E;
    83539603                        }
    83549604                    }
    … …  
    83619611                }
    83629612            #endif /* HAVE_SECURE_RENEGOTIATION */
    8363 
     9613            } /* if (count > 0) */
     9614
     9615            if (sigRet != 0)
     9616                ret = sigRet;
     9617            /* Check for error */
     9618            if (args->fatal && ret != 0) {
     9619                goto exit_ppc;
     9620            }
     9621
     9622            /* Advance state and proceed */
     9623            ssl->options.asyncState = TLS_ASYNC_VERIFY;
     9624        } /* case TLS_ASYNC_DO */
     9625        FALL_THROUGH;
     9626
     9627        case TLS_ASYNC_VERIFY:
     9628        {
     9629            if (args->count > 0) {
    83649630            #if defined(HAVE_OCSP) || defined(HAVE_CRL)
    83659631                if (args->fatal == 0) {
    … …  
    83729638                                                    args->dCert, ssl->heap);
    83739639                            doLookup = 0;
     9640                        #ifdef WOLFSSL_TLS13
     9641                            if (ssl->options.tls1_3) {
     9642                                TLSX* ext = TLSX_Find(ssl->extensions,
     9643                                                           TLSX_STATUS_REQUEST);
     9644                                if (ext != NULL) {
     9645                                    word32 idx = 0;
     9646                                    CertificateStatusRequest* csr =
     9647                                           (CertificateStatusRequest*)ext->data;
     9648                                    ret = ProcessCSR(ssl, csr->response.buffer,
     9649                                                    &idx, csr->response.length);
     9650                                    if (ret < 0)
     9651                                        goto exit_ppc;
     9652                                }
     9653                            }
     9654                        #endif
    83749655                        }
    83759656                #endif /* HAVE_CERTIFICATE_STATUS_REQUEST */
    … …  
    83889669                        ret = CheckCertOCSP_ex(ssl->ctx->cm->ocsp,
    83899670                                                    args->dCert, NULL, ssl);
    8390                     #ifdef WOLFSSL_ASYNC_CRYPT
    8391                         /* non-blocking socket re-entry requires async */
    8392                         if (ret == WANT_READ) {
     9671                    #ifdef WOLFSSL_NONBLOCK_OCSP
     9672                        if (ret == OCSP_WANT_READ) {
    83939673                            goto exit_ppc;
    83949674                        }
    … …  
    84099689                        WOLFSSL_MSG("Doing Leaf CRL check");
    84109690                        ret = CheckCertCRL(ssl->ctx->cm->crl, args->dCert);
    8411                     #ifdef WOLFSSL_ASYNC_CRYPT
    8412                         /* non-blocking socket re-entry requires async */
    8413                         if (ret == WANT_READ) {
     9691                    #ifdef WOLFSSL_NONBLOCK_OCSP
     9692                        if (ret == OCSP_WANT_READ) {
    84149693                            goto exit_ppc;
    84159694                        }
    … …  
    84339712                    int copyRet = CopyDecodedToX509(&ssl->peerCert,
    84349713                                                                args->dCert);
    8435                     if (copyRet == MEMORY_E)
     9714                    if (copyRet == MEMORY_E) {
    84369715                        args->fatal = 1;
    84379716                }
     9717                }
    84389718            #endif /* KEEP_PEER_CERT */
    84399719
    84409720            #ifndef IGNORE_KEY_EXTENSIONS
     9721                #if defined(OPENSSL_EXTRA)
     9722                  /* when compatibility layer is turned on and no verify is
     9723                   * set then ignore the certificate key extension */
     9724                    if (args->dCert->extKeyUsageSet &&
     9725                          args->dCert->extKeyUsageCrit == 0 &&
     9726                          ssl->options.verifyNone) {
     9727                        WOLFSSL_MSG("Not verifying certificate key usage");
     9728                    }
     9729                    else
     9730                #endif
    84419731                if (args->dCert->extKeyUsageSet) {
    84429732                    if ((ssl->specs.kea == rsa_kea) &&
    … …  
    84549744                }
    84559745
     9746                #if defined(OPENSSL_EXTRA)
     9747                    /* when compatibility layer is turned on and no verify is
     9748                     * set then ignore the certificate key extension */
     9749                    if (args->dCert->extExtKeyUsageSet &&
     9750                            args->dCert->extExtKeyUsageCrit == 0 &&
     9751                          ssl->options.verifyNone) {
     9752                                WOLFSSL_MSG("Not verifying certificate ext key usage");
     9753                    }
     9754                    else
     9755                #endif
    84569756                if (args->dCert->extExtKeyUsageSet) {
    84579757                    if (ssl->options.side == WOLFSSL_CLIENT_END) {
    … …  
    84759775                    ssl->error = ret;
    84769776                #ifdef OPENSSL_EXTRA
     9777                    SendAlert(ssl, alert_fatal, bad_certificate);
    84779778                    ssl->peerVerifyRet = X509_V_ERR_CERT_REJECTED;
    84789779                #endif
    … …  
    84819782
    84829783                ssl->options.havePeerCert = 1;
    8483             } /* if (count > 0) */
    8484 
    8485             /* Check for error */
    8486             if (args->fatal && ret != 0) {
    8487                 goto exit_ppc;
    8488             }
    8489 
    8490             /* Advance state and proceed */
    8491             ssl->options.asyncState = TLS_ASYNC_VERIFY;
    8492         } /* case TLS_ASYNC_DO */
    8493         FALL_THROUGH;
    8494 
    8495         case TLS_ASYNC_VERIFY:
    8496         {
    8497             if (args->count > 0) {
    8498                 args->domain = (char*)XMALLOC(ASN_NAME_MAX, ssl->heap,
    8499                                                     DYNAMIC_TYPE_STRING);
    8500                 if (args->domain == NULL) {
    8501                     ERROR_OUT(MEMORY_E, exit_ppc);
     9784
     9785                if (!ssl->options.verifyNone && ssl->buffers.domainName.buffer) {
     9786                #ifndef WOLFSSL_ALLOW_NO_CN_IN_SAN
     9787                    /* Per RFC 5280 section 4.2.1.6, "Whenever such identities
     9788                     * are to be bound into a certificate, the subject
     9789                     * alternative name extension MUST be used." */
     9790                    if (args->dCert->altNames) {
     9791                        if (CheckAltNames(args->dCert,
     9792                                (char*)ssl->buffers.domainName.buffer) == 0 ) {
     9793                            WOLFSSL_MSG("DomainName match on alt names failed");
     9794                            /* try to get peer key still */
     9795                            ret = DOMAIN_NAME_MISMATCH;
    85029796                }
    8503 
    8504                 /* store for callback use */
    8505                 if (args->dCert->subjectCNLen < ASN_NAME_MAX) {
    8506                     XMEMCPY(args->domain, args->dCert->subjectCN, args->dCert->subjectCNLen);
    8507                     args->domain[args->dCert->subjectCNLen] = '\0';
    85089797                }
    85099798                else {
    8510                     args->domain[0] = '\0';
     9799                        if (MatchDomainName(
     9800                                 args->dCert->subjectCN,
     9801                                 args->dCert->subjectCNLen,
     9802                                 (char*)ssl->buffers.domainName.buffer) == 0) {
     9803                            WOLFSSL_MSG("DomainName match on common name failed");
     9804                            ret = DOMAIN_NAME_MISMATCH;
    85119805                }
    8512 
    8513                 if (!ssl->options.verifyNone && ssl->buffers.domainName.buffer) {
     9806                    }
     9807                #else /* WOLFSSL_ALL_NO_CN_IN_SAN */
     9808                    /* Old behavior. */
    85149809                    if (MatchDomainName(args->dCert->subjectCN,
    85159810                                args->dCert->subjectCNLen,
    … …  
    85249819                        }
    85259820                    }
     9821                #endif /* WOLFSSL_ALL_NO_CN_IN_SAN */
    85269822                }
    85279823
    … …  
    85999895                    case ECDSAk:
    86009896                    {
    8601                         int curveId;
    86029897                        int keyRet = 0;
     9898                        word32 idx = 0;
     9899
    86039900                        if (ssl->peerEccDsaKey == NULL) {
    86049901                            /* alloc/init on demand */
    … …  
    86119908                        }
    86129909
    8613                         curveId = wc_ecc_get_oid(args->dCert->keyOID, NULL, NULL);
    86149910                        if (keyRet != 0 ||
    8615                             wc_ecc_import_x963_ex(args->dCert->publicKey,
    8616                                     args->dCert->pubKeySize, ssl->peerEccDsaKey,
    8617                                                             curveId) != 0) {
     9911                            wc_EccPublicKeyDecode(args->dCert->publicKey, &idx,
     9912                                                ssl->peerEccDsaKey,
     9913                                                args->dCert->pubKeySize) != 0) {
    86189914                            ret = PEER_KEY_ERROR;
    86199915                        }
    … …  
    86979993                        break;
    86989994                    }
    8699                 #endif /* HAVE_ECC */
     9995                #endif /* HAVE_ED25519 */
    87009996                    default:
    87019997                        break;
    87029998                }
    87039999
    8704                 FreeDecodedCert(args->dCert);
    8705                 args->dCertInit = 0;
    8706 
    8707                 /* release since we don't need it anymore */
    8708                 if (args->dCert) {
    8709                     XFREE(args->dCert, ssl->heap, DYNAMIC_TYPE_DCERT);
    8710                     args->dCert = NULL;
    8711                 }
     10000                /* args->dCert free'd in function cleanup after callback */
    871210001            } /* if (count > 0) */
    871310002
    … …  
    872410013        case TLS_ASYNC_FINALIZE:
    872510014        {
    8726         #ifdef WOLFSSL_SMALL_STACK
    8727             WOLFSSL_X509_STORE_CTX* store = (WOLFSSL_X509_STORE_CTX*)XMALLOC(
    8728                                     sizeof(WOLFSSL_X509_STORE_CTX), ssl->heap,
    8729                                                     DYNAMIC_TYPE_X509_STORE);
    8730             if (store == NULL) {
    8731                 ERROR_OUT(MEMORY_E, exit_ppc);
    8732             }
    8733         #else
    8734             WOLFSSL_X509_STORE_CTX  store[1];
    8735         #endif
    8736 
    8737             XMEMSET(store, 0, sizeof(WOLFSSL_X509_STORE_CTX));
    8738 
    873910015            /* load last error */
    874010016            if (args->lastErr != 0 && ret == 0) {
    … …  
    874810024            }
    874910025        #endif
    8750             if (ret != 0) {
    8751                 if (!ssl->options.verifyNone) {
    8752                     int why = bad_certificate;
    8753 
    8754                     if (ret == ASN_AFTER_DATE_E || ret == ASN_BEFORE_DATE_E) {
    8755                         why = certificate_expired;
    8756                     }
    8757                     if (ssl->verifyCallback) {
    8758                         int ok;
    8759 
    8760                         store->error = ret;
    8761                         store->error_depth = args->totalCerts;
    8762                         store->discardSessionCerts = 0;
    8763                         store->domain = args->domain;
    8764                         store->userCtx = ssl->verifyCbCtx;
    8765                         store->certs = args->certs;
    8766                         store->totalCerts = args->totalCerts;
    8767                     #ifdef KEEP_PEER_CERT
    8768                         if (ssl->peerCert.subject.sz > 0)
    8769                             store->current_cert = &ssl->peerCert;
    8770                         else
    8771                             store->current_cert = NULL;
    8772                     #else
    8773                         store->current_cert = NULL;
    8774                     #endif /* KEEP_PEER_CERT */
    8775                     #if defined(HAVE_EX_DATA) || defined(HAVE_FORTRESS)
    8776                         store->ex_data = ssl;
    8777                     #endif
    8778                         ok = ssl->verifyCallback(0, store);
    8779                         if (ok) {
    8780                             WOLFSSL_MSG("Verify callback overriding error!");
    8781                             ret = 0;
    8782                         }
    8783                     #ifdef SESSION_CERTS
    8784                         if (store->discardSessionCerts) {
    8785                             WOLFSSL_MSG("Verify callback requested discard sess certs");
    8786                             ssl->session.chain.count = 0;
    8787                         #ifdef WOLFSSL_ALT_CERT_CHAINS
    8788                             ssl->session.altChain.count = 0;
    8789                         #endif
    8790                         }
    8791                     #endif /* SESSION_CERTS */
    8792                     }
    8793                     if (ret != 0) {
    8794                         SendAlert(ssl, alert_fatal, why);   /* try to send */
    8795                         ssl->options.isClosed = 1;
    8796                     }
    8797                 }
    8798                 ssl->error = ret;
    8799             }
    8800         #ifdef WOLFSSL_ALWAYS_VERIFY_CB
    8801             else {
    8802                 if (ssl->verifyCallback) {
    8803                     int ok;
    8804 
    8805                     store->error = ret;
    8806                 #ifdef WOLFSSL_WPAS
    8807                     store->error_depth = 0;
    8808                 #else
    8809                     store->error_depth = args->totalCerts;
    8810                 #endif
    8811                     store->discardSessionCerts = 0;
    8812                     store->domain = args->domain;
    8813                     store->userCtx = ssl->verifyCbCtx;
    8814                     store->certs = args->certs;
    8815                     store->totalCerts = args->totalCerts;
    8816                 #ifdef KEEP_PEER_CERT
    8817                     if (ssl->peerCert.subject.sz > 0)
    8818                         store->current_cert = &ssl->peerCert;
    8819                     else
    8820                         store->current_cert = NULL;
    8821                 #endif
    8822                     store->ex_data = ssl;
    8823 
    8824                     ok = ssl->verifyCallback(1, store);
    8825                     if (!ok) {
    8826                         WOLFSSL_MSG("Verify callback overriding valid certificate!");
    8827                         ret = -1;
    8828                         SendAlert(ssl, alert_fatal, bad_certificate);
    8829                         ssl->options.isClosed = 1;
    8830                     }
    8831                 #ifdef SESSION_CERTS
    8832                     if (store->discardSessionCerts) {
    8833                         WOLFSSL_MSG("Verify callback requested discard sess certs");
    8834                         ssl->session.chain.count = 0;
    8835                     #ifdef WOLFSSL_ALT_CERT_CHAINS
    8836                         ssl->session.altChain.count = 0;
    8837                     #endif
    8838                     }
    8839                 #endif /* SESSION_CERTS */
    8840                 }
    8841             }
    8842         #endif /* WOLFSSL_ALWAYS_VERIFY_CB */
     10026
     10027            /* Do verify callback */
     10028            ret = DoVerifyCallback(ssl, ret, args);
    884310029
    884410030            if (ssl->options.verifyNone &&
    … …  
    885610042            }
    885710043
    8858         #ifdef WOLFSSL_SMALL_STACK
    8859             XFREE(store, ssl->heap, DYNAMIC_TYPE_X509_STORE);
    8860         #endif
    886110044            /* Advance state and proceed */
    886210045            ssl->options.asyncState = TLS_ASYNC_END;
    … …  
    888010063    WOLFSSL_LEAVE("ProcessPeerCerts", ret);
    888110064
    8882 #ifdef WOLFSSL_ASYNC_CRYPT
    8883     if (ret == WC_PENDING_E || ret == WANT_READ) {
    8884         /* Mark message as not recevied so it can process again */
     10065
     10066#if defined(WOLFSSL_ASYNC_CRYPT) || defined(WOLFSSL_NONBLOCK_OCSP)
     10067    if (ret == WC_PENDING_E || ret == OCSP_WANT_READ) {
     10068        /* Mark message as not received so it can process again */
    888510069        ssl->msgsReceived.got_certificate = 0;
    888610070
    888710071        return ret;
    888810072    }
    8889 #endif /* WOLFSSL_ASYNC_CRYPT */
     10073#endif /* WOLFSSL_ASYNC_CRYPT || WOLFSSL_NONBLOCK_OCSP */
    889010074
    889110075    FreeProcPeerCertArgs(ssl, args);
     10076
     10077#if defined(WOLFSSL_ASYNC_CRYPT)
     10078#elif defined(WOLFSSL_NONBLOCK_OCSP)
     10079    XFREE(args, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
     10080    ssl->nonblockarg = NULL;
     10081#elif defined(WOLFSSL_SMALL_STACK)
     10082    XFREE(args, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
     10083#endif
     10084
    889210085    FreeKeyExchange(ssl);
    889310086
    … …  
    889510088}
    889610089
     10090#ifndef WOLFSSL_NO_TLS12
     10091
     10092/* handle processing of certificate (11) */
    889710093static int DoCertificate(WOLFSSL* ssl, byte* input, word32* inOutIdx,
    889810094                                                                word32 size)
    889910095{
    8900     return ProcessPeerCerts(ssl, input, inOutIdx, size);
     10096    int ret;
     10097
     10098    WOLFSSL_START(WC_FUNC_CERTIFICATE_DO);
     10099    WOLFSSL_ENTER("DoCertificate");
     10100
     10101#ifdef SESSION_CERTS
     10102    /* Reset the session cert chain count in case the session resume failed. */
     10103    ssl->session.chain.count = 0;
     10104    #ifdef WOLFSSL_ALT_CERT_CHAINS
     10105        ssl->session.altChain.count = 0;
     10106    #endif
     10107#endif /* SESSION_CERTS */
     10108
     10109    ret = ProcessPeerCerts(ssl, input, inOutIdx, size);
     10110
     10111#ifdef OPENSSL_EXTRA
     10112    ssl->options.serverState = SERVER_CERT_COMPLETE;
     10113#endif
     10114
     10115    WOLFSSL_LEAVE("DoCertificate", ret);
     10116    WOLFSSL_END(WC_FUNC_CERTIFICATE_DO);
     10117
     10118    return ret;
    890110119}
    890210120
     10121/* handle processing of certificate_status (22) */
    890310122static int DoCertificateStatus(WOLFSSL* ssl, byte* input, word32* inOutIdx,
    890410123                                                                    word32 size)
    … …  
    890810127    word32 status_length;
    890910128
     10129    WOLFSSL_START(WC_FUNC_CERTIFICATE_STATUS_DO);
     10130    WOLFSSL_ENTER("DoCertificateStatus");
     10131
    891010132    if (size < ENUM_LEN + OPAQUE24_LEN)
    891110133        return BUFFER_ERROR;
    … …  
    892510147
    892610148        /* WOLFSSL_CSR_OCSP overlaps with WOLFSSL_CSR2_OCSP */
    8927         case WOLFSSL_CSR2_OCSP: {
     10149        case WOLFSSL_CSR2_OCSP:
     10150            ret = ProcessCSR(ssl, input, inOutIdx, status_length);
     10151            break;
     10152
     10153    #endif
     10154
     10155    #if defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
     10156
     10157        case WOLFSSL_CSR2_OCSP_MULTI: {
    892810158            OcspRequest* request;
     10159            word32 list_length = status_length;
     10160            byte   idx = 0;
    892910161
    893010162            #ifdef WOLFSSL_SMALL_STACK
    … …  
    893710169
    893810170            do {
    8939                 #ifdef HAVE_CERTIFICATE_STATUS_REQUEST
    8940                     if (ssl->status_request) {
    8941                         request = (OcspRequest*)TLSX_CSR_GetRequest(
    8942                                                                ssl->extensions);
    8943                         ssl->status_request = 0;
    8944                         break;
    8945                     }
    8946                 #endif
    8947 
    8948                 #ifdef HAVE_CERTIFICATE_STATUS_REQUEST_V2
    8949                     if (ssl->status_request_v2) {
    8950                         request = (OcspRequest*)TLSX_CSR2_GetRequest(
    8951                                                ssl->extensions, status_type, 0);
    8952                         ssl->status_request_v2 = 0;
    8953                         break;
    8954                     }
    8955                 #endif
    8956 
    8957                 return BUFFER_ERROR;
    8958             } while(0);
    8959 
    8960             if (request == NULL)
    8961                 return BAD_CERTIFICATE_STATUS_ERROR; /* not expected */
    8962 
    8963             #ifdef WOLFSSL_SMALL_STACK
    8964                 status = (CertStatus*)XMALLOC(sizeof(CertStatus), ssl->heap,
    8965                                                        DYNAMIC_TYPE_OCSP_STATUS);
    8966                 response = (OcspResponse*)XMALLOC(sizeof(OcspResponse), ssl->heap,
    8967                                                        DYNAMIC_TYPE_OCSP_REQUEST);
    8968 
    8969                 if (status == NULL || response == NULL) {
    8970                     if (status)
    8971                         XFREE(status, NULL, DYNAMIC_TYPE_OCSP_STATUS);
    8972                     if (response)
    8973                         XFREE(response, NULL, DYNAMIC_TYPE_OCSP_REQUEST);
    8974 
    8975                     return MEMORY_ERROR;
    8976                 }
    8977             #endif
    8978 
    8979             InitOcspResponse(response, status, input +*inOutIdx, status_length);
    8980 
    8981             if (OcspResponseDecode(response, ssl->ctx->cm, ssl->heap, 0) != 0)
    8982                 ret = BAD_CERTIFICATE_STATUS_ERROR;
    8983             else if (CompareOcspReqResp(request, response) != 0)
    8984                 ret = BAD_CERTIFICATE_STATUS_ERROR;
    8985             else if (response->responseStatus != OCSP_SUCCESSFUL)
    8986                 ret = BAD_CERTIFICATE_STATUS_ERROR;
    8987             else if (response->status->status == CERT_REVOKED)
    8988                 ret = OCSP_CERT_REVOKED;
    8989             else if (response->status->status != CERT_GOOD)
    8990                 ret = BAD_CERTIFICATE_STATUS_ERROR;
    8991 
    8992             *inOutIdx += status_length;
    8993 
    8994             #ifdef WOLFSSL_SMALL_STACK
    8995                 XFREE(status,   ssl->heap, DYNAMIC_TYPE_OCSP_STATUS);
    8996                 XFREE(response, ssl->heap, DYNAMIC_TYPE_OCSP_REQUEST);
    8997             #endif
    8998 
    8999         }
    9000         break;
    9001 
    9002     #endif
    9003 
    9004     #if defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
    9005 
    9006         case WOLFSSL_CSR2_OCSP_MULTI: {
    9007             OcspRequest* request;
    9008             word32 list_length = status_length;
    9009             byte   idx = 0;
    9010 
    9011             #ifdef WOLFSSL_SMALL_STACK
    9012                 CertStatus* status;
    9013                 OcspResponse* response;
    9014             #else
    9015                 CertStatus status[1];
    9016                 OcspResponse response[1];
    9017             #endif
    9018 
    9019             do {
    902010171                if (ssl->status_request_v2) {
    902110172                    ssl->status_request_v2 = 0;
    … …  
    910510256        SendAlert(ssl, alert_fatal, bad_certificate_status_response);
    910610257
     10258    if (IsEncryptionOn(ssl, 0)) {
     10259        if (*inOutIdx + ssl->keys.padSz > size)
     10260            return BUFFER_E;
     10261        *inOutIdx += ssl->keys.padSz;
     10262    }
     10263
     10264    WOLFSSL_LEAVE("DoCertificateStatus", ret);
     10265    WOLFSSL_END(WC_FUNC_CERTIFICATE_STATUS_DO);
     10266
    910710267    return ret;
    910810268}
    910910269
     10270#endif /* !WOLFSSL_NO_TLS12 */
     10271
    911010272#endif /* !NO_CERTS */
    911110273
     10274#ifndef WOLFSSL_NO_TLS12
    911210275
    911310276static int DoHelloRequest(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
    … …  
    911610279    (void)input;
    911710280
     10281    WOLFSSL_START(WC_FUNC_HELLO_REQUEST_DO);
     10282    WOLFSSL_ENTER("DoHelloRequest");
     10283
    911810284    if (size) /* must be 0 */
    911910285        return BUFFER_ERROR;
    … …  
    913410300    else if (ssl->secure_renegotiation && ssl->secure_renegotiation->enabled) {
    913510301        ssl->secure_renegotiation->startScr = 1;
     10302        WOLFSSL_LEAVE("DoHelloRequest", 0);
     10303        WOLFSSL_END(WC_FUNC_HELLO_REQUEST_DO);
    913610304        return 0;
    913710305    }
    … …  
    914810316    word32 finishedSz = (ssl->options.tls ? TLS_FINISHED_SZ : FINISHED_SZ);
    914910317
     10318    WOLFSSL_START(WC_FUNC_FINISHED_DO);
     10319    WOLFSSL_ENTER("DoFinished");
     10320
    915010321    if (finishedSz != size)
    915110322        return BUFFER_ERROR;
    … …  
    915610327
    915710328    #ifdef WOLFSSL_CALLBACKS
    9158         if (ssl->hsInfoOn) AddPacketName("Finished", &ssl->handShakeInfo);
     10329        if (ssl->hsInfoOn) AddPacketName(ssl, "Finished");
    915910330        if (ssl->toInfoOn) AddLateName("Finished", &ssl->timeoutInfo);
    916010331    #endif
    … …  
    917610347            XMEMCPY(ssl->secure_renegotiation->client_verify_data,
    917710348                    input + *inOutIdx, TLS_FINISHED_SZ);
     10349        ssl->secure_renegotiation->verifySet = 1;
    917810350    }
    917910351#endif
    … …  
    918410356    if (ssl->options.side == WOLFSSL_CLIENT_END) {
    918510357        ssl->options.serverState = SERVER_FINISHED_COMPLETE;
     10358#ifdef OPENSSL_EXTRA
     10359                ssl->cbmode = SSL_CB_MODE_WRITE;
     10360                ssl->options.clientState = CLIENT_FINISHED_COMPLETE;
     10361#endif
    918610362        if (!ssl->options.resuming) {
     10363#ifdef OPENSSL_EXTRA
     10364                        if (ssl->CBIS != NULL) {
     10365                                ssl->CBIS(ssl, SSL_CB_CONNECT_LOOP, SSL_SUCCESS);
     10366                        }
     10367#endif
    918710368            ssl->options.handShakeState = HANDSHAKE_DONE;
    918810369            ssl->options.handShakeDone  = 1;
    … …  
    919110372    else {
    919210373        ssl->options.clientState = CLIENT_FINISHED_COMPLETE;
     10374#ifdef OPENSSL_EXTRA
     10375        ssl->cbmode = SSL_CB_MODE_READ;
     10376        ssl->options.serverState = SERVER_FINISHED_COMPLETE;
     10377#endif
    919310378        if (ssl->options.resuming) {
     10379#ifdef OPENSSL_EXTRA
     10380                        if (ssl->CBIS != NULL) {
     10381                                ssl->CBIS(ssl, SSL_CB_ACCEPT_LOOP, SSL_SUCCESS);
     10382                        }
     10383#endif
    919410384            ssl->options.handShakeState = HANDSHAKE_DONE;
    919510385            ssl->options.handShakeDone  = 1;
    919610386        }
    919710387    }
     10388
     10389    WOLFSSL_LEAVE("DoFinished", 0);
     10390    WOLFSSL_END(WC_FUNC_FINISHED_DO);
    919810391
    919910392    return 0;
    … …  
    952410717                  (ssl->keys.encryptionOn ? ssl->keys.padSz : 0);
    952510718
     10719#if !defined(WOLFSSL_NO_SERVER) && \
     10720    defined(HAVE_SECURE_RENEGOTIATION) && \
     10721    defined(HAVE_SERVER_RENEGOTIATION_INFO)
     10722    if (ssl->options.handShakeDone && type == client_hello &&
     10723            ssl->secure_renegotiation &&
     10724            ssl->secure_renegotiation->enabled)
     10725    {
     10726        WOLFSSL_MSG("Reset handshake state");
     10727        XMEMSET(&ssl->msgsReceived, 0, sizeof(MsgsReceived));
     10728        ssl->options.serverState = NULL_STATE;
     10729        ssl->options.clientState = NULL_STATE;
     10730        ssl->options.connectState = CONNECT_BEGIN;
     10731        ssl->options.acceptState = ACCEPT_FIRST_REPLY_DONE;
     10732        ssl->options.handShakeState = NULL_STATE;
     10733        ssl->secure_renegotiation->cache_status = SCR_CACHE_NEEDED;
     10734
     10735        ret = InitHandshakeHashes(ssl);
     10736        if (ret != 0)
     10737            return ret;
     10738    }
     10739#endif
     10740
    952610741    /* sanity check msg received */
    952710742    if ( (ret = SanityCheckMsgReceived(ssl, type)) != 0) {
    … …  
    953010745    }
    953110746
    9532 #ifdef WOLFSSL_CALLBACKS
     10747#if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
    953310748    /* add name later, add on record and handshake header part back on */
    953410749    if (ssl->toInfoOn) {
    953510750        int add = RECORD_HEADER_SZ + HANDSHAKE_HEADER_SZ;
    9536         AddPacketInfo(0, &ssl->timeoutInfo, input + *inOutIdx - add,
    9537                       size + add, ssl->heap);
     10751        AddPacketInfo(ssl, 0, handshake, input + *inOutIdx - add,
     10752                      size + add, READ_PROTO, ssl->heap);
     10753        #ifdef WOLFSSL_CALLBACKS
    953810754        AddLateRecordHeader(&ssl->curRL, &ssl->timeoutInfo);
     10755        #endif
    953910756    }
    954010757#endif
    … …  
    957310790     * hashed later if the DTLS cookie is correct. */
    957410791    if (type != hello_request &&
    9575             !(IsDtlsNotSctpMode(ssl) && type == client_hello) &&
    9576             ssl->error != WC_PENDING_E) {
     10792            !(IsDtlsNotSctpMode(ssl) && type == client_hello)
     10793    #ifdef WOLFSSL_ASYNC_CRYPT
     10794            && ssl->error != WC_PENDING_E
     10795    #endif
     10796    #ifdef WOLFSSL_NONBLOCK_OCSP
     10797            && ssl->error != OCSP_WANT_READ
     10798    #endif
     10799    ) {
    957710800        ret = HashInput(ssl, input + *inOutIdx, size);
    957810801        if (ret != 0) return ret;
    957910802    }
     10803
     10804#ifdef OPENSSL_EXTRA
     10805    if (ssl->CBIS != NULL){
     10806                ssl->cbmode = SSL_CB_MODE_READ;
     10807                ssl->cbtype = type;
     10808                ssl->CBIS(ssl, SSL_CB_ACCEPT_LOOP, SSL_SUCCESS);
     10809    }
     10810#endif
    958010811
    958110812    switch (type) {
    … …  
    959510826        WOLFSSL_MSG("processing server hello");
    959610827        ret = DoServerHello(ssl, input, inOutIdx, size);
     10828    #if !defined(WOLFSSL_NO_CLIENT_AUTH) && defined(HAVE_ED25519) && \
     10829                                                !defined(NO_ED25519_CLIENT_AUTH)
     10830        if (ssl->options.resuming || !IsAtLeastTLSv1_2(ssl) ||
     10831                                               IsAtLeastTLSv1_3(ssl->version)) {
     10832
     10833        #if defined(WOLFSSL_ASYNC_CRYPT) || defined(WOLFSSL_NONBLOCK_OCSP)
     10834            if (ret != WC_PENDING_E && ret != OCSP_WANT_READ)
     10835        #endif
     10836            {
     10837                ssl->options.cacheMessages = 0;
     10838                if (ssl->hsHashes->messages != NULL) {
     10839                    XFREE(ssl->hsHashes->messages, ssl->heap,
     10840                        DYNAMIC_TYPE_HASHES);
     10841                    ssl->hsHashes->messages = NULL;
     10842                }
     10843            }
     10844        }
     10845    #endif
    959710846        break;
    959810847
    … …  
    963310882    #ifdef WOLFSSL_CALLBACKS
    963410883        if (ssl->hsInfoOn)
    9635             AddPacketName("ServerHelloDone", &ssl->handShakeInfo);
     10884            AddPacketName(ssl, "ServerHelloDone");
    963610885        if (ssl->toInfoOn)
    963710886            AddLateName("ServerHelloDone", &ssl->timeoutInfo);
    … …  
    965610905        WOLFSSL_MSG("processing client hello");
    965710906        ret = DoClientHello(ssl, input, inOutIdx, size);
     10907    #if !defined(WOLFSSL_NO_CLIENT_AUTH) && defined(HAVE_ED25519) && \
     10908                                                !defined(NO_ED25519_CLIENT_AUTH)
     10909        if (ssl->options.resuming || !ssl->options.verifyPeer || \
     10910                     !IsAtLeastTLSv1_2(ssl) || IsAtLeastTLSv1_3(ssl->version)) {
     10911        #if defined(WOLFSSL_ASYNC_CRYPT) || defined(WOLFSSL_NONBLOCK_OCSP)
     10912            if (ret != WC_PENDING_E && ret != OCSP_WANT_READ)
     10913        #endif
     10914            {
     10915                ssl->options.cacheMessages = 0;
     10916                if (ssl->hsHashes->messages != NULL) {
     10917                    XFREE(ssl->hsHashes->messages, ssl->heap, DYNAMIC_TYPE_HASHES);
     10918                    ssl->hsHashes->messages = NULL;
     10919                }
     10920            }
     10921        }
     10922    #endif
     10923        if (IsEncryptionOn(ssl, 0)) {
     10924            /* access beyond input + size should be checked against totalSz */
     10925            if (*inOutIdx + ssl->keys.padSz > totalSz)
     10926                return BUFFER_E;
     10927
     10928            *inOutIdx += ssl->keys.padSz;
     10929        }
    965810930        break;
    965910931
    … …  
    966310935        break;
    966410936
    9665 #if !defined(NO_RSA) || defined(HAVE_ECC)
     10937#if (!defined(NO_RSA) || defined(HAVE_ECC) || defined(HAVE_ED25519)) && \
     10938                                                !defined(WOLFSSL_NO_CLIENT_AUTH)
    966610939    case certificate_verify:
    966710940        WOLFSSL_MSG("processing certificate verify");
    966810941        ret = DoCertificateVerify(ssl, input, inOutIdx, size);
    966910942        break;
    9670 #endif /* !NO_RSA || HAVE_ECC */
     10943#endif /* (!NO_RSA || HAVE_ECC || HAVE_ED25519) && !WOLFSSL_NO_CLIENT_AUTH */
    967110944
    967210945#endif /* !NO_WOLFSSL_SERVER */
    … …  
    967710950        break;
    967810951    }
    9679 
    968010952    if (ret == 0 && expectedIdx != *inOutIdx) {
    968110953        WOLFSSL_MSG("Extra data in handshake message");
    … …  
    968410956        ret = DECODE_E;
    968510957    }
    9686 
    9687 #ifdef WOLFSSL_ASYNC_CRYPT
     10958    if (ret == 0 && ssl->buffers.inputBuffer.dynamicFlag) {
     10959        ShrinkInputBuffer(ssl, NO_FORCED_FREE);
     10960    }
     10961
     10962#if defined(WOLFSSL_ASYNC_CRYPT) || defined(WOLFSSL_NONBLOCK_OCSP)
    968810963    /* if async, offset index so this msg will be processed again */
    9689     if (ret == WC_PENDING_E && *inOutIdx > 0) {
     10964    if ((ret == WC_PENDING_E || ret == OCSP_WANT_READ) && *inOutIdx > 0) {
    969010965        *inOutIdx -= HANDSHAKE_HEADER_SZ;
    969110966    #ifdef WOLFSSL_DTLS
    … …  
    969510970    #endif
    969610971    }
    9697 #endif
     10972
     10973    /* make sure async error is cleared */
     10974    if (ret == 0 && (ssl->error == WC_PENDING_E || ssl->error == OCSP_WANT_READ)) {
     10975        ssl->error = 0;
     10976    }
     10977#endif /* WOLFSSL_ASYNC_CRYPT || WOLFSSL_NONBLOCK_OCSP */
    969810978
    969910979    WOLFSSL_LEAVE("DoHandShakeMsgType()", ret);
    … …  
    971610996        if (GetHandShakeHeader(ssl,input,inOutIdx,&type, &size, totalSz) != 0)
    971710997            return PARSE_ERROR;
     10998
     10999        ssl->options.handShakeState = type;
    971811000
    971911001        return DoHandShakeMsgType(ssl, input, inOutIdx, type, size, totalSz);
    … …  
    980011082}
    980111083
     11084#endif /* !WOLFSSL_NO_TLS12 */
     11085
    980211086#ifdef WOLFSSL_DTLS
    980311087
    9804 static INLINE int DtlsCheckWindow(WOLFSSL* ssl)
     11088static WC_INLINE int DtlsCheckWindow(WOLFSSL* ssl)
    980511089{
    980611090    word32* window;
    … …  
    990311187
    990411188#ifdef WOLFSSL_MULTICAST
    9905 static INLINE word32 UpdateHighwaterMark(word32 cur, word32 first,
     11189static WC_INLINE word32 UpdateHighwaterMark(word32 cur, word32 first,
    990611190                                         word32 second, word32 max)
    990711191{
    … …  
    992011204
    992111205
    9922 static INLINE int DtlsUpdateWindow(WOLFSSL* ssl)
     11206static WC_INLINE int DtlsUpdateWindow(WOLFSSL* ssl)
    992311207{
    992411208    word32* window;
    … …  
    1004211326    /* While there is an item in the store list, and it is the expected
    1004311327     * message, and it is complete, and there hasn't been an error in the
    10044      * last messge... */
     11328     * last message... */
    1004511329    while (item != NULL &&
    1004611330            ssl->keys.dtls_expected_peer_handshake_number == item->seq &&
    … …  
    1005111335        ret = DoHandShakeMsgType(ssl, item->msg,
    1005211336                                 &idx, item->type, item->sz, item->sz);
     11337    #ifdef WOLFSSL_ASYNC_CRYPT
    1005311338        if (ret == WC_PENDING_E) {
    1005411339            ssl->keys.dtls_expected_peer_handshake_number--;
    1005511340            break;
    1005611341        }
     11342    #endif
    1005711343        ssl->dtls_rx_msg_list = item->next;
    1005811344        DtlsMsgDelete(item, ssl->heap);
    … …  
    1018011466#endif
    1018111467
     11468#ifndef WOLFSSL_NO_TLS12
    1018211469
    1018311470#ifdef HAVE_AEAD
    10184 static INLINE void AeadIncrementExpIV(WOLFSSL* ssl)
     11471static WC_INLINE void AeadIncrementExpIV(WOLFSSL* ssl)
    1018511472{
    1018611473    int i;
    … …  
    1024611533
    1024711534/* When the flag oldPoly is not set this follows RFC7905. When oldPoly is set
    10248  * the implmentation follows an older draft for creating the nonce and MAC.
    10249  * The flag oldPoly gets set automaticlly depending on what cipher suite was
     11535 * the implementation follows an older draft for creating the nonce and MAC.
     11536 * The flag oldPoly gets set automatically depending on what cipher suite was
    1025011537 * negotiated in the handshake. This is able to be done because the IDs for the
    1025111538 * cipher suites was updated in RFC7905 giving unique values for the older
    10252  * draft in comparision to the more recent RFC.
     11539 * draft in comparison to the more recent RFC.
    1025311540 *
    1025411541 * ssl   WOLFSSL structure to get cipher and TLS state from
    … …  
    1039711684
    1039811685/* When the flag oldPoly is not set this follows RFC7905. When oldPoly is set
    10399  * the implmentation follows an older draft for creating the nonce and MAC.
    10400  * The flag oldPoly gets set automaticlly depending on what cipher suite was
     11686 * the implementation follows an older draft for creating the nonce and MAC.
     11687 * The flag oldPoly gets set automatically depending on what cipher suite was
    1040111688 * negotiated in the handshake. This is able to be done because the IDs for the
    1040211689 * cipher suites was updated in RFC7905 giving unique values for the older
    10403  * draft in comparision to the more recent RFC.
     11690 * draft in comparison to the more recent RFC.
    1040411691 *
    1040511692 * ssl   WOLFSSL structure to get cipher and TLS state from
    … …  
    1053811825
    1053911826
    10540 static INLINE int EncryptDo(WOLFSSL* ssl, byte* out, const byte* input,
     11827static WC_INLINE int EncryptDo(WOLFSSL* ssl, byte* out, const byte* input,
    1054111828    word16 sz, int asyncOkay)
    1054211829{
    … …  
    1056311850        case wolfssl_triple_des:
    1056411851        #ifdef WOLFSSL_ASYNC_CRYPT
    10565             /* intialize event */
     11852            /* initialize event */
    1056611853            asyncDev = &ssl->encrypt.des3->asyncDev;
    1056711854            ret = wolfSSL_AsyncInit(ssl, asyncDev, event_flags);
    … …  
    1057911866    #endif
    1058011867
    10581     #ifdef BUILD_AES
     11868    #if defined(BUILD_AES) && defined(HAVE_AES_CBC)
    1058211869        case wolfssl_aes:
    1058311870        #ifdef WOLFSSL_ASYNC_CRYPT
    10584             /* intialize event */
     11871            /* initialize event */
    1058511872            asyncDev = &ssl->encrypt.aes->asyncDev;
    1058611873            ret = wolfSSL_AsyncInit(ssl, asyncDev, event_flags);
    … …  
    1060611893
    1060711894        #ifdef WOLFSSL_ASYNC_CRYPT
    10608             /* intialize event */
     11895            /* initialize event */
    1060911896            asyncDev = &ssl->encrypt.aes->asyncDev;
    1061011897            ret = wolfSSL_AsyncInit(ssl, asyncDev, event_flags);
    … …  
    1071512002}
    1071612003
    10717 static INLINE int Encrypt(WOLFSSL* ssl, byte* out, const byte* input, word16 sz,
     12004static WC_INLINE int Encrypt(WOLFSSL* ssl, byte* out, const byte* input, word16 sz,
    1071812005    int asyncOkay)
    1071912006{
    … …  
    1080712094}
    1080812095
    10809 static INLINE int DecryptDo(WOLFSSL* ssl, byte* plain, const byte* input,
     12096static WC_INLINE int DecryptDo(WOLFSSL* ssl, byte* plain, const byte* input,
    1081012097                           word16 sz)
    1081112098{
    … …  
    1082712114        case wolfssl_triple_des:
    1082812115        #ifdef WOLFSSL_ASYNC_CRYPT
    10829             /* intialize event */
     12116            /* initialize event */
    1083012117            ret = wolfSSL_AsyncInit(ssl, &ssl->decrypt.des3->asyncDev,
    1083112118                WC_ASYNC_FLAG_CALL_AGAIN);
    … …  
    1084312130    #endif
    1084412131
    10845     #ifdef BUILD_AES
     12132    #if defined(BUILD_AES) && defined(HAVE_AES_CBC)
    1084612133        case wolfssl_aes:
    1084712134        #ifdef WOLFSSL_ASYNC_CRYPT
    10848             /* intialize event */
     12135            /* initialize event */
    1084912136            ret = wolfSSL_AsyncInit(ssl, &ssl->decrypt.aes->asyncDev,
    1085012137                WC_ASYNC_FLAG_CALL_AGAIN);
    … …  
    1086912156
    1087012157        #ifdef WOLFSSL_ASYNC_CRYPT
    10871             /* intialize event */
     12158            /* initialize event */
    1087212159            ret = wolfSSL_AsyncInit(ssl, &ssl->decrypt.aes->asyncDev,
    1087312160                WC_ASYNC_FLAG_CALL_AGAIN);
    … …  
    1096412251}
    1096512252
    10966 static INLINE int Decrypt(WOLFSSL* ssl, byte* plain, const byte* input,
     12253static WC_INLINE int Decrypt(WOLFSSL* ssl, byte* plain, const byte* input,
    1096712254                           word16 sz)
    1096812255{
    … …  
    1106712354}
    1106812355
     12356#endif /* !WOLFSSL_NO_TLS12 */
     12357
    1106912358/* Check conditions for a cipher to have an explicit IV.
    1107012359 *
    … …  
    1107212361 * returns 1 if the cipher in use has an explicit IV and 0 otherwise.
    1107312362 */
    11074 static INLINE int CipherHasExpIV(WOLFSSL *ssl)
     12363static WC_INLINE int CipherHasExpIV(WOLFSSL *ssl)
    1107512364{
    1107612365#ifdef WOLFSSL_TLS13
    … …  
    1109212381#endif
    1109312382
     12383#ifndef WOLFSSL_AEAD_ONLY
    1109412384    if (ssl->specs.cipher_type == block) {
    1109512385        if (encryptSz % ssl->specs.block_size) {
    … …  
    1110612396            minLength += ssl->specs.block_size;  /* explicit IV */
    1110712397    }
    11108     else if (ssl->specs.cipher_type == aead) {
     12398    else
     12399#endif
     12400    if (ssl->specs.cipher_type == aead) {
    1110912401        minLength = ssl->specs.aead_mac_size;    /* authTag size */
    1111012402        if (CipherHasExpIV(ssl))
    … …  
    1112112413
    1112212414
    11123 #ifndef NO_OLD_TLS
    11124 
    11125 static INLINE void Md5Rounds(int rounds, const byte* data, int sz)
    11126 {
    11127     wc_Md5 md5;
    11128     int i;
    11129 
    11130     wc_InitMd5(&md5);   /* no error check on purpose, dummy round */
    11131 
    11132     for (i = 0; i < rounds; i++)
    11133         wc_Md5Update(&md5, data, sz);
    11134     wc_Md5Free(&md5); /* in case needed to release resources */
    11135 }
    11136 
    11137 
    11138 
    11139 /* do a dummy sha round */
    11140 static INLINE void ShaRounds(int rounds, const byte* data, int sz)
    11141 {
    11142     wc_Sha sha;
    11143     int i;
    11144 
    11145     wc_InitSha(&sha);  /* no error check on purpose, dummy round */
    11146 
    11147     for (i = 0; i < rounds; i++)
    11148         wc_ShaUpdate(&sha, data, sz);
    11149     wc_ShaFree(&sha); /* in case needed to release resources */
    11150 }
    11151 #endif
    11152 
    11153 
    11154 #ifndef NO_SHA256
    11155 
    11156 static INLINE void Sha256Rounds(int rounds, const byte* data, int sz)
    11157 {
    11158     wc_Sha256 sha256;
    11159     int i;
    11160 
    11161     wc_InitSha256(&sha256);  /* no error check on purpose, dummy round */
    11162 
    11163     for (i = 0; i < rounds; i++) {
    11164         wc_Sha256Update(&sha256, data, sz);
    11165         /* no error check on purpose, dummy round */
    11166     }
    11167     wc_Sha256Free(&sha256); /* in case needed to release resources */
    11168 }
    11169 
    11170 #endif
    11171 
    11172 
    11173 #ifdef WOLFSSL_SHA384
    11174 
    11175 static INLINE void Sha384Rounds(int rounds, const byte* data, int sz)
    11176 {
    11177     wc_Sha384 sha384;
    11178     int i;
    11179 
    11180     wc_InitSha384(&sha384);  /* no error check on purpose, dummy round */
    11181 
    11182     for (i = 0; i < rounds; i++) {
    11183         wc_Sha384Update(&sha384, data, sz);
    11184         /* no error check on purpose, dummy round */
    11185     }
    11186     wc_Sha384Free(&sha384); /* in case needed to release resources */
    11187 }
    11188 
    11189 #endif
    11190 
    11191 
    11192 #ifdef WOLFSSL_SHA512
    11193 
    11194 static INLINE void Sha512Rounds(int rounds, const byte* data, int sz)
    11195 {
    11196     wc_Sha512 sha512;
    11197     int i;
    11198 
    11199     wc_InitSha512(&sha512);  /* no error check on purpose, dummy round */
    11200 
    11201     for (i = 0; i < rounds; i++) {
    11202         wc_Sha512Update(&sha512, data, sz);
    11203         /* no error check on purpose, dummy round */
    11204     }
    11205     wc_Sha512Free(&sha512); /* in case needed to release resources */
    11206 }
    11207 
    11208 #endif
    11209 
    11210 
    11211 #ifdef WOLFSSL_RIPEMD
    11212 
    11213 static INLINE void RmdRounds(int rounds, const byte* data, int sz)
    11214 {
    11215     RipeMd ripemd;
    11216     int i;
    11217 
    11218     wc_InitRipeMd(&ripemd);
    11219 
    11220     for (i = 0; i < rounds; i++)
    11221         wc_RipeMdUpdate(&ripemd, data, sz);
    11222 }
    11223 
    11224 #endif
    11225 
    11226 
    11227 /* Do dummy rounds */
    11228 static INLINE void DoRounds(int type, int rounds, const byte* data, int sz)
    11229 {
    11230     (void)rounds;
    11231     (void)data;
    11232     (void)sz;
    11233 
    11234     switch (type) {
    11235         case no_mac :
    11236             break;
    11237 
    11238 #ifndef NO_OLD_TLS
    11239 #ifndef NO_MD5
    11240         case md5_mac :
    11241             Md5Rounds(rounds, data, sz);
    11242             break;
    11243 #endif
    11244 
    11245 #ifndef NO_SHA
    11246         case sha_mac :
    11247             ShaRounds(rounds, data, sz);
    11248             break;
    11249 #endif
    11250 #endif
    11251 
    11252 #ifndef NO_SHA256
    11253         case sha256_mac :
    11254             Sha256Rounds(rounds, data, sz);
    11255             break;
    11256 #endif
    11257 
    11258 #ifdef WOLFSSL_SHA384
    11259         case sha384_mac :
    11260             Sha384Rounds(rounds, data, sz);
    11261             break;
    11262 #endif
    11263 
    11264 #ifdef WOLFSSL_SHA512
    11265         case sha512_mac :
    11266             Sha512Rounds(rounds, data, sz);
    11267             break;
    11268 #endif
    11269 
    11270 #ifdef WOLFSSL_RIPEMD
    11271         case rmd_mac :
    11272             RmdRounds(rounds, data, sz);
    11273             break;
    11274 #endif
    11275 
    11276         default:
    11277             WOLFSSL_MSG("Bad round type");
    11278             break;
    11279     }
    11280 }
    11281 
    11282 
    11283 /* do number of compression rounds on dummy data */
    11284 static INLINE void CompressRounds(WOLFSSL* ssl, int rounds, const byte* dummy)
    11285 {
    11286     if (rounds)
    11287         DoRounds(ssl->specs.mac_algorithm, rounds, dummy, COMPRESS_LOWER);
    11288 }
    11289 
    11290 
     12415#ifndef WOLFSSL_AEAD_ONLY
    1129112416/* check all length bytes for the pad value, return 0 on success */
    1129212417static int PadCheck(const byte* a, byte pad, int length)
    … …  
    1129712422    for (i = 0; i < length; i++) {
    1129812423        compareSum |= a[i] ^ pad;
    11299     }
     12424}
    1130012425
    1130112426    return compareSum;
    … …  
    1130312428
    1130412429
    11305 /* get compression extra rounds */
    11306 static INLINE int GetRounds(int pLen, int padLen, int t)
     12430/* Mask the padding bytes with the expected values.
     12431 * Constant time implementation - does maximum pad size possible.
     12432 *
     12433 * data   Message data.
     12434 * sz     Size of the message including MAC and padding and padding length.
     12435 * macSz  Size of the MAC.
     12436 * returns 0 on success, otherwise failure.
     12437 */
     12438static byte MaskPadding(const byte* data, int sz, int macSz)
    1130712439{
    11308     int  roundL1 = 1;  /* round up flags */
    11309     int  roundL2 = 1;
    11310 
    11311     int L1 = COMPRESS_CONSTANT + pLen - t;
    11312     int L2 = COMPRESS_CONSTANT + pLen - padLen - 1 - t;
    11313 
    11314     L1 -= COMPRESS_UPPER;
    11315     L2 -= COMPRESS_UPPER;
    11316 
    11317     if ( (L1 % COMPRESS_LOWER) == 0)
    11318         roundL1 = 0;
    11319     if ( (L2 % COMPRESS_LOWER) == 0)
    11320         roundL2 = 0;
    11321 
    11322     L1 /= COMPRESS_LOWER;
    11323     L2 /= COMPRESS_LOWER;
    11324 
    11325     L1 += roundL1;
    11326     L2 += roundL2;
    11327 
    11328     return L1 - L2;
     12440    int i;
     12441    int checkSz = sz - 1;
     12442    byte paddingSz = data[sz - 1];
     12443    byte mask;
     12444    byte good = ctMaskGT(paddingSz, sz - 1 - macSz);
     12445
     12446    if (checkSz > TLS_MAX_PAD_SZ)
     12447        checkSz = TLS_MAX_PAD_SZ;
     12448
     12449    for (i = 0; i < checkSz; i++) {
     12450        mask = ctMaskLTE(i, paddingSz);
     12451        good |= mask & (data[sz - 1 - i] ^ paddingSz);
    1132912452}
    1133012453
     12454    return good;
     12455}
     12456
     12457/* Mask the MAC in the message with the MAC calculated.
     12458 * Constant time implementation - starts looking for MAC where maximum padding
     12459 * size has it.
     12460 *
     12461 * data    Message data.
     12462 * sz      Size of the message including MAC and padding and padding length.
     12463 * macSz   Size of the MAC data.
     12464 * expMac  Expected MAC value.
     12465 * returns 0 on success, otherwise failure.
     12466 */
     12467static byte MaskMac(const byte* data, int sz, int macSz, byte* expMac)
     12468{
     12469    int i, j;
     12470    unsigned char mac[WC_MAX_DIGEST_SIZE];
     12471    int scanStart = sz - 1 - TLS_MAX_PAD_SZ - macSz;
     12472    int macEnd = sz - 1 - data[sz - 1];
     12473    int macStart = macEnd - macSz;
     12474    int r = 0;
     12475    unsigned char started, notEnded;
     12476    unsigned char good = 0;
     12477
     12478    scanStart &= (~scanStart) >> (sizeof(int) * 8 - 1);
     12479    macStart &= (~macStart) >> (sizeof(int) * 8 - 1);
     12480
     12481    /* Div on Intel has different speeds depending on value.
     12482     * Use a bitwise AND or mod a specific value (converted to mul). */
     12483    if ((macSz & (macSz - 1)) == 0)
     12484        r = (macSz - (scanStart - macStart)) & (macSz - 1);
     12485#ifndef NO_SHA
     12486    else if (macSz == WC_SHA_DIGEST_SIZE)
     12487        r = (macSz - (scanStart - macStart)) % WC_SHA_DIGEST_SIZE;
     12488#endif
     12489#ifdef WOLFSSL_SHA384
     12490    else if (macSz == WC_SHA384_DIGEST_SIZE)
     12491        r = (macSz - (scanStart - macStart)) % WC_SHA384_DIGEST_SIZE;
     12492#endif
     12493
     12494    XMEMSET(mac, 0, macSz);
     12495    for (i = scanStart; i < sz; i += macSz) {
     12496        for (j = 0; j < macSz && j + i < sz; j++) {
     12497            started = ctMaskGTE(i + j, macStart);
     12498            notEnded = ctMaskLT(i + j, macEnd);
     12499            mac[j] |= started & notEnded & data[i + j];
     12500    }
     12501}
     12502
     12503    if ((macSz & (macSz - 1)) == 0) {
     12504        for (i = 0; i < macSz; i++)
     12505            good |= expMac[i] ^ mac[(i + r) & (macSz - 1)];
     12506    }
     12507#ifndef NO_SHA
     12508    else if (macSz == WC_SHA_DIGEST_SIZE) {
     12509        for (i = 0; i < macSz; i++)
     12510            good |= expMac[i] ^ mac[(i + r) % WC_SHA_DIGEST_SIZE];
     12511    }
     12512#endif
     12513#ifdef WOLFSSL_SHA384
     12514    else if (macSz == WC_SHA384_DIGEST_SIZE) {
     12515        for (i = 0; i < macSz; i++)
     12516            good |= expMac[i] ^ mac[(i + r) % WC_SHA384_DIGEST_SIZE];
     12517    }
     12518#endif
     12519
     12520    return good;
     12521}
    1133112522
    1133212523/* timing resistant pad/verify check, return 0 on success */
    11333 static int TimingPadVerify(WOLFSSL* ssl, const byte* input, int padLen, int t,
    11334                            int pLen, int content)
     12524int TimingPadVerify(WOLFSSL* ssl, const byte* input, int padLen, int macSz,
     12525                    int pLen, int content)
    1133512526{
    11336     byte verify[MAX_DIGEST_SIZE];
    11337     byte dmy[sizeof(WOLFSSL) >= MAX_PAD_SIZE ? 1 : MAX_PAD_SIZE] = {0};
    11338     byte* dummy = sizeof(dmy) < MAX_PAD_SIZE ? (byte*) ssl : dmy;
     12527    byte verify[WC_MAX_DIGEST_SIZE];
     12528    byte good;
    1133912529    int  ret = 0;
    1134012530
    11341     (void)dmy;
    11342 
    11343     if ( (t + padLen + 1) > pLen) {
    11344         WOLFSSL_MSG("Plain Len not long enough for pad/mac");
    11345         PadCheck(dummy, (byte)padLen, MAX_PAD_SIZE);
    11346         ssl->hmac(ssl, verify, input, pLen - t, content, 1); /* still compare */
    11347         ConstantCompare(verify, input + pLen - t, t);
    11348 
    11349         return VERIFY_MAC_ERROR;
    11350     }
    11351 
    11352     if (PadCheck(input + pLen - (padLen + 1), (byte)padLen, padLen + 1) != 0) {
    11353         WOLFSSL_MSG("PadCheck failed");
    11354         PadCheck(dummy, (byte)padLen, MAX_PAD_SIZE - padLen - 1);
    11355         ssl->hmac(ssl, verify, input, pLen - t, content, 1); /* still compare */
    11356         ConstantCompare(verify, input + pLen - t, t);
    11357 
    11358         return VERIFY_MAC_ERROR;
    11359     }
    11360 
    11361     PadCheck(dummy, (byte)padLen, MAX_PAD_SIZE - padLen - 1);
    11362     ret = ssl->hmac(ssl, verify, input, pLen - padLen - 1 - t, content, 1);
    11363 
    11364     CompressRounds(ssl, GetRounds(pLen, padLen, t), dummy);
    11365 
    11366     if (ConstantCompare(verify, input + (pLen - padLen - 1 - t), t) != 0) {
    11367         WOLFSSL_MSG("Verify MAC compare failed");
    11368         return VERIFY_MAC_ERROR;
    11369     }
    11370 
    11371     /* treat any faulure as verify MAC error */
     12531    good = MaskPadding(input, pLen, macSz);
     12532    /* 4th argument has potential to underflow, ssl->hmac function should
     12533     * either increment the size by (macSz + padLen + 1) before use or check on
     12534     * the size to make sure is valid. */
     12535    ret = ssl->hmac(ssl, verify, input, pLen - macSz - padLen - 1, padLen,
     12536                                                                    content, 1);
     12537    good |= MaskMac(input, pLen, ssl->specs.hash_size, verify);
     12538
     12539    /* Non-zero on failure. */
     12540    good = (byte)~(word32)good;
     12541    good &= good >> 4;
     12542    good &= good >> 2;
     12543    good &= good >> 1;
     12544    /* Make ret negative on masking failure. */
     12545    ret -= 1 - good;
     12546
     12547    /* Treat any faulure as verify MAC error. */
    1137212548    if (ret != 0)
    1137312549        ret = VERIFY_MAC_ERROR;
    … …  
    1137512551    return ret;
    1137612552}
     12553#endif
    1137712554
    1137812555
    … …  
    1138912566
    1139012567#ifdef WOLFSSL_EARLY_DATA
    11391     if (ssl->earlyData) {
     12568    if (ssl->earlyData != no_early_data) {
    1139212569    }
    1139312570    else
    … …  
    1139912576    }
    1140012577
     12578#ifndef WOLFSSL_AEAD_ONLY
    1140112579    if (ssl->specs.cipher_type == block) {
    1140212580        if (ssl->options.tls1_1)
    1140312581            ivExtra = ssl->specs.block_size;
    1140412582    }
    11405     else if (ssl->specs.cipher_type == aead) {
     12583    else
     12584#endif
     12585    if (ssl->specs.cipher_type == aead) {
    1140612586        if (CipherHasExpIV(ssl))
    1140712587            ivExtra = AESGCM_EXP_IV_SZ;
    … …  
    1141412594    }
    1141512595#ifdef WOLFSSL_EARLY_DATA
    11416     if (ssl->earlyData) {
     12596    if (ssl->earlyData != no_early_data) {
    1141712597        if (ssl->earlyDataSz + dataSz > ssl->options.maxEarlyDataSz) {
    1141812598            SendAlert(ssl, alert_fatal, unexpected_message);
    … …  
    1145912639    byte code;
    1146012640
    11461     #ifdef WOLFSSL_CALLBACKS
     12641    #if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
    1146212642        if (ssl->hsInfoOn)
    11463             AddPacketName("Alert", &ssl->handShakeInfo);
     12643            AddPacketName(ssl, "Alert");
    1146412644        if (ssl->toInfoOn)
    1146512645            /* add record header back on to info + alert bytes level/code */
    11466             AddPacketInfo("Alert", &ssl->timeoutInfo, input + *inOutIdx -
     12646            AddPacketInfo(ssl, "Alert", alert, input + *inOutIdx -
    1146712647                          RECORD_HEADER_SZ, RECORD_HEADER_SZ + ALERT_SIZE,
    11468                           ssl->heap);
     12648                          READ_PROTO, ssl->heap);
    1146912649    #endif
    1147012650
    … …  
    1155412734    /* read data from network */
    1155512735    do {
    11556         in = Receive(ssl,
     12736        in = wolfSSLReceive(ssl,
    1155712737                     ssl->buffers.inputBuffer.buffer +
    1155812738                     ssl->buffers.inputBuffer.length,
    … …  
    1158412764
    1158512765
    11586 static INLINE int VerifyMac(WOLFSSL* ssl, const byte* input, word32 msgSz,
     12766static WC_INLINE int VerifyMac(WOLFSSL* ssl, const byte* input, word32 msgSz,
    1158712767                            int content, word32* padSz)
    1158812768{
     12769#if !defined(WOLFSSL_NO_TLS12) && !defined(WOLFSSL_AEAD_ONLY)
    1158912770    int    ivExtra = 0;
    1159012771    int    ret;
    … …  
    1159712778    word32 digestSz = ssl->specs.hash_size;
    1159812779#endif
    11599     byte   verify[MAX_DIGEST_SIZE];
     12780    byte   verify[WC_MAX_DIGEST_SIZE];
     12781
    1160012782
    1160112783    if (ssl->specs.cipher_type == block) {
    … …  
    1162512807            }
    1162612808            PadCheck(dummy, (byte)pad, MAX_PAD_SIZE);  /* timing only */
    11627             ret = ssl->hmac(ssl, verify, input, msgSz - digestSz - pad - 1,
     12809            ret = ssl->hmac(ssl, verify, input, msgSz - digestSz - pad - 1, pad,
    1162812810                            content, 1);
    1162912811            if (ConstantCompare(verify, input + msgSz - digestSz - pad - 1,
    … …  
    1163512817    }
    1163612818    else if (ssl->specs.cipher_type == stream) {
    11637         ret = ssl->hmac(ssl, verify, input, msgSz - digestSz, content, 1);
     12819        ret = ssl->hmac(ssl, verify, input, msgSz - digestSz, -1, content, 1);
    1163812820        if (ConstantCompare(verify, input + msgSz - digestSz, digestSz) != 0){
    1163912821            return VERIFY_MAC_ERROR;
    … …  
    1164212824            return VERIFY_MAC_ERROR;
    1164312825    }
     12826#endif /* !WOLFSSL_NO_TLS12 && !WOLFSSL_AEAD_ONLY */
    1164412827
    1164512828    if (ssl->specs.cipher_type == aead) {
    1164612829        *padSz = ssl->specs.aead_mac_size;
    1164712830    }
     12831#if !defined(WOLFSSL_NO_TLS12) && !defined(WOLFSSL_AEAD_ONLY)
    1164812832    else {
    1164912833        *padSz = digestSz + pad + padByte;
    1165012834    }
     12835#endif /* !WOLFSSL_NO_TLS12 && !WOLFSSL_AEAD_ONLY */
     12836
     12837    (void)input;
     12838    (void)msgSz;
     12839    (void)content;
    1165112840
    1165212841    return 0;
    … …  
    1167012859#endif
    1167112860
    11672     if (ssl->error != 0 && ssl->error != WANT_READ &&
    11673         ssl->error != WANT_WRITE && ssl->error != WC_PENDING_E) {
     12861    if (ssl->error != 0 && ssl->error != WANT_READ && ssl->error != WANT_WRITE
     12862    #ifdef WOLFSSL_ASYNC_CRYPT
     12863        && ssl->error != WC_PENDING_E
     12864    #endif
     12865    #ifdef WOLFSSL_NONBLOCK_OCSP
     12866        && ssl->error != OCSP_WANT_READ
     12867    #endif
     12868    ) {
    1167412869        WOLFSSL_MSG("ProcessReply retry in error state, not allowed");
    1167512870        return ssl->error;
    … …  
    1183613031        case decryptMessage:
    1183713032
    11838             if (IsEncryptionOn(ssl, 0) && ssl->keys.decryptedCur == 0) {
     13033#if !defined(WOLFSSL_TLS13) || defined(WOLFSSL_TLS13_DRAFT_18)
     13034            if (IsEncryptionOn(ssl, 0) && ssl->keys.decryptedCur == 0)
     13035#else
     13036            if (IsEncryptionOn(ssl, 0) && ssl->keys.decryptedCur == 0 &&
     13037                                        (!IsAtLeastTLSv1_3(ssl->version) ||
     13038                                         ssl->curRL.type != change_cipher_spec))
     13039#endif
     13040            {
    1183913041                bufferStatic* in = &ssl->buffers.inputBuffer;
    1184013042
    … …  
    1185413056                else {
    1185513057                    if (!ssl->options.tls1_3) {
     13058                #ifndef WOLFSSL_NO_TLS12
    1185613059                        ret = Decrypt(ssl,
    1185713060                                      in->buffer + in->idx,
    1185813061                                      in->buffer + in->idx,
    1185913062                                      ssl->curSize);
     13063                #else
     13064                        ret = DECRYPT_ERROR;
     13065                #endif
    1186013066                    }
    11861                     else {
     13067                    else
     13068                    {
    1186213069                    #ifdef WOLFSSL_TLS13
     13070                    #if defined(WOLFSSL_TLS13_DRAFT_18) || \
     13071                        defined(WOLFSSL_TLS13_DRAFT_22) || \
     13072                        defined(WOLFSSL_TLS13_DRAFT_23)
    1186313073                        ret = DecryptTls13(ssl,
    1186413074                                           in->buffer + in->idx,
    1186513075                                           in->buffer + in->idx,
    11866                                            ssl->curSize);
     13076                                           ssl->curSize, NULL, 0);
     13077                    #else
     13078                        ret = DecryptTls13(ssl,
     13079                                        in->buffer + in->idx,
     13080                                        in->buffer + in->idx,
     13081                                        ssl->curSize,
     13082                                        (byte*)&ssl->curRL, RECORD_HEADER_SZ);
     13083                    #endif
    1186713084                    #else
    1186813085                        ret = DECRYPT_ERROR;
    … …  
    1187713094
    1187813095                if (ret >= 0) {
     13096            #ifndef WOLFSSL_NO_TLS12
    1187913097                    /* handle success */
     13098                #ifndef WOLFSSL_AEAD_ONLY
    1188013099                    if (ssl->options.tls1_1 && ssl->specs.cipher_type == block)
    1188113100                        ssl->buffers.inputBuffer.idx += ssl->specs.block_size;
     13101                #endif
    1188213102                        /* go past TLSv1.1 IV */
    1188313103                    if (CipherHasExpIV(ssl))
    1188413104                        ssl->buffers.inputBuffer.idx += AESGCM_EXP_IV_SZ;
     13105            #endif
    1188513106                }
    1188613107                else {
    … …  
    1192313144        case verifyMessage:
    1192413145
    11925             if (IsEncryptionOn(ssl, 0) && ssl->keys.decryptedCur == 0) {
     13146#if !defined(WOLFSSL_TLS13) || defined(WOLFSSL_TLS13_DRAFT_18)
     13147            if (IsEncryptionOn(ssl, 0) && ssl->keys.decryptedCur == 0)
     13148#else
     13149            if (IsEncryptionOn(ssl, 0) && ssl->keys.decryptedCur == 0 &&
     13150                                        (!IsAtLeastTLSv1_3(ssl->version) ||
     13151                                         ssl->curRL.type != change_cipher_spec))
     13152#endif
     13153            {
    1192613154                if (!atomicUser) {
    1192713155                    ret = VerifyMac(ssl, ssl->buffers.inputBuffer.buffer +
    … …  
    1195613184#ifdef WOLFSSL_TLS13
    1195713185                if (ssl->options.tls1_3) {
     13186                    word16 i = (word16)(ssl->buffers.inputBuffer.length -
     13187                                        ssl->keys.padSz);
     13188                    /* Remove padding from end of plain text. */
     13189                    for (--i; i > ssl->buffers.inputBuffer.idx; i--) {
     13190                        if (ssl->buffers.inputBuffer.buffer[i] != 0)
     13191                            break;
     13192                    }
    1195813193                    /* Get the real content type from the end of the data. */
    11959                     ssl->keys.padSz++;
    11960                     ssl->curRL.type = ssl->buffers.inputBuffer.buffer[
    11961                         ssl->buffers.inputBuffer.length - ssl->keys.padSz];
     13194                    ssl->curRL.type = ssl->buffers.inputBuffer.buffer[i];
     13195                    ssl->keys.padSz = ssl->buffers.inputBuffer.length - i;
    1196213196                }
    1196313197#endif
    … …  
    1199013224                    }
    1199113225                    else if (!IsAtLeastTLSv1_3(ssl->version)) {
     13226#ifndef WOLFSSL_NO_TLS12
    1199213227                        ret = DoHandShakeMsg(ssl,
    1199313228                                            ssl->buffers.inputBuffer.buffer,
    1199413229                                            &ssl->buffers.inputBuffer.idx,
    1199513230                                            ssl->buffers.inputBuffer.length);
     13231#else
     13232                        ret = BUFFER_ERROR;
     13233#endif
    1199613234                    }
    1199713235                    else {
    … …  
    1200713245                                ssl->earlyData &&
    1200813246                                ssl->options.handShakeState == HANDSHAKE_DONE) {
    12009                             ssl->earlyData = 0;
     13247                            ssl->earlyData = no_early_data;
    1201013248                            ssl->options.processReply = doProcessInit;
    1201113249                            return ZERO_RETURN;
    … …  
    1202213260                case change_cipher_spec:
    1202313261                    WOLFSSL_MSG("got CHANGE CIPHER SPEC");
    12024                     #ifdef WOLFSSL_CALLBACKS
     13262                    #if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
    1202513263                        if (ssl->hsInfoOn)
    12026                             AddPacketName("ChangeCipher", &ssl->handShakeInfo);
     13264                            AddPacketName(ssl, "ChangeCipher");
    1202713265                        /* add record header back on info */
    1202813266                        if (ssl->toInfoOn) {
    12029                             AddPacketInfo("ChangeCipher", &ssl->timeoutInfo,
     13267                            AddPacketInfo(ssl, "ChangeCipher",
     13268                                change_cipher_spec,
    1203013269                                ssl->buffers.inputBuffer.buffer +
    1203113270                                ssl->buffers.inputBuffer.idx - RECORD_HEADER_SZ,
    12032                                 1 + RECORD_HEADER_SZ, ssl->heap);
     13271                                1 + RECORD_HEADER_SZ, READ_PROTO, ssl->heap);
     13272                            #ifdef WOLFSSL_CALLBACKS
    1203313273                            AddLateRecordHeader(&ssl->curRL, &ssl->timeoutInfo);
     13274                            #endif
    1203413275                        }
    1203513276                    #endif
    1203613277
     13278#ifdef WOLFSSL_TLS13
     13279    #ifdef WOLFSSL_TLS13_DRAFT_18
     13280                    if (IsAtLeastTLSv1_3(ssl->version)) {
     13281                        SendAlert(ssl, alert_fatal, illegal_parameter);
     13282                        return UNKNOWN_RECORD_TYPE;
     13283                    }
     13284    #else
     13285                    if (IsAtLeastTLSv1_3(ssl->version)) {
     13286                        word32 i = ssl->buffers.inputBuffer.idx;
     13287                        if (ssl->curSize != 1 ||
     13288                                      ssl->buffers.inputBuffer.buffer[i] != 1) {
     13289                            SendAlert(ssl, alert_fatal, illegal_parameter);
     13290                            return UNKNOWN_RECORD_TYPE;
     13291                        }
     13292                        ssl->buffers.inputBuffer.idx++;
     13293                        break;
     13294                        }
     13295                    #endif
     13296#endif
     13297
     13298#ifndef WOLFSSL_NO_TLS12
    1203713299                    ret = SanityCheckMsgReceived(ssl, change_cipher_hs);
    1203813300                    if (ret != 0) {
    … …  
    1211913381                    if (ret != 0)
    1212013382                        return ret;
     13383#endif /* !WOLFSSL_NO_TLS12 */
    1212113384                    break;
    1212213385
    … …  
    1221413477    int                ret;
    1221513478
     13479    #ifdef OPENSSL_EXTRA
     13480        ssl->cbmode = SSL_CB_MODE_WRITE;
     13481        if (ssl->options.side == WOLFSSL_SERVER_END){
     13482                ssl->options.serverState = SERVER_CHANGECIPHERSPEC_COMPLETE;
     13483                if (ssl->CBIS != NULL)
     13484                        ssl->CBIS(ssl, SSL_CB_ACCEPT_LOOP, SSL_SUCCESS);
     13485        }
     13486        else{
     13487                ssl->options.clientState =
     13488                        CLIENT_CHANGECIPHERSPEC_COMPLETE;
     13489                if (ssl->CBIS != NULL)
     13490                        ssl->CBIS(ssl, SSL_CB_CONNECT_LOOP, SSL_SUCCESS);
     13491        }
     13492    #endif
     13493
    1221613494    #ifdef WOLFSSL_DTLS
    1221713495        if (ssl->options.dtls) {
    … …  
    1222613504    }
    1222713505
    12228     /* check for avalaible size */
     13506    /* check for available size */
    1222913507    if ((ret = CheckAvailableSize(ssl, sendSz)) != 0)
    1223013508        return ret;
    … …  
    1225613534        }
    1225713535    #endif
    12258     #ifdef WOLFSSL_CALLBACKS
    12259         if (ssl->hsInfoOn) AddPacketName("ChangeCipher", &ssl->handShakeInfo);
     13536    #if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
     13537        if (ssl->hsInfoOn) AddPacketName(ssl, "ChangeCipher");
    1226013538        if (ssl->toInfoOn)
    12261             AddPacketInfo("ChangeCipher", &ssl->timeoutInfo, output, sendSz,
    12262                           ssl->heap);
     13539            AddPacketInfo(ssl, "ChangeCipher", change_cipher_spec, output,
     13540                    sendSz, WRITE_PROTO, ssl->heap);
    1226313541    #endif
    1226413542    ssl->buffers.outputBuffer.length += sendSz;
    … …  
    1227813556
    1227913557
    12280 #ifndef NO_OLD_TLS
     13558#if !defined(NO_OLD_TLS) && !defined(WOLFSSL_AEAD_ONLY)
    1228113559static int SSL_hmac(WOLFSSL* ssl, byte* digest, const byte* in, word32 sz,
    12282                  int content, int verify)
     13560                    int padLen, int content, int verify)
    1228313561{
    12284     byte   result[MAX_DIGEST_SIZE];
     13562    byte   result[WC_MAX_DIGEST_SIZE];
    1228513563    word32 digestSz = ssl->specs.hash_size;            /* actual sizes */
    1228613564    word32 padSz    = ssl->specs.pad_size;
    … …  
    1229413572    byte conLen[ENUM_LEN + LENGTH_SZ];     /* content & length */
    1229513573    const byte* macSecret = wolfSSL_GetMacSecret(ssl, verify);
     13574
     13575    (void)padLen;
    1229613576
    1229713577#ifdef HAVE_FUZZER
    … …  
    1239113671    return 0;
    1239213672}
    12393 #endif /* NO_OLD_TLS */
     13673#endif /* !NO_OLD_TLS && !WOLFSSL_AEAD_ONLY */
    1239413674
    1239513675
    … …  
    1253813818}
    1253913819
    12540 #endif /* WOLFSSL_LEANPSK */
    12541 
     13820#endif /* !NO_CERTS */
     13821
     13822#ifndef WOLFSSL_NO_TLS12
    1254213823/* Persistable BuildMessage arguments */
    1254313824typedef struct BuildMsgArgs {
    … …  
    1254913830    word16 size;
    1255013831    word32 ivSz;      /* TLSv1.1  IV */
    12551     byte   iv[AES_BLOCK_SIZE]; /* max size */
     13832    byte*  iv;
    1255213833} BuildMsgArgs;
    1255313834
    … …  
    1255913840    (void)args;
    1256013841
    12561     /* no allocations in BuildMessage */
     13842    if (args->iv) {
     13843        XFREE(args->iv, ssl->heap, DYNAMIC_TYPE_SALT);
     13844        args->iv = NULL;
    1256213845}
     13846}
     13847#endif
    1256313848
    1256413849/* Build SSL Message, encrypted */
    … …  
    1256613851             int inSz, int type, int hashOutput, int sizeOnly, int asyncOkay)
    1256713852{
     13853#ifndef WOLFSSL_NO_TLS12
    1256813854    int ret = 0;
    1256913855    BuildMsgArgs* args;
    … …  
    1257413860    (void)sizeof(args_test);
    1257513861#endif
     13862#endif
    1257613863
    1257713864    WOLFSSL_ENTER("BuildMessage");
    … …  
    1258113868    }
    1258213869
     13870#ifdef WOLFSSL_NO_TLS12
     13871    return BuildTls13Message(ssl, output, outSz, input, inSz, type,
     13872                                               hashOutput, sizeOnly, asyncOkay);
     13873#else
    1258313874#ifdef WOLFSSL_TLS13
    1258413875    if (ssl->options.tls1_3) {
    … …  
    1262313914            /* catch mistaken sizeOnly parameter */
    1262413915            if (!sizeOnly && (output == NULL || input == NULL) ) {
    12625                 return BAD_FUNC_ARG;
     13916                ERROR_OUT(BAD_FUNC_ARG, exit_buildmsg);
    1262613917            }
    1262713918            if (sizeOnly && (output || input) ) {
    1262813919                WOLFSSL_MSG("BuildMessage w/sizeOnly doesn't need input/output");
    12629                 return BAD_FUNC_ARG;
     13920                ERROR_OUT(BAD_FUNC_ARG, exit_buildmsg);
    1263013921            }
    1263113922
    … …  
    1265013941        #endif
    1265113942
     13943        #ifndef WOLFSSL_AEAD_ONLY
    1265213944            if (ssl->specs.cipher_type == block) {
    1265313945                word32 blockSz = ssl->specs.block_size;
    … …  
    1265613948                    args->sz  += args->ivSz;
    1265713949
    12658                     if (args->ivSz > (word32)sizeof(args->iv))
     13950                    if (args->ivSz > MAX_IV_SZ)
    1265913951                        ERROR_OUT(BUFFER_E, exit_buildmsg);
    1266013952                }
    1266113953                args->sz += 1;       /* pad byte */
    1266213954                args->pad = (args->sz - args->headerSz) % blockSz;
     13955                #ifdef OPENSSL_EXTRA
     13956                if(args->pad != 0)
     13957                #endif
    1266313958                args->pad = blockSz - args->pad;
    1266413959                args->sz += args->pad;
    1266513960            }
     13961        #endif /* WOLFSSL_AEAD_ONLY */
    1266613962
    1266713963        #ifdef HAVE_AEAD
    … …  
    1268413980
    1268513981            if (args->ivSz > 0) {
     13982                args->iv = (byte*)XMALLOC(args->ivSz, ssl->heap, DYNAMIC_TYPE_SALT);
     13983                if (args->iv == NULL)
     13984                    ERROR_OUT(MEMORY_E, exit_buildmsg);
     13985
    1268613986                ret = wc_RNG_GenerateBlock(ssl->rng, args->iv, args->ivSz);
    1268713987                if (ret != 0)
    … …  
    1270114001
    1270214002            /* write to output */
    12703             if (args->ivSz) {
     14003            if (args->ivSz > 0) {
    1270414004                XMEMCPY(output + args->idx, args->iv,
    12705                                         min(args->ivSz, sizeof(args->iv)));
     14005                                        min(args->ivSz, MAX_IV_SZ));
    1270614006                args->idx += args->ivSz;
    1270714007            }
    … …  
    1271414014        case BUILD_MSG_HASH:
    1271514015        {
    12716             word32 i;
    12717 
    1271814016            if (type == handshake && hashOutput) {
    1271914017                ret = HashOutput(ssl, output, args->headerSz + inSz, args->ivSz);
    … …  
    1272114019                    goto exit_buildmsg;
    1272214020            }
     14021        #ifndef WOLFSSL_AEAD_ONLY
    1272314022            if (ssl->specs.cipher_type == block) {
    1272414023                word32 tmpIdx = args->idx + args->digestSz;
     14024                word32 i;
    1272514025
    1272614026                for (i = 0; i <= args->pad; i++)
    1272714027                    output[tmpIdx++] = (byte)args->pad; /* pad byte gets pad value */
    1272814028            }
     14029        #endif
    1272914030
    1273014031            ssl->options.buildMsgState = BUILD_MSG_VERIFY_MAC;
    … …  
    1274414045        #endif
    1274514046
     14047        #ifndef WOLFSSL_AEAD_ONLY
    1274614048            if (ssl->specs.cipher_type != aead) {
    1274714049        #ifdef HAVE_TRUNCATED_HMAC
    12748             if (ssl->truncated_hmac && ssl->specs.hash_size > args->digestSz) {
     14050                if (ssl->truncated_hmac &&
     14051                                        ssl->specs.hash_size > args->digestSz) {
    1274914052            #ifdef WOLFSSL_SMALL_STACK
    1275014053                byte* hmac = NULL;
    1275114054            #else
    12752                 byte  hmac[MAX_DIGEST_SIZE];
     14055                    byte  hmac[WC_MAX_DIGEST_SIZE];
    1275314056            #endif
    1275414057
    1275514058            #ifdef WOLFSSL_SMALL_STACK
    12756                 hmac = (byte*)XMALLOC(MAX_DIGEST_SIZE, ssl->heap,
     14059                    hmac = (byte*)XMALLOC(WC_MAX_DIGEST_SIZE, ssl->heap,
    1275714060                                                       DYNAMIC_TYPE_DIGEST);
    1275814061                if (hmac == NULL)
    … …  
    1276014063            #endif
    1276114064
    12762                 ret = ssl->hmac(ssl, hmac, output + args->headerSz + args->ivSz, inSz,
    12763                                                                        type, 0);
     14065                    ret = ssl->hmac(ssl, hmac,
     14066                                     output + args->headerSz + args->ivSz, inSz,
     14067                                     -1, type, 0);
    1276414068                XMEMCPY(output + args->idx, hmac, args->digestSz);
    1276514069
    … …  
    1277014074            else
    1277114075        #endif
    12772                 ret = ssl->hmac(ssl, output + args->idx, output + args->headerSz + args->ivSz,
    12773                                                                 inSz, type, 0);
    12774             #ifdef WOLFSSL_DTLS
    12775                 if (ssl->options.dtls)
    12776                     DtlsSEQIncrement(ssl, CUR_ORDER);
    12777             #endif
    12778             }
     14076                {
     14077                    ret = ssl->hmac(ssl, output + args->idx, output +
     14078                                args->headerSz + args->ivSz, inSz, -1, type, 0);
     14079            }
     14080            }
     14081        #endif /* WOLFSSL_AEAD_ONLY */
    1277914082            if (ret != 0)
    1278014083                goto exit_buildmsg;
    … …  
    1280414107    ssl->options.buildMsgState = BUILD_MSG_BEGIN;
    1280514108
     14109    #ifdef WOLFSSL_DTLS
     14110        if (ret == 0 && ssl->options.dtls)
     14111            DtlsSEQIncrement(ssl, CUR_ORDER);
     14112    #endif
     14113
    1280614114    /* return sz on success */
    1280714115    if (ret == 0)
    … …  
    1281014118    /* Final cleanup */
    1281114119    FreeBuildMsgArgs(ssl, args);
     14120#ifdef WOLFSSL_ASYNC_CRYPT
     14121    ssl->async.freeArgs = NULL;
     14122#endif
    1281214123
    1281314124    return ret;
     14125#endif /* !WOLFSSL_NO_TLS12 */
    1281414126}
    1281514127
     14128#ifndef WOLFSSL_NO_TLS12
    1281614129
    1281714130int SendFinished(WOLFSSL* ssl)
    … …  
    1282714140    int              outputSz;
    1282814141
     14142    WOLFSSL_START(WC_FUNC_FINISHED_SEND);
     14143    WOLFSSL_ENTER("SendFinished");
     14144
    1282914145    /* setup encrypt keys */
    1283014146    if ((ret = SetKeysSide(ssl, ENCRYPT_SIDE_ONLY)) != 0)
    … …  
    1288914205#endif
    1289014206        if (ssl->options.side == WOLFSSL_SERVER_END) {
     14207        #ifdef OPENSSL_EXTRA
     14208            ssl->options.serverState = SERVER_FINISHED_COMPLETE;
     14209            ssl->cbmode = SSL_CB_MODE_WRITE;
     14210            if (ssl->CBIS != NULL)
     14211                ssl->CBIS(ssl, SSL_CB_HANDSHAKE_DONE, SSL_SUCCESS);
     14212        #endif
    1289114213            ssl->options.handShakeState = HANDSHAKE_DONE;
    1289214214            ssl->options.handShakeDone  = 1;
    … …  
    1289514217    else {
    1289614218        if (ssl->options.side == WOLFSSL_CLIENT_END) {
     14219        #ifdef OPENSSL_EXTRA
     14220            ssl->options.clientState = CLIENT_FINISHED_COMPLETE;
     14221            ssl->cbmode = SSL_CB_MODE_WRITE;
     14222            if (ssl->CBIS != NULL)
     14223                ssl->CBIS(ssl, SSL_CB_HANDSHAKE_DONE, SSL_SUCCESS);
     14224        #endif
    1289714225            ssl->options.handShakeState = HANDSHAKE_DONE;
    1289814226            ssl->options.handShakeDone  = 1;
    … …  
    1290014228    }
    1290114229
    12902     #ifdef WOLFSSL_CALLBACKS
    12903         if (ssl->hsInfoOn) AddPacketName("Finished", &ssl->handShakeInfo);
     14230    #if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
     14231        if (ssl->hsInfoOn) AddPacketName(ssl, "Finished");
    1290414232        if (ssl->toInfoOn)
    12905             AddPacketInfo("Finished", &ssl->timeoutInfo, output, sendSz,
    12906                           ssl->heap);
     14233            AddPacketInfo(ssl, "Finished", handshake, output, sendSz,
     14234                          WRITE_PROTO, ssl->heap);
    1290714235    #endif
    1290814236
    1290914237    ssl->buffers.outputBuffer.length += sendSz;
    1291014238
    12911     return SendBuffered(ssl);
     14239    ret = SendBuffered(ssl);
     14240
     14241    WOLFSSL_LEAVE("SendFinished", ret);
     14242    WOLFSSL_END(WC_FUNC_FINISHED_SEND);
     14243
     14244    return ret;
    1291214245}
    12913 
     14246#endif /* WOLFSSL_NO_TLS12 */
     14247
     14248#ifndef NO_WOLFSSL_SERVER
     14249#if (!defined(WOLFSSL_NO_TLS12) && \
     14250        (defined(HAVE_CERTIFICATE_STATUS_REQUEST) || \
     14251         defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2))) || \
     14252    (defined(WOLFSSL_TLS13) && defined(HAVE_CERTIFICATE_STATUS_REQUEST))
     14253static int CreateOcspRequest(WOLFSSL* ssl, OcspRequest* request,
     14254                             DecodedCert* cert, byte* certData, word32 length)
     14255{
     14256    int ret;
     14257
     14258    InitDecodedCert(cert, certData, length, ssl->heap);
     14259    /* TODO: Setup async support here */
     14260    ret = ParseCertRelative(cert, CERT_TYPE, VERIFY, ssl->ctx->cm);
     14261    if (ret != 0) {
     14262        WOLFSSL_MSG("ParseCert failed");
     14263    }
     14264    if (ret == 0)
     14265        ret = InitOcspRequest(request, cert, 0, ssl->heap);
     14266    if (ret == 0) {
     14267        /* make sure ctx OCSP request is updated */
     14268        if (!ssl->buffers.weOwnCert) {
     14269            wolfSSL_Mutex* ocspLock = &ssl->ctx->cm->ocsp_stapling->ocspLock;
     14270            if (wc_LockMutex(ocspLock) == 0) {
     14271                if (ssl->ctx->certOcspRequest == NULL)
     14272                    ssl->ctx->certOcspRequest = request;
     14273                wc_UnLockMutex(ocspLock);
     14274            }
     14275        }
     14276    }
     14277
     14278    FreeDecodedCert(cert);
     14279
     14280    return ret;
     14281}
     14282
     14283
     14284int CreateOcspResponse(WOLFSSL* ssl, OcspRequest** ocspRequest,
     14285                       buffer* response)
     14286{
     14287    int          ret = 0;
     14288    OcspRequest* request;
     14289
     14290    if (ssl == NULL || ocspRequest == NULL || response == NULL)
     14291        return BAD_FUNC_ARG;
     14292
     14293    request = *ocspRequest;
     14294
     14295    XMEMSET(response, 0, sizeof(*response));
     14296
     14297    /* unable to fetch status. skip. */
     14298    if (ssl->ctx->cm == NULL || ssl->ctx->cm->ocspStaplingEnabled == 0)
     14299        return 0;
     14300
     14301    if (request == NULL || ssl->buffers.weOwnCert) {
     14302        DerBuffer* der = ssl->buffers.certificate;
     14303        #ifdef WOLFSSL_SMALL_STACK
     14304            DecodedCert* cert = NULL;
     14305        #else
     14306            DecodedCert  cert[1];
     14307        #endif
     14308
     14309        /* unable to fetch status. skip. */
     14310        if (der->buffer == NULL || der->length == 0)
     14311            return 0;
     14312
     14313    #ifdef WOLFSSL_SMALL_STACK
     14314        cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), ssl->heap,
     14315                                        DYNAMIC_TYPE_DCERT);
     14316        if (cert == NULL)
     14317            return MEMORY_E;
     14318    #endif
     14319        request = (OcspRequest*)XMALLOC(sizeof(OcspRequest), ssl->heap,
     14320                                                     DYNAMIC_TYPE_OCSP_REQUEST);
     14321        if (request == NULL)
     14322            ret = MEMORY_E;
     14323
     14324        if (ret == 0) {
     14325            ret = CreateOcspRequest(ssl, request, cert, der->buffer,
     14326                                                                   der->length);
     14327        }
     14328
     14329        if (request != NULL && ret != 0) {
     14330            FreeOcspRequest(request);
     14331            XFREE(request, ssl->heap, DYNAMIC_TYPE_OCSP_REQUEST);
     14332            request = NULL;
     14333        }
     14334    #ifdef WOLFSSL_SMALL_STACK
     14335        XFREE(cert, ssl->heap, DYNAMIC_TYPE_DCERT);
     14336    #endif
     14337    }
     14338
     14339    if (ret == 0) {
     14340        request->ssl = ssl;
     14341        ret = CheckOcspRequest(ssl->ctx->cm->ocsp_stapling, request, response);
     14342
     14343        /* Suppressing, not critical */
     14344        if (ret == OCSP_CERT_REVOKED ||
     14345            ret == OCSP_CERT_UNKNOWN ||
     14346            ret == OCSP_LOOKUP_FAIL) {
     14347            ret = 0;
     14348        }
     14349}
     14350
     14351    *ocspRequest = request;
     14352
     14353    return ret;
     14354}
     14355#endif
     14356#endif /* !NO_WOLFSSL_SERVER */
     14357
     14358#ifndef WOLFSSL_NO_TLS12
    1291414359
    1291514360#ifndef NO_CERTS
     14361#if !defined(NO_WOLFSSL_SERVER) || !defined(WOLFSSL_NO_CLIENT_AUTH)
     14362/* handle generation of certificate (11) */
    1291614363int SendCertificate(WOLFSSL* ssl)
    1291714364{
    … …  
    1292014367    word32 length, maxFragment;
    1292114368
     14369    WOLFSSL_START(WC_FUNC_CERTIFICATE_SEND);
     14370    WOLFSSL_ENTER("SendCertificate");
     14371
    1292214372    if (ssl->options.usingPSK_cipher || ssl->options.usingAnon_cipher)
    1292314373        return 0;  /* not needed */
    1292414374
    1292514375    if (ssl->options.sendVerify == SEND_BLANK_CERT) {
     14376    #ifdef OPENSSL_EXTRA
     14377        if (ssl->version.major == SSLv3_MAJOR
     14378            && ssl->version.minor == SSLv3_MINOR){
     14379            SendAlert(ssl, alert_warning, no_certificate);
     14380            return 0;
     14381        } else {
     14382    #endif
    1292614383        certSz = 0;
    1292714384        certChainSz = 0;
    … …  
    1292914386        length = CERT_HEADER_SZ;
    1293014387        listSz = 0;
     14388    #ifdef OPENSSL_EXTRA
     14389        }
     14390    #endif
    1293114391    }
    1293214392    else {
    … …  
    1295714417
    1295814418    maxFragment = MAX_RECORD_SIZE;
     14419
    1295914420    if (ssl->options.dtls) {
    1296014421    #ifdef WOLFSSL_DTLS
     14422        /* The 100 bytes is used to account for the UDP and IP headers.
     14423           It can also include the record padding and MAC if the
     14424           SendCertificate is called for a secure renegotiation. */
    1296114425        maxFragment = MAX_MTU - DTLS_RECORD_HEADER_SZ
    1296214426                      - DTLS_HANDSHAKE_HEADER_SZ - 100;
    … …  
    1296414428    }
    1296514429
    12966     #ifdef HAVE_MAX_FRAGMENT
    12967     if (ssl->max_fragment != 0 && maxFragment >= ssl->max_fragment)
    12968         maxFragment = ssl->max_fragment;
    12969     #endif /* HAVE_MAX_FRAGMENT */
     14430    maxFragment = wolfSSL_GetMaxRecordSize(ssl, maxFragment);
    1297014431
    1297114432    while (length > 0 && ret == 0) {
    … …  
    1313214593    #endif
    1313314594
    13134     #ifdef WOLFSSL_CALLBACKS
     14595    #if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
    1313514596        if (ssl->hsInfoOn)
    13136             AddPacketName("Certificate", &ssl->handShakeInfo);
     14597            AddPacketName(ssl, "Certificate");
    1313714598        if (ssl->toInfoOn)
    13138             AddPacketInfo("Certificate", &ssl->timeoutInfo, output, sendSz,
    13139                            ssl->heap);
     14599            AddPacketInfo(ssl, "Certificate", handshake, output, sendSz,
     14600                           WRITE_PROTO, ssl->heap);
    1314014601    #endif
    1314114602
    … …  
    1315214613                ssl->keys.dtls_handshake_number++;
    1315314614        #endif
    13154         if (ssl->options.side == WOLFSSL_SERVER_END)
     14615        if (ssl->options.side == WOLFSSL_SERVER_END){
    1315514616            ssl->options.serverState = SERVER_CERT_COMPLETE;
    1315614617    }
     14618    }
     14619
     14620    WOLFSSL_LEAVE("SendCertificate", ret);
     14621    WOLFSSL_END(WC_FUNC_CERTIFICATE_SEND);
    1315714622
    1315814623    return ret;
    1315914624}
    13160 
    13161 
     14625#endif /* !NO_WOLFSSL_SERVER || !WOLFSSL_NO_CLIENT_AUTH */
     14626
     14627/* handle generation of certificate_request (13) */
    1316214628int SendCertificateRequest(WOLFSSL* ssl)
    1316314629{
    … …  
    1316714633    word32 i = RECORD_HEADER_SZ + HANDSHAKE_HEADER_SZ;
    1316814634    word32 dnLen = 0;
    13169 #ifdef WOLFSSL_NGINX
     14635#if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX)
    1317014636    WOLF_STACK_OF(WOLFSSL_X509_NAME)* names;
    1317114637#endif
    … …  
    1317414640    int  reqSz = ENUM_LEN + typeTotal + REQ_HEADER_SZ;  /* add auth later */
    1317514641
     14642    WOLFSSL_START(WC_FUNC_CERTIFICATE_REQUEST_SEND);
     14643    WOLFSSL_ENTER("SendCertificateRequest");
     14644
    1317614645    if (IsAtLeastTLSv1_2(ssl))
    1317714646        reqSz += LENGTH_SZ + ssl->suites->hashSigAlgoSz;
    1317814647
    13179 #ifdef WOLFSSL_NGINX
     14648#if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX)
    1318014649    /* Certificate Authorities */
    1318114650    names = ssl->ctx->ca_names;
    … …  
    1319614665    sendSz = RECORD_HEADER_SZ + HANDSHAKE_HEADER_SZ + reqSz;
    1319714666
     14667    if (!ssl->options.dtls) {
     14668        if (IsEncryptionOn(ssl, 1))
     14669            sendSz += MAX_MSG_EXTRA;
     14670    }
     14671    else {
    1319814672    #ifdef WOLFSSL_DTLS
    13199         if (ssl->options.dtls) {
    1320014673            sendSz += DTLS_RECORD_EXTRA + DTLS_HANDSHAKE_EXTRA;
    1320114674            i      += DTLS_RECORD_EXTRA + DTLS_HANDSHAKE_EXTRA;
    13202         }
    1320314675    #endif
     14676    }
    1320414677    /* check for available size */
    1320514678    if ((ret = CheckAvailableSize(ssl, sendSz)) != 0)
    … …  
    1322814701    if (IsAtLeastTLSv1_2(ssl)) {
    1322914702        c16toa(ssl->suites->hashSigAlgoSz, &output[i]);
    13230         i += LENGTH_SZ;
     14703        i += OPAQUE16_LEN;
    1323114704
    1323214705        XMEMCPY(&output[i],
    … …  
    1323814711    c16toa((word16)dnLen, &output[i]);  /* auth's */
    1323914712    i += REQ_HEADER_SZ;
    13240 #ifdef WOLFSSL_NGINX
     14713#if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX)
    1324114714    names = ssl->ctx->ca_names;
    1324214715    while (names != NULL) {
    1324314716        byte seq[MAX_SEQ_SZ];
    1324414717
    13245         c16toa(names->data.name->rawLen +
     14718        c16toa((word16)names->data.name->rawLen +
    1324614719               SetSequence(names->data.name->rawLen, seq), &output[i]);
    1324714720        i += OPAQUE16_LEN;
    … …  
    1325414727    (void)i;
    1325514728
     14729        if (IsEncryptionOn(ssl, 1)) {
     14730            byte* input;
     14731            int   inputSz = i - RECORD_HEADER_SZ; /* build msg adds rec hdr */
     14732
     14733            input = (byte*)XMALLOC(inputSz, ssl->heap, DYNAMIC_TYPE_IN_BUFFER);
     14734            if (input == NULL)
     14735                return MEMORY_E;
     14736
     14737            XMEMCPY(input, output + RECORD_HEADER_SZ, inputSz);
     14738            sendSz = BuildMessage(ssl, output, sendSz, input, inputSz,
     14739                                  handshake, 1, 0, 0);
     14740            XFREE(input, ssl->heap, DYNAMIC_TYPE_IN_BUFFER);
     14741
     14742            if (sendSz < 0)
     14743                return sendSz;
     14744        } else {
    1325614745    #ifdef WOLFSSL_DTLS
     14746                if (ssl->options.dtls)
     14747                    DtlsSEQIncrement(ssl, CUR_ORDER);
    1325714748        if (IsDtlsNotSctpMode(ssl)) {
    1325814749            if ((ret = DtlsMsgPoolSave(ssl, output, sendSz)) != 0)
    1325914750                return ret;
    1326014751        }
    13261         if (ssl->options.dtls)
    13262             DtlsSEQIncrement(ssl, CUR_ORDER);
    1326314752    #endif
    13264 
    1326514753    ret = HashOutput(ssl, output, sendSz, 0);
    1326614754    if (ret != 0)
    1326714755        return ret;
    13268 
    13269     #ifdef WOLFSSL_CALLBACKS
     14756        }
     14757
     14758    #if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
    1327014759        if (ssl->hsInfoOn)
    13271             AddPacketName("CertificateRequest", &ssl->handShakeInfo);
     14760            AddPacketName(ssl, "CertificateRequest");
    1327214761        if (ssl->toInfoOn)
    13273             AddPacketInfo("CertificateRequest", &ssl->timeoutInfo, output,
    13274                           sendSz, ssl->heap);
     14762            AddPacketInfo(ssl, "CertificateRequest", handshake, output, sendSz,
     14763                    WRITE_PROTO, ssl->heap);
    1327514764    #endif
    1327614765    ssl->buffers.outputBuffer.length += sendSz;
    1327714766    if (ssl->options.groupMessages)
    13278         return 0;
     14767        ret = 0;
    1327914768    else
    13280         return SendBuffered(ssl);
     14769        ret = SendBuffered(ssl);
     14770
     14771    WOLFSSL_LEAVE("SendCertificateRequest", ret);
     14772    WOLFSSL_END(WC_FUNC_CERTIFICATE_REQUEST_SEND);
     14773
     14774    return ret;
    1328114775}
    1328214776
    … …  
    1336514859    #endif
    1336614860
    13367     #ifdef WOLFSSL_CALLBACKS
     14861    #if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
    1336814862        if (ret == 0 && ssl->hsInfoOn)
    13369             AddPacketName("CertificateStatus", &ssl->handShakeInfo);
     14863            AddPacketName(ssl, "CertificateStatus");
    1337014864        if (ret == 0 && ssl->toInfoOn)
    13371             AddPacketInfo("CertificateStatus", &ssl->timeoutInfo, output,
    13372                                                              sendSz, ssl->heap);
     14865            AddPacketInfo(ssl, "CertificateStatus", handshake, output, sendSz,
     14866                    WRITE_PROTO, ssl->heap);
    1337314867    #endif
    1337414868
    … …  
    1338614880#endif /* NO_WOLFSSL_SERVER */
    1338714881
    13388 
     14882/* handle generation of certificate_status (22) */
    1338914883int SendCertificateStatus(WOLFSSL* ssl)
    1339014884{
    … …  
    1339214886    byte status_type = 0;
    1339314887
     14888    WOLFSSL_START(WC_FUNC_CERTIFICATE_STATUS_SEND);
    1339414889    WOLFSSL_ENTER("SendCertificateStatus");
    1339514890
    … …  
    1341514910            buffer response;
    1341614911
    13417             XMEMSET(&response, 0, sizeof(response));
    13418 
    13419             /* unable to fetch status. skip. */
    13420             if (ssl->ctx->cm == NULL || ssl->ctx->cm->ocspStaplingEnabled == 0)
    13421                 return 0;
    13422 
    13423             if (request == NULL || ssl->buffers.weOwnCert) {
    13424                 DerBuffer* der = ssl->buffers.certificate;
     14912            ret = CreateOcspResponse(ssl, &request, &response);
     14913            if (ret == 0 && response.buffer) {
     14914                ret = BuildCertificateStatus(ssl, status_type, &response, 1);
     14915
     14916                XFREE(response.buffer, ssl->heap, DYNAMIC_TYPE_OCSP_REQUEST);
     14917                response.buffer = NULL;
     14918            }
     14919
     14920            break;
     14921        }
     14922
     14923    #endif /* HAVE_CERTIFICATE_STATUS_REQUEST    */
     14924           /* HAVE_CERTIFICATE_STATUS_REQUEST_V2 */
     14925
     14926    #if defined HAVE_CERTIFICATE_STATUS_REQUEST_V2
     14927        case WOLFSSL_CSR2_OCSP_MULTI:
     14928        {
     14929            OcspRequest* request = ssl->ctx->certOcspRequest;
     14930            buffer responses[1 + MAX_CHAIN_DEPTH];
     14931            int i = 0;
     14932
     14933            XMEMSET(responses, 0, sizeof(responses));
     14934
     14935            ret = CreateOcspResponse(ssl, &request, &responses[0]);
     14936            if (ret == 0 && (!ssl->ctx->chainOcspRequest[0]
     14937                                              || ssl->buffers.weOwnCertChain)) {
     14938                buffer der;
     14939                word32 idx = 0;
    1342514940                #ifdef WOLFSSL_SMALL_STACK
    1342614941                    DecodedCert* cert = NULL;
    … …  
    1342814943                    DecodedCert  cert[1];
    1342914944                #endif
    13430 
    13431                 /* unable to fetch status. skip. */
    13432                 if (der->buffer == NULL || der->length == 0)
    13433                     return 0;
    1343414945
    1343514946            #ifdef WOLFSSL_SMALL_STACK
    … …  
    1343914950                    return MEMORY_E;
    1344014951            #endif
    13441 
    13442                 InitDecodedCert(cert, der->buffer, der->length, ssl->heap);
    13443                 /* TODO: Setup async support here */
    13444                 if ((ret = ParseCertRelative(cert, CERT_TYPE, VERIFY,
    13445                                                           ssl->ctx->cm)) != 0) {
    13446                     WOLFSSL_MSG("ParseCert failed");
    13447                 }
    13448                 else {
    13449                     request = (OcspRequest*)XMALLOC(sizeof(OcspRequest),
    13450                                           ssl->heap, DYNAMIC_TYPE_OCSP_REQUEST);
    13451                     if (request) {
    13452                         ret = InitOcspRequest(request, cert, 0, ssl->heap);
    13453                         if (ret == 0) {
    13454                             /* make sure ctx OCSP request is updated */
    13455                             if (!ssl->buffers.weOwnCert) {
    13456                                 wolfSSL_Mutex* ocspLock =
    13457                                     &ssl->ctx->cm->ocsp_stapling->ocspLock;
    13458                                 if (wc_LockMutex(ocspLock) == 0) {
    13459                                     if (ssl->ctx->certOcspRequest == NULL)
    13460                                         ssl->ctx->certOcspRequest = request;
    13461                                     wc_UnLockMutex(ocspLock);
    13462                                 }
    13463                             }
    13464                         }
    13465                         else {
    13466                             XFREE(request, ssl->heap, DYNAMIC_TYPE_OCSP_REQUEST);
    13467                             request = NULL;
    13468                         }
    13469                     }
    13470                     else {
    13471                         ret = MEMORY_E;
    13472                     }
    13473                 }
    13474 
    13475                 FreeDecodedCert(cert);
    13476 
     14952                request = (OcspRequest*)XMALLOC(sizeof(OcspRequest), ssl->heap,
     14953                                                     DYNAMIC_TYPE_OCSP_REQUEST);
     14954                if (request == NULL) {
    1347714955            #ifdef WOLFSSL_SMALL_STACK
    1347814956                XFREE(cert, ssl->heap, DYNAMIC_TYPE_DCERT);
    1347914957            #endif
    13480             }
    13481 
     14958                    return MEMORY_E;
     14959            }
     14960
     14961                while (idx + OPAQUE24_LEN < ssl->buffers.certChain->length) {
     14962                    c24to32(ssl->buffers.certChain->buffer + idx, &der.length);
     14963                    idx += OPAQUE24_LEN;
     14964
     14965                    der.buffer = ssl->buffers.certChain->buffer + idx;
     14966                    idx += der.length;
     14967
     14968                    if (idx > ssl->buffers.certChain->length)
     14969                        break;
     14970
     14971                    ret = CreateOcspRequest(ssl, request, cert, der.buffer,
     14972                                                                    der.length);
    1348214973            if (ret == 0) {
    1348314974                request->ssl = ssl;
    13484                 ret = CheckOcspRequest(ssl->ctx->cm->ocsp_stapling, request,
    13485                                                                      &response);
     14975                        ret = CheckOcspRequest(ssl->ctx->cm->ocsp_stapling,
     14976                                                    request, &responses[i + 1]);
    1348614977
    1348714978                /* Suppressing, not critical */
    … …  
    1349214983                }
    1349314984
    13494                 if (response.buffer) {
    13495                     if (ret == 0)
    13496                         ret = BuildCertificateStatus(ssl, status_type,
    13497                                                                   &response, 1);
    13498 
    13499                     XFREE(response.buffer, ssl->heap, DYNAMIC_TYPE_OCSP_REQUEST);
    13500                     response.buffer = NULL;
     14985
     14986                        i++;
     14987                        FreeOcspRequest(request);
    1350114988                }
    13502 
    13503             }
    13504 
    13505             if (request != ssl->ctx->certOcspRequest)
     14989            }
     14990
    1350614991                XFREE(request, ssl->heap, DYNAMIC_TYPE_OCSP_REQUEST);
    13507 
    13508             break;
    13509         }
    13510 
    13511     #endif /* HAVE_CERTIFICATE_STATUS_REQUEST    */
    13512            /* HAVE_CERTIFICATE_STATUS_REQUEST_V2 */
    13513 
    13514     #if defined HAVE_CERTIFICATE_STATUS_REQUEST_V2
    13515         case WOLFSSL_CSR2_OCSP_MULTI:
    13516         {
    13517             OcspRequest* request = ssl->ctx->certOcspRequest;
    13518             buffer responses[1 + MAX_CHAIN_DEPTH];
    13519             int i = 0;
    13520 
    13521             XMEMSET(responses, 0, sizeof(responses));
    13522 
    13523             /* unable to fetch status. skip. */
    13524             if (ssl->ctx->cm == NULL || ssl->ctx->cm->ocspStaplingEnabled == 0)
    13525                 return 0;
    13526 
    13527             if (!request || ssl->buffers.weOwnCert) {
    13528                 DerBuffer* der = ssl->buffers.certificate;
    13529             #ifdef WOLFSSL_SMALL_STACK
    13530                 DecodedCert* cert = NULL;
    13531             #else
    13532                 DecodedCert  cert[1];
    13533             #endif
    13534 
    13535                 /* unable to fetch status. skip. */
    13536                 if (der->buffer == NULL || der->length == 0)
    13537                     return 0;
    13538 
    13539             #ifdef WOLFSSL_SMALL_STACK
    13540                 cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), ssl->heap,
    13541                                              DYNAMIC_TYPE_DCERT);
    13542                 if (cert == NULL)
    13543                     return MEMORY_E;
    13544             #endif
    13545 
    13546                 InitDecodedCert(cert, der->buffer, der->length, ssl->heap);
    13547                 /* TODO: Setup async support here */
    13548                 if ((ret = ParseCertRelative(cert, CERT_TYPE, VERIFY,
    13549                                                           ssl->ctx->cm)) != 0) {
    13550                     WOLFSSL_MSG("ParseCert failed");
    13551                 }
    13552                 else {
    13553                     request = (OcspRequest*)XMALLOC(sizeof(OcspRequest),
    13554                                           ssl->heap, DYNAMIC_TYPE_OCSP_REQUEST);
    13555                     if (request) {
    13556                         ret = InitOcspRequest(request, cert, 0, ssl->heap);
    13557                         if (ret == 0) {
    13558                             /* make sure ctx OCSP request is updated */
    13559                             if (!ssl->buffers.weOwnCert) {
    13560                                 wolfSSL_Mutex* ocspLock =
    13561                                     &ssl->ctx->cm->ocsp_stapling->ocspLock;
    13562                                 if (wc_LockMutex(ocspLock) == 0) {
    13563                                     if (ssl->ctx->certOcspRequest == NULL)
    13564                                         ssl->ctx->certOcspRequest = request;
    13565                                     wc_UnLockMutex(ocspLock);
    13566                                 }
    13567                             }
    13568                         }
    13569                         else {
    13570                             XFREE(request, ssl->heap, DYNAMIC_TYPE_OCSP_REQUEST);
    13571                             request = NULL;
    13572                         }
    13573                     }
    13574                     else {
    13575                         ret = MEMORY_E;
    13576                     }
    13577                 }
    13578 
    13579                 FreeDecodedCert(cert);
    13580 
    1358114992            #ifdef WOLFSSL_SMALL_STACK
    1358214993                XFREE(cert, ssl->heap, DYNAMIC_TYPE_DCERT);
    1358314994            #endif
    13584             }
    13585 
    13586             if (ret == 0) {
    13587                 request->ssl = ssl;
    13588                 ret = CheckOcspRequest(ssl->ctx->cm->ocsp_stapling, request,
    13589                                                                  &responses[0]);
     14995        }
     14996            else {
     14997                while (ret == 0 &&
     14998                            NULL != (request = ssl->ctx->chainOcspRequest[i])) {
     14999                    request->ssl = ssl;
     15000                    ret = CheckOcspRequest(ssl->ctx->cm->ocsp_stapling,
     15001                                                request, &responses[++i]);
    1359015002
    1359115003                /* Suppressing, not critical */
    … …  
    1359615008                }
    1359715009            }
    13598 
    13599             if (request != ssl->ctx->certOcspRequest)
    13600                 XFREE(request, ssl->heap, DYNAMIC_TYPE_OCSP_REQUEST);
    13601 
    13602             if (ret == 0 && (!ssl->ctx->chainOcspRequest[0]
    13603                                               || ssl->buffers.weOwnCertChain)) {
    13604                 buffer der;
    13605                 word32 idx = 0;
    13606             #ifdef WOLFSSL_SMALL_STACK
    13607                 DecodedCert* cert = NULL;
    13608             #else
    13609                 DecodedCert  cert[1];
    13610             #endif
    13611 
    13612                 XMEMSET(&der, 0, sizeof(buffer));
    13613 
    13614             #ifdef WOLFSSL_SMALL_STACK
    13615                 cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), ssl->heap,
    13616                                              DYNAMIC_TYPE_DCERT);
    13617                 if (cert == NULL)
    13618                     return MEMORY_E;
    13619             #endif
    13620 
    13621                 while (idx + OPAQUE24_LEN < ssl->buffers.certChain->length) {
    13622                     c24to32(ssl->buffers.certChain->buffer + idx, &der.length);
    13623                     idx += OPAQUE24_LEN;
    13624 
    13625                     der.buffer = ssl->buffers.certChain->buffer + idx;
    13626                     idx += der.length;
    13627 
    13628                     if (idx > ssl->buffers.certChain->length)
    13629                         break;
    13630 
    13631                     InitDecodedCert(cert, der.buffer, der.length, ssl->heap);
    13632                     /* TODO: Setup async support here */
    13633                     if ((ret = ParseCertRelative(cert, CERT_TYPE, VERIFY,
    13634                                                       ssl->ctx->cm)) != 0) {
    13635                         WOLFSSL_MSG("ParseCert failed");
    13636                         break;
    13637                     }
    13638                     else {
    13639                         request = (OcspRequest*)XMALLOC(sizeof(OcspRequest),
    13640                                           ssl->heap, DYNAMIC_TYPE_OCSP_REQUEST);
    13641                         if (request == NULL) {
    13642                             FreeDecodedCert(cert);
    13643 
    13644                             ret = MEMORY_E;
    13645                             break;
    1364615010                        }
    1364715011
    13648                         ret = InitOcspRequest(request, cert, 0, ssl->heap);
     15012            if (responses[0].buffer) {
    1364915013                        if (ret == 0) {
    13650                             /* make sure ctx OCSP request is updated */
    13651                             if (!ssl->buffers.weOwnCertChain) {
    13652                                 wolfSSL_Mutex* ocspLock =
    13653                                     &ssl->ctx->cm->ocsp_stapling->ocspLock;
    13654                                 if (wc_LockMutex(ocspLock) == 0) {
    13655                                     if (ssl->ctx->chainOcspRequest[i] == NULL)
    13656                                         ssl->ctx->chainOcspRequest[i] = request;
    13657                                     wc_UnLockMutex(ocspLock);
    13658                                 }
    13659                             }
    13660                         }
    13661                         else {
    13662                             FreeDecodedCert(cert);
    13663                             XFREE(request, ssl->heap, DYNAMIC_TYPE_OCSP_REQUEST);
    13664                             request = NULL;
    13665                             break;
    13666                         }
    13667 
    13668                         request->ssl = ssl;
    13669                         ret = CheckOcspRequest(ssl->ctx->cm->ocsp_stapling,
    13670                                                     request, &responses[i + 1]);
    13671 
    13672                         /* Suppressing, not critical */
    13673                         if (ret == OCSP_CERT_REVOKED ||
    13674                             ret == OCSP_CERT_UNKNOWN ||
    13675                             ret == OCSP_LOOKUP_FAIL) {
    13676                             ret = 0;
    13677                         }
    13678 
    13679                         if (request != ssl->ctx->chainOcspRequest[i])
    13680                             XFREE(request, ssl->heap, DYNAMIC_TYPE_OCSP_REQUEST);
    13681 
    13682                         i++;
    13683                     }
    13684 
    13685                     FreeDecodedCert(cert);
    13686                 }
    13687 
    13688             #ifdef WOLFSSL_SMALL_STACK
    13689                 XFREE(cert, ssl->heap, DYNAMIC_TYPE_DCERT);
    13690             #endif
    13691             }
    13692             else {
    13693                 while (ret == 0 &&
    13694                             NULL != (request = ssl->ctx->chainOcspRequest[i])) {
    13695                     request->ssl = ssl;
    13696                     ret = CheckOcspRequest(ssl->ctx->cm->ocsp_stapling,
    13697                                                 request, &responses[++i]);
    13698 
    13699                     /* Suppressing, not critical */
    13700                     if (ret == OCSP_CERT_REVOKED ||
    13701                         ret == OCSP_CERT_UNKNOWN ||
    13702                         ret == OCSP_LOOKUP_FAIL) {
    13703                         ret = 0;
    13704                     }
    13705                 }
    13706             }
    13707 
    13708             if (responses[0].buffer) {
    13709                 if (ret == 0)
    13710                     ret = BuildCertificateStatus(ssl, status_type,
    13711                                                         responses, (byte)i + 1);
    13712 
    13713                 for (i = 0; i < 1 + MAX_CHAIN_DEPTH; i++)
    13714                     if (responses[i].buffer)
     15014                    ret = BuildCertificateStatus(ssl, status_type, responses,
     15015                                                                   (byte)i + 1);
     15016            }
     15017
     15018                for (i = 0; i < 1 + MAX_CHAIN_DEPTH; i++) {
     15019                    if (responses[i].buffer) {
    1371515020                        XFREE(responses[i].buffer, ssl->heap,
    1371615021                                                       DYNAMIC_TYPE_OCSP_REQUEST);
    1371715022            }
     15023                }
     15024            }
    1371815025
    1371915026            break;
    … …  
    1372615033    }
    1372715034
     15035    WOLFSSL_LEAVE("SendCertificateStatus", ret);
     15036    WOLFSSL_END(WC_FUNC_CERTIFICATE_STATUS_SEND);
     15037
    1372815038    return ret;
    1372915039}
    … …  
    1373115041#endif /* !NO_CERTS */
    1373215042
     15043#endif /* WOLFSSL_NO_TLS12 */
    1373315044
    1373415045int SendData(WOLFSSL* ssl, const void* data, int sz)
    … …  
    1373815049        ret,
    1373915050        dtlsExtra = 0;
    13740 
    13741     if (ssl->error == WANT_WRITE || ssl->error == WC_PENDING_E)
     15051    int groupMsgs = 0;
     15052
     15053    if (ssl->error == WANT_WRITE
     15054    #ifdef WOLFSSL_ASYNC_CRYPT
     15055        || ssl->error == WC_PENDING_E
     15056    #endif
     15057    ) {
    1374215058        ssl->error = 0;
     15059    }
    1374315060
    1374415061#ifdef WOLFSSL_DTLS
    … …  
    1375215069
    1375315070#ifdef WOLFSSL_EARLY_DATA
    13754     if (ssl->earlyData) {
     15071    if (ssl->earlyData != no_early_data) {
    1375515072        if (ssl->options.handShakeState == HANDSHAKE_DONE) {
    1375615073            WOLFSSL_MSG("handshake complete, trying to send early data");
    1375715074            return BUILD_MSG_ERROR;
    1375815075        }
     15076    #ifdef WOLFSSL_EARLY_DATA_GROUP
     15077        groupMsgs = 1;
     15078    #endif
    1375915079    }
    1376015080    else
    … …  
    1376415084        WOLFSSL_MSG("handshake not complete, trying to finish");
    1376515085        if ( (err = wolfSSL_negotiate(ssl)) != WOLFSSL_SUCCESS) {
     15086        #ifdef WOLFSSL_ASYNC_CRYPT
    1376615087            /* if async would block return WANT_WRITE */
    1376715088            if (ssl->error == WC_PENDING_E) {
    1376815089                return WOLFSSL_CBIO_ERR_WANT_WRITE;
    1376915090            }
     15091        #endif
    1377015092            return  err;
    1377115093        }
    … …  
    1377315095
    1377415096    /* last time system socket output buffer was full, try again to send */
    13775     if (ssl->buffers.outputBuffer.length > 0) {
     15097    if (!groupMsgs && ssl->buffers.outputBuffer.length > 0) {
    1377615098        WOLFSSL_MSG("output buffer was full, trying to send again");
    1377715099        if ( (ssl->error = SendBuffered(ssl)) < 0) {
    1377815100            WOLFSSL_ERROR(ssl->error);
    13779             if (ssl->error == SOCKET_ERROR_E && ssl->options.connReset)
    13780                 return 0;     /* peer reset */
     15101            if (ssl->error == SOCKET_ERROR_E && (ssl->options.connReset ||
     15102                                                 ssl->options.isClosed)) {
     15103                ssl->error = SOCKET_PEER_CLOSED_E;
     15104                WOLFSSL_ERROR(ssl->error);
     15105                return 0;  /* peer reset or closed */
     15106            }
    1378115107            return ssl->error;
    1378215108        }
    … …  
    1381115137        if (sent == sz) break;
    1381215138
    13813         len = min(sz - sent, OUTPUT_RECORD_SIZE);
    13814 #ifdef HAVE_MAX_FRAGMENT
    13815         len = min(len, ssl->max_fragment);
    13816 #endif
     15139        len = wolfSSL_GetMaxRecordSize(ssl, sz - sent);
    1381715140
    1381815141#ifdef WOLFSSL_DTLS
    … …  
    1386315186        ssl->buffers.outputBuffer.length += sendSz;
    1386415187
    13865         if ( (ret = SendBuffered(ssl)) < 0) {
    13866             WOLFSSL_ERROR(ret);
     15188        if ( (ssl->error = SendBuffered(ssl)) < 0) {
     15189            WOLFSSL_ERROR(ssl->error);
    1386715190            /* store for next call if WANT_WRITE or user embedSend() that
    1386815191               doesn't present like WANT_WRITE */
    1386915192            ssl->buffers.plainSz  = len;
    1387015193            ssl->buffers.prevSent = sent;
    13871             if (ret == SOCKET_ERROR_E && ssl->options.connReset)
    13872                 return 0;  /* peer reset */
    13873             return ssl->error = ret;
     15194            if (ssl->error == SOCKET_ERROR_E && (ssl->options.connReset ||
     15195                                                 ssl->options.isClosed)) {
     15196                ssl->error = SOCKET_PEER_CLOSED_E;
     15197                WOLFSSL_ERROR(ssl->error);
     15198                return 0;  /* peer reset or closed */
     15199            }
     15200            return ssl->error;
    1387415201        }
    1387515202
    … …  
    1387815205        /* only one message per attempt */
    1387915206        if (ssl->options.partialWrite == 1) {
    13880             WOLFSSL_MSG("Paritial Write on, only sending one record");
     15207            WOLFSSL_MSG("Partial Write on, only sending one record");
    1388115208            break;
    1388215209        }
    … …  
    1389415221
    1389515222    /* reset error state */
    13896     if (ssl->error == WANT_READ || ssl->error == WC_PENDING_E) {
     15223    if (ssl->error == WANT_READ
     15224    #ifdef WOLFSSL_ASYNC_CRYPT
     15225        || ssl->error == WC_PENDING_E
     15226    #endif
     15227    ) {
    1389715228        ssl->error = 0;
    1389815229    }
    … …  
    1391315244
    1391415245#ifdef WOLFSSL_EARLY_DATA
    13915     if (ssl->earlyData) {
     15246    if (ssl->earlyData != no_early_data) {
    1391615247    }
    1391715248    else
    … …  
    1393515266    if (ssl->secure_renegotiation && ssl->secure_renegotiation->startScr) {
    1393615267        int err;
    13937         ssl->secure_renegotiation->startScr = 0;  /* only start once */
    1393815268        WOLFSSL_MSG("Need to start scr, server requested");
    1393915269        if ( (err = wolfSSL_Rehandshake(ssl)) != WOLFSSL_SUCCESS)
    1394015270            return  err;
     15271        ssl->secure_renegotiation->startScr = 0;  /* only start once */
    1394115272    }
    1394215273#endif
    … …  
    1402615357    }
    1402715358
     15359   #ifdef OPENSSL_EXTRA
     15360        if (ssl->CBIS != NULL) {
     15361            ssl->CBIS(ssl, SSL_CB_ALERT, type);
     15362        }
     15363   #endif
    1402815364   #ifdef WOLFSSL_DTLS
    1402915365        if (ssl->options.dtls)
    … …  
    1403515371    if ((ret = CheckAvailableSize(ssl, outputSz)) != 0)
    1403615372        return ret;
     15373
     15374    /* Check output buffer */
     15375    if (ssl->buffers.outputBuffer.buffer == NULL)
     15376        return BUFFER_E;
    1403715377
    1403815378    /* get output buffer */
    … …  
    1407215412        return BUILD_MSG_ERROR;
    1407315413
    14074     #ifdef WOLFSSL_CALLBACKS
     15414    #if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
    1407515415        if (ssl->hsInfoOn)
    14076             AddPacketName("Alert", &ssl->handShakeInfo);
     15416            AddPacketName(ssl, "Alert");
    1407715417        if (ssl->toInfoOn)
    14078             AddPacketInfo("Alert", &ssl->timeoutInfo, output, sendSz,ssl->heap);
     15418            AddPacketInfo(ssl, "Alert", alert, output, sendSz, WRITE_PROTO,
     15419                    ssl->heap);
    1407915420    #endif
    1408015421
    … …  
    1410315444    switch (error) {
    1410415445
     15446#ifdef WOLFSSL_WPAS
     15447    case 0 :
     15448        return "ok";
     15449#endif
     15450
    1410515451    case UNSUPPORTED_SUITE :
    1410615452        return "unsupported cipher suite";
    … …  
    1419115537        return "handshake layer not ready yet, complete first";
    1419215538
    14193     case PMS_VERSION_ERROR :
    14194         return "premaster secret version mismatch error";
    14195 
    1419615539    case VERSION_ERROR :
    1419715540        return "record layer version error";
    … …  
    1423115574        return "NTRU decrypt error";
    1423215575
    14233     case ZLIB_INIT_ERROR:
    14234         return "zlib init error";
    14235 
    14236     case ZLIB_COMPRESS_ERROR:
    14237         return "zlib compress error";
    14238 
    14239     case ZLIB_DECOMPRESS_ERROR:
    14240         return "zlib decompress error";
    14241 
    1424215576    case GETTIME_ERROR:
    1424315577        return "gettimeofday() error";
    … …  
    1432515659        return "Suites Pointer Error";
    1432615660
    14327     case SSL_NO_PEM_HEADER:
    14328         return "No PEM Header Error";
    14329 
    1433015661    case OUT_OF_ORDER_E:
    1433115662        return "Out of order message, fatal";
    … …  
    1443015761        return "Invalid OCSP Status Error";
    1443115762
     15763    case OCSP_WANT_READ:
     15764        return "OCSP nonblock wants read";
     15765
    1443215766    case RSA_KEY_SIZE_E:
    1443315767        return "RSA key too small";
    … …  
    1446415798
    1446515799    case BAD_KEY_SHARE_DATA:
    14466         return "The Key Share data contains group that was in Client Hello";
     15800        return "The Key Share data contains group that wasn't in Client Hello";
    1446715801
    1446815802    case MISSING_HANDSHAKE_DATA:
    … …  
    1447715811    case INVALID_PARAMETER:
    1447815812        return "The security parameter is invalid";
     15813
     15814    case UNSUPPORTED_EXTENSION:
     15815        return "TLS Extension not requested by the client";
    1447915816
    1448015817    case KEY_SHARE_ERROR:
    … …  
    1450815845}
    1450915846
    14510 
    14511 /* be sure to add to cipher_name_idx too !!!! */
    14512 static const char* const cipher_names[] =
     15847#ifndef NO_ERROR_STRINGS
     15848    #define SUITE_INFO(x,y,z,w) {(x),(y),(z),(w)}
     15849#else
     15850    #define SUITE_INFO(x,y,z,w) {(x),(z),(w)}
     15851#endif
     15852
     15853static const CipherSuiteInfo cipher_names[] =
    1451315854{
     15855#ifndef WOLFSSL_NO_TLS12
     15856
    1451415857#ifdef BUILD_SSL_RSA_WITH_RC4_128_SHA
    14515     "RC4-SHA",
     15858    SUITE_INFO("RC4-SHA","SSL_RSA_WITH_RC4_128_SHA",CIPHER_BYTE,SSL_RSA_WITH_RC4_128_SHA),
    1451615859#endif
    1451715860
    1451815861#ifdef BUILD_SSL_RSA_WITH_RC4_128_MD5
    14519     "RC4-MD5",
     15862    SUITE_INFO("RC4-MD5","SSL_RSA_WITH_RC4_128_MD5",CIPHER_BYTE,SSL_RSA_WITH_RC4_128_MD5),
    1452015863#endif
    1452115864
    1452215865#ifdef BUILD_SSL_RSA_WITH_3DES_EDE_CBC_SHA
    14523     "DES-CBC3-SHA",
     15866    SUITE_INFO("DES-CBC3-SHA","SSL_RSA_WITH_3DES_EDE_CBC_SHA",CIPHER_BYTE,SSL_RSA_WITH_3DES_EDE_CBC_SHA),
    1452415867#endif
    1452515868
    1452615869#ifdef BUILD_TLS_RSA_WITH_AES_128_CBC_SHA
    14527     "AES128-SHA",
     15870    SUITE_INFO("AES128-SHA","TLS_RSA_WITH_AES_128_CBC_SHA",CIPHER_BYTE,TLS_RSA_WITH_AES_128_CBC_SHA),
    1452815871#endif
    1452915872
    1453015873#ifdef BUILD_TLS_RSA_WITH_AES_256_CBC_SHA
    14531     "AES256-SHA",
     15874    SUITE_INFO("AES256-SHA","TLS_RSA_WITH_AES_256_CBC_SHA",CIPHER_BYTE,TLS_RSA_WITH_AES_256_CBC_SHA),
    1453215875#endif
    1453315876
    1453415877#ifdef BUILD_TLS_RSA_WITH_NULL_SHA
    14535     "NULL-SHA",
     15878    SUITE_INFO("NULL-SHA","TLS_RSA_WITH_NULL_SHA",CIPHER_BYTE,TLS_RSA_WITH_NULL_SHA),
    1453615879#endif
    1453715880
    1453815881#ifdef BUILD_TLS_RSA_WITH_NULL_SHA256
    14539     "NULL-SHA256",
     15882    SUITE_INFO("NULL-SHA256","TLS_RSA_WITH_NULL_SHA256",CIPHER_BYTE,TLS_RSA_WITH_NULL_SHA256),
    1454015883#endif
    1454115884
    1454215885#ifdef BUILD_TLS_DHE_RSA_WITH_AES_128_CBC_SHA
    14543     "DHE-RSA-AES128-SHA",
     15886    SUITE_INFO("DHE-RSA-AES128-SHA","TLS_DHE_RSA_WITH_AES_128_CBC_SHA",CIPHER_BYTE,TLS_DHE_RSA_WITH_AES_128_CBC_SHA),
    1454415887#endif
    1454515888
    1454615889#ifdef BUILD_TLS_DHE_RSA_WITH_AES_256_CBC_SHA
    14547     "DHE-RSA-AES256-SHA",
     15890    SUITE_INFO("DHE-RSA-AES256-SHA","TLS_DHE_RSA_WITH_AES_256_CBC_SHA",CIPHER_BYTE,TLS_DHE_RSA_WITH_AES_256_CBC_SHA),
    1454815891#endif
    1454915892
    1455015893#ifdef BUILD_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384
    14551     "DHE-PSK-AES256-GCM-SHA384",
     15894    SUITE_INFO("DHE-PSK-AES256-GCM-SHA384","TLS_DHE_PSK_WITH_AES_256_GCM_SHA384",CIPHER_BYTE,TLS_DHE_PSK_WITH_AES_256_GCM_SHA384),
    1455215895#endif
    1455315896
    1455415897#ifdef BUILD_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256
    14555     "DHE-PSK-AES128-GCM-SHA256",
     15898    SUITE_INFO("DHE-PSK-AES128-GCM-SHA256","TLS_DHE_PSK_WITH_AES_128_GCM_SHA256",CIPHER_BYTE,TLS_DHE_PSK_WITH_AES_128_GCM_SHA256),
    1455615899#endif
    1455715900
    1455815901#ifdef BUILD_TLS_PSK_WITH_AES_256_GCM_SHA384
    14559     "PSK-AES256-GCM-SHA384",
     15902    SUITE_INFO("PSK-AES256-GCM-SHA384","TLS_PSK_WITH_AES_256_GCM_SHA384",CIPHER_BYTE,TLS_PSK_WITH_AES_256_GCM_SHA384),
    1456015903#endif
    1456115904
    1456215905#ifdef BUILD_TLS_PSK_WITH_AES_128_GCM_SHA256
    14563     "PSK-AES128-GCM-SHA256",
     15906    SUITE_INFO("PSK-AES128-GCM-SHA256","TLS_PSK_WITH_AES_128_GCM_SHA256",CIPHER_BYTE,TLS_PSK_WITH_AES_128_GCM_SHA256),
    1456415907#endif
    1456515908
    1456615909#ifdef BUILD_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384
    14567     "DHE-PSK-AES256-CBC-SHA384",
     15910    SUITE_INFO("DHE-PSK-AES256-CBC-SHA384","TLS_DHE_PSK_WITH_AES_256_CBC_SHA384",CIPHER_BYTE,TLS_DHE_PSK_WITH_AES_256_CBC_SHA384),
    1456815911#endif
    1456915912
    1457015913#ifdef BUILD_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256
    14571     "DHE-PSK-AES128-CBC-SHA256",
     15914    SUITE_INFO("DHE-PSK-AES128-CBC-SHA256","TLS_DHE_PSK_WITH_AES_128_CBC_SHA256",CIPHER_BYTE,TLS_DHE_PSK_WITH_AES_128_CBC_SHA256),
    1457215915#endif
    1457315916
    1457415917#ifdef BUILD_TLS_PSK_WITH_AES_256_CBC_SHA384
    14575     "PSK-AES256-CBC-SHA384",
     15918    SUITE_INFO("PSK-AES256-CBC-SHA384","TLS_PSK_WITH_AES_256_CBC_SHA384",CIPHER_BYTE,TLS_PSK_WITH_AES_256_CBC_SHA384),
    1457615919#endif
    1457715920
    1457815921#ifdef BUILD_TLS_PSK_WITH_AES_128_CBC_SHA256
    14579     "PSK-AES128-CBC-SHA256",
     15922    SUITE_INFO("PSK-AES128-CBC-SHA256","TLS_PSK_WITH_AES_128_CBC_SHA256",CIPHER_BYTE,TLS_PSK_WITH_AES_128_CBC_SHA256),
    1458015923#endif
    1458115924
    1458215925#ifdef BUILD_TLS_PSK_WITH_AES_128_CBC_SHA
    14583     "PSK-AES128-CBC-SHA",
     15926    SUITE_INFO("PSK-AES128-CBC-SHA","TLS_PSK_WITH_AES_128_CBC_SHA",CIPHER_BYTE,TLS_PSK_WITH_AES_128_CBC_SHA),
    1458415927#endif
    1458515928
    1458615929#ifdef BUILD_TLS_PSK_WITH_AES_256_CBC_SHA
    14587     "PSK-AES256-CBC-SHA",
     15930    SUITE_INFO("PSK-AES256-CBC-SHA","TLS_PSK_WITH_AES_256_CBC_SHA",CIPHER_BYTE,TLS_PSK_WITH_AES_256_CBC_SHA),
    1458815931#endif
    1458915932
    1459015933#ifdef BUILD_TLS_DHE_PSK_WITH_AES_128_CCM
    14591     "DHE-PSK-AES128-CCM",
     15934    SUITE_INFO("DHE-PSK-AES128-CCM","TLS_DHE_PSK_WITH_AES_128_CCM",ECC_BYTE,TLS_DHE_PSK_WITH_AES_128_CCM),
    1459215935#endif
    1459315936
    1459415937#ifdef BUILD_TLS_DHE_PSK_WITH_AES_256_CCM
    14595     "DHE-PSK-AES256-CCM",
     15938    SUITE_INFO("DHE-PSK-AES256-CCM","TLS_DHE_PSK_WITH_AES_256_CCM",ECC_BYTE,TLS_DHE_PSK_WITH_AES_256_CCM),
    1459615939#endif
    1459715940
    1459815941#ifdef BUILD_TLS_PSK_WITH_AES_128_CCM
    14599     "PSK-AES128-CCM",
     15942    SUITE_INFO("PSK-AES128-CCM","TLS_PSK_WITH_AES_128_CCM",ECC_BYTE,TLS_PSK_WITH_AES_128_CCM),
    1460015943#endif
    1460115944
    1460215945#ifdef BUILD_TLS_PSK_WITH_AES_256_CCM
    14603     "PSK-AES256-CCM",
     15946    SUITE_INFO("PSK-AES256-CCM","TLS_PSK_WITH_AES_256_CCM",ECC_BYTE,TLS_PSK_WITH_AES_256_CCM),
    1460415947#endif
    1460515948
    1460615949#ifdef BUILD_TLS_PSK_WITH_AES_128_CCM_8
    14607     "PSK-AES128-CCM-8",
     15950    SUITE_INFO("PSK-AES128-CCM-8","TLS_PSK_WITH_AES_128_CCM_8",ECC_BYTE,TLS_PSK_WITH_AES_128_CCM_8),
    1460815951#endif
    1460915952
    1461015953#ifdef BUILD_TLS_PSK_WITH_AES_256_CCM_8
    14611     "PSK-AES256-CCM-8",
     15954    SUITE_INFO("PSK-AES256-CCM-8","TLS_PSK_WITH_AES_256_CCM_8",ECC_BYTE,TLS_PSK_WITH_AES_256_CCM_8),
    1461215955#endif
    1461315956
    1461415957#ifdef BUILD_TLS_DHE_PSK_WITH_NULL_SHA384
    14615     "DHE-PSK-NULL-SHA384",
     15958    SUITE_INFO("DHE-PSK-NULL-SHA384","TLS_DHE_PSK_WITH_NULL_SHA384",CIPHER_BYTE,TLS_DHE_PSK_WITH_NULL_SHA384),
    1461615959#endif
    1461715960
    1461815961#ifdef BUILD_TLS_DHE_PSK_WITH_NULL_SHA256
    14619     "DHE-PSK-NULL-SHA256",
     15962    SUITE_INFO("DHE-PSK-NULL-SHA256","TLS_DHE_PSK_WITH_NULL_SHA256",CIPHER_BYTE,TLS_DHE_PSK_WITH_NULL_SHA256),
    1462015963#endif
    1462115964
    1462215965#ifdef BUILD_TLS_PSK_WITH_NULL_SHA384
    14623     "PSK-NULL-SHA384",
     15966    SUITE_INFO("PSK-NULL-SHA384","TLS_PSK_WITH_NULL_SHA384",CIPHER_BYTE,TLS_PSK_WITH_NULL_SHA384),
    1462415967#endif
    1462515968
    1462615969#ifdef BUILD_TLS_PSK_WITH_NULL_SHA256
    14627     "PSK-NULL-SHA256",
     15970    SUITE_INFO("PSK-NULL-SHA256","TLS_PSK_WITH_NULL_SHA256",CIPHER_BYTE,TLS_PSK_WITH_NULL_SHA256),
    1462815971#endif
    1462915972
    1463015973#ifdef BUILD_TLS_PSK_WITH_NULL_SHA
    14631     "PSK-NULL-SHA",
     15974    SUITE_INFO("PSK-NULL-SHA","TLS_PSK_WITH_NULL_SHA",CIPHER_BYTE,TLS_PSK_WITH_NULL_SHA),
    1463215975#endif
    1463315976
    1463415977#ifdef BUILD_TLS_RSA_WITH_HC_128_MD5
    14635     "HC128-MD5",
     15978    SUITE_INFO("HC128-MD5","TLS_RSA_WITH_HC_128_MD5",CIPHER_BYTE,TLS_RSA_WITH_HC_128_MD5),
    1463615979#endif
    1463715980
    1463815981#ifdef BUILD_TLS_RSA_WITH_HC_128_SHA
    14639     "HC128-SHA",
     15982    SUITE_INFO("HC128-SHA","TLS_RSA_WITH_HC_128_SHA",CIPHER_BYTE,TLS_RSA_WITH_HC_128_SHA),
    1464015983#endif
    1464115984
    1464215985#ifdef BUILD_TLS_RSA_WITH_HC_128_B2B256
    14643     "HC128-B2B256",
     15986    SUITE_INFO("HC128-B2B256","TLS_RSA_WITH_HC_128_B2B256",CIPHER_BYTE,TLS_RSA_WITH_HC_128_B2B256),
    1464415987#endif
    1464515988
    1464615989#ifdef BUILD_TLS_RSA_WITH_AES_128_CBC_B2B256
    14647     "AES128-B2B256",
     15990    SUITE_INFO("AES128-B2B256","TLS_RSA_WITH_AES_128_CBC_B2B256",CIPHER_BYTE,TLS_RSA_WITH_AES_128_CBC_B2B256),
    1464815991#endif
    1464915992
    1465015993#ifdef BUILD_TLS_RSA_WITH_AES_256_CBC_B2B256
    14651     "AES256-B2B256",
     15994    SUITE_INFO("AES256-B2B256","TLS_RSA_WITH_AES_256_CBC_B2B256",CIPHER_BYTE,TLS_RSA_WITH_AES_256_CBC_B2B256),
    1465215995#endif
    1465315996
    1465415997#ifdef BUILD_TLS_RSA_WITH_RABBIT_SHA
    14655     "RABBIT-SHA",
     15998    SUITE_INFO("RABBIT-SHA","TLS_RSA_WITH_RABBIT_SHA",CIPHER_BYTE,TLS_RSA_WITH_RABBIT_SHA),
    1465615999#endif
    1465716000
    1465816001#ifdef BUILD_TLS_NTRU_RSA_WITH_RC4_128_SHA
    14659     "NTRU-RC4-SHA",
     16002    SUITE_INFO("NTRU-RC4-SHA","TLS_NTRU_RSA_WITH_RC4_128_SHA",CIPHER_BYTE,TLS_NTRU_RSA_WITH_RC4_128_SHA),
    1466016003#endif
    1466116004
    1466216005#ifdef BUILD_TLS_NTRU_RSA_WITH_3DES_EDE_CBC_SHA
    14663     "NTRU-DES-CBC3-SHA",
     16006    SUITE_INFO("NTRU-DES-CBC3-SHA","TLS_NTRU_RSA_WITH_3DES_EDE_CBC_SHA",CIPHER_BYTE,TLS_NTRU_RSA_WITH_3DES_EDE_CBC_SHA),
    1466416007#endif
    1466516008
    1466616009#ifdef BUILD_TLS_NTRU_RSA_WITH_AES_128_CBC_SHA
    14667     "NTRU-AES128-SHA",
     16010    SUITE_INFO("NTRU-AES128-SHA","TLS_NTRU_RSA_WITH_AES_128_CBC_SHA",CIPHER_BYTE,TLS_NTRU_RSA_WITH_AES_128_CBC_SHA),
    1466816011#endif
    1466916012
    1467016013#ifdef BUILD_TLS_NTRU_RSA_WITH_AES_256_CBC_SHA
    14671     "NTRU-AES256-SHA",
     16014    SUITE_INFO("NTRU-AES256-SHA","TLS_NTRU_RSA_WITH_AES_256_CBC_SHA",CIPHER_BYTE,TLS_NTRU_RSA_WITH_AES_256_CBC_SHA),
    1467216015#endif
    1467316016
    1467416017#ifdef BUILD_TLS_RSA_WITH_AES_128_CCM_8
    14675     "AES128-CCM-8",
     16018    SUITE_INFO("AES128-CCM-8","TLS_RSA_WITH_AES_128_CCM_8",ECC_BYTE,TLS_RSA_WITH_AES_128_CCM_8),
    1467616019#endif
    1467716020
    1467816021#ifdef BUILD_TLS_RSA_WITH_AES_256_CCM_8
    14679     "AES256-CCM-8",
     16022    SUITE_INFO("AES256-CCM-8","TLS_RSA_WITH_AES_256_CCM_8",ECC_BYTE,TLS_RSA_WITH_AES_256_CCM_8),
    1468016023#endif
    1468116024
    1468216025#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_128_CCM
    14683     "ECDHE-ECDSA-AES128-CCM",
     16026        SUITE_INFO("ECDHE-ECDSA-AES128-CCM","TLS_ECDHE_ECDSA_WITH_AES_128_CCM",ECC_BYTE,TLS_ECDHE_ECDSA_WITH_AES_128_CCM),
    1468416027#endif
    1468516028
    1468616029#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8
    14687     "ECDHE-ECDSA-AES128-CCM-8",
     16030    SUITE_INFO("ECDHE-ECDSA-AES128-CCM-8","TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8",ECC_BYTE,TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8),
    1468816031#endif
    1468916032
    1469016033#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8
    14691     "ECDHE-ECDSA-AES256-CCM-8",
     16034    SUITE_INFO("ECDHE-ECDSA-AES256-CCM-8","TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8",ECC_BYTE,TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8),
    1469216035#endif
    1469316036
    1469416037#ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
    14695     "ECDHE-RSA-AES128-SHA",
     16038    SUITE_INFO("ECDHE-RSA-AES128-SHA","TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA",ECC_BYTE,TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA),
    1469616039#endif
    1469716040
    1469816041#ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
    14699     "ECDHE-RSA-AES256-SHA",
     16042    SUITE_INFO("ECDHE-RSA-AES256-SHA","TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA",ECC_BYTE,TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA),
    1470016043#endif
    1470116044
    1470216045#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
    14703     "ECDHE-ECDSA-AES128-SHA",
     16046    SUITE_INFO("ECDHE-ECDSA-AES128-SHA","TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",ECC_BYTE,TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA),
    1470416047#endif
    1470516048
    1470616049#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
    14707     "ECDHE-ECDSA-AES256-SHA",
     16050    SUITE_INFO("ECDHE-ECDSA-AES256-SHA","TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA",ECC_BYTE,TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA),
    1470816051#endif
    1470916052
    1471016053#ifdef BUILD_TLS_ECDHE_RSA_WITH_RC4_128_SHA
    14711     "ECDHE-RSA-RC4-SHA",
     16054    SUITE_INFO("ECDHE-RSA-RC4-SHA","TLS_ECDHE_RSA_WITH_RC4_128_SHA",ECC_BYTE,TLS_ECDHE_RSA_WITH_RC4_128_SHA),
    1471216055#endif
    1471316056
    1471416057#ifdef BUILD_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA
    14715     "ECDHE-RSA-DES-CBC3-SHA",
     16058    SUITE_INFO("ECDHE-RSA-DES-CBC3-SHA","TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA",ECC_BYTE,TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA),
    1471616059#endif
    1471716060
    1471816061#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA
    14719     "ECDHE-ECDSA-RC4-SHA",
     16062    SUITE_INFO("ECDHE-ECDSA-RC4-SHA","TLS_ECDHE_ECDSA_WITH_RC4_128_SHA",ECC_BYTE,TLS_ECDHE_ECDSA_WITH_RC4_128_SHA),
    1472016063#endif
    1472116064
    1472216065#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA
    14723     "ECDHE-ECDSA-DES-CBC3-SHA",
     16066    SUITE_INFO("ECDHE-ECDSA-DES-CBC3-SHA","TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA",ECC_BYTE,TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA),
    1472416067#endif
    1472516068
    1472616069#ifdef BUILD_TLS_RSA_WITH_AES_128_CBC_SHA256
    14727     "AES128-SHA256",
     16070    SUITE_INFO("AES128-SHA256","TLS_RSA_WITH_AES_128_CBC_SHA256",CIPHER_BYTE,TLS_RSA_WITH_AES_128_CBC_SHA256),
    1472816071#endif
    1472916072
    1473016073#ifdef BUILD_TLS_RSA_WITH_AES_256_CBC_SHA256
    14731     "AES256-SHA256",
     16074    SUITE_INFO("AES256-SHA256","TLS_RSA_WITH_AES_256_CBC_SHA256",CIPHER_BYTE,TLS_RSA_WITH_AES_256_CBC_SHA256),
    1473216075#endif
    1473316076
    1473416077#ifdef BUILD_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
    14735     "DHE-RSA-AES128-SHA256",
     16078    SUITE_INFO("DHE-RSA-AES128-SHA256","TLS_DHE_RSA_WITH_AES_128_CBC_SHA256",CIPHER_BYTE,TLS_DHE_RSA_WITH_AES_128_CBC_SHA256),
    1473616079#endif
    1473716080
    1473816081#ifdef BUILD_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
    14739     "DHE-RSA-AES256-SHA256",
     16082    SUITE_INFO("DHE-RSA-AES256-SHA256","TLS_DHE_RSA_WITH_AES_256_CBC_SHA256",CIPHER_BYTE,TLS_DHE_RSA_WITH_AES_256_CBC_SHA256),
    1474016083#endif
    1474116084
    1474216085#ifdef BUILD_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA
    14743     "ECDH-RSA-AES128-SHA",
     16086    SUITE_INFO("ECDH-RSA-AES128-SHA","TLS_ECDH_RSA_WITH_AES_128_CBC_SHA",ECC_BYTE,TLS_ECDH_RSA_WITH_AES_128_CBC_SHA),
    1474416087#endif
    1474516088
    1474616089#ifdef BUILD_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA
    14747     "ECDH-RSA-AES256-SHA",
     16090    SUITE_INFO("ECDH-RSA-AES256-SHA","TLS_ECDH_RSA_WITH_AES_256_CBC_SHA",ECC_BYTE,TLS_ECDH_RSA_WITH_AES_256_CBC_SHA),
    1474816091#endif
    1474916092
    1475016093#ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA
    14751     "ECDH-ECDSA-AES128-SHA",
     16094    SUITE_INFO("ECDH-ECDSA-AES128-SHA","TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA",ECC_BYTE,TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA),
    1475216095#endif
    1475316096
    1475416097#ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA
    14755     "ECDH-ECDSA-AES256-SHA",
     16098    SUITE_INFO("ECDH-ECDSA-AES256-SHA","TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA",ECC_BYTE,TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA),
    1475616099#endif
    1475716100
    1475816101#ifdef BUILD_TLS_ECDH_RSA_WITH_RC4_128_SHA
    14759     "ECDH-RSA-RC4-SHA",
     16102    SUITE_INFO("ECDH-RSA-RC4-SHA","TLS_ECDH_RSA_WITH_RC4_128_SHA",ECC_BYTE,TLS_ECDH_RSA_WITH_RC4_128_SHA),
    1476016103#endif
    1476116104
    1476216105#ifdef BUILD_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA
    14763     "ECDH-RSA-DES-CBC3-SHA",
     16106    SUITE_INFO("ECDH-RSA-DES-CBC3-SHA","TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA",ECC_BYTE,TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA),
    1476416107#endif
    1476516108
    1476616109#ifdef BUILD_TLS_ECDH_ECDSA_WITH_RC4_128_SHA
    14767     "ECDH-ECDSA-RC4-SHA",
     16110    SUITE_INFO("ECDH-ECDSA-RC4-SHA","TLS_ECDH_ECDSA_WITH_RC4_128_SHA",ECC_BYTE,TLS_ECDH_ECDSA_WITH_RC4_128_SHA),
    1476816111#endif
    1476916112
    1477016113#ifdef BUILD_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA
    14771     "ECDH-ECDSA-DES-CBC3-SHA",
     16114    SUITE_INFO("ECDH-ECDSA-DES-CBC3-SHA","TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA",ECC_BYTE,TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA),
    1477216115#endif
    1477316116
    1477416117#ifdef BUILD_TLS_RSA_WITH_AES_128_GCM_SHA256
    14775     "AES128-GCM-SHA256",
     16118    SUITE_INFO("AES128-GCM-SHA256","TLS_RSA_WITH_AES_128_GCM_SHA256",CIPHER_BYTE,TLS_RSA_WITH_AES_128_GCM_SHA256),
    1477616119#endif
    1477716120
    1477816121#ifdef BUILD_TLS_RSA_WITH_AES_256_GCM_SHA384
    14779     "AES256-GCM-SHA384",
     16122    SUITE_INFO("AES256-GCM-SHA384","TLS_RSA_WITH_AES_256_GCM_SHA384",CIPHER_BYTE,TLS_RSA_WITH_AES_256_GCM_SHA384),
    1478016123#endif
    1478116124
    1478216125#ifdef BUILD_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
    14783     "DHE-RSA-AES128-GCM-SHA256",
     16126    SUITE_INFO("DHE-RSA-AES128-GCM-SHA256","TLS_DHE_RSA_WITH_AES_128_GCM_SHA256",CIPHER_BYTE,TLS_DHE_RSA_WITH_AES_128_GCM_SHA256),
    1478416127#endif
    1478516128
    1478616129#ifdef BUILD_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
    14787     "DHE-RSA-AES256-GCM-SHA384",
     16130    SUITE_INFO("DHE-RSA-AES256-GCM-SHA384","TLS_DHE_RSA_WITH_AES_256_GCM_SHA384",CIPHER_BYTE,TLS_DHE_RSA_WITH_AES_256_GCM_SHA384),
    1478816131#endif
    1478916132
    1479016133#ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
    14791     "ECDHE-RSA-AES128-GCM-SHA256",
     16134    SUITE_INFO("ECDHE-RSA-AES128-GCM-SHA256","TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",ECC_BYTE,TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256),
    1479216135#endif
    1479316136
    1479416137#ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
    14795     "ECDHE-RSA-AES256-GCM-SHA384",
     16138    SUITE_INFO("ECDHE-RSA-AES256-GCM-SHA384","TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",ECC_BYTE,TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384),
    1479616139#endif
    1479716140
    1479816141#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
    14799     "ECDHE-ECDSA-AES128-GCM-SHA256",
     16142    SUITE_INFO("ECDHE-ECDSA-AES128-GCM-SHA256","TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",ECC_BYTE,TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256),
    1480016143#endif
    1480116144
    1480216145#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
    14803     "ECDHE-ECDSA-AES256-GCM-SHA384",
     16146    SUITE_INFO("ECDHE-ECDSA-AES256-GCM-SHA384","TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",ECC_BYTE,TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384),
    1480416147#endif
    1480516148
    1480616149#ifdef BUILD_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256
    14807     "ECDH-RSA-AES128-GCM-SHA256",
     16150    SUITE_INFO("ECDH-RSA-AES128-GCM-SHA256","TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256",ECC_BYTE,TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256),
    1480816151#endif
    1480916152
    1481016153#ifdef BUILD_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384
    14811     "ECDH-RSA-AES256-GCM-SHA384",
     16154    SUITE_INFO("ECDH-RSA-AES256-GCM-SHA384","TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384",ECC_BYTE,TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384),
    1481216155#endif
    1481316156
    1481416157#ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256
    14815     "ECDH-ECDSA-AES128-GCM-SHA256",
     16158    SUITE_INFO("ECDH-ECDSA-AES128-GCM-SHA256","TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256",ECC_BYTE,TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256),
    1481616159#endif
    1481716160
    1481816161#ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384
    14819     "ECDH-ECDSA-AES256-GCM-SHA384",
     16162    SUITE_INFO("ECDH-ECDSA-AES256-GCM-SHA384","TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384",ECC_BYTE,TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384),
    1482016163#endif
    1482116164
    1482216165#ifdef BUILD_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA
    14823     "CAMELLIA128-SHA",
     16166    SUITE_INFO("CAMELLIA128-SHA","TLS_RSA_WITH_CAMELLIA_128_CBC_SHA",CIPHER_BYTE,TLS_RSA_WITH_CAMELLIA_128_CBC_SHA),
    1482416167#endif
    1482516168
    1482616169#ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA
    14827     "DHE-RSA-CAMELLIA128-SHA",
     16170    SUITE_INFO("DHE-RSA-CAMELLIA128-SHA","TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA",CIPHER_BYTE,TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA),
    1482816171#endif
    1482916172
    1483016173#ifdef BUILD_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA
    14831     "CAMELLIA256-SHA",
     16174    SUITE_INFO("CAMELLIA256-SHA","TLS_RSA_WITH_CAMELLIA_256_CBC_SHA",CIPHER_BYTE,TLS_RSA_WITH_CAMELLIA_256_CBC_SHA),
    1483216175#endif
    1483316176
    1483416177#ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA
    14835     "DHE-RSA-CAMELLIA256-SHA",
     16178    SUITE_INFO("DHE-RSA-CAMELLIA256-SHA","TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA",CIPHER_BYTE,TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA),
    1483616179#endif
    1483716180
    1483816181#ifdef BUILD_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256
    14839     "CAMELLIA128-SHA256",
     16182    SUITE_INFO("CAMELLIA128-SHA256","TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256",CIPHER_BYTE,TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256),
    1484016183#endif
    1484116184
    1484216185#ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256
    14843     "DHE-RSA-CAMELLIA128-SHA256",
     16186    SUITE_INFO("DHE-RSA-CAMELLIA128-SHA256","TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256",CIPHER_BYTE,TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256),
    1484416187#endif
    1484516188
    1484616189#ifdef BUILD_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256
    14847     "CAMELLIA256-SHA256",
     16190    SUITE_INFO("CAMELLIA256-SHA256","TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256",CIPHER_BYTE,TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256),
    1484816191#endif
    1484916192
    1485016193#ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256
    14851     "DHE-RSA-CAMELLIA256-SHA256",
     16194    SUITE_INFO("DHE-RSA-CAMELLIA256-SHA256","TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256",CIPHER_BYTE,TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256),
    1485216195#endif
    1485316196
    1485416197#ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
    14855     "ECDHE-RSA-AES128-SHA256",
     16198    SUITE_INFO("ECDHE-RSA-AES128-SHA256","TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",ECC_BYTE,TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256),
    1485616199#endif
    1485716200
    1485816201#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
    14859     "ECDHE-ECDSA-AES128-SHA256",
     16202    SUITE_INFO("ECDHE-ECDSA-AES128-SHA256","TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",ECC_BYTE,TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256),
    1486016203#endif
    1486116204
    1486216205#ifdef BUILD_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256
    14863     "ECDH-RSA-AES128-SHA256",
     16206    SUITE_INFO("ECDH-RSA-AES128-SHA256","TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256",ECC_BYTE,TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256),
    1486416207#endif
    1486516208
    1486616209#ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256
    14867     "ECDH-ECDSA-AES128-SHA256",
     16210    SUITE_INFO("ECDH-ECDSA-AES128-SHA256","TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256",ECC_BYTE,TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256),
    1486816211#endif
    1486916212
    1487016213#ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384
    14871     "ECDHE-RSA-AES256-SHA384",
     16214    SUITE_INFO("ECDHE-RSA-AES256-SHA384","TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384",ECC_BYTE,TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384),
    1487216215#endif
    1487316216
    1487416217#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
    14875     "ECDHE-ECDSA-AES256-SHA384",
     16218    SUITE_INFO("ECDHE-ECDSA-AES256-SHA384","TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",ECC_BYTE,TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384),
    1487616219#endif
    1487716220
    1487816221#ifdef BUILD_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384
    14879     "ECDH-RSA-AES256-SHA384",
     16222    SUITE_INFO("ECDH-RSA-AES256-SHA384","TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384",ECC_BYTE,TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384),
    1488016223#endif
    1488116224
    1488216225#ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384
    14883     "ECDH-ECDSA-AES256-SHA384",
     16226    SUITE_INFO("ECDH-ECDSA-AES256-SHA384","TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384",ECC_BYTE,TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384),
    1488416227#endif
    1488516228
    1488616229#ifdef BUILD_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
    14887     "ECDHE-RSA-CHACHA20-POLY1305",
     16230    SUITE_INFO("ECDHE-RSA-CHACHA20-POLY1305","TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256",CHACHA_BYTE,TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256),
    1488816231#endif
    1488916232
    1489016233#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
    14891     "ECDHE-ECDSA-CHACHA20-POLY1305",
     16234    SUITE_INFO("ECDHE-ECDSA-CHACHA20-POLY1305","TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256",CHACHA_BYTE,TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256),
    1489216235#endif
    1489316236
    1489416237#ifdef BUILD_TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256
    14895     "DHE-RSA-CHACHA20-POLY1305",
     16238    SUITE_INFO("DHE-RSA-CHACHA20-POLY1305","TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256",CHACHA_BYTE,TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256),
    1489616239#endif
    1489716240
    1489816241#ifdef BUILD_TLS_ECDHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256
    14899     "ECDHE-RSA-CHACHA20-POLY1305-OLD",
     16242    SUITE_INFO("ECDHE-RSA-CHACHA20-POLY1305-OLD","TLS_ECDHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256",CHACHA_BYTE,TLS_ECDHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256),
    1490016243#endif
    1490116244
    1490216245#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_CHACHA20_OLD_POLY1305_SHA256
    14903     "ECDHE-ECDSA-CHACHA20-POLY1305-OLD",
     16246    SUITE_INFO("ECDHE-ECDSA-CHACHA20-POLY1305-OLD","TLS_ECDHE_ECDSA_WITH_CHACHA20_OLD_POLY1305_SHA256",CHACHA_BYTE,TLS_ECDHE_ECDSA_WITH_CHACHA20_OLD_POLY1305_SHA256),
    1490416247#endif
    1490516248
    1490616249#ifdef BUILD_TLS_DHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256
    14907     "DHE-RSA-CHACHA20-POLY1305-OLD",
     16250    SUITE_INFO("DHE-RSA-CHACHA20-POLY1305-OLD","TLS_DHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256",CHACHA_BYTE,TLS_DHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256),
    1490816251#endif
    1490916252
    1491016253#ifdef BUILD_TLS_DH_anon_WITH_AES_128_CBC_SHA
    14911     "ADH-AES128-SHA",
     16254    SUITE_INFO("ADH-AES128-SHA","TLS_DH_anon_WITH_AES_128_CBC_SHA",CIPHER_BYTE,TLS_DH_anon_WITH_AES_128_CBC_SHA),
     16255#endif
     16256
     16257#ifdef BUILD_TLS_DH_anon_WITH_AES_256_GCM_SHA384
     16258    SUITE_INFO("ADH-AES256-GCM-SHA384","TLS_DH_anon_WITH_AES_256_GCM_SHA384",CIPHER_BYTE,TLS_DH_anon_WITH_AES_256_GCM_SHA384),
    1491216259#endif
    1491316260
    1491416261#ifdef BUILD_TLS_QSH
    14915     "QSH",
     16262    SUITE_INFO("QSH","TLS_QSH",QSH_BYTE,TLS_QSH),
    1491616263#endif
    1491716264
    1491816265#ifdef HAVE_RENEGOTIATION_INDICATION
    14919     "RENEGOTIATION-INFO",
     16266    SUITE_INFO("RENEGOTIATION-INFO","TLS_EMPTY_RENEGOTIATION_INFO_SCSV",CIPHER_BYTE,TLS_EMPTY_RENEGOTIATION_INFO_SCSV),
    1492016267#endif
    1492116268
    1492216269#ifdef BUILD_SSL_RSA_WITH_IDEA_CBC_SHA
    14923     "IDEA-CBC-SHA",
     16270    SUITE_INFO("IDEA-CBC-SHA","SSL_RSA_WITH_IDEA_CBC_SHA",CIPHER_BYTE,SSL_RSA_WITH_IDEA_CBC_SHA),
    1492416271#endif
    1492516272
    1492616273#ifdef BUILD_TLS_ECDHE_ECDSA_WITH_NULL_SHA
    14927     "ECDHE-ECDSA-NULL-SHA",
     16274    SUITE_INFO("ECDHE-ECDSA-NULL-SHA","TLS_ECDHE_ECDSA_WITH_NULL_SHA",ECC_BYTE,TLS_ECDHE_ECDSA_WITH_NULL_SHA),
    1492816275#endif
    1492916276
    1493016277#ifdef BUILD_TLS_ECDHE_PSK_WITH_NULL_SHA256
    14931     "ECDHE-PSK-NULL-SHA256",
     16278    SUITE_INFO("ECDHE-PSK-NULL-SHA256","TLS_ECDHE_PSK_WITH_NULL_SHA256",ECC_BYTE,TLS_ECDHE_PSK_WITH_NULL_SHA256),
    1493216279#endif
    1493316280
    1493416281#ifdef BUILD_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256
    14935     "ECDHE-PSK-AES128-CBC-SHA256",
     16282    SUITE_INFO("ECDHE-PSK-AES128-CBC-SHA256","TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256",ECC_BYTE,TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256),
    1493616283#endif
    1493716284
    1493816285#ifdef BUILD_TLS_PSK_WITH_CHACHA20_POLY1305_SHA256
    14939     "PSK-CHACHA20-POLY1305",
     16286    SUITE_INFO("PSK-CHACHA20-POLY1305","TLS_PSK_WITH_CHACHA20_POLY1305_SHA256",CHACHA_BYTE,TLS_PSK_WITH_CHACHA20_POLY1305_SHA256),
    1494016287#endif
    1494116288
    1494216289#ifdef BUILD_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256
    14943     "ECDHE-PSK-CHACHA20-POLY1305",
     16290    SUITE_INFO("ECDHE-PSK-CHACHA20-POLY1305","TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256",CHACHA_BYTE,TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256),
    1494416291#endif
    1494516292
    1494616293#ifdef BUILD_TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256
    14947     "DHE-PSK-CHACHA20-POLY1305",
     16294    SUITE_INFO("DHE-PSK-CHACHA20-POLY1305","TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256",CHACHA_BYTE,TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256),
    1494816295#endif
    1494916296
    1495016297#ifdef BUILD_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA
    14951     "EDH-RSA-DES-CBC3-SHA",
    14952 #endif
     16298    SUITE_INFO("EDH-RSA-DES-CBC3-SHA","TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA",CIPHER_BYTE,TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA),
     16299#endif
     16300
     16301#ifdef BUILD_WDM_WITH_NULL_SHA256
     16302    SUITE_INFO("WDM-NULL-SHA256","WDM_WITH_NULL_SHA256",CIPHER_BYTE,WDM_WITH_NULL_SHA256),
     16303#endif
     16304
     16305#endif /* WOLFSSL_NO_TLS12 */
    1495316306
    1495416307#ifdef BUILD_TLS_AES_128_GCM_SHA256
    14955     "TLS13-AES128-GCM-SHA256",
     16308    SUITE_INFO("TLS13-AES128-GCM-SHA256","TLS_AES_128_GCM_SHA256",TLS13_BYTE,TLS_AES_128_GCM_SHA256),
    1495616309#endif
    1495716310
    1495816311#ifdef BUILD_TLS_AES_256_GCM_SHA384
    14959     "TLS13-AES256-GCM-SHA384",
     16312    SUITE_INFO("TLS13-AES256-GCM-SHA384","TLS_AES_256_GCM_SHA384",TLS13_BYTE,TLS_AES_256_GCM_SHA384),
    1496016313#endif
    1496116314
    1496216315#ifdef BUILD_TLS_CHACHA20_POLY1305_SHA256
    14963     "TLS13-CHACHA20-POLY1305-SHA256",
     16316    SUITE_INFO("TLS13-CHACHA20-POLY1305-SHA256","TLS_CHACHA20_POLY1305_SHA256",TLS13_BYTE,TLS_CHACHA20_POLY1305_SHA256),
    1496416317#endif
    1496516318
    1496616319#ifdef BUILD_TLS_AES_128_CCM_SHA256
    14967     "TLS13-AES128-CCM-SHA256",
     16320    SUITE_INFO("TLS13-AES128-CCM-SHA256","TLS_AES_128_CCM_SHA256",TLS13_BYTE,TLS_AES_128_CCM_SHA256),
    1496816321#endif
    1496916322
    1497016323#ifdef BUILD_TLS_AES_128_CCM_8_SHA256
    14971     "TLS13-AES128-CCM-8-SHA256",
    14972 #endif
    14973 
    14974 #ifdef BUILD_WDM_WITH_NULL_SHA256
    14975     "WDM-NULL-SHA256",
     16324    SUITE_INFO("TLS13-AES128-CCM-8-SHA256","TLS_AES_128_CCM_8_SHA256",TLS13_BYTE,TLS_AES_128_CCM_8_SHA256),
    1497616325#endif
    1497716326};
    1497816327
    1497916328
    14980 /* cipher suite number that matches above name table */
    14981 static int cipher_name_idx[] =
    14982 {
    14983 
    14984 #ifdef BUILD_SSL_RSA_WITH_RC4_128_SHA
    14985     SSL_RSA_WITH_RC4_128_SHA,
    14986 #endif
    14987 
    14988 #ifdef BUILD_SSL_RSA_WITH_RC4_128_MD5
    14989     SSL_RSA_WITH_RC4_128_MD5,
    14990 #endif
    14991 
    14992 #ifdef BUILD_SSL_RSA_WITH_3DES_EDE_CBC_SHA
    14993     SSL_RSA_WITH_3DES_EDE_CBC_SHA,
    14994 #endif
    14995 
    14996 #ifdef BUILD_TLS_RSA_WITH_AES_128_CBC_SHA
    14997     TLS_RSA_WITH_AES_128_CBC_SHA,
    14998 #endif
    14999 
    15000 #ifdef BUILD_TLS_RSA_WITH_AES_256_CBC_SHA
    15001     TLS_RSA_WITH_AES_256_CBC_SHA,
    15002 #endif
    15003 
    15004 #ifdef BUILD_TLS_RSA_WITH_NULL_SHA
    15005     TLS_RSA_WITH_NULL_SHA,
    15006 #endif
    15007 
    15008 #ifdef BUILD_TLS_RSA_WITH_NULL_SHA256
    15009     TLS_RSA_WITH_NULL_SHA256,
    15010 #endif
    15011 
    15012 #ifdef BUILD_TLS_DHE_RSA_WITH_AES_128_CBC_SHA
    15013     TLS_DHE_RSA_WITH_AES_128_CBC_SHA,
    15014 #endif
    15015 
    15016 #ifdef BUILD_TLS_DHE_RSA_WITH_AES_256_CBC_SHA
    15017     TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
    15018 #endif
    15019 
    15020 #ifdef BUILD_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384
    15021     TLS_DHE_PSK_WITH_AES_256_GCM_SHA384,
    15022 #endif
    15023 
    15024 #ifdef BUILD_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256
    15025     TLS_DHE_PSK_WITH_AES_128_GCM_SHA256,
    15026 #endif
    15027 
    15028 #ifdef BUILD_TLS_PSK_WITH_AES_256_GCM_SHA384
    15029     TLS_PSK_WITH_AES_256_GCM_SHA384,
    15030 #endif
    15031 
    15032 #ifdef BUILD_TLS_PSK_WITH_AES_128_GCM_SHA256
    15033     TLS_PSK_WITH_AES_128_GCM_SHA256,
    15034 #endif
    15035 
    15036 #ifdef BUILD_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384
    15037     TLS_DHE_PSK_WITH_AES_256_CBC_SHA384,
    15038 #endif
    15039 
    15040 #ifdef BUILD_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256
    15041     TLS_DHE_PSK_WITH_AES_128_CBC_SHA256,
    15042 #endif
    15043 
    15044 #ifdef BUILD_TLS_PSK_WITH_AES_256_CBC_SHA384
    15045     TLS_PSK_WITH_AES_256_CBC_SHA384,
    15046 #endif
    15047 
    15048 #ifdef BUILD_TLS_PSK_WITH_AES_128_CBC_SHA256
    15049     TLS_PSK_WITH_AES_128_CBC_SHA256,
    15050 #endif
    15051 
    15052 #ifdef BUILD_TLS_PSK_WITH_AES_128_CBC_SHA
    15053     TLS_PSK_WITH_AES_128_CBC_SHA,
    15054 #endif
    15055 
    15056 #ifdef BUILD_TLS_PSK_WITH_AES_256_CBC_SHA
    15057     TLS_PSK_WITH_AES_256_CBC_SHA,
    15058 #endif
    15059 
    15060 #ifdef BUILD_TLS_DHE_PSK_WITH_AES_128_CCM
    15061     TLS_DHE_PSK_WITH_AES_128_CCM,
    15062 #endif
    15063 
    15064 #ifdef BUILD_TLS_DHE_PSK_WITH_AES_256_CCM
    15065     TLS_DHE_PSK_WITH_AES_256_CCM,
    15066 #endif
    15067 
    15068 #ifdef BUILD_TLS_PSK_WITH_AES_128_CCM
    15069     TLS_PSK_WITH_AES_128_CCM,
    15070 #endif
    15071 
    15072 #ifdef BUILD_TLS_PSK_WITH_AES_256_CCM
    15073     TLS_PSK_WITH_AES_256_CCM,
    15074 #endif
    15075 
    15076 #ifdef BUILD_TLS_PSK_WITH_AES_128_CCM_8
    15077     TLS_PSK_WITH_AES_128_CCM_8,
    15078 #endif
    15079 
    15080 #ifdef BUILD_TLS_PSK_WITH_AES_256_CCM_8
    15081     TLS_PSK_WITH_AES_256_CCM_8,
    15082 #endif
    15083 
    15084 #ifdef BUILD_TLS_DHE_PSK_WITH_NULL_SHA384
    15085     TLS_DHE_PSK_WITH_NULL_SHA384,
    15086 #endif
    15087 
    15088 #ifdef BUILD_TLS_DHE_PSK_WITH_NULL_SHA256
    15089     TLS_DHE_PSK_WITH_NULL_SHA256,
    15090 #endif
    15091 
    15092 #ifdef BUILD_TLS_PSK_WITH_NULL_SHA384
    15093     TLS_PSK_WITH_NULL_SHA384,
    15094 #endif
    15095 
    15096 #ifdef BUILD_TLS_PSK_WITH_NULL_SHA256
    15097     TLS_PSK_WITH_NULL_SHA256,
    15098 #endif
    15099 
    15100 #ifdef BUILD_TLS_PSK_WITH_NULL_SHA
    15101     TLS_PSK_WITH_NULL_SHA,
    15102 #endif
    15103 
    15104 #ifdef BUILD_TLS_RSA_WITH_HC_128_MD5
    15105     TLS_RSA_WITH_HC_128_MD5,
    15106 #endif
    15107 
    15108 #ifdef BUILD_TLS_RSA_WITH_HC_128_SHA
    15109     TLS_RSA_WITH_HC_128_SHA,
    15110 #endif
    15111 
    15112 #ifdef BUILD_TLS_RSA_WITH_HC_128_B2B256
    15113     TLS_RSA_WITH_HC_128_B2B256,
    15114 #endif
    15115 
    15116 #ifdef BUILD_TLS_RSA_WITH_AES_128_CBC_B2B256
    15117     TLS_RSA_WITH_AES_128_CBC_B2B256,
    15118 #endif
    15119 
    15120 #ifdef BUILD_TLS_RSA_WITH_AES_256_CBC_B2B256
    15121     TLS_RSA_WITH_AES_256_CBC_B2B256,
    15122 #endif
    15123 
    15124 #ifdef BUILD_TLS_RSA_WITH_RABBIT_SHA
    15125     TLS_RSA_WITH_RABBIT_SHA,
    15126 #endif
    15127 
    15128 #ifdef BUILD_TLS_NTRU_RSA_WITH_RC4_128_SHA
    15129     TLS_NTRU_RSA_WITH_RC4_128_SHA,
    15130 #endif
    15131 
    15132 #ifdef BUILD_TLS_NTRU_RSA_WITH_3DES_EDE_CBC_SHA
    15133     TLS_NTRU_RSA_WITH_3DES_EDE_CBC_SHA,
    15134 #endif
    15135 
    15136 #ifdef BUILD_TLS_NTRU_RSA_WITH_AES_128_CBC_SHA
    15137     TLS_NTRU_RSA_WITH_AES_128_CBC_SHA,
    15138 #endif
    15139 
    15140 #ifdef BUILD_TLS_NTRU_RSA_WITH_AES_256_CBC_SHA
    15141     TLS_NTRU_RSA_WITH_AES_256_CBC_SHA,
    15142 #endif
    15143 
    15144 #ifdef BUILD_TLS_RSA_WITH_AES_128_CCM_8
    15145     TLS_RSA_WITH_AES_128_CCM_8,
    15146 #endif
    15147 
    15148 #ifdef BUILD_TLS_RSA_WITH_AES_256_CCM_8
    15149     TLS_RSA_WITH_AES_256_CCM_8,
    15150 #endif
    15151 
    15152 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_128_CCM
    15153     TLS_ECDHE_ECDSA_WITH_AES_128_CCM,
    15154 #endif
    15155 
    15156 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8
    15157     TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8,
    15158 #endif
    15159 
    15160 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8
    15161     TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8,
    15162 #endif
    15163 
    15164 #ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
    15165     TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
    15166 #endif
    15167 
    15168 #ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
    15169     TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
    15170 #endif
    15171 
    15172 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
    15173     TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
    15174 #endif
    15175 
    15176 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
    15177     TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
    15178 #endif
    15179 
    15180 #ifdef BUILD_TLS_ECDHE_RSA_WITH_RC4_128_SHA
    15181     TLS_ECDHE_RSA_WITH_RC4_128_SHA,
    15182 #endif
    15183 
    15184 #ifdef BUILD_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA
    15185     TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
    15186 #endif
    15187 
    15188 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA
    15189     TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,
    15190 #endif
    15191 
    15192 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA
    15193     TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA,
    15194 #endif
    15195 
    15196 #ifdef BUILD_TLS_RSA_WITH_AES_128_CBC_SHA256
    15197     TLS_RSA_WITH_AES_128_CBC_SHA256,
    15198 #endif
    15199 
    15200 #ifdef BUILD_TLS_RSA_WITH_AES_256_CBC_SHA256
    15201     TLS_RSA_WITH_AES_256_CBC_SHA256,
    15202 #endif
    15203 
    15204 #ifdef BUILD_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
    15205     TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
    15206 #endif
    15207 
    15208 #ifdef BUILD_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
    15209     TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,
    15210 #endif
    15211 
    15212 #ifdef BUILD_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA
    15213     TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,
    15214 #endif
    15215 
    15216 #ifdef BUILD_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA
    15217     TLS_ECDH_RSA_WITH_AES_256_CBC_SHA,
    15218 #endif
    15219 
    15220 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA
    15221     TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA,
    15222 #endif
    15223 
    15224 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA
    15225     TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA,
    15226 #endif
    15227 
    15228 #ifdef BUILD_TLS_ECDH_RSA_WITH_RC4_128_SHA
    15229     TLS_ECDH_RSA_WITH_RC4_128_SHA,
    15230 #endif
    15231 
    15232 #ifdef BUILD_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA
    15233     TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA,
    15234 #endif
    15235 
    15236 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_RC4_128_SHA
    15237     TLS_ECDH_ECDSA_WITH_RC4_128_SHA,
    15238 #endif
    15239 
    15240 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA
    15241     TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA,
    15242 #endif
    15243 
    15244 #ifdef BUILD_TLS_RSA_WITH_AES_128_GCM_SHA256
    15245     TLS_RSA_WITH_AES_128_GCM_SHA256,
    15246 #endif
    15247 
    15248 #ifdef BUILD_TLS_RSA_WITH_AES_256_GCM_SHA384
    15249     TLS_RSA_WITH_AES_256_GCM_SHA384,
    15250 #endif
    15251 
    15252 #ifdef BUILD_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
    15253     TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
    15254 #endif
    15255 
    15256 #ifdef BUILD_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
    15257     TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,
    15258 #endif
    15259 
    15260 #ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
    15261     TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
    15262 #endif
    15263 
    15264 #ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
    15265     TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
    15266 #endif
    15267 
    15268 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
    15269     TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
    15270 #endif
    15271 
    15272 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
    15273     TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
    15274 #endif
    15275 
    15276 #ifdef BUILD_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256
    15277     TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256,
    15278 #endif
    15279 
    15280 #ifdef BUILD_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384
    15281     TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384,
    15282 #endif
    15283 
    15284 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256
    15285     TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256,
    15286 #endif
    15287 
    15288 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384
    15289     TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384,
    15290 #endif
    15291 
    15292 #ifdef BUILD_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA
    15293     TLS_RSA_WITH_CAMELLIA_128_CBC_SHA,
    15294 #endif
    15295 
    15296 #ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA
    15297     TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,
    15298 #endif
    15299 
    15300 #ifdef BUILD_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA
    15301     TLS_RSA_WITH_CAMELLIA_256_CBC_SHA,
    15302 #endif
    15303 
    15304 #ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA
    15305     TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,
    15306 #endif
    15307 
    15308 #ifdef BUILD_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256
    15309     TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256,
    15310 #endif
    15311 
    15312 #ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256
    15313     TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
    15314 #endif
    15315 
    15316 #ifdef BUILD_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256
    15317     TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256,
    15318 #endif
    15319 
    15320 #ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256
    15321     TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256,
    15322 #endif
    15323 
    15324 #ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
    15325     TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
    15326 #endif
    15327 
    15328 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
    15329     TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
    15330 #endif
    15331 
    15332 #ifdef BUILD_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256
    15333     TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256,
    15334 #endif
    15335 
    15336 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256
    15337     TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256,
    15338 #endif
    15339 
    15340 #ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384
    15341     TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
    15342 #endif
    15343 
    15344 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
    15345     TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
    15346 #endif
    15347 
    15348 #ifdef BUILD_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384
    15349     TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384,
    15350 #endif
    15351 
    15352 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384
    15353     TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384,
    15354 #endif
    15355 
    15356 #ifdef BUILD_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
    15357     TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
    15358 #endif
    15359 
    15360 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
    15361     TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
    15362 #endif
    15363 
    15364 #ifdef BUILD_TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256
    15365     TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
    15366 #endif
    15367 
    15368 #ifdef BUILD_TLS_ECDHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256
    15369     TLS_ECDHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256,
    15370 #endif
    15371 
    15372 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_CHACHA20_OLD_POLY1305_SHA256
    15373     TLS_ECDHE_ECDSA_WITH_CHACHA20_OLD_POLY1305_SHA256,
    15374 #endif
    15375 
    15376 #ifdef BUILD_TLS_DHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256
    15377     TLS_DHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256,
    15378 #endif
    15379 
    15380 #ifdef BUILD_TLS_DH_anon_WITH_AES_128_CBC_SHA
    15381     TLS_DH_anon_WITH_AES_128_CBC_SHA,
    15382 #endif
    15383 
    15384 #ifdef BUILD_TLS_QSH
    15385     TLS_QSH,
    15386 #endif
    15387 
    15388 #ifdef HAVE_RENEGOTIATION_INDICATION
    15389     TLS_EMPTY_RENEGOTIATION_INFO_SCSV,
    15390 #endif
    15391 
    15392 #ifdef BUILD_SSL_RSA_WITH_IDEA_CBC_SHA
    15393     SSL_RSA_WITH_IDEA_CBC_SHA,
    15394 #endif
    15395 
    15396 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_NULL_SHA
    15397     TLS_ECDHE_ECDSA_WITH_NULL_SHA,
    15398 #endif
    15399 
    15400 #ifdef BUILD_TLS_ECDHE_PSK_WITH_NULL_SHA256
    15401     TLS_ECDHE_PSK_WITH_NULL_SHA256,
    15402 #endif
    15403 
    15404 #ifdef BUILD_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256
    15405     TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
    15406 #endif
    15407 
    15408 #ifdef BUILD_TLS_PSK_WITH_CHACHA20_POLY1305_SHA256
    15409     TLS_PSK_WITH_CHACHA20_POLY1305_SHA256,
    15410 #endif
    15411 
    15412 #ifdef BUILD_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256
    15413     TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256,
    15414 #endif
    15415 
    15416 #ifdef BUILD_TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256
    15417     TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256,
    15418 #endif
    15419 
    15420 #ifdef BUILD_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA
    15421     TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA,
    15422 #endif
    15423 
    15424 #ifdef BUILD_TLS_AES_128_GCM_SHA256
    15425     TLS_AES_128_GCM_SHA256,
    15426 #endif
    15427 
    15428 #ifdef BUILD_TLS_AES_256_GCM_SHA384
    15429     TLS_AES_256_GCM_SHA384,
    15430 #endif
    15431 
    15432 #ifdef BUILD_TLS_CHACHA20_POLY1305_SHA256
    15433     TLS_CHACHA20_POLY1305_SHA256,
    15434 #endif
    15435 
    15436 #ifdef BUILD_TLS_AES_128_CCM_SHA256
    15437     TLS_AES_128_CCM_SHA256,
    15438 #endif
    15439 
    15440 #ifdef BUILD_TLS_AES_128_CCM_8_SHA256
    15441     TLS_AES_128_CCM_8_SHA256,
    15442 #endif
    15443 
    15444 #ifdef BUILD_WDM_WITH_NULL_SHA256
    15445     WDM_WITH_NULL_SHA256,
    15446 #endif
    15447 };
    15448 
    15449 
    1545016329/* returns the cipher_names array */
    15451 const char* const* GetCipherNames(void)
     16330const CipherSuiteInfo* GetCipherNames(void)
    1545216331{
    1545316332    return cipher_names;
    … …  
    1545516334
    1545616335
    15457 /* returns the size of the cipher_names array */
     16336/* returns the number of elements in the cipher_names array */
    1545816337int GetCipherNamesSize(void)
    1545916338{
    15460     return (int)(sizeof(cipher_names) / sizeof(char*));
     16339    return (int)(sizeof(cipher_names) / sizeof(CipherSuiteInfo));
    1546116340}
    1546216341
    15463 /* gets cipher name in the format DHE-RSA-... rather then TLS_DHE... */
    15464 const char* GetCipherNameInternal(const char* cipherName, int cipherSuite)
     16342
     16343const char* GetCipherNameInternal(const byte cipherSuite0, const byte cipherSuite)
    1546516344{
    15466     const char* result = NULL;
    15467     const char* first;
    1546816345    int i;
    15469 
    15470     if (cipherName == NULL) {
    15471         WOLFSSL_MSG("Bad argument");
    15472         return NULL;
    15473     }
    15474 
    15475     first = (XSTRSTR(cipherName, "CHACHA")) ? "CHACHA"
    15476           : (XSTRSTR(cipherName, "EC"))     ? "EC"
    15477           : (XSTRSTR(cipherName, "CCM"))    ? "CCM"
    15478           : NULL; /* normal */
    15479 
    15480     for (i = 0; i < (int)(sizeof(cipher_name_idx)/sizeof(int)); i++) {
    15481         if (cipher_name_idx[i] == cipherSuite) {
    15482             const char* nameFound = cipher_names[i];
    15483 
    15484             /* extra sanity check on returned cipher name */
    15485             if (nameFound == NULL) {
    15486                 continue;
    15487             }
    15488 
    15489             /* if first is null then not any */
    15490             if (first == NULL) {
    15491                 if (    !XSTRSTR(nameFound, "CHACHA") &&
    15492                         !XSTRSTR(nameFound, "EC") &&
    15493                         !XSTRSTR(nameFound, "CCM")) {
    15494                     result = nameFound;
    15495                     break;
    15496                 }
    15497             }
    15498             else if (XSTRSTR(nameFound, first)) {
    15499                 result = nameFound;
    15500                 break;
    15501             }
    15502         }
    15503     }
    15504 
    15505     return result;
     16346    const char* nameInternal = NULL;
     16347
     16348    for (i = 0; i < GetCipherNamesSize(); i++) {
     16349        if ((cipher_names[i].cipherSuite0 == cipherSuite0) &&
     16350            (cipher_names[i].cipherSuite  == cipherSuite)) {
     16351            nameInternal = cipher_names[i].name;
     16352            break;
     16353        }
     16354    }
     16355    return nameInternal;
     16356}
     16357
     16358const char* GetCipherNameIana(const byte cipherSuite0, const byte cipherSuite)
     16359{
     16360#ifndef NO_ERROR_STRINGS
     16361    int i;
     16362    const char* nameIana = "NONE";
     16363
     16364    for (i = 0; i < GetCipherNamesSize(); i++) {
     16365        if ((cipher_names[i].cipherSuite0 == cipherSuite0) &&
     16366            (cipher_names[i].cipherSuite  == cipherSuite)) {
     16367            nameIana = cipher_names[i].name_iana;
     16368            break;
     16369        }
     16370    }
     16371    return nameIana;
     16372#else
     16373    (void)cipherSuite0;
     16374    (void)cipherSuite;
     16375    return NULL;
     16376#endif
    1550616377}
    1550716378
    … …  
    1550916380{
    1551016381    if (ssl == NULL) {
    15511         WOLFSSL_MSG("Bad argument");
    1551216382        return NULL;
    1551316383    }
    1551416384
    15515     return GetCipherNameInternal(
    15516         wolfSSL_CIPHER_get_name(&ssl->cipher),
    15517         ssl->options.cipherSuite);
     16385    return GetCipherNameInternal(ssl->options.cipherSuite0, ssl->options.cipherSuite);
    1551816386}
    1551916387
    15520 
    15521 const char* wolfSSL_get_cipher_name_from_suite(const unsigned char cipherSuite,
    15522     const unsigned char cipherSuite0)
     16388const char* wolfSSL_get_cipher_name_iana(WOLFSSL* ssl)
    1552316389{
    15524 
    15525     WOLFSSL_ENTER("wolfSSL_get_cipher_name_from_suite");
    15526 
    15527     (void)cipherSuite;
    15528     (void)cipherSuite0;
    15529 
    15530 #ifndef NO_ERROR_STRINGS
    15531 
    15532 #if defined(HAVE_CHACHA)
    15533     if (cipherSuite0 == CHACHA_BYTE) {
    15534         /* ChaCha suites */
    15535         switch (cipherSuite) {
    15536 #ifdef HAVE_POLY1305
    15537 #ifndef NO_RSA
    15538             case TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 :
    15539                 return "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256";
    15540 
    15541             case TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 :
    15542                 return "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256";
    15543 
    15544             case TLS_ECDHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256 :
    15545                 return "TLS_ECDHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256";
    15546 
    15547             case TLS_DHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256 :
    15548                 return "TLS_DHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256";
    15549 #endif
    15550             case TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 :
    15551                 return "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256";
    15552 
    15553             case TLS_ECDHE_ECDSA_WITH_CHACHA20_OLD_POLY1305_SHA256 :
    15554                 return "TLS_ECDHE_ECDSA_WITH_CHACHA20_OLD_POLY1305_SHA256";
    15555 #ifndef NO_PSK
    15556             case TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256 :
    15557                 return "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256";
    15558             case TLS_PSK_WITH_CHACHA20_POLY1305_SHA256 :
    15559                 return "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256";
    15560             case TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256 :
    15561                 return "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256";
    15562 #endif /* NO_PSK */
    15563 #endif /* HAVE_POLY1305 */
    15564         } /* switch */
    15565     } /* chacha */
    15566 #endif /* HAVE_CHACHA */
    15567 
    15568 #if defined(HAVE_ECC) || defined(HAVE_AESCCM)
    15569         /* Awkwardly, the ECC cipher suites use the ECC_BYTE as expected,
    15570          * but the AES-CCM cipher suites also use it, even the ones that
    15571          * aren't ECC. */
    15572     if (cipherSuite0 == ECC_BYTE) {
    15573         /* ECC suites */
    15574         switch (cipherSuite) {
    15575 #ifdef HAVE_ECC
    15576     #ifndef NO_RSA
    15577             case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 :
    15578                 return "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256";
    15579     #endif /* !NO_RSA */
    15580             case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 :
    15581                 return "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256";
    15582     #ifndef NO_RSA
    15583             case TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 :
    15584                 return "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256";
    15585     #endif /* !NO_RSA */
    15586             case TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 :
    15587                 return "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256";
    15588     #ifndef NO_RSA
    15589             case TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 :
    15590                 return "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384";
    15591     #endif /* !NO_RSA */
    15592             case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 :
    15593                 return "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384";
    15594     #ifndef NO_RSA
    15595             case TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 :
    15596                 return "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384";
    15597     #endif /* !NO_RSA */
    15598             case TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 :
    15599                 return "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384";
    15600 #ifndef NO_SHA
    15601     #ifndef NO_RSA
    15602             case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA :
    15603                 return "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA";
    15604             case TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA :
    15605                 return "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA";
    15606     #endif /* !NO_RSA */
    15607             case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA :
    15608                 return "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA";
    15609             case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA :
    15610                 return "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA";
    15611     #ifndef NO_RC4
    15612         #ifndef NO_RSA
    15613             case TLS_ECDHE_RSA_WITH_RC4_128_SHA :
    15614                 return "TLS_ECDHE_RSA_WITH_RC4_128_SHA";
    15615         #endif /* !NO_RSA */
    15616             case TLS_ECDHE_ECDSA_WITH_RC4_128_SHA :
    15617                 return "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA";
    15618     #endif /* !NO_RC4 */
    15619     #ifndef NO_DES3
    15620         #ifndef NO_RSA
    15621             case TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA :
    15622                 return "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA";
    15623         #endif /* !NO_RSA */
    15624             case TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA :
    15625                 return "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA";
    15626     #endif /* !NO_DES3 */
    15627 
    15628     #ifndef NO_RSA
    15629             case TLS_ECDH_RSA_WITH_AES_128_CBC_SHA :
    15630                 return "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA";
    15631             case TLS_ECDH_RSA_WITH_AES_256_CBC_SHA :
    15632                 return "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA";
    15633     #endif /* !NO_RSA */
    15634             case TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA :
    15635                 return "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA";
    15636             case TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA :
    15637                 return "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA";
    15638     #ifndef NO_RC4
    15639         #ifndef NO_RSA
    15640             case TLS_ECDH_RSA_WITH_RC4_128_SHA :
    15641                 return "TLS_ECDH_RSA_WITH_RC4_128_SHA";
    15642         #endif /* !NO_RSA */
    15643             case TLS_ECDH_ECDSA_WITH_RC4_128_SHA :
    15644                 return "TLS_ECDH_ECDSA_WITH_RC4_128_SHA";
    15645     #endif /* !NO_RC4 */
    15646     #ifndef NO_DES3
    15647         #ifndef NO_RSA
    15648             case TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA :
    15649                 return "TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA";
    15650         #endif /* !NO_RSA */
    15651             case TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA :
    15652                 return "TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA";
    15653     #endif /* !NO_DES3 */
    15654 #endif /* HAVE_ECC */
    15655 
    15656 #ifdef HAVE_AESGCM
    15657     #ifndef NO_RSA
    15658             case TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 :
    15659                 return "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256";
    15660             case TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 :
    15661                 return "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384";
    15662     #endif /* !NO_RSA */
    15663             case TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 :
    15664                 return "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256";
    15665             case TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 :
    15666                 return "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384";
    15667     #ifndef NO_RSA
    15668             case TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 :
    15669                 return "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256";
    15670             case TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 :
    15671                 return "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384";
    15672     #endif /* !NO_RSA */
    15673             case TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 :
    15674                 return "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256";
    15675             case TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 :
    15676                 return "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384";
    15677 #endif /* HAVE_AESGCM */
    15678 
    15679             case TLS_ECDHE_ECDSA_WITH_NULL_SHA :
    15680                 return "TLS_ECDHE_ECDSA_WITH_NULL_SHA";
    15681     #ifndef NO_PSK
    15682             case TLS_ECDHE_PSK_WITH_NULL_SHA256 :
    15683                 return "TLS_ECDHE_PSK_WITH_NULL_SHA256";
    15684             case TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 :
    15685                 return "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256";
    15686     #endif /* !NO_PSK */
    15687     #ifndef NO_RSA
    15688             case TLS_RSA_WITH_AES_128_CCM_8 :
    15689                 return "TLS_RSA_WITH_AES_128_CCM_8";
    15690             case TLS_RSA_WITH_AES_256_CCM_8 :
    15691                 return "TLS_RSA_WITH_AES_256_CCM_8";
    15692     #endif /* !NO_RSA */
    15693     #ifndef NO_PSK
    15694             case TLS_PSK_WITH_AES_128_CCM_8 :
    15695                 return "TLS_PSK_WITH_AES_128_CCM_8";
    15696             case TLS_PSK_WITH_AES_256_CCM_8 :
    15697                 return "TLS_PSK_WITH_AES_256_CCM_8";
    15698             case TLS_PSK_WITH_AES_128_CCM :
    15699                 return "TLS_PSK_WITH_AES_128_CCM";
    15700             case TLS_PSK_WITH_AES_256_CCM :
    15701                 return "TLS_PSK_WITH_AES_256_CCM";
    15702             case TLS_DHE_PSK_WITH_AES_128_CCM :
    15703                 return "TLS_DHE_PSK_WITH_AES_128_CCM";
    15704             case TLS_DHE_PSK_WITH_AES_256_CCM :
    15705                 return "TLS_DHE_PSK_WITH_AES_256_CCM";
    15706     #endif /* !NO_PSK */
    15707     #ifdef HAVE_ECC
    15708             case TLS_ECDHE_ECDSA_WITH_AES_128_CCM:
    15709                 return "TLS_ECDHE_ECDSA_WITH_AES_128_CCM";
    15710             case TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8:
    15711                 return "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8";
    15712             case TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8 :
    15713                 return "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8";
    15714     #endif /* HAVE_ECC */
    15715 #endif /* HAVE_AESGCM */
    15716 
    15717             default:
    15718                 return "NONE";
    15719         } /* switch */
    15720     } /* ECC and AES CCM/GCM */
    15721 #endif  /* HAVE_ECC || HAVE_AESCCM*/
    15722 
    15723     if (cipherSuite0 == TLS13_BYTE) {
    15724         /* TLS v1.3 suites */
    15725         switch (cipherSuite) {
    15726 #ifdef WOLFSSL_TLS13
    15727     #ifdef HAVE_AESGCM
    15728             case TLS_AES_128_GCM_SHA256 :
    15729                 return "TLS_AES_128_GCM_SHA256";
    15730             case TLS_AES_256_GCM_SHA384 :
    15731                 return "TLS_AES_256_GCM_SHA384";
    15732     #endif
    15733 
    15734     #ifdef HAVE_CHACHA
    15735             case TLS_CHACHA20_POLY1305_SHA256 :
    15736                 return "TLS_CHACHA20_POLY1305_SHA256";
    15737     #endif
    15738 
    15739     #ifdef HAVE_AESCCM
    15740             case TLS_AES_128_CCM_SHA256 :
    15741                 return "TLS_AES_128_CCM_SHA256";
    15742             case TLS_AES_128_CCM_8_SHA256 :
    15743                 return "TLS_AES_256_CCM_8_SHA256";
    15744     #endif
    15745 #endif
    15746 
    15747             default:
    15748                 return "NONE";
    15749         }
    15750     }
    15751 
    15752     if (cipherSuite0 != ECC_BYTE &&
    15753         cipherSuite0 != CHACHA_BYTE &&
    15754         cipherSuite0 != TLS13_BYTE) {
    15755 
    15756         /* normal suites */
    15757         switch (cipherSuite) {
    15758 #ifndef NO_RSA
    15759     #ifndef NO_RC4
    15760         #ifndef NO_SHA
    15761             case SSL_RSA_WITH_RC4_128_SHA :
    15762                 return "SSL_RSA_WITH_RC4_128_SHA";
    15763         #endif /* !NO_SHA */
    15764         #ifndef NO_MD5
    15765             case SSL_RSA_WITH_RC4_128_MD5 :
    15766                 return "SSL_RSA_WITH_RC4_128_MD5";
    15767         #endif /* !NO_MD5 */
    15768     #endif /* !NO_RC4 */
    15769     #ifndef NO_SHA
    15770         #ifndef NO_DES3
    15771             case SSL_RSA_WITH_3DES_EDE_CBC_SHA :
    15772                 return "SSL_RSA_WITH_3DES_EDE_CBC_SHA";
    15773         #endif /* !NO_DES3 */
    15774         #ifdef HAVE_IDEA
    15775             case SSL_RSA_WITH_IDEA_CBC_SHA :
    15776                 return "SSL_RSA_WITH_IDEA_CBC_SHA";
    15777         #endif /* HAVE_IDEA */
    15778 
    15779             case TLS_RSA_WITH_AES_128_CBC_SHA :
    15780                 return "TLS_RSA_WITH_AES_128_CBC_SHA";
    15781             case TLS_RSA_WITH_AES_256_CBC_SHA :
    15782                 return "TLS_RSA_WITH_AES_256_CBC_SHA";
    15783     #endif /* !NO_SHA */
    15784             case TLS_RSA_WITH_AES_128_CBC_SHA256 :
    15785                 return "TLS_RSA_WITH_AES_128_CBC_SHA256";
    15786             case TLS_RSA_WITH_AES_256_CBC_SHA256 :
    15787                 return "TLS_RSA_WITH_AES_256_CBC_SHA256";
    15788     #ifdef HAVE_BLAKE2
    15789             case TLS_RSA_WITH_AES_128_CBC_B2B256:
    15790                 return "TLS_RSA_WITH_AES_128_CBC_B2B256";
    15791             case TLS_RSA_WITH_AES_256_CBC_B2B256:
    15792                 return "TLS_RSA_WITH_AES_256_CBC_B2B256";
    15793     #endif /* HAVE_BLAKE2 */
    15794     #ifndef NO_SHA
    15795             case TLS_RSA_WITH_NULL_SHA :
    15796                 return "TLS_RSA_WITH_NULL_SHA";
    15797     #endif /* !NO_SHA */
    15798             case TLS_RSA_WITH_NULL_SHA256 :
    15799                 return "TLS_RSA_WITH_NULL_SHA256";
    15800 #endif /* NO_RSA */
    15801 
    15802 #ifndef NO_PSK
    15803     #ifndef NO_SHA
    15804             case TLS_PSK_WITH_AES_128_CBC_SHA :
    15805                 return "TLS_PSK_WITH_AES_128_CBC_SHA";
    15806             case TLS_PSK_WITH_AES_256_CBC_SHA :
    15807                 return "TLS_PSK_WITH_AES_256_CBC_SHA";
    15808     #endif /* !NO_SHA */
    15809     #ifndef NO_SHA256
    15810             case TLS_PSK_WITH_AES_128_CBC_SHA256 :
    15811                 return "TLS_PSK_WITH_AES_128_CBC_SHA256";
    15812             case TLS_PSK_WITH_NULL_SHA256 :
    15813                 return "TLS_PSK_WITH_NULL_SHA256";
    15814             case TLS_DHE_PSK_WITH_AES_128_CBC_SHA256 :
    15815                 return "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256";
    15816             case TLS_DHE_PSK_WITH_NULL_SHA256 :
    15817                 return "TLS_DHE_PSK_WITH_NULL_SHA256";
    15818         #ifdef HAVE_AESGCM
    15819             case TLS_PSK_WITH_AES_128_GCM_SHA256 :
    15820                 return "TLS_PSK_WITH_AES_128_GCM_SHA256";
    15821             case TLS_DHE_PSK_WITH_AES_128_GCM_SHA256 :
    15822                 return "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256";
    15823         #endif /* HAVE_AESGCM */
    15824     #endif /* !NO_SHA256 */
    15825     #ifdef WOLFSSL_SHA384
    15826             case TLS_PSK_WITH_AES_256_CBC_SHA384 :
    15827                 return "TLS_PSK_WITH_AES_256_CBC_SHA384";
    15828             case TLS_PSK_WITH_NULL_SHA384 :
    15829                 return "TLS_PSK_WITH_NULL_SHA384";
    15830             case TLS_DHE_PSK_WITH_AES_256_CBC_SHA384 :
    15831                 return "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384";
    15832             case TLS_DHE_PSK_WITH_NULL_SHA384 :
    15833                 return "TLS_DHE_PSK_WITH_NULL_SHA384";
    15834         #ifdef HAVE_AESGCM
    15835             case TLS_PSK_WITH_AES_256_GCM_SHA384 :
    15836                 return "TLS_PSK_WITH_AES_256_GCM_SHA384";
    15837             case TLS_DHE_PSK_WITH_AES_256_GCM_SHA384 :
    15838                 return "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384";
    15839         #endif /* HAVE_AESGCM */
    15840     #endif /* WOLFSSL_SHA384 */
    15841     #ifndef NO_SHA
    15842             case TLS_PSK_WITH_NULL_SHA :
    15843                 return "TLS_PSK_WITH_NULL_SHA";
    15844     #endif /* !NO_SHA */
    15845     #endif /* NO_PSK */
    15846 
    15847     #ifndef NO_RSA
    15848             case TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 :
    15849                 return "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256";
    15850             case TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 :
    15851                 return "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256";
    15852     #ifndef NO_SHA
    15853             case TLS_DHE_RSA_WITH_AES_128_CBC_SHA :
    15854                 return "TLS_DHE_RSA_WITH_AES_128_CBC_SHA";
    15855             case TLS_DHE_RSA_WITH_AES_256_CBC_SHA :
    15856                 return "TLS_DHE_RSA_WITH_AES_256_CBC_SHA";
    15857         #ifndef NO_DES3
    15858             case TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA:
    15859                 return "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA";
    15860          #endif
    15861     #endif /* !NO_RSA */
    15862     #ifndef NO_HC128
    15863         #ifndef NO_MD5
    15864             case TLS_RSA_WITH_HC_128_MD5 :
    15865                 return "TLS_RSA_WITH_HC_128_MD5";
    15866         #endif /* !NO_MD5 */
    15867         #ifndef NO_SHA
    15868             case TLS_RSA_WITH_HC_128_SHA :
    15869                 return "TLS_RSA_WITH_HC_128_SHA";
    15870         #endif /* !NO_SHA */
    15871         #ifdef HAVE_BLAKE2
    15872             case TLS_RSA_WITH_HC_128_B2B256:
    15873                 return "TLS_RSA_WITH_HC_128_B2B256";
    15874         #endif /* HAVE_BLAKE2 */
    15875     #endif /* !NO_HC128 */
    15876     #ifndef NO_SHA
    15877         #ifndef NO_RABBIT
    15878             case TLS_RSA_WITH_RABBIT_SHA :
    15879                 return "TLS_RSA_WITH_RABBIT_SHA";
    15880         #endif /* !NO_RABBIT */
    15881         #ifdef HAVE_NTRU
    15882             #ifndef NO_RC4
    15883             case TLS_NTRU_RSA_WITH_RC4_128_SHA :
    15884                 return "TLS_NTRU_RSA_WITH_RC4_128_SHA";
    15885             #endif /* !NO_RC4 */
    15886             #ifndef NO_DES3
    15887             case TLS_NTRU_RSA_WITH_3DES_EDE_CBC_SHA :
    15888                 return "TLS_NTRU_RSA_WITH_3DES_EDE_CBC_SHA";
    15889             #endif /* !NO_DES3 */
    15890             case TLS_NTRU_RSA_WITH_AES_128_CBC_SHA :
    15891                 return "TLS_NTRU_RSA_WITH_AES_128_CBC_SHA";
    15892             case TLS_NTRU_RSA_WITH_AES_256_CBC_SHA :
    15893                 return "TLS_NTRU_RSA_WITH_AES_256_CBC_SHA";
    15894         #endif /* HAVE_NTRU */
    15895 
    15896         #ifdef HAVE_QSH
    15897             case TLS_QSH :
    15898                 return "TLS_QSH";
    15899         #endif /* HAVE_QSH */
    15900     #endif /* !NO_SHA */
    15901 
    15902             case TLS_RSA_WITH_AES_128_GCM_SHA256 :
    15903                 return "TLS_RSA_WITH_AES_128_GCM_SHA256";
    15904             case TLS_RSA_WITH_AES_256_GCM_SHA384 :
    15905                 return "TLS_RSA_WITH_AES_256_GCM_SHA384";
    15906             case TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 :
    15907                 return "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256";
    15908             case TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 :
    15909                 return "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384";
    15910     #ifndef NO_SHA
    15911             case TLS_RSA_WITH_CAMELLIA_128_CBC_SHA :
    15912                 return "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA";
    15913             case TLS_RSA_WITH_CAMELLIA_256_CBC_SHA :
    15914                 return "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA";
    15915     #endif /* !NO_SHA */
    15916             case TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256 :
    15917                 return "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256";
    15918             case TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256 :
    15919                 return "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256";
    15920     #ifndef NO_SHA
    15921             case TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA :
    15922                 return "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA";
    15923             case TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA :
    15924                 return "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA";
    15925     #endif /* !NO_SHA */
    15926             case TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 :
    15927                 return "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256";
    15928             case TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 :
    15929                 return "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256";
    15930 #endif /* !NO_PSK */
    15931 
    15932 #ifdef BUILD_TLS_DH_anon_WITH_AES_128_CBC_SHA
    15933             case TLS_DH_anon_WITH_AES_128_CBC_SHA :
    15934                 return "TLS_DH_anon_WITH_AES_128_CBC_SHA";
    15935 #endif
    15936 #ifdef BUILD_WDM_WITH_NULL_SHA256
    15937             case WDM_WITH_NULL_SHA256 :
    15938                 return "WDM_WITH_NULL_SHA256";
    15939 #endif
    15940             default:
    15941                 return "NONE";
    15942         } /* switch */
    15943     } /* normal / PSK */
    15944 #endif /* NO_ERROR_STRINGS */
    15945 
    15946     return "NONE";
     16390    if (ssl == NULL) {
     16391        return NULL;
     16392    }
     16393
     16394    return GetCipherNameIana(ssl->options.cipherSuite0, ssl->options.cipherSuite);
    1594716395}
    1594816396
     16397int GetCipherSuiteFromName(const char* name, byte* cipherSuite0,
     16398                           byte* cipherSuite)
     16399{
     16400    int           ret = BAD_FUNC_ARG;
     16401    int           i;
     16402    unsigned long len = (unsigned long)XSTRLEN(name);
     16403
     16404    for (i = 0; i < GetCipherNamesSize(); i++) {
     16405        if (XSTRNCMP(name, cipher_names[i].name, len) == 0) {
     16406            *cipherSuite0 = cipher_names[i].cipherSuite0;
     16407            *cipherSuite  = cipher_names[i].cipherSuite;
     16408            ret = 0;
     16409            break;
     16410        }
     16411}
     16412
     16413    return ret;
     16414}
    1594916415
    1595016416/**
    … …  
    1597416440    if (next[0] == 0 || XSTRNCMP(next, "ALL", 3) == 0 ||
    1597516441                        XSTRNCMP(next, "DEFAULT", 7) == 0)
    15976         return 1; /* wolfSSL defualt */
     16442        return 1; /* wolfSSL default */
    1597716443
    1597816444    do {
    … …  
    1599016456
    1599116457        for (i = 0; i < suiteSz; i++) {
    15992             if (XSTRNCMP(name, cipher_names[i], sizeof(name)) == 0) {
     16458            if (XSTRNCMP(name, cipher_names[i].name, sizeof(name)) == 0) {
    1599316459            #ifdef WOLFSSL_DTLS
    1599416460                /* don't allow stream ciphers with DTLS */
    … …  
    1601016476                }
    1601116477
    16012                 suites->suites[idx++] = (XSTRSTR(name, "TLS13"))  ? TLS13_BYTE
    16013                                       : (XSTRSTR(name, "CHACHA")) ? CHACHA_BYTE
    16014                                       : (XSTRSTR(name, "QSH"))    ? QSH_BYTE
    16015                                       : (XSTRSTR(name, "EC"))     ? ECC_BYTE
    16016                                       : (XSTRSTR(name, "CCM"))    ? ECC_BYTE
    16017                                       : 0x00; /* normal */
    16018                 suites->suites[idx++] = (byte)cipher_name_idx[i];
    16019 
     16478                suites->suites[idx++] =
     16479            #ifdef WOLFSSL_TLS13
     16480                    (XSTRSTR(name, "TLS13"))  ? TLS13_BYTE :
     16481            #endif
     16482            #ifdef HAVE_CHACHA
     16483                    (XSTRSTR(name, "CHACHA")) ? CHACHA_BYTE :
     16484            #endif
     16485            #ifdef HAVE_QSH
     16486                    (XSTRSTR(name, "QSH"))    ? QSH_BYTE :
     16487            #endif
     16488            #if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
     16489                    (XSTRSTR(name, "EC"))     ? ECC_BYTE :
     16490            #endif
     16491            #ifdef HAVE_AESCCM
     16492                    (XSTRSTR(name, "CCM"))    ? ECC_BYTE :
     16493            #endif
     16494                    CIPHER_BYTE; /* normal */
     16495
     16496                suites->suites[idx++] = cipher_names[i].cipherSuite;
    1602016497                /* The suites are either ECDSA, RSA, PSK, or Anon. The RSA
    1602116498                 * suites don't necessarily have RSA in the name. */
     16499            #ifdef WOLFSSL_TLS13
    1602216500                if (XSTRSTR(name, "TLS13")) {
     16501                #ifndef NO_RSA
    1602316502                    haveRSAsig = 1;
     16503                #endif
     16504                #if defined(HAVE_ECC) || defined(HAVE_ED25519)
    1602416505                    haveECDSAsig = 1;
     16506                #endif
    1602516507                }
    16026                 else if ((haveECDSAsig == 0) && XSTRSTR(name, "ECDSA"))
     16508                else
     16509            #endif
     16510            #if defined(HAVE_ECC) || defined(HAVE_ED25519)
     16511                if ((haveECDSAsig == 0) && XSTRSTR(name, "ECDSA"))
    1602716512                    haveECDSAsig = 1;
    16028                 else if (XSTRSTR(name, "ADH"))
     16513                else
     16514            #endif
     16515            #ifdef HAVE_ANON
     16516                if (XSTRSTR(name, "ADH"))
    1602916517                    haveAnon = 1;
    16030                 else if ((haveRSAsig == 0) && (XSTRSTR(name, "PSK") == NULL))
     16518                else
     16519            #endif
     16520                if (haveRSAsig == 0
     16521                    #ifndef NO_PSK
     16522                        && (XSTRSTR(name, "PSK") == NULL)
     16523                    #endif
     16524                   ) {
    1603116525                    haveRSAsig = 1;
     16526                }
    1603216527
    1603316528                ret = 1; /* found at least one */
    … …  
    1605416549}
    1605516550
     16551
    1605616552#if !defined(NO_WOLFSSL_SERVER) || !defined(NO_CERTS)
    1605716553void PickHashSigAlgo(WOLFSSL* ssl, const byte* hashSigAlgo,
    … …  
    1606916565    #endif
    1607016566    }
     16567#ifndef WOLFSSL_NO_TLS12
    1607116568    else if (IsAtLeastTLSv1_2(ssl)) {
    1607216569    #ifdef WOLFSSL_ALLOW_TLS_SHA1
    … …  
    1607916576        ssl->suites->hashAlgo = sha_mac;
    1608016577    }
     16578#endif
    1608116579
    1608216580    /* i+1 since peek a byte ahead for type */
    … …  
    1608516583
    1608616584        DecodeSigAlg(&hashSigAlgo[i], &hashAlgo, &sigAlgo);
    16087     #ifdef HAVE_ECC
     16585    #ifdef HAVE_ED25519
    1608816586        if (ssl->pkCurveOID == ECC_ED25519_OID && sigAlgo != ed25519_sa_algo)
    1608916587            continue;
    … …  
    1609616594        }
    1609716595    #endif
     16596    /* For ECDSA the `USE_ECDSA_KEYSZ_HASH_ALGO` build option will choose a hash
     16597     * algorithm that matches the ephemeral ECDHE key size or the next higest
     16598     * available. This workaround resolves issue with some peer's that do not
     16599     * properly support scenarios such as a P-256 key hashed with SHA512.
     16600     */
     16601    #if defined(HAVE_ECC) && defined(USE_ECDSA_KEYSZ_HASH_ALGO)
     16602        if (sigAlgo == ssl->suites->sigAlgo && sigAlgo == ecc_dsa_sa_algo) {
     16603            word32 digestSz = 0;
     16604            switch (hashAlgo) {
     16605            #ifndef NO_SHA
     16606                case sha_mac:
     16607                    digestSz = WC_SHA_DIGEST_SIZE;
     16608                break;
     16609            #endif
     16610            #ifndef NO_SHA256
     16611                case sha256_mac:
     16612                    digestSz = WC_SHA256_DIGEST_SIZE;
     16613                break;
     16614            #endif
     16615            #ifdef WOLFSSL_SHA384
     16616                case sha384_mac:
     16617                    digestSz = WC_SHA384_DIGEST_SIZE;
     16618                    break;
     16619            #endif
     16620            #ifdef WOLFSSL_SHA512
     16621                case sha512_mac:
     16622                    digestSz = WC_SHA512_DIGEST_SIZE;
     16623                break;
     16624            #endif
     16625                default:
     16626                    continue;
     16627            }
     16628
     16629            /* For ecc_dsa_sa_algo, pick hash algo that is curve size unless
     16630                algorithm in not compiled in, then choose next highest */
     16631            if (digestSz == ssl->eccTempKeySz) {
     16632                ssl->suites->hashAlgo = hashAlgo;
     16633                ssl->suites->sigAlgo = sigAlgo;
     16634                return; /* done selected sig/hash algorithms */
     16635            }
     16636            /* not strong enough, so keep checking hashSigAlso list */
     16637            if (digestSz < ssl->eccTempKeySz)
     16638                continue;
     16639
     16640            /* mark as highest and check remainder of hashSigAlgo list */
     16641            ssl->suites->hashAlgo = hashAlgo;
     16642            ssl->suites->sigAlgo = sigAlgo;
     16643            }
     16644        else
     16645    #endif
    1609816646        if (sigAlgo == ssl->suites->sigAlgo || (sigAlgo == rsa_pss_sa_algo &&
    1609916647                                         ssl->suites->sigAlgo == rsa_sa_algo)) {
    16100             if (hashAlgo == sha_mac) {
     16648            /* pick highest available between both server and client */
     16649            switch (hashAlgo) {
     16650                case sha_mac:
     16651            #ifndef NO_SHA256
     16652                case sha256_mac:
     16653            #endif
     16654            #ifdef WOLFSSL_SHA384
     16655                case sha384_mac:
     16656            #endif
     16657            #ifdef WOLFSSL_SHA512
     16658                case sha512_mac:
     16659            #endif
     16660                    /* not strong enough, so keep checking hashSigAlso list */
     16661                    if (hashAlgo < ssl->suites->hashAlgo)
     16662                        continue;
     16663                    /* mark as highest and check remainder of hashSigAlgo list */
     16664                    ssl->suites->hashAlgo = hashAlgo;
    1610116665                ssl->suites->sigAlgo = sigAlgo;
    1610216666                break;
    16103             }
    16104             #ifndef NO_SHA256
    16105             else if (hashAlgo == sha256_mac) {
    16106                 ssl->suites->hashAlgo = sha256_mac;
    16107                 ssl->suites->sigAlgo = sigAlgo;
    16108                 break;
    16109             }
    16110             #endif
    16111             #ifdef WOLFSSL_SHA384
    16112             else if (hashAlgo == sha384_mac) {
    16113                 ssl->suites->hashAlgo = sha384_mac;
    16114                 ssl->suites->sigAlgo = sigAlgo;
    16115                 break;
    16116             }
    16117             #endif
    16118             #ifdef WOLFSSL_SHA512
    16119             else if (hashAlgo == sha512_mac) {
    16120                 ssl->suites->hashAlgo = sha512_mac;
    16121                 ssl->suites->sigAlgo = sigAlgo;
    16122                 break;
    16123             }
    16124             #endif
     16667                default:
     16668                    continue;
     16669            }
     16670            break;
    1612516671        }
    1612616672        else if (ssl->specs.sig_algo == 0) {
    … …  
    1612816674        }
    1612916675    }
    16130 
    1613116676}
    1613216677#endif /* !defined(NO_WOLFSSL_SERVER) || !defined(NO_CERTS) */
    1613316678
    16134 #ifdef WOLFSSL_CALLBACKS
    16135 
    16136     /* Initialisze HandShakeInfo */
     16679#if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
     16680
     16681    /* Initialize HandShakeInfo */
    1613716682    void InitHandShakeInfo(HandShakeInfo* info, WOLFSSL* ssl)
    1613816683    {
    … …  
    1615116696    {
    1615216697        int i;
    16153         int sz = sizeof(cipher_name_idx)/sizeof(int);
     16698        int sz = GetCipherNamesSize();
    1615416699
    1615516700        for (i = 0; i < sz; i++)
    16156             if (info->ssl->options.cipherSuite == (byte)cipher_name_idx[i]) {
     16701            if (info->ssl->options.cipherSuite ==
     16702                                            (byte)cipher_names[i].cipherSuite) {
    1615716703                if (info->ssl->options.cipherSuite0 == ECC_BYTE)
    1615816704                    continue;   /* ECC suites at end */
    16159                 XSTRNCPY(info->cipherName, cipher_names[i], MAX_CIPHERNAME_SZ);
     16705                XSTRNCPY(info->cipherName, cipher_names[i].name, MAX_CIPHERNAME_SZ);
     16706                info->cipherName[MAX_CIPHERNAME_SZ] = '\0';
    1616016707                break;
    1616116708            }
    … …  
    1616816715
    1616916716    /* Add name to info packet names, increase packet name count */
    16170     void AddPacketName(const char* name, HandShakeInfo* info)
     16717    void AddPacketName(WOLFSSL* ssl, const char* name)
    1617116718    {
     16719    #ifdef WOLFSSL_CALLBACKS
     16720        HandShakeInfo* info = &ssl->handShakeInfo;
    1617216721        if (info->numberPackets < MAX_PACKETS_HANDSHAKE) {
    16173             XSTRNCPY(info->packetNames[info->numberPackets++], name,
    16174                     MAX_PACKETNAME_SZ);
    16175         }
    16176     }
    16177 
    16178 
    16179     /* Initialisze TimeoutInfo */
     16722            char* packetName = info->packetNames[info->numberPackets];
     16723            XSTRNCPY(packetName, name, MAX_PACKETNAME_SZ);
     16724            packetName[MAX_PACKETNAME_SZ] = '\0';
     16725            info->numberPackets++;
     16726        }
     16727    #endif
     16728        (void)ssl;
     16729        (void)name;
     16730    }
     16731
     16732
     16733    #ifdef WOLFSSL_CALLBACKS
     16734    /* Initialize TimeoutInfo */
    1618016735    void InitTimeoutInfo(TimeoutInfo* info)
    1618116736    {
    … …  
    1621116766    }
    1621216767
    16213 
    16214     /* Add PacketInfo to TimeoutInfo */
    16215     void AddPacketInfo(const char* name, TimeoutInfo* info, const byte* data,
    16216                        int sz, void* heap)
     16768    /* Add packet name to previsouly added packet info */
     16769    void AddLateName(const char* name, TimeoutInfo* info)
    1621716770    {
     16771        /* make sure we have a valid previous one */
     16772        if (info->numberPackets > 0 && info->numberPackets <
     16773                                                        MAX_PACKETS_HANDSHAKE) {
     16774            char* packetName = info->packets[info->numberPackets-1].packetName;
     16775            XSTRNCPY(packetName, name, MAX_PACKETNAME_SZ);
     16776            packetName[MAX_PACKETNAME_SZ] = '\0';
     16777        }
     16778    }
     16779
     16780    /* Add record header to previsouly added packet info */
     16781    void AddLateRecordHeader(const RecordLayerHeader* rl, TimeoutInfo* info)
     16782    {
     16783        /* make sure we have a valid previous one */
     16784        if (info->numberPackets > 0 && info->numberPackets <
     16785                                                        MAX_PACKETS_HANDSHAKE) {
     16786            if (info->packets[info->numberPackets - 1].bufferValue)
     16787                XMEMCPY(info->packets[info->numberPackets - 1].bufferValue, rl,
     16788                       RECORD_HEADER_SZ);
     16789            else
     16790                XMEMCPY(info->packets[info->numberPackets - 1].value, rl,
     16791                       RECORD_HEADER_SZ);
     16792        }
     16793    }
     16794
     16795    #endif /* WOLFSSL_CALLBACKS */
     16796
     16797
     16798    /* Add PacketInfo to TimeoutInfo
     16799     *
     16800     * ssl   WOLFSSL structure sending or receiving packet
     16801     * name  name of packet being sent
     16802     * type  type of packet being sent
     16803     * data  data bing sent with packet
     16804     * sz    size of data buffer
     16805     * written 1 if this packet is being written to wire, 0 if being read
     16806     * heap  custom heap to use for mallocs/frees
     16807     */
     16808    void AddPacketInfo(WOLFSSL* ssl, const char* name, int type,
     16809            const byte* data, int sz, int written, void* heap)
     16810    {
     16811    #ifdef WOLFSSL_CALLBACKS
     16812        TimeoutInfo* info = &ssl->timeoutInfo;
     16813
    1621816814        if (info->numberPackets < (MAX_PACKETS_HANDSHAKE - 1)) {
    1621916815            Timeval currTime;
    1622016816
    1622116817            /* may add name after */
    16222             if (name)
    16223                 XSTRNCPY(info->packets[info->numberPackets].packetName, name,
    16224                         MAX_PACKETNAME_SZ);
     16818            if (name) {
     16819                char* packetName = info->packets[info->numberPackets].packetName;
     16820                XSTRNCPY(packetName, name, MAX_PACKETNAME_SZ);
     16821                packetName[MAX_PACKETNAME_SZ] = '\0';
     16822            }
    1622516823
    1622616824            /* add data, put in buffer if bigger than static buffer */
    … …  
    1624516843            info->numberPackets++;
    1624616844        }
    16247     }
    16248 
    16249 
    16250     /* Add packet name to previsouly added packet info */
    16251     void AddLateName(const char* name, TimeoutInfo* info)
    16252     {
    16253         /* make sure we have a valid previous one */
    16254         if (info->numberPackets > 0 && info->numberPackets <
    16255                                                         MAX_PACKETS_HANDSHAKE) {
    16256             XSTRNCPY(info->packets[info->numberPackets - 1].packetName, name,
    16257                     MAX_PACKETNAME_SZ);
    16258         }
    16259     }
    16260 
    16261     /* Add record header to previsouly added packet info */
    16262     void AddLateRecordHeader(const RecordLayerHeader* rl, TimeoutInfo* info)
    16263     {
    16264         /* make sure we have a valid previous one */
    16265         if (info->numberPackets > 0 && info->numberPackets <
    16266                                                         MAX_PACKETS_HANDSHAKE) {
    16267             if (info->packets[info->numberPackets - 1].bufferValue)
    16268                 XMEMCPY(info->packets[info->numberPackets - 1].bufferValue, rl,
    16269                        RECORD_HEADER_SZ);
    16270             else
    16271                 XMEMCPY(info->packets[info->numberPackets - 1].value, rl,
    16272                        RECORD_HEADER_SZ);
    16273         }
     16845    #endif /* WOLFSSL_CALLBACKS */
     16846    #ifdef OPENSSL_EXTRA
     16847        if (ssl->protoMsgCb != NULL && sz > RECORD_HEADER_SZ) {
     16848            /* version from hex to dec  16 is 16^1, 256 from 16^2 and
     16849               4096 from 16^3 */
     16850            int version = (ssl->version.minor & 0X0F) +
     16851                          (ssl->version.minor & 0xF0) * 16  +
     16852                          (ssl->version.major & 0X0F) * 256 +
     16853                          (ssl->version.major & 0xF0) * 4096;
     16854
     16855            ssl->protoMsgCb(written, version, type,
     16856                         (const void *)(data + RECORD_HEADER_SZ),
     16857                         (size_t)(sz - RECORD_HEADER_SZ),
     16858                         ssl, ssl->protoMsgCtx);
     16859        }
     16860    #endif /* OPENSSL_EXTRA */
     16861        (void)written;
     16862        (void)name;
     16863        (void)heap;
     16864        (void)type;
     16865        (void)ssl;
    1627416866    }
    1627516867
    1627616868#endif /* WOLFSSL_CALLBACKS */
    1627716869
    16278 
     16870#if !defined(NO_CERTS) && (defined(WOLFSSL_TLS13) || \
     16871                                                    !defined(NO_WOLFSSL_CLIENT))
     16872
     16873/* Decode the private key - RSA, ECC, or Ed25519 - and creates a key object.
     16874 * The signature type is set as well.
     16875 * The maximum length of a signature is returned.
     16876 *
     16877 * ssl     The SSL/TLS object.
     16878 * length  The length of a signature.
     16879 * returns 0 on success, otherwise failure.
     16880 */
     16881int DecodePrivateKey(WOLFSSL *ssl, word16* length)
     16882{
     16883    int      ret = BAD_FUNC_ARG;
     16884    int      keySz;
     16885    word32   idx;
     16886
     16887    /* make sure private key exists */
     16888    if (ssl->buffers.key == NULL || ssl->buffers.key->buffer == NULL) {
     16889        WOLFSSL_MSG("Private key missing!");
     16890        ERROR_OUT(NO_PRIVATE_KEY, exit_dpk);
     16891    }
     16892
     16893#ifndef NO_RSA
     16894    if (ssl->buffers.keyType == rsa_sa_algo || ssl->buffers.keyType == 0) {
     16895        ssl->hsType = DYNAMIC_TYPE_RSA;
     16896        ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
     16897        if (ret != 0) {
     16898            goto exit_dpk;
     16899        }
     16900
     16901        WOLFSSL_MSG("Trying RSA private key");
     16902
     16903        /* Set start of data to beginning of buffer. */
     16904        idx = 0;
     16905        /* Decode the key assuming it is an RSA private key. */
     16906        ret = wc_RsaPrivateKeyDecode(ssl->buffers.key->buffer, &idx,
     16907                    (RsaKey*)ssl->hsKey, ssl->buffers.key->length);
     16908        if (ret == 0) {
     16909            WOLFSSL_MSG("Using RSA private key");
     16910
     16911            /* It worked so check it meets minimum key size requirements. */
     16912            keySz = wc_RsaEncryptSize((RsaKey*)ssl->hsKey);
     16913            if (keySz < 0) { /* check if keySz has error case */
     16914                ERROR_OUT(keySz, exit_dpk);
     16915            }
     16916
     16917            if (keySz < ssl->options.minRsaKeySz) {
     16918                WOLFSSL_MSG("RSA key size too small");
     16919                ERROR_OUT(RSA_KEY_SIZE_E, exit_dpk);
     16920            }
     16921
     16922            /* Return the maximum signature length. */
     16923            *length = (word16)keySz;
     16924
     16925            goto exit_dpk;
     16926        }
     16927    }
     16928#endif /* !NO_RSA */
     16929
     16930#ifdef HAVE_ECC
     16931#ifndef NO_RSA
     16932    FreeKey(ssl, ssl->hsType, (void**)&ssl->hsKey);
     16933#endif /* !NO_RSA */
     16934
     16935    if (ssl->buffers.keyType == ecc_dsa_sa_algo || ssl->buffers.keyType == 0) {
     16936        ssl->hsType = DYNAMIC_TYPE_ECC;
     16937        ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
     16938        if (ret != 0) {
     16939            goto exit_dpk;
     16940            }
     16941
     16942    #ifndef NO_RSA
     16943        WOLFSSL_MSG("Trying ECC private key, RSA didn't work");
     16944    #else
     16945        WOLFSSL_MSG("Trying ECC private key");
     16946    #endif
     16947
     16948        /* Set start of data to beginning of buffer. */
     16949        idx = 0;
     16950        /* Decode the key assuming it is an ECC private key. */
     16951        ret = wc_EccPrivateKeyDecode(ssl->buffers.key->buffer, &idx,
     16952                                     (ecc_key*)ssl->hsKey,
     16953                                     ssl->buffers.key->length);
     16954        if (ret == 0) {
     16955            WOLFSSL_MSG("Using ECC private key");
     16956
     16957            /* Check it meets the minimum ECC key size requirements. */
     16958            keySz = wc_ecc_size((ecc_key*)ssl->hsKey);
     16959            if (keySz < ssl->options.minEccKeySz) {
     16960                WOLFSSL_MSG("ECC key size too small");
     16961                ERROR_OUT(ECC_KEY_SIZE_E, exit_dpk);
     16962            }
     16963
     16964            /* Return the maximum signature length. */
     16965            *length = (word16)wc_ecc_sig_size((ecc_key*)ssl->hsKey);
     16966
     16967            goto exit_dpk;
     16968            }
     16969        }
     16970#endif
     16971#ifdef HAVE_ED25519
     16972    #if !defined(NO_RSA) || defined(HAVE_ECC)
     16973        FreeKey(ssl, ssl->hsType, (void**)&ssl->hsKey);
     16974    #endif
     16975
     16976    if (ssl->buffers.keyType == ed25519_sa_algo || ssl->buffers.keyType == 0) {
     16977        ssl->hsType = DYNAMIC_TYPE_ED25519;
     16978        ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
     16979        if (ret != 0) {
     16980            goto exit_dpk;
     16981    }
     16982
     16983        #ifdef HAVE_ECC
     16984            WOLFSSL_MSG("Trying ED25519 private key, ECC didn't work");
     16985        #elif !defined(NO_RSA)
     16986            WOLFSSL_MSG("Trying ED25519 private key, RSA didn't work");
     16987        #else
     16988            WOLFSSL_MSG("Trying ED25519 private key");
     16989        #endif
     16990
     16991        /* Set start of data to beginning of buffer. */
     16992        idx = 0;
     16993        /* Decode the key assuming it is an ED25519 private key. */
     16994        ret = wc_Ed25519PrivateKeyDecode(ssl->buffers.key->buffer, &idx,
     16995                                         (ed25519_key*)ssl->hsKey,
     16996                                         ssl->buffers.key->length);
     16997        if (ret == 0) {
     16998            WOLFSSL_MSG("Using ED25519 private key");
     16999
     17000            /* Check it meets the minimum ECC key size requirements. */
     17001            if (ED25519_KEY_SIZE < ssl->options.minEccKeySz) {
     17002                WOLFSSL_MSG("ED25519 key size too small");
     17003                ERROR_OUT(ECC_KEY_SIZE_E, exit_dpk);
     17004    }
     17005
     17006            /* Return the maximum signature length. */
     17007            *length = ED25519_SIG_SIZE;
     17008
     17009            goto exit_dpk;
     17010        }
     17011    }
     17012#endif /* HAVE_ED25519 */
     17013
     17014    (void)idx;
     17015    (void)keySz;
     17016    (void)length;
     17017exit_dpk:
     17018    return ret;
     17019}
     17020
     17021#endif /* WOLFSSL_TLS13 || !NO_WOLFSSL_CLIENT */
    1627917022
    1628017023/* client only parts */
    1628117024#ifndef NO_WOLFSSL_CLIENT
    1628217025
     17026#ifndef WOLFSSL_NO_TLS12
     17027
     17028    /* handle generation of client_hello (1) */
    1628317029    int SendClientHello(WOLFSSL* ssl)
    1628417030    {
    … …  
    1629217038        word16             extSz = 0;
    1629317039
    16294 
    1629517040#ifdef WOLFSSL_TLS13
    1629617041        if (IsAtLeastTLSv1_3(ssl->version))
    … …  
    1629817043#endif
    1629917044
     17045        WOLFSSL_START(WC_FUNC_CLIENT_HELLO_SEND);
     17046        WOLFSSL_ENTER("SendClientHello");
     17047
    1630017048        if (ssl->suites == NULL) {
    1630117049            WOLFSSL_MSG("Bad suites pointer in SendClientHello");
    … …  
    1631217060
    1631317061            ret = TLSX_UseSessionTicket(&ssl->extensions, ticket, ssl->heap);
    16314             if (ret != WOLFSSL_SUCCESS) return ret;
     17062            if (ret != WOLFSSL_SUCCESS) {
     17063                TLSX_SessionTicket_Free(ticket, ssl->heap);
     17064                return ret;
     17065            }
    1631517066
    1631617067            idSz = 0;
    … …  
    1633017081            return MEMORY_E;
    1633117082    #endif
    16332         extSz = TLSX_GetRequestSize(ssl, client_hello);
    16333         if (extSz != 0)
     17083        extSz = 0;
     17084        ret = TLSX_GetRequestSize(ssl, client_hello, &extSz);
     17085        if (ret != 0)
     17086            return ret;
    1633417087            length += extSz;
    1633517088#else
    … …  
    1642717180
    1642817181#ifdef HAVE_TLS_EXTENSIONS
    16429         idx += TLSX_WriteRequest(ssl, output + idx, client_hello);
     17182        extSz = 0;
     17183        ret = TLSX_WriteRequest(ssl, output + idx, client_hello, &extSz);
     17184        if (ret != 0)
     17185            return ret;
     17186        idx += extSz;
    1643017187
    1643117188        (void)idx; /* suppress analyzer warning, keep idx current */
    … …  
    1648117238        } else {
    1648217239            #ifdef WOLFSSL_DTLS
     17240                if (IsDtlsNotSctpMode(ssl)) {
     17241                    if ((ret = DtlsMsgPoolSave(ssl, output, sendSz)) != 0)
     17242                        return ret;
     17243                }
    1648317244                if (ssl->options.dtls)
    1648417245                    DtlsSEQIncrement(ssl, CUR_ORDER);
    … …  
    1648917250        }
    1649017251
    16491         #ifdef WOLFSSL_DTLS
    16492             if (IsDtlsNotSctpMode(ssl)) {
    16493                 if ((ret = DtlsMsgPoolSave(ssl, output, sendSz)) != 0)
    16494                     return ret;
    16495             }
    16496         #endif
    16497 
    1649817252        ssl->options.clientState = CLIENT_HELLO_COMPLETE;
    16499 
    16500 #ifdef WOLFSSL_CALLBACKS
    16501         if (ssl->hsInfoOn) AddPacketName("ClientHello", &ssl->handShakeInfo);
     17253#ifdef OPENSSL_EXTRA
     17254        ssl->cbmode = SSL_CB_MODE_WRITE;
     17255                if (ssl->CBIS != NULL)
     17256                        ssl->CBIS(ssl, SSL_CB_CONNECT_LOOP, SSL_SUCCESS);
     17257#endif
     17258
     17259#if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
     17260        if (ssl->hsInfoOn) AddPacketName(ssl, "ClientHello");
    1650217261        if (ssl->toInfoOn)
    16503             AddPacketInfo("ClientHello", &ssl->timeoutInfo, output, sendSz,
    16504                           ssl->heap);
     17262            AddPacketInfo(ssl, "ClientHello", handshake, output, sendSz,
     17263                          WRITE_PROTO, ssl->heap);
    1650517264#endif
    1650617265
    1650717266        ssl->buffers.outputBuffer.length += sendSz;
    1650817267
    16509         return SendBuffered(ssl);
    16510     }
    16511 
    16512 
     17268        ret = SendBuffered(ssl);
     17269
     17270        WOLFSSL_LEAVE("SendClientHello", ret);
     17271        WOLFSSL_END(WC_FUNC_CLIENT_HELLO_SEND);
     17272
     17273        return ret;
     17274    }
     17275
     17276
     17277    /* handle processing of DTLS hello_verify_request (3) */
    1651317278    static int DoHelloVerifyRequest(WOLFSSL* ssl, const byte* input,
    1651417279                                    word32* inOutIdx, word32 size)
    … …  
    1651917284
    1652017285#ifdef WOLFSSL_CALLBACKS
    16521         if (ssl->hsInfoOn) AddPacketName("HelloVerifyRequest",
    16522                                          &ssl->handShakeInfo);
     17286        if (ssl->hsInfoOn) AddPacketName(ssl, "HelloVerifyRequest");
    1652317287        if (ssl->toInfoOn) AddLateName("HelloVerifyRequest", &ssl->timeoutInfo);
    1652417288#endif
    … …  
    1656017324
    1656117325
    16562     static INLINE int DSH_CheckSessionId(WOLFSSL* ssl)
     17326    static WC_INLINE int DSH_CheckSessionId(WOLFSSL* ssl)
    1656317327    {
    1656417328        int ret = 0;
    … …  
    1659217356    int CheckVersion(WOLFSSL *ssl, ProtocolVersion pv)
    1659317357    {
    16594 #ifdef WOLFSSL_TLS13
    16595         /* TODO: [TLS13] Remove this.
    16596          * Translate the draft TLS v1.3 version to final version.
    16597          */
     17358    #ifdef WOLFSSL_TLS13_DRAFT
    1659817359        if (pv.major == TLS_DRAFT_MAJOR) {
    1659917360            pv.major = SSLv3_MAJOR;
    … …  
    1660217363#endif
    1660317364
    16604         /* Check for upgrade attack. */
     17365        #ifdef OPENSSL_EXTRA
     17366        if (ssl->CBIS != NULL) {
     17367            ssl->CBIS(ssl, SSL_CB_HANDSHAKE_START, SSL_SUCCESS);
     17368        }
     17369        #endif
     17370
    1660517371        if (pv.minor > ssl->version.minor) {
    1660617372            WOLFSSL_MSG("Server using higher version, fatal error");
    … …  
    1669217458    }
    1669317459
     17460    /* handle processing of server_hello (2) */
    1669417461    int DoServerHello(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
    1669517462                      word32 helloSz)
    … …  
    1670317470        int             ret;
    1670417471
     17472        WOLFSSL_START(WC_FUNC_SERVER_HELLO_DO);
     17473        WOLFSSL_ENTER("DoServerHello");
     17474
    1670517475#ifdef WOLFSSL_CALLBACKS
    16706         if (ssl->hsInfoOn) AddPacketName("ServerHello", &ssl->handShakeInfo);
     17476        if (ssl->hsInfoOn) AddPacketName(ssl, "ServerHello");
    1670717477        if (ssl->toInfoOn) AddLateName("ServerHello", &ssl->timeoutInfo);
    1670817478#endif
    … …  
    1672117491
    1672217492#ifdef WOLFSSL_TLS13
    16723         if (IsAtLeastTLSv1_3(pv))
    16724             return DoTls13ServerHello(ssl, input, inOutIdx, helloSz);
     17493        if (IsAtLeastTLSv1_3(pv)) {
     17494            byte type = server_hello;
     17495            return DoTls13ServerHello(ssl, input, inOutIdx, helloSz, &type);
     17496        }
    1672517497#endif
    1672617498
    … …  
    1672817500        XMEMCPY(ssl->arrays->serverRandom, input + i, RAN_LEN);
    1672917501        i += RAN_LEN;
    16730 
    16731 #ifdef WOLFSSL_TLS13
    16732         if (IsAtLeastTLSv1_3(ssl->ctx->method->version)) {
    16733             /* TLS v1.3 capable client not allowed to downgrade when connecting
    16734              * to TLS v1.3 capable server.
    16735              */
    16736             if (XMEMCMP(input + i - (TLS13_DOWNGRADE_SZ + 1),
    16737                              tls13Downgrade, TLS13_DOWNGRADE_SZ) == 0 &&
    16738                              (*(input + i - 1) == 0 || *(input + i - 1) == 1)) {
    16739                 SendAlert(ssl, alert_fatal, illegal_parameter);
    16740                 return VERSION_ERROR;
    16741             }
    16742         }
    16743         else
    16744 #endif
    16745         if (ssl->ctx->method->version.major == SSLv3_MAJOR &&
    16746                              ssl->ctx->method->version.minor == TLSv1_2_MINOR) {
    16747             /* TLS v1.2 capable client not allowed to downgrade when connecting
    16748              * to TLS v1.2 capable server.
    16749              */
    16750             if (XMEMCMP(input + i - (TLS13_DOWNGRADE_SZ + 1),
    16751                         tls13Downgrade, TLS13_DOWNGRADE_SZ) == 0 &&
    16752                                                         *(input + i - 1) == 0) {
    16753                 SendAlert(ssl, alert_fatal, illegal_parameter);
    16754                 return VERSION_ERROR;
    16755             }
    16756         }
    1675717502
    1675817503        /* session id */
    … …  
    1682317568                    return BUFFER_ERROR;
    1682417569
    16825                 if ((ret = TLSX_Parse(ssl, (byte *) input + i,
    16826                                                           totalExtSz, 0, NULL)))
     17570                if ((ret = TLSX_Parse(ssl, (byte *) input + i, totalExtSz,
     17571                                                           server_hello, NULL)))
    1682717572                    return ret;
    1682817573
    … …  
    1691217657#endif /* HAVE_SECRET_CALLBACK */
    1691317658
    16914         if (ssl->options.resuming) {
     17659        ret = CompleteServerHello(ssl);
     17660
     17661        WOLFSSL_LEAVE("DoServerHello", ret);
     17662        WOLFSSL_END(WC_FUNC_SERVER_HELLO_DO);
     17663
     17664        return ret;
     17665    }
     17666
     17667    int CompleteServerHello(WOLFSSL* ssl)
     17668    {
     17669        int ret;
     17670
     17671        if (!ssl->options.resuming) {
     17672            byte* down = ssl->arrays->serverRandom + RAN_LEN -
     17673                                                         TLS13_DOWNGRADE_SZ - 1;
     17674            byte  vers = ssl->arrays->serverRandom[RAN_LEN - 1];
     17675    #ifdef WOLFSSL_TLS13
     17676            if (IsAtLeastTLSv1_3(ssl->ctx->method->version)) {
     17677                /* TLS v1.3 capable client not allowed to downgrade when
     17678                 * connecting to TLS v1.3 capable server unless cipher suite
     17679                 * demands it.
     17680                 */
     17681                if (XMEMCMP(down, tls13Downgrade, TLS13_DOWNGRADE_SZ) == 0 &&
     17682                                                     (vers == 0 || vers == 1)) {
     17683                    SendAlert(ssl, alert_fatal, illegal_parameter);
     17684                    return VERSION_ERROR;
     17685                }
     17686            }
     17687            else
     17688    #endif
     17689            if (ssl->ctx->method->version.major == SSLv3_MAJOR &&
     17690                             ssl->ctx->method->version.minor == TLSv1_2_MINOR) {
     17691                /* TLS v1.2 capable client not allowed to downgrade when
     17692                 * connecting to TLS v1.2 capable server.
     17693                 */
     17694                if (XMEMCMP(down, tls13Downgrade, TLS13_DOWNGRADE_SZ) == 0 &&
     17695                                                                    vers == 0) {
     17696                    SendAlert(ssl, alert_fatal, illegal_parameter);
     17697                    return VERSION_ERROR;
     17698                }
     17699            }
     17700        }
     17701        else {
    1691517702            if (DSH_CheckSessionId(ssl)) {
    1691617703                if (SetCipherSpecs(ssl) == 0) {
    … …  
    1695217739    }
    1695317740
     17741#endif /* WOLFSSL_NO_TLS12 */
     17742
    1695417743
    1695517744    /* Make sure client setup is valid for this suite, true on success */
    … …  
    1697717766    }
    1697817767
     17768#ifndef WOLFSSL_NO_TLS12
    1697917769
    1698017770#ifndef NO_CERTS
    16981     /* just read in and ignore for now TODO: */
     17771    /* handle processing of certificate_request (13) */
    1698217772    static int DoCertificateRequest(WOLFSSL* ssl, const byte* input, word32*
    1698317773                                    inOutIdx, word32 size)
    … …  
    1698617776        word32 begin = *inOutIdx;
    1698717777
     17778        WOLFSSL_START(WC_FUNC_CERTIFICATE_REQUEST_DO);
     17779        WOLFSSL_ENTER("DoCertificateRequest");
     17780
    1698817781        #ifdef WOLFSSL_CALLBACKS
    1698917782            if (ssl->hsInfoOn)
    16990                 AddPacketName("CertificateRequest", &ssl->handShakeInfo);
     17783                AddPacketName(ssl, "CertificateRequest");
    1699117784            if (ssl->toInfoOn)
    1699217785                AddLateName("CertificateRequest", &ssl->timeoutInfo);
    … …  
    1705217845        /* don't send client cert or cert verify if user hasn't provided
    1705317846           cert and private key */
    17054         if (ssl->buffers.certificate && ssl->buffers.certificate->buffer &&
    17055             ssl->buffers.key && ssl->buffers.key->buffer)
     17847        if (ssl->buffers.certificate && ssl->buffers.certificate->buffer) {
     17848        #ifdef HAVE_PK_CALLBACKS
     17849            if (wolfSSL_CTX_IsPrivatePkSet(ssl->ctx)) {
     17850                WOLFSSL_MSG("Using PK for client private key");
     17851                ssl->options.sendVerify = SEND_CERT;
     17852            }
     17853        #endif
     17854            if (ssl->buffers.key && ssl->buffers.key->buffer) {
    1705617855            ssl->options.sendVerify = SEND_CERT;
     17856            }
     17857        }
     17858        #ifdef OPENSSL_EXTRA
     17859                else
     17860        #else
    1705717861        else if (IsTLS(ssl))
     17862        #endif
     17863        {
    1705817864            ssl->options.sendVerify = SEND_BLANK_CERT;
     17865        }
    1705917866
    1706017867        if (IsEncryptionOn(ssl, 0))
    1706117868            *inOutIdx += ssl->keys.padSz;
    1706217869
     17870        WOLFSSL_LEAVE("DoCertificateRequest", 0);
     17871        WOLFSSL_END(WC_FUNC_CERTIFICATE_REQUEST_DO);
     17872
    1706317873        return 0;
    1706417874    }
    … …  
    1706617876
    1706717877
    17068 #ifdef HAVE_ECC
     17878#if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
    1706917879
    1707017880    static int CheckCurveId(int tlsCurveId)
    … …  
    1714317953typedef struct DskeArgs {
    1714417954    byte*  output; /* not allocated */
    17145 #if !defined(NO_DH) || defined(HAVE_ECC)
     17955#if !defined(NO_DH) || defined(HAVE_ECC) || defined(HAVE_ED25519)
    1714617956    byte*  verifySig;
    1714717957#endif
    1714817958    word32 idx;
    1714917959    word32 begin;
    17150 #if !defined(NO_DH) || defined(HAVE_ECC)
     17960#if !defined(NO_DH) || defined(HAVE_ECC) || defined(HAVE_ED25519)
    1715117961    word16 verifySigSz;
    1715217962#endif
    … …  
    1716317973    (void)args;
    1716417974
    17165 #if !defined(NO_DH) || defined(HAVE_ECC)
     17975#if !defined(NO_DH) || defined(HAVE_ECC) || defined(HAVE_ED25519)
    1716617976    if (args->verifySig) {
    1716717977        XFREE(args->verifySig, ssl->heap, DYNAMIC_TYPE_SIGNATURE);
    … …  
    1717117981}
    1717217982
     17983/* handle processing of server_key_exchange (12) */
    1717317984static int DoServerKeyExchange(WOLFSSL* ssl, const byte* input,
    1717417985                               word32* inOutIdx, word32 size)
    … …  
    1718317994#endif
    1718417995
     17996    (void)input;
     17997    (void)size;
     17998
     17999    WOLFSSL_START(WC_FUNC_SERVER_KEY_EXCHANGE_DO);
    1718518000    WOLFSSL_ENTER("DoServerKeyExchange");
    1718618001
    … …  
    1721418029        #ifdef WOLFSSL_CALLBACKS
    1721518030            if (ssl->hsInfoOn)
    17216                 AddPacketName("ServerKeyExchange", &ssl->handShakeInfo);
     18031                AddPacketName(ssl, "ServerKeyExchange");
    1721718032            if (ssl->toInfoOn)
    1721818033                AddLateName("ServerKeyExchange", &ssl->timeoutInfo);
    … …  
    1726918084                        ERROR_OUT(DH_KEY_SIZE_E, exit_dske);
    1727018085                    }
     18086                    if (length > ssl->options.maxDhKeySz) {
     18087                        WOLFSSL_MSG("Server using a DH key that is too big");
     18088                        SendAlert(ssl, alert_fatal, handshake_failure);
     18089                        ERROR_OUT(DH_KEY_SIZE_E, exit_dske);
     18090                    }
    1727118091
    1727218092                    ssl->buffers.serverDH_P.buffer =
    … …  
    1731018130                    args->idx += length;
    1731118131
     18132                    ssl->buffers.weOwnDH = 1;
     18133
    1731218134                    /* pub */
    1731318135                    if ((args->idx - args->begin) + OPAQUE16_LEN > size) {
    … …  
    1733718159                }
    1733818160            #endif /* !NO_DH */
    17339             #ifdef HAVE_ECC
     18161            #if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
    1734018162                case ecc_diffie_hellman_kea:
    1734118163                {
    1734218164                    byte b;
    17343                     int curveId, curveOid;
     18165                #ifdef HAVE_ECC
     18166                    int curveId;
     18167                #endif
     18168                    int curveOid;
    1734418169                    word16 length;
    1734518170
    … …  
    1737418199                                goto exit_dske;
    1737518200                            }
    17376                         } else if (ssl->peerEccKeyPresent) {
     18201                        } else if (ssl->peerX25519KeyPresent) {
    1737718202                            ret = ReuseKey(ssl, DYNAMIC_TYPE_CURVE25519,
    1737818203                                           ssl->peerX25519Key);
    … …  
    1739418219                    }
    1739518220             #endif
     18221                #ifdef HAVE_ECC
    1739618222                    if (ssl->peerEccKey == NULL) {
    1739718223                        ret = AllocKey(ssl, DYNAMIC_TYPE_ECC,
    … …  
    1741718243                    ssl->peerEccKeyPresent = 1;
    1741818244                    break;
     18245                #endif
    1741918246                }
    17420             #endif /* HAVE_ECC */
     18247            #endif /* HAVE_ECC || HAVE_CURVE25519 */
    1742118248            #if !defined(NO_DH) && !defined(NO_PSK)
    1742218249                case dhe_psk_kea:
    … …  
    1745718284                    if (length < ssl->options.minDhKeySz) {
    1745818285                        WOLFSSL_MSG("Server using a DH key that is too small");
     18286                        SendAlert(ssl, alert_fatal, handshake_failure);
     18287                        ERROR_OUT(DH_KEY_SIZE_E, exit_dske);
     18288                    }
     18289                    if (length > ssl->options.maxDhKeySz) {
     18290                        WOLFSSL_MSG("Server using a DH key that is too big");
    1745918291                        SendAlert(ssl, alert_fatal, handshake_failure);
    1746018292                        ERROR_OUT(DH_KEY_SIZE_E, exit_dske);
    … …  
    1750118333                    args->idx += length;
    1750218334
     18335                    ssl->buffers.weOwnDH = 1;
     18336
    1750318337                    /* pub */
    1750418338                    if ((args->idx - args->begin) + OPAQUE16_LEN > size) {
    … …  
    1752818362                }
    1752918363            #endif /* !NO_DH || !NO_PSK */
    17530             #if defined(HAVE_ECC) && !defined(NO_PSK)
     18364            #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     18365                                                                !defined(NO_PSK)
    1753118366                case ecdhe_psk_kea:
    1753218367                {
    … …  
    1760718442
    1760818443                    if (ssl->peerEccKey == NULL) {
    17609                         AllocKey(ssl, DYNAMIC_TYPE_ECC,
     18444                        ret = AllocKey(ssl, DYNAMIC_TYPE_ECC,
    1761018445                                 (void**)&ssl->peerEccKey);
    1761118446                        if (ret != 0) {
    … …  
    1763018465                    break;
    1763118466                }
    17632             #endif /* HAVE_ECC || !NO_PSK */
     18467            #endif /* (HAVE_ECC || HAVE_CURVE25519) && !NO_PSK */
    1763318468                default:
    1763418469                    ret = BAD_KEA_TYPE_E;
    … …  
    1766018495                case ecc_diffie_hellman_kea:
    1766118496                {
    17662             #if defined(NO_DH) && !defined(HAVE_ECC)
     18497            #if defined(NO_DH) && !defined(HAVE_ECC) && !defined(HAVE_ED25519)
    1766318498                    ERROR_OUT(NOT_COMPILED_IN, exit_dske);
    1766418499            #else
    … …  
    1772918564
    1773018565                    if (args->sigAlgo != ed25519_sa_algo) {
     18566                        int digest_sz = wc_HashGetDigestSize(hashType);
     18567                        if (digest_sz <= 0) {
     18568                            ERROR_OUT(BUFFER_ERROR, exit_dske);
     18569                        }
     18570                        ssl->buffers.digest.length = (unsigned int)digest_sz;
     18571
    1773118572                        /* buffer for hash */
    17732                         ssl->buffers.digest.length =
    17733                                                  wc_HashGetDigestSize(hashType);
    1773418573                        ssl->buffers.digest.buffer = (byte*)XMALLOC(
    1773518574                            ssl->buffers.digest.length, ssl->heap,
    … …  
    1777318612                        }
    1777418613                    #endif /* HAVE_ECC */
    17775                     #ifdef HAVE_ED25519
     18614                    #if defined(HAVE_ED25519)
    1777618615                        case ed25519_sa_algo:
    1777718616                        {
    … …  
    1778118620                            break;
    1778218621                        }
    17783                     #endif /* HAVE_ECC */
     18622                    #endif /* HAVE_ED25519 */
    1778418623
    1778518624                    default:
    … …  
    1778718626                    } /* switch (args->sigAlgo) */
    1778818627
    17789             #endif /* NO_DH && !HAVE_ECC */
     18628            #endif /* NO_DH && !HAVE_ECC && !HAVE_ED25519 */
    1779018629                    break;
    1779118630                }
    … …  
    1781918658                case ecc_diffie_hellman_kea:
    1782018659                {
    17821             #if defined(NO_DH) && !defined(HAVE_ECC)
     18660            #if defined(NO_DH) && !defined(HAVE_ECC) && !defined(HAVE_ED25519)
    1782218661                    ERROR_OUT(NOT_COMPILED_IN, exit_dske);
    1782318662            #else
    … …  
    1785018689                                ssl->peerRsaKey,
    1785118690                            #ifdef HAVE_PK_CALLBACKS
    17852                                 ssl->buffers.peerRsaKey.buffer,
    17853                                 ssl->buffers.peerRsaKey.length,
    17854                                 ssl->RsaVerifyCtx
     18691                                &ssl->buffers.peerRsaKey
    1785518692                            #else
    17856                                 NULL, 0, NULL
     18693                                NULL
    1785718694                            #endif
    1785818695                            );
    … …  
    1786118698                                args->sigSz = (word16)ret;
    1786218699                                ret = 0;
     18700                            }
     18701                        #ifdef WOLFSSL_ASYNC_CRYPT
     18702                            if (ret != WC_PENDING_E)
     18703                        #endif
     18704                            {
     18705                                /* peerRsaKey */
     18706                                FreeKey(ssl, DYNAMIC_TYPE_RSA,
     18707                                                      (void**)&ssl->peerRsaKey);
     18708                                ssl->peerRsaKeyPresent = 0;
    1786318709                            }
    1786418710                            break;
    … …  
    1787418720                                ssl->peerEccDsaKey,
    1787518721                            #ifdef HAVE_PK_CALLBACKS
    17876                                 ssl->buffers.peerEccDsaKey.buffer,
    17877                                 ssl->buffers.peerEccDsaKey.length,
    17878                                 ssl->EccVerifyCtx
     18722                                &ssl->buffers.peerEccDsaKey
    1787918723                            #else
    17880                                 NULL, 0, NULL
     18724                                NULL
    1788118725                            #endif
    1788218726                            );
    1788318727
     18728                        #ifdef WOLFSSL_ASYNC_CRYPT
     18729                            if (ret != WC_PENDING_E)
     18730                        #endif
     18731                            {
     18732                                /* peerEccDsaKey */
     18733                                FreeKey(ssl, DYNAMIC_TYPE_ECC,
     18734                                                   (void**)&ssl->peerEccDsaKey);
     18735                                ssl->peerEccDsaKeyPresent = 0;
     18736                            }
    1788418737                            break;
    1788518738                        }
    1788618739                    #endif /* HAVE_ECC */
    17887                     #ifdef HAVE_ED25519
     18740                    #if defined(HAVE_ED25519)
    1788818741                        case ed25519_sa_algo:
    1788918742                        {
    … …  
    1789418747                                ssl->peerEd25519Key,
    1789518748                            #ifdef HAVE_PK_CALLBACKS
    17896                                 ssl->buffers.peerEccDsaKey.buffer,
    17897                                 ssl->buffers.peerEccDsaKey.length,
    17898                                 ssl->Ed25519VerifyCtx
     18749                                &ssl->buffers.peerEd25519Key
    1789918750                            #else
    17900                                 NULL, 0, NULL
     18751                                NULL
    1790118752                            #endif
    1790218753                            );
    1790318754
     18755                        #ifdef WOLFSSL_ASYNC_CRYPT
     18756                            if (ret != WC_PENDING_E)
     18757                        #endif
     18758                            {
     18759                                /* peerEccDsaKey */
     18760                                FreeKey(ssl, DYNAMIC_TYPE_ED25519,
     18761                                                  (void**)&ssl->peerEd25519Key);
     18762                                ssl->peerEd25519KeyPresent = 0;
     18763                            }
    1790418764                            break;
    1790518765                        }
    17906                     #endif /* HAVE_ECC */
     18766                    #endif /* HAVE_ED25519 */
    1790718767
    1790818768                    default:
    1790918769                        ret = ALGO_ID_E;
    1791018770                    } /* switch (sigAlgo) */
    17911             #endif /* NO_DH && !HAVE_ECC */
     18771            #endif /* NO_DH && !HAVE_ECC && !HAVE_ED25519 */
    1791218772                    break;
    1791318773                }
    … …  
    1794118801                case ecc_diffie_hellman_kea:
    1794218802                {
    17943             #if defined(NO_DH) && !defined(HAVE_ECC)
     18803            #if defined(NO_DH) && !defined(HAVE_ECC) && !defined(HAVE_ED25519)
    1794418804                    ERROR_OUT(NOT_COMPILED_IN, exit_dske);
    1794518805            #else
    … …  
    1801418874                            break;
    1801518875                    #endif /* HAVE_ECC */
    18016                     #ifdef HAVE_ED25519
     18876                    #if defined(HAVE_ED25519)
    1801718877                        case ed25519_sa_algo:
    1801818878                            /* Nothing to do in this algo */
    1801918879                            break;
    18020                     #endif /* HAVE_ECC */
     18880                    #endif /* HAVE_ED25519 */
    1802118881                        default:
    1802218882                            ret = ALGO_ID_E;
    1802318883                    } /* switch (sigAlgo) */
    18024             #endif /* NO_DH && !HAVE_ECC */
     18884            #endif /* NO_DH && !HAVE_ECC && !HAVE_ED25519 */
    1802518885                    break;
    1802618886                }
    … …  
    1809118951
    1809218952    WOLFSSL_LEAVE("DoServerKeyExchange", ret);
     18953    WOLFSSL_END(WC_FUNC_SERVER_KEY_EXCHANGE_DO);
    1809318954
    1809418955#ifdef WOLFSSL_ASYNC_CRYPT
    1809518956    /* Handle async operation */
    1809618957    if (ret == WC_PENDING_E) {
    18097         /* Mark message as not recevied so it can process again */
     18958        /* Mark message as not received so it can process again */
    1809818959        ssl->msgsReceived.got_server_key_exchange = 0;
    1809918960
    … …  
    1851819379}
    1851919380
     19381/* handle generation client_key_exchange (16) */
    1852019382int SendClientKeyExchange(WOLFSSL* ssl)
    1852119383{
    … …  
    1852919391#endif
    1853019392
     19393    WOLFSSL_START(WC_FUNC_CLIENT_KEY_EXCHANGE_SEND);
    1853119394    WOLFSSL_ENTER("SendClientKeyExchange");
     19395
     19396#ifdef OPENSSL_EXTRA
     19397        ssl->options.clientState = CLIENT_KEYEXCHANGE_COMPLETE;
     19398        ssl->cbmode = SSL_CB_MODE_WRITE;
     19399        if (ssl->CBIS != NULL)
     19400                ssl->CBIS(ssl, SSL_CB_CONNECT_LOOP, SSL_SUCCESS);
     19401#endif
    1853219402
    1853319403#ifdef WOLFSSL_ASYNC_CRYPT
    … …  
    1859619466                    break;
    1859719467            #endif /* !NO_DH && !NO_PSK */
    18598             #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && !defined(NO_PSK)
     19468            #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     19469                                                                !defined(NO_PSK)
    1859919470                case ecdhe_psk_kea:
    1860019471                    /* sanity check that PSK client callback has been set */
    … …  
    1864319514                #endif
    1864419515
    18645                     /* create private key */
     19516                    /* create ephemeral private key */
    1864619517                    ssl->hsType = DYNAMIC_TYPE_ECC;
    1864719518                    ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
    … …  
    1870219573                #ifdef HAVE_ECC
    1870319574                    if (ssl->specs.static_ecdh) {
    18704                         /* TODO: EccDsa is really fixed Ecc change naming */
    18705                         if (!ssl->peerEccDsaKey ||
    18706                                 !ssl->peerEccDsaKeyPresent ||
     19575                        /* Note: EccDsa is really fixed Ecc key here */
     19576                        if (!ssl->peerEccDsaKey || !ssl->peerEccDsaKeyPresent ||
    1870719577                                    !ssl->peerEccDsaKey->dp) {
    1870819578                            ERROR_OUT(NO_PEER_KEY, exit_scke);
    … …  
    1872119591                    }
    1872219592
    18723                     /* create private key */
     19593                    /* create ephemeral private key */
    1872419594                    ssl->hsType = DYNAMIC_TYPE_ECC;
    1872519595                    ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
    … …  
    1875719627                ERROR_OUT(MEMORY_E, exit_scke);
    1875819628            }
     19629            if (ssl->arrays->preMasterSecret == NULL) {
     19630                ssl->arrays->preMasterSecret = (byte*)XMALLOC(ENCRYPT_LEN,
     19631                                                ssl->heap, DYNAMIC_TYPE_SECRET);
     19632                if (ssl->arrays->preMasterSecret == NULL) {
     19633                    ERROR_OUT(MEMORY_E, exit_scke);
     19634                }
     19635                XMEMSET(ssl->arrays->preMasterSecret, 0, ENCRYPT_LEN);
     19636            }
    1875919637
    1876019638            switch(ssl->specs.kea)
    … …  
    1876319641                case rsa_kea:
    1876419642                {
     19643                    /* build PreMasterSecret with RNG data */
    1876519644                    ret = wc_RNG_GenerateBlock(ssl->rng,
    18766                         ssl->arrays->preMasterSecret, SECRET_LEN);
     19645                        &ssl->arrays->preMasterSecret[VERSION_SZ],
     19646                        SECRET_LEN - VERSION_SZ);
    1876719647                    if (ret != 0) {
    1876819648                        goto exit_scke;
    … …  
    1879119671                    }
    1879219672
     19673                    #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \
     19674                        !defined(WOLFSSL_OLD_PRIME_CHECK)
     19675                    if (ssl->options.dhDoKeyTest &&
     19676                        !ssl->options.dhKeyTested)
     19677                    {
     19678                        ret = wc_DhSetCheckKey(ssl->buffers.serverDH_Key,
     19679                            ssl->buffers.serverDH_P.buffer,
     19680                            ssl->buffers.serverDH_P.length,
     19681                            ssl->buffers.serverDH_G.buffer,
     19682                            ssl->buffers.serverDH_G.length,
     19683                            NULL, 0, 0, ssl->rng);
     19684                        if (ret != 0) {
     19685                            goto exit_scke;
     19686                        }
     19687                        ssl->options.dhKeyTested = 1;
     19688                    }
     19689                    else
     19690                    #endif
     19691                    {
    1879319692                    ret = wc_DhSetKey(ssl->buffers.serverDH_Key,
    1879419693                        ssl->buffers.serverDH_P.buffer,
    … …  
    1879819697                    if (ret != 0) {
    1879919698                        goto exit_scke;
     19699                    }
    1880019700                    }
    1880119701
    … …  
    1888619786                    }
    1888719787
     19788                    #if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && \
     19789                        !defined(WOLFSSL_OLD_PRIME_CHECK)
     19790                    if (ssl->options.dhDoKeyTest &&
     19791                        !ssl->options.dhKeyTested)
     19792                    {
     19793                        ret = wc_DhSetCheckKey(ssl->buffers.serverDH_Key,
     19794                            ssl->buffers.serverDH_P.buffer,
     19795                            ssl->buffers.serverDH_P.length,
     19796                            ssl->buffers.serverDH_G.buffer,
     19797                            ssl->buffers.serverDH_G.length,
     19798                            NULL, 0, 0, ssl->rng);
     19799                        if (ret != 0) {
     19800                            goto exit_scke;
     19801                        }
     19802                        ssl->options.dhKeyTested = 1;
     19803                    }
     19804                    else
     19805                    #endif
     19806                    {
    1888819807                    ret = wc_DhSetKey(ssl->buffers.serverDH_Key,
    1888919808                        ssl->buffers.serverDH_P.buffer,
    … …  
    1889419813                        goto exit_scke;
    1889519814                    }
     19815                    }
    1889619816
    1889719817                    /* for DH, encSecret is Yc, agree is pre-master */
    … …  
    1890219822                }
    1890319823            #endif /* !NO_DH && !NO_PSK */
    18904             #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && !defined(NO_PSK)
     19824            #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     19825                                                                !defined(NO_PSK)
    1890519826                case ecdhe_psk_kea:
    1890619827                {
    … …  
    1897219893                    break;
    1897319894                }
    18974             #endif /* HAVE_ECC && !NO_PSK */
     19895            #endif /* (HAVE_ECC || HAVE_CURVE25519) && !NO_PSK */
    1897519896            #ifdef HAVE_NTRU
    1897619897                case ntru_kea:
    … …  
    1901219933                    }
    1901319934                #endif
    19014                 #ifdef HAVE_ECC
     19935                #if defined(HAVE_ECC) && defined(HAVE_ECC_KEY_EXPORT)
    1901519936                #ifdef HAVE_PK_CALLBACKS
    1901619937                    /* if callback then use it for shared secret */
    … …  
    1905719978                        ssl->peerRsaKey,
    1905819979                    #if defined(HAVE_PK_CALLBACKS)
    19059                         ssl->buffers.peerRsaKey.buffer,
    19060                         ssl->buffers.peerRsaKey.length,
    19061                         ssl->RsaEncCtx
     19980                        &ssl->buffers.peerRsaKey
    1906219981                    #else
    19063                         NULL, 0, NULL
     19982                        NULL
    1906419983                    #endif
    1906519984                    );
    … …  
    1909820017                }
    1909920018            #endif /* !NO_DH && !NO_PSK */
    19100             #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && !defined(NO_PSK)
     20019            #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     20020                                                                !defined(NO_PSK)
    1910120021                case ecdhe_psk_kea:
    1910220022                {
    … …  
    1910820028                            ssl->arrays->preMasterSecret + OPAQUE16_LEN,
    1910920029                            &ssl->arrays->preMasterSz,
    19110                             WOLFSSL_CLIENT_END,
    19111                         #ifdef HAVE_PK_CALLBACKS
    19112                             ssl->EccSharedSecretCtx
    19113                         #else
    19114                             NULL
     20030                            WOLFSSL_CLIENT_END
     20031                        );
     20032                        if (!ssl->specs.static_ecdh
     20033                        #ifdef WOLFSSL_ASYNC_CRYPT
     20034                            && ret != WC_PENDING_E
    1911520035                        #endif
    19116                         );
     20036                        ) {
     20037                            FreeKey(ssl, DYNAMIC_TYPE_CURVE25519,
     20038                                                   (void**)&ssl->peerX25519Key);
     20039                            ssl->peerX25519KeyPresent = 0;
     20040                        }
    1911720041                        break;
    1911820042                    }
    … …  
    1912320047                        ssl->arrays->preMasterSecret + OPAQUE16_LEN,
    1912420048                        &ssl->arrays->preMasterSz,
    19125                         WOLFSSL_CLIENT_END,
    19126                     #ifdef HAVE_PK_CALLBACKS
    19127                         ssl->EccSharedSecretCtx
    19128                     #else
    19129                         NULL
    19130                     #endif
     20049                        WOLFSSL_CLIENT_END
    1913120050                    );
     20051                #ifdef WOLFSSL_ASYNC_CRYPT
     20052                    if (ret != WC_PENDING_E)
     20053                #endif
     20054                    {
     20055                        FreeKey(ssl, DYNAMIC_TYPE_ECC,
     20056                                                      (void**)&ssl->peerEccKey);
     20057                        ssl->peerEccKeyPresent = 0;
     20058                    }
    1913220059                    break;
    1913320060                }
    … …  
    1917320100                            ssl->arrays->preMasterSecret,
    1917420101                            &ssl->arrays->preMasterSz,
    19175                             WOLFSSL_CLIENT_END,
    19176                         #ifdef HAVE_PK_CALLBACKS
    19177                             ssl->EccSharedSecretCtx
    19178                         #else
    19179                             NULL
     20102                            WOLFSSL_CLIENT_END
     20103                        );
     20104                        if (!ssl->specs.static_ecdh
     20105                        #ifdef WOLFSSL_ASYNC_CRYPT
     20106                            && ret != WC_PENDING_E
    1918020107                        #endif
    19181                         );
     20108                        ) {
     20109                            FreeKey(ssl, DYNAMIC_TYPE_CURVE25519,
     20110                                                   (void**)&ssl->peerX25519Key);
     20111                            ssl->peerX25519KeyPresent = 0;
     20112                        }
    1918220113                        break;
    1918320114                    }
    … …  
    1919220123                        ssl->arrays->preMasterSecret,
    1919320124                        &ssl->arrays->preMasterSz,
    19194                         WOLFSSL_CLIENT_END,
    19195                     #ifdef HAVE_PK_CALLBACKS
    19196                         ssl->EccSharedSecretCtx
    19197                     #else
    19198                         NULL
    19199                     #endif
     20125                        WOLFSSL_CLIENT_END
    1920020126                    );
     20127                    if (!ssl->specs.static_ecdh
     20128                #ifdef WOLFSSL_ASYNC_CRYPT
     20129                        && ret != WC_PENDING_E
     20130                #endif
     20131                    ) {
     20132                        FreeKey(ssl, DYNAMIC_TYPE_ECC,
     20133                                                      (void**)&ssl->peerEccKey);
     20134                        ssl->peerEccKeyPresent = 0;
     20135                    }
    1920120136                #endif
    1920220137
    … …  
    1926920204                }
    1927020205            #endif /* !NO_DH && !NO_PSK */
    19271             #if defined(HAVE_ECC) && !defined(NO_PSK)
     20206            #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     20207                                                                !defined(NO_PSK)
    1927220208                case ecdhe_psk_kea:
    1927320209                {
    … …  
    1928320219                    args->encSz += args->length + OPAQUE8_LEN;
    1928420220
    19285                     /* Create pre master secret is the concatination of
     20221                    /* Create pre master secret is the concatenation of
    1928620222                       eccSize + eccSharedKey + pskSize + pskKey */
    1928720223                    c16toa((word16)ssl->arrays->preMasterSz, pms);
    … …  
    1929920235                    break;
    1930020236                }
    19301             #endif /* HAVE_ECC && !NO_PSK */
     20237            #endif /* (HAVE_ECC || HAVE_CURVE25519) && !NO_PSK */
    1930220238            #ifdef HAVE_NTRU
    1930320239                case ntru_kea:
    … …  
    1930620242                }
    1930720243            #endif /* HAVE_NTRU */
    19308             #ifdef HAVE_ECC
     20244            #if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
    1930920245                case ecc_diffie_hellman_kea:
    1931020246                {
    … …  
    1931420250                    break;
    1931520251                }
    19316             #endif /* HAVE_ECC */
     20252            #endif /* HAVE_ECC || HAVE_CURVE25519 */
    1931720253
    1931820254                default:
    … …  
    1946720403        #endif
    1946820404
    19469         #ifdef WOLFSSL_CALLBACKS
     20405        #if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
    1947020406            if (ssl->hsInfoOn)
    19471                 AddPacketName("ClientKeyExchange", &ssl->handShakeInfo);
     20407                AddPacketName(ssl, "ClientKeyExchange");
    1947220408            if (ssl->toInfoOn)
    19473                 AddPacketInfo("ClientKeyExchange", &ssl->timeoutInfo,
    19474                               args->output, args->sendSz, ssl->heap);
     20409                AddPacketInfo(ssl, "ClientKeyExchange", handshake,
     20410                            args->output, args->sendSz, WRITE_PROTO, ssl->heap);
    1947520411        #endif
    1947620412
    … …  
    1949620432
    1949720433    WOLFSSL_LEAVE("SendClientKeyExchange", ret);
     20434    WOLFSSL_END(WC_FUNC_CLIENT_KEY_EXCHANGE_SEND);
    1949820435
    1949920436#ifdef WOLFSSL_ASYNC_CRYPT
    … …  
    1950420441
    1950520442    /* No further need for PMS */
     20443    if (ssl->arrays->preMasterSecret != NULL) {
    1950620444    ForceZero(ssl->arrays->preMasterSecret, ssl->arrays->preMasterSz);
     20445    }
    1950720446    ssl->arrays->preMasterSz = 0;
    1950820447
    … …  
    1951420453}
    1951520454
     20455#endif /* !WOLFSSL_NO_TLS12 */
    1951620456
    1951720457#ifndef NO_CERTS
    19518 /* Decode the private key - RSA, ECC, or Ed25519 - and creates a key object.
    19519  * The signature type is set as well.
    19520  * The maximum length of a signature is returned.
    19521  *
    19522  * ssl     The SSL/TLS object.
    19523  * length  The length of a signature.
    19524  * returns 0 on success, otherwise failure.
    19525  */
    19526 int DecodePrivateKey(WOLFSSL *ssl, word16* length)
    19527 {
    19528     int      ret;
    19529     int      keySz;
    19530     word32   idx;
    19531 
    19532     /* make sure private key exists */
    19533     if (ssl->buffers.key == NULL || ssl->buffers.key->buffer == NULL) {
    19534         WOLFSSL_MSG("Private key missing!");
    19535         ERROR_OUT(NO_PRIVATE_KEY, exit_dpk);
    19536     }
    19537 
     20458
     20459#ifdef HAVE_PK_CALLBACKS
     20460    int GetPrivateKeySigSize(WOLFSSL* ssl)
     20461    {
     20462        int sigSz = 0;
     20463
     20464        if (ssl == NULL)
     20465            return 0;
     20466
     20467        switch (ssl->buffers.keyType) {
    1953820468#ifndef NO_RSA
    19539     ssl->hsType = DYNAMIC_TYPE_RSA;
    19540     ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
    19541     if (ret != 0) {
    19542         goto exit_dpk;
    19543     }
    19544 
    19545     WOLFSSL_MSG("Trying RSA private key");
    19546 
    19547     /* Set start of data to beginning of buffer. */
    19548     idx = 0;
    19549     /* Decode the key assuming it is an RSA private key. */
    19550     ret = wc_RsaPrivateKeyDecode(ssl->buffers.key->buffer, &idx,
    19551                 (RsaKey*)ssl->hsKey, ssl->buffers.key->length);
    19552     if (ret == 0) {
    19553         WOLFSSL_MSG("Using RSA private key");
    19554 
    19555         /* It worked so check it meets minimum key size requirements. */
    19556         keySz = wc_RsaEncryptSize((RsaKey*)ssl->hsKey);
    19557         if (keySz < 0) { /* check if keySz has error case */
    19558             ERROR_OUT(keySz, exit_dpk);
    19559         }
    19560 
    19561         if (keySz < ssl->options.minRsaKeySz) {
    19562             WOLFSSL_MSG("RSA key size too small");
    19563             ERROR_OUT(RSA_KEY_SIZE_E, exit_dpk);
    19564         }
    19565 
    19566         /* Return the maximum signature length. */
    19567         *length = (word16)keySz;
    19568 
    19569         goto exit_dpk;
    19570     }
    19571 #endif /* !NO_RSA */
    19572 
    19573 #ifdef HAVE_ECC
    19574 #ifndef NO_RSA
    19575     FreeKey(ssl, ssl->hsType, (void**)&ssl->hsKey);
    19576 #endif /* !NO_RSA */
    19577 
    19578     ssl->hsType = DYNAMIC_TYPE_ECC;
    19579     ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
    19580     if (ret != 0) {
    19581         goto exit_dpk;
    19582     }
    19583 
    19584 #ifndef NO_RSA
    19585     WOLFSSL_MSG("Trying ECC private key, RSA didn't work");
    19586 #else
    19587     WOLFSSL_MSG("Trying ECC private key");
    19588 #endif
    19589 
    19590     /* Set start of data to beginning of buffer. */
    19591     idx = 0;
    19592     /* Decode the key assuming it is an ECC private key. */
    19593     ret = wc_EccPrivateKeyDecode(ssl->buffers.key->buffer, &idx,
    19594                                  (ecc_key*)ssl->hsKey,
    19595                                  ssl->buffers.key->length);
    19596     if (ret == 0) {
    19597         WOLFSSL_MSG("Using ECC private key");
    19598 
    19599         /* Check it meets the minimum ECC key size requirements. */
    19600         keySz = wc_ecc_size((ecc_key*)ssl->hsKey);
    19601         if (keySz < ssl->options.minEccKeySz) {
    19602             WOLFSSL_MSG("ECC key size too small");
    19603             ERROR_OUT(ECC_KEY_SIZE_E, exit_dpk);
    19604         }
    19605 
    19606         /* Return the maximum signature length. */
    19607         *length = (word16)wc_ecc_sig_size((ecc_key*)ssl->hsKey);
    19608 
    19609         goto exit_dpk;
    19610     }
    19611 #endif
    19612 #ifdef HAVE_ED25519
    19613 #if !defined(NO_RSA) || defined(HAVE_ECC)
    19614     FreeKey(ssl, ssl->hsType, (void**)&ssl->hsKey);
    19615 #endif
    19616 
    19617     ssl->hsType = DYNAMIC_TYPE_ED25519;
    19618     ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
    19619     if (ret != 0) {
    19620         goto exit_dpk;
    19621     }
    19622 
    19623 #ifdef HAVE_ECC
    19624     WOLFSSL_MSG("Trying ED25519 private key, ECC didn't work");
    19625 #elif !defined(NO_RSA)
    19626     WOLFSSL_MSG("Trying ED25519 private key, RSA didn't work");
    19627 #else
    19628     WOLFSSL_MSG("Trying ED25519 private key");
    19629 #endif
    19630 
    19631     /* Set start of data to beginning of buffer. */
    19632     idx = 0;
    19633     /* Decode the key assuming it is an ED25519 private key. */
    19634     ret = wc_Ed25519PrivateKeyDecode(ssl->buffers.key->buffer, &idx,
    19635                                      (ed25519_key*)ssl->hsKey,
    19636                                      ssl->buffers.key->length);
    19637     if (ret == 0) {
    19638         WOLFSSL_MSG("Using ED25519 private key");
    19639 
    19640         /* Check it meets the minimum ECC key size requirements. */
    19641         (void)keySz;
    19642         if (ED25519_KEY_SIZE < ssl->options.minEccKeySz) {
    19643             WOLFSSL_MSG("ED25519 key size too small");
    19644             ERROR_OUT(ECC_KEY_SIZE_E, exit_dpk);
    19645         }
    19646 
    19647         /* Return the maximum signature length. */
    19648         *length = ED25519_SIG_SIZE;
    19649 
    19650         goto exit_dpk;
    19651     }
    19652 #endif
    19653 
    19654 exit_dpk:
    19655     return ret;
     20469        #ifdef WC_RSA_PSS
     20470            case rsa_pss_sa_algo:
     20471#endif
     20472            case rsa_sa_algo:
     20473                sigSz = ssl->buffers.keySz;
     20474                ssl->hsType = DYNAMIC_TYPE_RSA;
     20475                break;
     20476#endif
     20477        #ifdef HAVE_ECC
     20478            case ecc_dsa_sa_algo:
     20479                sigSz = wc_ecc_sig_size_calc(ssl->buffers.keySz);
     20480                ssl->hsType = DYNAMIC_TYPE_ECC;
     20481                break;
     20482        #endif
     20483        #ifdef HAVE_ED25519
     20484            case ed25519_sa_algo:
     20485                sigSz = ED25519_SIG_SIZE; /* fixed known value */
     20486                ssl->hsType = DYNAMIC_TYPE_ED25519;
     20487                break;
     20488        #endif
     20489            default:
     20490                break;
    1965620491}
    19657 
    19658 
     20492        return sigSz;
     20493    }
     20494#endif /* HAVE_PK_CALLBACKS */
     20495
     20496#ifndef WOLFSSL_NO_TLS12
     20497
     20498#ifndef WOLFSSL_NO_CLIENT_AUTH
    1965920499typedef struct ScvArgs {
    1966020500    byte*  output; /* not allocated */
    … …  
    1969120531}
    1969220532
     20533/* handle generation of certificate_verify (15) */
    1969320534int SendCertificateVerify(WOLFSSL* ssl)
    1969420535{
    … …  
    1970220543#endif
    1970320544
     20545    WOLFSSL_START(WC_FUNC_CERTIFICATE_VERIFY_SEND);
    1970420546    WOLFSSL_ENTER("SendCertificateVerify");
    1970520547
    … …  
    1973120573            }
    1973220574
    19733             args->sendSz = MAX_CERT_VERIFY_SZ;
     20575            args->sendSz = MAX_CERT_VERIFY_SZ + MAX_MSG_EXTRA;
    1973420576            if (IsEncryptionOn(ssl, 1)) {
    1973520577                args->sendSz += MAX_MSG_EXTRA;
    … …  
    1975720599            }
    1975820600
     20601            if (ssl->buffers.key == NULL) {
     20602            #ifdef HAVE_PK_CALLBACKS
     20603                if (wolfSSL_CTX_IsPrivatePkSet(ssl->ctx))
     20604                    args->length = GetPrivateKeySigSize(ssl);
     20605                else
     20606            #endif
     20607                    ERROR_OUT(NO_PRIVATE_KEY, exit_scv);
     20608            }
     20609            else {
    1975920610            /* Decode private key. */
    1976020611            ret = DecodePrivateKey(ssl, &args->length);
    1976120612            if (ret != 0) {
    1976220613                goto exit_scv;
     20614            }
     20615            }
     20616
     20617            if (args->length <= 0) {
     20618                ERROR_OUT(NO_PRIVATE_KEY, exit_scv);
    1976320619            }
    1976420620
    … …  
    1984920705            }
    1985020706        #endif /* !NO_RSA */
     20707        #if defined(HAVE_ED25519) && !defined(NO_ED25519_CLIENT_AUTH)
     20708            if (args->sigAlgo == ed25519_sa_algo) {
     20709                ret = Ed25519CheckPubKey(ssl);
     20710                if (ret != 0)
     20711                    goto exit_scv;
     20712            }
     20713        #endif /* HAVE_ED25519 && !NO_ED25519_CLIENT_AUTH */
    1985120714
    1985220715            /* Advance state and proceed */
    … …  
    1986520728                    ssl->buffers.sig.buffer, &ssl->buffers.sig.length,
    1986620729                    key,
    19867             #if defined(HAVE_PK_CALLBACKS)
    19868                     ssl->buffers.key->buffer,
    19869                     ssl->buffers.key->length,
    19870                     ssl->EccSignCtx
     20730            #ifdef HAVE_PK_CALLBACKS
     20731                    ssl->buffers.key
    1987120732            #else
    19872                     NULL, 0, NULL
     20733                    NULL
    1987320734            #endif
    1987420735                );
    1987520736            }
    1987620737        #endif /* HAVE_ECC */
    19877         #ifdef HAVE_ED25519
     20738        #if defined(HAVE_ED25519) && !defined(NO_ED25519_CLIENT_AUTH)
    1987820739           if (ssl->hsType == DYNAMIC_TYPE_ED25519) {
    1987920740                ed25519_key* key = (ed25519_key*)ssl->hsKey;
    1988020741
    1988120742                ret = Ed25519Sign(ssl,
    19882                     ssl->buffers.digest.buffer, ssl->buffers.digest.length,
     20743                    ssl->hsHashes->messages, ssl->hsHashes->length,
    1988320744                    ssl->buffers.sig.buffer, &ssl->buffers.sig.length,
    1988420745                    key,
    19885             #if defined(HAVE_PK_CALLBACKS)
    19886                     ssl->buffers.key->buffer,
    19887                     ssl->buffers.key->length,
    19888                     ssl->Ed25519SignCtx
     20746            #ifdef HAVE_PK_CALLBACKS
     20747                    ssl->buffers.key
    1988920748            #else
    19890                     NULL, 0, NULL
     20749                    NULL
    1989120750            #endif
    1989220751                );
    1989320752            }
    19894         #endif /* HAVE_ECC */
     20753        #endif /* HAVE_ED25519 && !NO_ED25519_CLIENT_AUTH */
    1989520754        #ifndef NO_RSA
    1989620755            if (ssl->hsType == DYNAMIC_TYPE_RSA) {
    … …  
    1990420763                    args->verify + args->extraSz + VERIFY_HEADER, &args->sigSz,
    1990520764                    args->sigAlgo, ssl->suites->hashAlgo, key,
    19906                     ssl->buffers.key->buffer, ssl->buffers.key->length,
    19907                 #ifdef HAVE_PK_CALLBACKS
    19908                     ssl->RsaSignCtx
    19909                 #else
    19910                     NULL
    19911                 #endif
     20765                    ssl->buffers.key
    1991220766                );
    1991320767            }
    … …  
    1993820792            }
    1993920793        #endif /* HAVE_ECC */
    19940         #ifdef HAVE_ECC
     20794        #ifdef HAVE_ED25519
    1994120795            if (ssl->hsType == DYNAMIC_TYPE_ED25519) {
    1994220796                args->length = (word16)ssl->buffers.sig.length;
    … …  
    1994620800                        ssl->buffers.sig.buffer, ssl->buffers.sig.length);
    1994720801            }
    19948         #endif /* HAVE_ECC */
     20802        #endif /* HAVE_ED25519 */
    1994920803        #ifndef NO_RSA
    1995020804            if (ssl->hsType == DYNAMIC_TYPE_RSA) {
    … …  
    1996520819                    args->verifySig, args->sigSz,
    1996620820                    ssl->buffers.sig.buffer, ssl->buffers.sig.length,
    19967                     args->sigAlgo, ssl->suites->hashAlgo, key
     20821                    args->sigAlgo, ssl->suites->hashAlgo, key,
     20822                    ssl->buffers.key
    1996820823                );
    1996920824            }
    … …  
    2005420909
    2005520910
    20056         #ifdef WOLFSSL_CALLBACKS
     20911        #if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
    2005720912            if (ssl->hsInfoOn)
    20058                 AddPacketName("CertificateVerify", &ssl->handShakeInfo);
     20913                AddPacketName(ssl, "CertificateVerify");
    2005920914            if (ssl->toInfoOn)
    20060                 AddPacketInfo("CertificateVerify", &ssl->timeoutInfo,
    20061                               args->output, args->sendSz, ssl->heap);
     20915                AddPacketInfo(ssl, "CertificateVerify", handshake,
     20916                            args->output, args->sendSz, WRITE_PROTO, ssl->heap);
    2006220917        #endif
    2006320918
    … …  
    2007620931
    2007720932    WOLFSSL_LEAVE("SendCertificateVerify", ret);
     20933    WOLFSSL_END(WC_FUNC_CERTIFICATE_VERIFY_SEND);
    2007820934
    2007920935#ifdef WOLFSSL_ASYNC_CRYPT
    … …  
    2009420950    return ret;
    2009520951}
     20952#endif /* WOLFSSL_NO_CLIENT_AUTH */
     20953
     20954#endif /* WOLFSSL_NO_TLS12 */
    2009620955
    2009720956#endif /* NO_CERTS */
    … …  
    2011620975        ssl->session.isDynamic = 1;
    2011720976    }
    20118     ssl->session.ticketLen = length;
     20977    ssl->session.ticketLen = (word16)length;
    2011920978
    2012020979    if (length > 0) {
    … …  
    2012820987         * supercede the existing session cache info. */
    2012920988        ssl->options.haveSessionId = 1;
     20989#ifdef WOLFSSL_TLS13
     20990        if (ssl->options.tls1_3) {
     20991            XMEMCPY(ssl->session.sessionID,
     20992                                 ssl->session.ticket + length - ID_LEN, ID_LEN);
     20993        }
     20994        else
     20995#endif
    2013020996        XMEMCPY(ssl->arrays->sessionID,
    2013120997                                 ssl->session.ticket + length - ID_LEN, ID_LEN);
    … …  
    2013521001}
    2013621002
     21003#ifndef WOLFSSL_NO_TLS12
     21004
     21005/* handle processing of session_ticket (4) */
    2013721006static int DoSessionTicket(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
    2013821007    word32 size)
    … …  
    2018121050    return 0;
    2018221051}
     21052
     21053#endif /* !WOLFSSL_NO_TLS12 */
     21054
    2018321055#endif /* HAVE_SESSION_TICKET */
    2018421056
    … …  
    2018721059#ifndef NO_WOLFSSL_SERVER
    2018821060
     21061#ifndef WOLFSSL_NO_TLS12
     21062
     21063    /* handle generation of server_hello (2) */
    2018921064    int SendServerHello(WOLFSSL* ssl)
    2019021065    {
     21066        int    ret;
    2019121067        byte              *output;
    20192         word32             length, idx = RECORD_HEADER_SZ + HANDSHAKE_HEADER_SZ;
     21068        word16 length;
     21069        word32 idx = RECORD_HEADER_SZ + HANDSHAKE_HEADER_SZ;
    2019321070        int                sendSz;
    20194         int                ret;
    2019521071        byte               sessIdSz = ID_LEN;
    2019621072        byte               echoId   = 0;  /* ticket echo id flag */
    2019721073        byte               cacheOff = 0;  /* session cache off flag */
     21074
     21075        WOLFSSL_START(WC_FUNC_SERVER_HELLO_SEND);
     21076        WOLFSSL_ENTER("SendServerHello");
    2019821077
    2019921078        length = VERSION_SZ + RAN_LEN
    … …  
    2020321082
    2020421083#ifdef HAVE_TLS_EXTENSIONS
    20205         length += TLSX_GetResponseSize(ssl, server_hello);
     21084        ret = TLSX_GetResponseSize(ssl, server_hello, &length);
     21085        if (ret != 0)
     21086            return ret;
    2020621087    #ifdef HAVE_SESSION_TICKET
    2020721088        if (ssl->options.useTicket) {
    … …  
    2022321104#endif
    2022421105
    20225         /* is the session cahce off at build or runtime */
     21106        /* is the session cache off at build or runtime */
    2022621107#ifdef NO_SESSION_CACHE
    2022721108        cacheOff = 1;
    … …  
    2023821119            sessIdSz = 0;
    2023921120        }
    20240 
    20241         /* check for avalaible size */
    20242         if ((ret = CheckAvailableSize(ssl, MAX_HELLO_SZ)) != 0)
    20243             return ret;
    20244 
    20245         /* get output buffer */
    20246         output = ssl->buffers.outputBuffer.buffer +
    20247                  ssl->buffers.outputBuffer.length;
    2024821121
    2024921122        sendSz = length + HANDSHAKE_HEADER_SZ + RECORD_HEADER_SZ;
    … …  
    2025821131        }
    2025921132        #endif /* WOLFSSL_DTLS */
     21133
     21134        if (IsEncryptionOn(ssl, 1))
     21135            sendSz += MAX_MSG_EXTRA;
     21136
     21137        /* check for available size */
     21138        if ((ret = CheckAvailableSize(ssl, sendSz)) != 0)
     21139            return ret;
     21140
     21141        /* get output buffer */
     21142        output = ssl->buffers.outputBuffer.buffer +
     21143                 ssl->buffers.outputBuffer.length;
     21144
    2026021145        AddHeaders(output, length, server_hello, ssl);
    2026121146
    2026221147        /* now write to output */
    2026321148        /* first version */
    20264         output[idx++] = ssl->version.major;
    20265         output[idx++] = ssl->version.minor;
     21149        output[idx++] = (byte)ssl->version.major;
     21150        output[idx++] = (byte)ssl->version.minor;
    2026621151
    2026721152        /* then random and session id */
    … …  
    2027821163                XMEMCPY(output + idx + RAN_LEN - (TLS13_DOWNGRADE_SZ + 1),
    2027921164                        tls13Downgrade, TLS13_DOWNGRADE_SZ);
    20280                 output[idx + RAN_LEN - 1] = IsAtLeastTLSv1_2(ssl);
     21165                output[idx + RAN_LEN - 1] = (byte)IsAtLeastTLSv1_2(ssl);
    2028121166            }
    2028221167            else
    … …  
    2032921214        /* last, extensions */
    2033021215#ifdef HAVE_TLS_EXTENSIONS
    20331         TLSX_WriteResponse(ssl, output + idx, server_hello);
     21216        {
     21217            word16 offset = 0;
     21218            ret = TLSX_WriteResponse(ssl, output + idx, server_hello, &offset);
     21219            if (ret != 0)
     21220                return ret;
     21221            idx += offset;
     21222        }
    2033221223#else
    2033321224#ifdef HAVE_EXTENDED_MASTER
    … …  
    2034121232            /*idx += HELLO_EXT_SZ_SZ;*/
    2034221233            /* idx is not used after this point. uncomment the line above
    20343              * if adding any more extentions in the future. */
    20344         }
    20345 #endif
    20346 #endif
    20347 
    20348         ssl->buffers.outputBuffer.length += sendSz;
    20349         #ifdef WOLFSSL_DTLS
    20350             if (IsDtlsNotSctpMode(ssl)) {
    20351                 if ((ret = DtlsMsgPoolSave(ssl, output, sendSz)) != 0)
    20352                     return ret;
    20353             }
    20354 
    20355             if (ssl->options.dtls) {
     21234             * if adding any more extensions in the future. */
     21235        }
     21236#endif
     21237#endif
     21238
     21239        if (IsEncryptionOn(ssl, 1)) {
     21240            byte* input;
     21241            int   inputSz = idx - RECORD_HEADER_SZ; /* build msg adds rec hdr */
     21242
     21243            input = (byte*)XMALLOC(inputSz, ssl->heap, DYNAMIC_TYPE_IN_BUFFER);
     21244            if (input == NULL)
     21245                return MEMORY_E;
     21246
     21247            XMEMCPY(input, output + RECORD_HEADER_SZ, inputSz);
     21248            sendSz = BuildMessage(ssl, output, sendSz, input, inputSz,
     21249                                  handshake, 1, 0, 0);
     21250            XFREE(input, ssl->heap, DYNAMIC_TYPE_IN_BUFFER);
     21251
     21252            if (sendSz < 0)
     21253                return sendSz;
     21254        } else {
     21255            #ifdef WOLFSSL_DTLS
     21256                if (ssl->options.dtls)
    2035621257                DtlsSEQIncrement(ssl, CUR_ORDER);
    20357             }
    2035821258        #endif
    20359 
    2036021259        ret = HashOutput(ssl, output, sendSz, 0);
    2036121260        if (ret != 0)
    2036221261            return ret;
    20363 
    20364 
    20365     #ifdef WOLFSSL_CALLBACKS
     21262        }
     21263
     21264    #if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
    2036621265        if (ssl->hsInfoOn)
    20367             AddPacketName("ServerHello", &ssl->handShakeInfo);
     21266            AddPacketName(ssl, "ServerHello");
    2036821267        if (ssl->toInfoOn)
    20369             AddPacketInfo("ServerHello", &ssl->timeoutInfo, output, sendSz,
    20370                           ssl->heap);
     21268            AddPacketInfo(ssl, "ServerHello", handshake, output, sendSz,
     21269                          WRITE_PROTO, ssl->heap);
    2037121270    #endif
    2037221271
    2037321272        ssl->options.serverState = SERVER_HELLO_COMPLETE;
     21273        ssl->buffers.outputBuffer.length += sendSz;
     21274
     21275    #ifdef WOLFSSL_DTLS
     21276        if (IsDtlsNotSctpMode(ssl)) {
     21277            if ((ret = DtlsMsgPoolSave(ssl, output, sendSz)) != 0)
     21278                return ret;
     21279        }
     21280
     21281        if (ssl->options.dtls) {
     21282            DtlsSEQIncrement(ssl, CUR_ORDER);
     21283        }
     21284    #endif
    2037421285
    2037521286        if (ssl->options.groupMessages)
    20376             return 0;
     21287            ret = 0;
    2037721288        else
    20378             return SendBuffered(ssl);
    20379     }
    20380 
    20381 
    20382 #ifdef HAVE_ECC
     21289            ret = SendBuffered(ssl);
     21290
     21291        WOLFSSL_LEAVE("SendServerHello", ret);
     21292        WOLFSSL_END(WC_FUNC_SERVER_HELLO_SEND);
     21293
     21294        return ret;
     21295    }
     21296
     21297
     21298#if defined(HAVE_ECC)
    2038321299
    2038421300    static byte SetCurveId(ecc_key* key)
    … …  
    2043921355    #endif
    2044021356    #if defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)
    20441         #ifdef HAVE_CURVE25519
    20442             case ECC_X25519_OID:
    20443                 return WOLFSSL_ECC_X25519;
    20444         #endif
    2044521357        #ifndef NO_ECC_SECP
    2044621358            case ECC_SECP384R1_OID:
    … …  
    2046921381    }
    2047021382
    20471 #endif /* HAVE_ECC */
     21383#endif /* HAVE_ECC || HAVE_CURVE25519 */
    2047221384
    2047321385    typedef struct SskeArgs {
    2047421386        byte*  output; /* not allocated */
    20475     #if defined(HAVE_ECC) || (!defined(NO_DH) && !defined(NO_RSA))
     21387    #if defined(HAVE_ECC) || defined(HAVE_ED25519) || \
     21388                                           (!defined(NO_DH) && !defined(NO_RSA))
    2047621389        byte*  sigDataBuf;
    2047721390    #endif
    20478     #if defined(HAVE_ECC)
     21391    #if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
    2047921392        byte*  exportBuf;
    2048021393    #endif
    … …  
    2048221395        byte*  verifySig;
    2048321396    #endif
     21397        byte*  input;
    2048421398        word32 idx;
    2048521399        word32 tmpSigSz;
    2048621400        word32 length;
    2048721401        word32 sigSz;
    20488     #if defined(HAVE_ECC) || (!defined(NO_DH) && !defined(NO_RSA))
     21402    #if defined(HAVE_ECC) || defined(HAVE_ED25519) || \
     21403                                           (!defined(NO_DH) && !defined(NO_RSA))
    2048921404        word32 sigDataSz;
    2049021405    #endif
    20491     #if defined(HAVE_ECC)
     21406    #if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
    2049221407        word32 exportSz;
    2049321408    #endif
    … …  
    2049621411    #endif
    2049721412        int    sendSz;
     21413        int    inputSz;
    2049821414    } SskeArgs;
    2049921415
    … …  
    2050421420        (void)ssl;
    2050521421
    20506     #if defined(HAVE_ECC)
     21422    #if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
    2050721423        if (args->exportBuf) {
    2050821424            XFREE(args->exportBuf, ssl->heap, DYNAMIC_TYPE_DER);
    … …  
    2051021426        }
    2051121427    #endif
    20512     #if defined(HAVE_ECC) || (!defined(NO_DH) && !defined(NO_RSA))
     21428    #if defined(HAVE_ECC) || defined(HAVE_ED25519) || \
     21429                                           (!defined(NO_DH) && !defined(NO_RSA))
    2051321430        if (args->sigDataBuf) {
    2051421431            XFREE(args->sigDataBuf, ssl->heap, DYNAMIC_TYPE_SIGNATURE);
    … …  
    2052521442    }
    2052621443
     21444    /* handle generation of server_key_exchange (12) */
    2052721445    int SendServerKeyExchange(WOLFSSL* ssl)
    2052821446    {
    … …  
    2053621454    #endif
    2053721455
     21456        WOLFSSL_START(WC_FUNC_SERVER_KEY_EXCHANGE_SEND);
    2053821457        WOLFSSL_ENTER("SendServerKeyExchange");
    2053921458
    … …  
    2057021489                switch(ssl->specs.kea)
    2057121490                {
    20572                 #if defined(HAVE_ECC) && !defined(NO_PSK)
     21491                #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     21492                                                                !defined(NO_PSK)
    2057321493                    case ecdhe_psk_kea:
    2057421494                    {
    … …  
    2057621496                        break;
    2057721497                    }
    20578                 #endif /* HAVE_ECC && !NO_PSK */
    20579                 #ifdef HAVE_ECC
     21498                #endif /* (HAVE_ECC || CURVE25519) && !NO_PSK */
     21499                #if defined(HAVE_ECC)
    2058021500                    case ecc_diffie_hellman_kea:
    2058121501                    {
    … …  
    2058321503                            WOLFSSL_MSG("Using Static ECDH, not sending ServerKeyExchange");
    2058421504                            ERROR_OUT(0, exit_sske);
    20585                         }
    20586 
    20587                         /* make sure private key exists */
    20588                         if (ssl->buffers.key == NULL ||
    20589                                             ssl->buffers.key->buffer == NULL) {
    20590                             ERROR_OUT(NO_PRIVATE_KEY, exit_sske);
    2059121505                        }
    2059221506
    … …  
    2065021564                        }
    2065121565
     21566                        #if !defined(WOLFSSL_OLD_PRIME_CHECK) && \
     21567                            !defined(HAVE_FIPS) && \
     21568                            !defined(HAVE_SELFTEST)
     21569                        if (ssl->options.dhDoKeyTest &&
     21570                            !ssl->options.dhKeyTested)
     21571                        {
     21572                            ret = wc_DhSetCheckKey(
     21573                                ssl->buffers.serverDH_Key,
     21574                                ssl->buffers.serverDH_P.buffer,
     21575                                ssl->buffers.serverDH_P.length,
     21576                                ssl->buffers.serverDH_G.buffer,
     21577                                ssl->buffers.serverDH_G.length,
     21578                                NULL, 0, 0, ssl->rng);
     21579                            if (ret != 0) {
     21580                                goto exit_sske;
     21581                            }
     21582                            ssl->options.dhKeyTested = 1;
     21583                        }
     21584                        else
     21585                        #endif
     21586                        {
    2065221587                        ret = wc_DhSetKey(ssl->buffers.serverDH_Key,
    2065321588                            ssl->buffers.serverDH_P.buffer,
    … …  
    2065821593                            goto exit_sske;
    2065921594                        }
     21595                        }
    2066021596
    2066121597                        ret = DhGenKeyPair(ssl, ssl->buffers.serverDH_Key,
    … …  
    2066721603                    }
    2066821604                #endif /* !NO_DH && (!NO_PSK || !NO_RSA) */
    20669                 #if defined(HAVE_ECC) && !defined(NO_PSK)
     21605                #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     21606                                                                !defined(NO_PSK)
    2067021607                    case ecdhe_psk_kea:
    2067121608                        /* Fall through to create temp ECC key */
    20672                 #endif /* HAVE_ECC && !NO_PSK */
     21609                #endif /* (HAVE_ECC || CURVE25519) && !NO_PSK */
    2067321610                #if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
    2067421611                    case ecc_diffie_hellman_kea:
    … …  
    2070921646
    2071021647                        if (ssl->eccTempKeyPresent == 0) {
    20711                             /* TODO: Need to first do wc_EccPrivateKeyDecode,
    20712                                 then we know curve dp */
    2071321648                            ret = EccMakeKey(ssl, ssl->eccTempKey, NULL);
    2071421649                            if (ret == 0 || ret == WC_PENDING_E) {
    … …  
    2073721672            case TLS_ASYNC_BUILD:
    2073821673            {
    20739             #if (!defined(NO_DH) && !defined(NO_RSA)) || defined(HAVE_ECC)
     21674            #if (!defined(NO_DH) && !defined(NO_RSA)) || (defined(HAVE_ECC) || \
     21675                                                       defined(HAVE_CURVE25519))
    2074021676                word32 preSigSz, preSigIdx;
    2074121677            #endif
    … …  
    2077321709                        }
    2077421710                    #endif
     21711
     21712                        if (IsEncryptionOn(ssl, 1)) {
     21713                            args->sendSz += MAX_MSG_EXTRA;
     21714                        }
     21715
    2077521716                        /* check for available size */
    2077621717                        if ((ret = CheckAvailableSize(ssl, args->sendSz)) != 0) {
    … …  
    2083121772                        }
    2083221773                    #endif
     21774
     21775                        if (IsEncryptionOn(ssl, 1)) {
     21776                            args->sendSz += MAX_MSG_EXTRA;
     21777                        }
    2083321778
    2083421779                        /* check for available size */
    … …  
    2088121826                    }
    2088221827                #endif /* !defined(NO_DH) && !defined(NO_PSK) */
    20883                 #if defined(HAVE_ECC) && !defined(NO_PSK)
     21828                #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     21829                                                                !defined(NO_PSK)
    2088421830                    case ecdhe_psk_kea:
    2088521831                    {
    … …  
    2093321879                        }
    2093421880                    #endif
     21881
     21882                        if (IsEncryptionOn(ssl, 1)) {
     21883                            args->sendSz += MAX_MSG_EXTRA;
     21884                        }
     21885
    2093521886                        /* check for available size */
    2093621887                        if ((ret = CheckAvailableSize(ssl, args->sendSz)) != 0) {
    … …  
    2095821909                    #endif
    2095921910                        {
     21911                    #ifdef HAVE_ECC
    2096021912                            args->output[args->idx++] =
    2096121913                                                    SetCurveId(ssl->eccTempKey);
     21914                    #endif
    2096221915                        }
    2096321916                        args->output[args->idx++] = (byte)args->exportSz;
    … …  
    2096621919                        break;
    2096721920                    }
    20968                 #endif /* HAVE_ECC && !NO_PSK */
    20969                 #ifdef HAVE_ECC
     21921                #endif /* (HAVE_ECC || HAVE_CURVE25519) && !NO_PSK */
     21922                #if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
    2097021923                    case ecc_diffie_hellman_kea:
    2097121924                    {
    … …  
    2099521948                    #endif
    2099621949                        {
     21950                    #if defined(HAVE_ECC) && defined(HAVE_ECC_KEY_EXPORT)
    2099721951                            if (wc_ecc_export_x963(ssl->eccTempKey,
    2099821952                                       args->exportBuf, &args->exportSz) != 0) {
    2099921953                                ERROR_OUT(ECC_EXPORT_ERROR, exit_sske);
    2100021954                            }
     21955                     #endif
    2100121956                       }
    2100221957                        args->length += args->exportSz;
    … …  
    2100521960                        preSigIdx = args->idx;
    2100621961
    21007                         switch(ssl->suites->sigAlgo)
    21008                         {
     21962                        if (ssl->buffers.key == NULL) {
     21963                        #ifdef HAVE_PK_CALLBACKS
     21964                            if (wolfSSL_CTX_IsPrivatePkSet(ssl->ctx)) {
     21965                                args->tmpSigSz = GetPrivateKeySigSize(ssl);
     21966                                if (args->tmpSigSz <= 0) {
     21967                                    ERROR_OUT(NO_PRIVATE_KEY, exit_sske);
     21968                                }
     21969                            }
     21970                            else
     21971                        #endif
     21972                                ERROR_OUT(NO_PRIVATE_KEY, exit_sske);
     21973                        }
     21974                        else {
     21975                            switch(ssl->suites->sigAlgo) {
    2100921976                        #ifndef NO_RSA
    2101021977                        #ifdef WC_RSA_PSS
    … …  
    2104322010                            }
    2104422011                        #endif /* !NO_RSA */
     22012                        #ifdef HAVE_ECC
    2104522013                            case ecc_dsa_sa_algo:
    2104622014                            {
    … …  
    2106922037                                        ssl->options.minEccKeySz) {
    2107022038                                    WOLFSSL_MSG("ECC key size too small");
    21071                                     ret = ECC_KEY_SIZE_E;
    21072                                     goto exit_sske;
     22039                                    ERROR_OUT(ECC_KEY_SIZE_E, exit_sske);
    2107322040                                }
    2107422041                                break;
    2107522042                            }
     22043                        #endif
    2107622044                        #ifdef HAVE_ED25519
    2107722045                            case ed25519_sa_algo:
    … …  
    2109322061                                    goto exit_sske;
    2109422062                                }
     22063
    2109522064                                /* worst case estimate */
    2109622065                                args->tmpSigSz = ED25519_SIG_SIZE;
    … …  
    2110022069                                        ssl->options.minEccKeySz) {
    2110122070                                    WOLFSSL_MSG("Ed25519 key size too small");
    21102                                     ret = ECC_KEY_SIZE_E;
    21103                                     goto exit_sske;
     22071                                    ERROR_OUT(ECC_KEY_SIZE_E, exit_sske);
    2110422072                                }
    2110522073                                break;
    2110622074                            }
    21107                         #endif
     22075                        #endif /* HAVE_ED25519 */
    2110822076                            default:
    2110922077                                ERROR_OUT(ALGO_ID_E, exit_sske);  /* unsupported type */
    2111022078                        } /* switch(ssl->specs.sig_algo) */
     22079                        }
    2111122080
    2111222081                        /* sig length */
    … …  
    2113122100                        }
    2113222101                    #endif
     22102                        if (IsEncryptionOn(ssl, 1)) {
     22103                            args->sendSz += MAX_MSG_EXTRA;
     22104                        }
     22105
    2113322106                        /* check for available size */
    2113422107                        if ((ret = CheckAvailableSize(ssl, args->sendSz)) != 0) {
    … …  
    2115222125                    #endif
    2115322126                        {
     22127                    #ifdef HAVE_ECC
    2115422128                            args->output[args->idx++] =
    2115522129                                                    SetCurveId(ssl->eccTempKey);
     22130                    #endif
    2115622131                        }
    2115722132                        args->output[args->idx++] = (byte)args->exportSz;
    … …  
    2127022245                        #endif
    2127122246                        #endif /* !NO_RSA */
    21272                         #ifdef HAVE_ED25519
    21273                             case ed25519_sa_algo:
    21274                         #endif
    2127522247                            case ecc_dsa_sa_algo:
    2127622248                            {
    2127722249                                break;
    2127822250                            }
     22251                        #ifdef  HAVE_ED25519
     22252                            case ed25519_sa_algo:
     22253                                ret = Ed25519CheckPubKey(ssl);
     22254                                if (ret != 0)
     22255                                    goto exit_sske;
     22256                                break;
     22257                        #endif /* HAVE_ED25519 */
    2127922258                        } /* switch(ssl->specs.sig_algo) */
    2128022259                        break;
    2128122260                    }
    21282                 #endif /* HAVE_ECC */
     22261                #endif /* HAVE_ECC || HAVE_CURVE25519 */
    2128322262                #if !defined(NO_DH) && !defined(NO_RSA)
    2128422263                    case diffie_hellman_kea:
    … …  
    2129622275
    2129722276                        if (!ssl->options.usingAnon_cipher) {
    21298                             word32   i = 0;
    2129922277                            int      keySz;
    2130022278
    21301                             /* make sure private key exists */
    21302                             if (ssl->buffers.key == NULL ||
    21303                                             ssl->buffers.key->buffer == NULL) {
     22279                            /* sig length */
     22280                            args->length += LENGTH_SZ;
     22281
     22282                            if (ssl->buffers.key == NULL) {
     22283                            #ifdef HAVE_PK_CALLBACKS
     22284                                if (wolfSSL_CTX_IsPrivatePkSet(ssl->ctx))
     22285                                    keySz = (word32)GetPrivateKeySigSize(ssl);
     22286                                else
     22287                            #endif
    2130422288                                ERROR_OUT(NO_PRIVATE_KEY, exit_sske);
    2130522289                            }
     22290                            else
     22291                            {
     22292                                word32 i = 0;
    2130622293
    2130722294                            ssl->hsType = DYNAMIC_TYPE_RSA;
    … …  
    2131122298                            }
    2131222299
    21313                             /* sig length */
    21314                             args->length += LENGTH_SZ;
    21315 
    2131622300                            ret = wc_RsaPrivateKeyDecode(
    2131722301                                ssl->buffers.key->buffer, &i,
    21318                                 (RsaKey*)ssl->hsKey, ssl->buffers.key->length);
     22302                                    (RsaKey*)ssl->hsKey,
     22303                                    ssl->buffers.key->length);
    2131922304                            if (ret != 0) {
    2132022305                                goto exit_sske;
    2132122306                            }
    2132222307                            keySz = wc_RsaEncryptSize((RsaKey*)ssl->hsKey);
    21323                             if (keySz < 0) { /* test if keySz has error */
     22308                            }
     22309
     22310                            if (keySz <= 0) { /* test if keySz has error */
    2132422311                                ERROR_OUT(keySz, exit_sske);
    2132522312                            }
     22313
    2132622314                            args->tmpSigSz = (word32)keySz;
    2132722315                            args->length += args->tmpSigSz;
    … …  
    2135122339                        }
    2135222340                    #endif
     22341
     22342                        if (IsEncryptionOn(ssl, 1)) {
     22343                            args->sendSz += MAX_MSG_EXTRA;
     22344                        }
    2135322345
    2135422346                        /* check for available size */
    … …  
    2152622518                    }
    2152722519                #endif /* !defined(NO_DH) && !defined(NO_PSK) */
    21528                 #if defined(HAVE_ECC) && !defined(NO_PSK)
     22520                #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     22521                                                                !defined(NO_PSK)
    2152922522                    case ecdhe_psk_kea:
    2153022523                    {
    2153122524                        break;
    2153222525                    }
    21533                 #endif /* HAVE_ECC && !NO_PSK */
    21534                 #ifdef HAVE_ECC
     22526                #endif /* (HAVE_ECC || HAVE_CURVE25519) && !NO_PSK */
     22527                #if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
    2153522528                    case ecc_diffie_hellman_kea:
    2153622529                    {
    … …  
    2155322546                                    ssl->suites->sigAlgo, ssl->suites->hashAlgo,
    2155422547                                    key,
    21555                                     ssl->buffers.key->buffer,
    21556                                     ssl->buffers.key->length,
     22548                                    ssl->buffers.key
     22549                                );
     22550                                break;
     22551                            }
     22552                        #endif /* !NO_RSA */
     22553                        #ifdef HAVE_ECC
     22554                            case ecc_dsa_sa_algo:
     22555                            {
     22556                                ecc_key* key = (ecc_key*)ssl->hsKey;
     22557
     22558                                ret = EccSign(ssl,
     22559                                    ssl->buffers.sig.buffer,
     22560                                    ssl->buffers.sig.length,
     22561                                    args->output + LENGTH_SZ + args->idx,
     22562                                    &args->sigSz,
     22563                                    key,
    2155722564                            #ifdef HAVE_PK_CALLBACKS
    21558                                     ssl->RsaSignCtx
     22565                                    ssl->buffers.key
    2155922566                            #else
    2156022567                                    NULL
    … …  
    2156322570                                break;
    2156422571                            }
    21565                         #endif /* !NO_RSA */
    21566                             case ecc_dsa_sa_algo:
    21567                             {
    21568                                 ecc_key* key = (ecc_key*)ssl->hsKey;
    21569 
    21570                                 ret = EccSign(ssl,
    21571                                     ssl->buffers.sig.buffer,
    21572                                     ssl->buffers.sig.length,
    21573                                     args->output + LENGTH_SZ + args->idx,
    21574                                     &args->sigSz,
    21575                                     key,
    21576                             #if defined(HAVE_PK_CALLBACKS)
    21577                                     ssl->buffers.key->buffer,
    21578                                     ssl->buffers.key->length,
    21579                                     ssl->EccSignCtx
    21580                             #else
    21581                                     NULL, 0, NULL
    21582                             #endif
    21583                                 );
    21584                                 break;
    21585                             }
     22572                        #endif /* HAVE_ECC */
    2158622573                        #ifdef HAVE_ED25519
    2158722574                            case ed25519_sa_algo:
    … …  
    2159422581                                    &args->sigSz,
    2159522582                                    key,
    21596                             #if defined(HAVE_PK_CALLBACKS)
    21597                                     ssl->buffers.key->buffer,
    21598                                     ssl->buffers.key->length,
    21599                                     ssl->Ed25519SignCtx
     22583                            #ifdef HAVE_PK_CALLBACKS
     22584                                    ssl->buffers.key
    2160022585                            #else
    21601                                     NULL, 0, NULL
     22586                                    NULL
    2160222587                            #endif
    2160322588                                );
    … …  
    2160822593                        break;
    2160922594                    }
    21610                 #endif /* HAVE_ECC */
     22595                #endif /* HAVE_ECC || HAVE_CURVE25519 */
    2161122596                #if !defined(NO_DH) && !defined(NO_RSA)
    2161222597                    case diffie_hellman_kea:
    … …  
    2163422619                                    ssl->suites->sigAlgo, ssl->suites->hashAlgo,
    2163522620                                    key,
    21636                                     ssl->buffers.key->buffer,
    21637                                     ssl->buffers.key->length,
    21638                                 #ifdef HAVE_PK_CALLBACKS
    21639                                     ssl->RsaSignCtx
    21640                                 #else
    21641                                     NULL
    21642                                 #endif
     22621                                    ssl->buffers.key
    2164322622                                );
    2164422623                                break;
    … …  
    2168022659                    }
    2168122660                #endif /* !defined(NO_DH) && !defined(NO_PSK) */
    21682                 #if defined(HAVE_ECC) && !defined(NO_PSK)
     22661                #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     22662                                                                !defined(NO_PSK)
    2168322663                    case ecdhe_psk_kea:
    2168422664                    {
    … …  
    2168622666                        break;
    2168722667                    }
    21688                 #endif /* HAVE_ECC && !NO_PSK */
    21689                 #ifdef HAVE_ECC
     22668                #endif /* (HAVE_ECC || HAVE_CURVE25519) && !NO_PSK */
     22669                #if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
    2169022670                    case ecc_diffie_hellman_kea:
    2169122671                    {
    … …  
    2172022700                                    ssl->buffers.sig.length,
    2172122701                                    ssl->suites->sigAlgo, ssl->suites->hashAlgo,
    21722                                     key
     22702                                    key, ssl->buffers.key
    2172322703                                );
    2172422704                                break;
    … …  
    2172622706                        #endif
    2172722707                            case ecc_dsa_sa_algo:
     22708                        #ifdef HAVE_ED25519
     22709                            case ed25519_sa_algo:
     22710                        #endif
    2172822711                            {
    2172922712                                /* Now that we know the real sig size, write it. */
    … …  
    2173622719                                break;
    2173722720                            }
    21738                         #ifdef HAVE_ED25519
    21739                             case ed25519_sa_algo:
    21740                             {
    21741                                 /* Now that we know the real sig size, write it. */
    21742                                 c16toa((word16)args->sigSz,
    21743                                                     args->output + args->idx);
    21744 
    21745                                 /* And adjust length and sendSz from estimates */
    21746                                 args->length += args->sigSz - args->tmpSigSz;
    21747                                 args->sendSz += args->sigSz - args->tmpSigSz;
    21748                                 break;
    21749                             }
    21750                         #endif
    2175122721                            default:
    2175222722                                ERROR_OUT(ALGO_ID_E, exit_sske);  /* unsupported type */
    … …  
    2175422724                        break;
    2175522725                    }
    21756                 #endif /* HAVE_ECC */
     22726                #endif /* HAVE_ECC || HAVE_CURVE25519 */
    2175722727                #if !defined(NO_DH) && !defined(NO_RSA)
    2175822728                    case diffie_hellman_kea:
    … …  
    2179222762                                    ssl->buffers.sig.length,
    2179322763                                    ssl->suites->sigAlgo, ssl->suites->hashAlgo,
    21794                                     key
     22764                                    key, ssl->buffers.key
    2179522765                                );
    2179622766                                break;
    … …  
    2183822808            #endif
    2183922809
    21840             #if defined(HAVE_ECC)
     22810            #if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
    2184122811                if (ssl->specs.kea == ecdhe_psk_kea ||
    2184222812                    ssl->specs.kea == ecc_diffie_hellman_kea) {
    … …  
    2185022820                    }
    2185122821                }
    21852             #endif /* HAVE_ECC */
    21853 
     22822            #endif /* HAVE_ECC || HAVE_CURVE25519 */
     22823
     22824                if (IsEncryptionOn(ssl, 1)) {
     22825                    args->inputSz = args->length + HANDSHAKE_HEADER_SZ;
     22826                                                     /* buildmsg adds rechdr */
     22827                    args->input = (byte*)XMALLOC(args->inputSz, ssl->heap,
     22828                                                        DYNAMIC_TYPE_IN_BUFFER);
     22829                    if (args->input == NULL) {
     22830                        ERROR_OUT(MEMORY_E, exit_sske);
     22831                    }
     22832
     22833                    XMEMCPY(args->input, args->output + RECORD_HEADER_SZ,
     22834                                                                 args->inputSz);
     22835                    ret = BuildMessage(ssl, args->output, args->sendSz,
     22836                                args->input, args->inputSz, handshake, 1, 0, 0);
     22837                    XFREE(args->input, ssl->heap, DYNAMIC_TYPE_IN_BUFFER);
     22838                    args->input = NULL;
     22839                        /* make sure its not double free'd on cleanup */
     22840
     22841                    if (ret >= 0) {
     22842                        args->sendSz = ret;
     22843                        ret = 0;
     22844                    }
     22845                }
     22846                else {
    2185422847            #ifdef WOLFSSL_DTLS
    2185522848                if (IsDtlsNotSctpMode(ssl)) {
    21856                     if ((ret = DtlsMsgPoolSave(ssl, args->output, args->sendSz)) != 0) {
     22849                        if ((ret = DtlsMsgPoolSave(ssl,
     22850                                            args->output, args->sendSz)) != 0) {
    2185722851                        goto exit_sske;
    2185822852                    }
    … …  
    2186722861                    goto exit_sske;
    2186822862                }
    21869 
    21870             #ifdef WOLFSSL_CALLBACKS
     22863                }
     22864
     22865            #if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
    2187122866                if (ssl->hsInfoOn) {
    21872                     AddPacketName("ServerKeyExchange", &ssl->handShakeInfo);
     22867                    AddPacketName(ssl, "ServerKeyExchange");
    2187322868                }
    2187422869                if (ssl->toInfoOn) {
    21875                     AddPacketInfo("ServerKeyExchange", &ssl->timeoutInfo,
    21876                         args->output, args->sendSz, ssl->heap);
     22870                    AddPacketInfo(ssl, "ServerKeyExchange", handshake,
     22871                        args->output, args->sendSz, WRITE_PROTO, ssl->heap);
    2187722872                }
    2187822873            #endif
    … …  
    2190022895
    2190122896        WOLFSSL_LEAVE("SendServerKeyExchange", ret);
     22897        WOLFSSL_END(WC_FUNC_SERVER_KEY_EXCHANGE_SEND);
    2190222898
    2190322899    #ifdef WOLFSSL_ASYNC_CRYPT
    … …  
    2193622932
    2193722933#endif
     22934
     22935#endif /* !WOLFSSL_NO_TLS12 */
    2193822936
    2193922937    /* Make sure server cert/key are valid for this suite, true on success */
    … …  
    2201923017        }
    2202023018
    22021 #ifdef HAVE_SUPPORTED_CURVES
     23019#if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     23020                                                  defined(HAVE_SUPPORTED_CURVES)
    2202223021        if (!TLSX_ValidateSupportedCurves(ssl, first, second)) {
    2202323022            WOLFSSL_MSG("Don't have matching curves");
    … …  
    2203523034            }
    2203623035            else {
    22037                 WOLFSSL_MSG("Version of SSL connection does not support TLS_QSH");
     23036                WOLFSSL_MSG("Version of SSL connection does not support "
     23037                            "TLS_QSH");
    2203823038            }
    2203923039            return 0;
    … …  
    2204723047            int ret = TLSX_KeyShare_Establish(ssl);
    2204823048            if (ret == KEY_SHARE_ERROR)
    22049                 ssl->options.serverState = SERVER_HELLO_RETRY_REQUEST;
     23049                ssl->options.serverState = SERVER_HELLO_RETRY_REQUEST_COMPLETE;
    2205023050            else if (ret != 0)
    2205123051                return 0;
     23052        }
     23053        else if (first == TLS13_BYTE) {
     23054            /* Can't negotiate TLS 1.3 cipher suites with lower protocol
     23055             * version. */
     23056            return 0;
    2205223057        }
    2205323058#endif
    … …  
    2213323138        ProtocolVersion pv;
    2213423139        Suites          clSuites;
     23140        int ret = -1;
    2213523141
    2213623142        (void)inSz;
    … …  
    2213823144#ifdef WOLFSSL_CALLBACKS
    2213923145        if (ssl->hsInfoOn)
    22140             AddPacketName("ClientHello", &ssl->handShakeInfo);
     23146            AddPacketName(ssl, "ClientHello");
    2214123147        if (ssl->toInfoOn)
    2214223148            AddLateName("ClientHello", &ssl->timeoutInfo);
    … …  
    2217223178            byte haveRSA = 0;
    2217323179            byte havePSK = 0;
     23180            int  keySz   = 0;
     23181
    2217423182            if (!ssl->options.downgrade) {
    2217523183                WOLFSSL_MSG("Client trying to connect with lesser version");
    … …  
    2220723215            havePSK = ssl->options.havePSK;
    2220823216#endif
    22209 
    22210             InitSuites(ssl->suites, ssl->version, ssl->keySz, haveRSA, havePSK,
     23217#ifndef NO_CERTS
     23218            keySz = ssl->buffers.keySz;
     23219#endif
     23220
     23221            InitSuites(ssl->suites, ssl->version, keySz, haveRSA, havePSK,
    2221123222                       ssl->options.haveDH, ssl->options.haveNTRU,
    2221223223                       ssl->options.haveECDSAsig, ssl->options.haveECC,
    … …  
    2226623277
    2226723278        ssl->options.clientState = CLIENT_HELLO_COMPLETE;
     23279        ssl->cbmode = SSL_CB_MODE_WRITE;
    2226823280        *inOutIdx = idx;
    2226923281
    … …  
    2227123283        /* DoClientHello uses same resume code */
    2227223284        if (ssl->options.resuming) {  /* let's try */
    22273             int ret = -1;
    2227423285            WOLFSSL_SESSION* session = GetSession(ssl,
    2227523286                                                  ssl->arrays->masterSecret, 1);
    … …  
    2231323324        }
    2231423325
    22315         return MatchSuite(ssl, &clSuites);
     23326        ret = MatchSuite(ssl, &clSuites);
     23327        if (ret != 0)return ret;
     23328        return SanityCheckMsgReceived(ssl, client_hello);
    2231623329    }
    2231723330
    2231823331#endif /* OLD_HELLO_ALLOWED */
    2231923332
    22320 
     23333#ifndef WOLFSSL_NO_TLS12
     23334
     23335    int HandleTlsResumption(WOLFSSL* ssl, int bogusID, Suites* clSuites)
     23336    {
     23337        int ret = 0;
     23338        WOLFSSL_SESSION* session = GetSession(ssl,
     23339                                                  ssl->arrays->masterSecret, 1);
     23340
     23341        (void)bogusID;
     23342
     23343        #ifdef HAVE_SESSION_TICKET
     23344            if (ssl->options.useTicket == 1) {
     23345                session = &ssl->session;
     23346            } else if (bogusID == 1 && ssl->options.rejectTicket == 0) {
     23347                WOLFSSL_MSG("Bogus session ID without session ticket");
     23348                return BUFFER_ERROR;
     23349            }
     23350        #endif
     23351
     23352        if (!session) {
     23353            WOLFSSL_MSG("Session lookup for resume failed");
     23354            ssl->options.resuming = 0;
     23355        }
     23356        else if (session->haveEMS != ssl->options.haveEMS) {
     23357            /* RFC 7627, 5.3, server-side */
     23358            /* if old sess didn't have EMS, but new does, full handshake */
     23359            if (!session->haveEMS && ssl->options.haveEMS) {
     23360                WOLFSSL_MSG("Attempting to resume a session that didn't "
     23361                            "use EMS with a new session with EMS. Do full "
     23362                            "handshake.");
     23363                ssl->options.resuming = 0;
     23364            }
     23365            /* if old sess used EMS, but new doesn't, MUST abort */
     23366            else if (session->haveEMS && !ssl->options.haveEMS) {
     23367                WOLFSSL_MSG("Trying to resume a session with EMS without "
     23368                            "using EMS");
     23369                return EXT_MASTER_SECRET_NEEDED_E;
     23370            }
     23371        #ifdef HAVE_EXT_CACHE
     23372            wolfSSL_SESSION_free(session);
     23373        #endif
     23374        }
     23375        else {
     23376        #ifdef HAVE_EXT_CACHE
     23377            wolfSSL_SESSION_free(session);
     23378        #endif
     23379            if (MatchSuite(ssl, clSuites) < 0) {
     23380                WOLFSSL_MSG("Unsupported cipher suite, ClientHello");
     23381                return UNSUPPORTED_SUITE;
     23382            }
     23383
     23384            ret = wc_RNG_GenerateBlock(ssl->rng, ssl->arrays->serverRandom,
     23385                                                                       RAN_LEN);
     23386            if (ret != 0)
     23387                return ret;
     23388
     23389            #ifdef NO_OLD_TLS
     23390                ret = DeriveTlsKeys(ssl);
     23391            #else
     23392                #ifndef NO_TLS
     23393                    if (ssl->options.tls)
     23394                        ret = DeriveTlsKeys(ssl);
     23395                #endif
     23396                    if (!ssl->options.tls)
     23397                        ret = DeriveKeys(ssl);
     23398            #endif
     23399            ssl->options.clientState = CLIENT_KEYEXCHANGE_COMPLETE;
     23400        }
     23401
     23402        return ret;
     23403    }
     23404
     23405
     23406    /* handle processing of client_hello (1) */
    2232123407    int DoClientHello(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
    2232223408                             word32 helloSz)
    … …  
    2232823414        word32          i = *inOutIdx;
    2232923415        word32          begin = i;
     23416        int             ret = 0;
    2233023417#ifdef WOLFSSL_DTLS
    2233123418        Hmac            cookieHmac;
    … …  
    2233823425#endif /* WOLFSSL_DTLS */
    2233923426
     23427        WOLFSSL_START(WC_FUNC_CLIENT_HELLO_DO);
     23428        WOLFSSL_ENTER("DoClientHello");
     23429
    2234023430#ifdef WOLFSSL_CALLBACKS
    22341         if (ssl->hsInfoOn) AddPacketName("ClientHello", &ssl->handShakeInfo);
     23431        if (ssl->hsInfoOn) AddPacketName(ssl, "ClientHello");
    2234223432        if (ssl->toInfoOn) AddLateName("ClientHello", &ssl->timeoutInfo);
    2234323433#endif
    22344 
    2234523434        /* protocol version, random and session id length check */
    2234623435        if ((i - begin) + OPAQUE16_LEN + RAN_LEN + OPAQUE8_LEN > helloSz)
    … …  
    2235223441#ifdef WOLFSSL_DTLS
    2235323442        if (IsDtlsNotSctpMode(ssl)) {
    22354             int ret;
    2235523443            #if defined(NO_SHA) && defined(NO_SHA256)
    2235623444                #error "DTLS needs either SHA or SHA-256"
    … …  
    2237923467        i += OPAQUE16_LEN;
    2238023468
     23469        /* Legacy protocol version cannot negotiate TLS 1.3 or higher. */
     23470        if (pv.major == SSLv3_MAJOR && pv.minor >= TLSv1_3_MINOR)
     23471            pv.minor = TLSv1_2_MINOR;
     23472
    2238123473        if ((!ssl->options.dtls && ssl->version.minor > pv.minor) ||
    2238223474            (ssl->options.dtls && ssl->version.minor != DTLS_MINOR
    … …  
    2249923591#ifdef WOLFSSL_DTLS
    2250023592        if (IsDtlsNotSctpMode(ssl)) {
    22501             int ret = wc_HmacUpdate(&cookieHmac, input + i, RAN_LEN);
     23593            ret = wc_HmacUpdate(&cookieHmac, input + i, RAN_LEN);
    2250223594            if (ret != 0) return ret;
    2250323595        }
    … …  
    2253223624#ifdef WOLFSSL_DTLS
    2253323625            if (IsDtlsNotSctpMode(ssl)) {
    22534                 int ret = wc_HmacUpdate(&cookieHmac, input + i - 1, b + 1);
     23626                ret = wc_HmacUpdate(&cookieHmac, input + i - 1, b + 1);
    2253523627                if (ret != 0) return ret;
    2253623628            }
    … …  
    2258823680        /* check for TLS_EMPTY_RENEGOTIATION_INFO_SCSV suite */
    2258923681        if (FindSuite(&clSuites, 0, TLS_EMPTY_RENEGOTIATION_INFO_SCSV) >= 0) {
    22590             int ret = 0;
    22591 
    22592             ret = TLSX_AddEmptyRenegotiationInfo(&ssl->extensions, ssl->heap);
     23682            ret = TLSX_AddEmptyRenegotiationInfo(&ssl->extensions);
    2259323683            if (ret != WOLFSSL_SUCCESS)
    2259423684                return ret;
     23685            ssl->secure_renegotiation->enabled = 1;
    2259523686        }
    2259623687#endif /* HAVE_SERVER_RENEGOTIATION_INFO */
    … …  
    2259823689#ifdef WOLFSSL_DTLS
    2259923690        if (IsDtlsNotSctpMode(ssl)) {
    22600             int ret = wc_HmacUpdate(&cookieHmac,
     23691            ret = wc_HmacUpdate(&cookieHmac,
    2260123692                                    input + i - OPAQUE16_LEN,
    2260223693                                    clSuites.suiteSz + OPAQUE16_LEN);
    … …  
    2262123712        if (IsDtlsNotSctpMode(ssl)) {
    2262223713            byte newCookie[MAX_COOKIE_LEN];
    22623             int ret;
    2262423714
    2262523715            ret = wc_HmacUpdate(&cookieHmac, input + i - 1, b + 1);
    … …  
    2265823748
    2265923749        {
    22660             /* copmression match types */
     23750            /* compression match types */
    2266123751            int matchNo = 0;
    2266223752            int matchZlib = 0;
    … …  
    2269423784            QSH_Init(ssl);
    2269523785        #endif
    22696             if (TLSX_SupportExtensions(ssl)) {
    22697                 int ret = 0;
     23786            if (TLSX_SupportExtensions(ssl))
    2269823787#else
    22699             if (IsAtLeastTLSv1_2(ssl)) {
    22700 #endif
     23788            if (IsAtLeastTLSv1_2(ssl))
     23789#endif
     23790            {
    2270123791                /* Process the hello extension. Skip unsupported. */
    2270223792                word16 totalExtSz;
    … …  
    2273023820                }
    2273123821    #endif
    22732 #if defined(HAVE_STUNNEL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY)
     23822    #if defined(OPENSSL_ALL) || defined(HAVE_STUNNEL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY)
    2273323823                if((ret=SNI_Callback(ssl)))
    2273423824                    return ret;
    2273523825                ssl->options.side = WOLFSSL_SERVER_END;
    22736 #endif /*HAVE_STUNNEL*/
     23826    #endif
    2273723827
    2273823828                i += totalExtSz;
    … …  
    2275323843
    2275423844                    if (extId == HELLO_EXT_SIG_ALGO) {
    22755                         ato16(&input[i], &clSuites.hashSigAlgoSz);
     23845                        word16 hashSigAlgoSz;
     23846
     23847                        ato16(&input[i], &hashSigAlgoSz);
    2275623848                        i += OPAQUE16_LEN;
    2275723849
    22758                         if (OPAQUE16_LEN + clSuites.hashSigAlgoSz > extSz)
     23850                        if (OPAQUE16_LEN + hashSigAlgoSz > extSz)
    2275923851                            return BUFFER_ERROR;
    2276023852
     23853                        clSuites.hashSigAlgoSz = hashSigAlgoSz;
     23854                        if (clSuites.hashSigAlgoSz > WOLFSSL_MAX_SIGALGO) {
     23855                            WOLFSSL_MSG("ClientHello SigAlgo list exceeds max, "
     23856                                                                  "truncating");
     23857                            clSuites.hashSigAlgoSz = WOLFSSL_MAX_SIGALGO;
     23858                        }
     23859
    2276123860                        XMEMCPY(clSuites.hashSigAlgo, &input[i],
    22762                             min(clSuites.hashSigAlgoSz, HELLO_EXT_SIGALGO_MAX));
    22763                         i += clSuites.hashSigAlgoSz;
    22764 
    22765                         if (clSuites.hashSigAlgoSz > HELLO_EXT_SIGALGO_MAX)
    22766                             clSuites.hashSigAlgoSz = HELLO_EXT_SIGALGO_MAX;
     23861                                                      clSuites.hashSigAlgoSz);
     23862
     23863                        i += hashSigAlgoSz;
    2276723864                    }
    2276823865#ifdef HAVE_EXTENDED_MASTER
    … …  
    2278723884        /* ProcessOld uses same resume code */
    2278823885        if (ssl->options.resuming) {
    22789             int ret = -1;
    22790             WOLFSSL_SESSION* session = GetSession(ssl,
    22791                                                   ssl->arrays->masterSecret, 1);
    22792             #ifdef HAVE_SESSION_TICKET
    22793                 if (ssl->options.useTicket == 1) {
    22794                     session = &ssl->session;
    22795                 } else if (bogusID == 1 && ssl->options.rejectTicket == 0) {
    22796                     WOLFSSL_MSG("Bogus session ID without session ticket");
    22797                     return BUFFER_ERROR;
     23886            ret = HandleTlsResumption(ssl, bogusID, &clSuites);
     23887            if (ret != 0)
     23888                return ret;
     23889            if (ssl->options.clientState == CLIENT_KEYEXCHANGE_COMPLETE) {
     23890                WOLFSSL_LEAVE("DoClientHello", ret);
     23891                WOLFSSL_END(WC_FUNC_CLIENT_HELLO_DO);
     23892
     23893                return ret;
     23894            }
    2279823895                }
    22799             #endif
    22800 
    22801             if (!session) {
    22802                 WOLFSSL_MSG("Session lookup for resume failed");
    22803                 ssl->options.resuming = 0;
    22804             }
    22805             else if (session->haveEMS != ssl->options.haveEMS) {
    22806                 /* RFC 7627, 5.3, server-side */
    22807                 /* if old sess didn't have EMS, but new does, full handshake */
    22808                 if (!session->haveEMS && ssl->options.haveEMS) {
    22809                     WOLFSSL_MSG("Attempting to resume a session that didn't "
    22810                                 "use EMS with a new session with EMS. Do full "
    22811                                 "handshake.");
    22812                     ssl->options.resuming = 0;
    22813                 }
    22814                 /* if old sess used EMS, but new doesn't, MUST abort */
    22815                 else if (session->haveEMS && !ssl->options.haveEMS) {
    22816                     WOLFSSL_MSG("Trying to resume a session with EMS without "
    22817                                 "using EMS");
    22818                     return EXT_MASTER_SECRET_NEEDED_E;
    22819                 }
    22820 #ifdef HAVE_EXT_CACHE
    22821                 wolfSSL_SESSION_free(session);
    22822 #endif
    22823             }
    22824             else {
    22825 #ifdef HAVE_EXT_CACHE
    22826                 wolfSSL_SESSION_free(session);
    22827 #endif
    22828                 if (MatchSuite(ssl, &clSuites) < 0) {
    22829                     WOLFSSL_MSG("Unsupported cipher suite, ClientHello");
    22830                     return UNSUPPORTED_SUITE;
    22831                 }
    22832 
    22833                 ret = wc_RNG_GenerateBlock(ssl->rng, ssl->arrays->serverRandom,
    22834                                                                        RAN_LEN);
    22835                 if (ret != 0)
    22836                     return ret;
    22837 
    22838                 #ifdef NO_OLD_TLS
    22839                     ret = DeriveTlsKeys(ssl);
    22840                 #else
    22841                     #ifndef NO_TLS
    22842                         if (ssl->options.tls)
    22843                             ret = DeriveTlsKeys(ssl);
    22844                     #endif
    22845                         if (!ssl->options.tls)
    22846                             ret = DeriveKeys(ssl);
     23896        ret = MatchSuite(ssl, &clSuites);
     23897
     23898#ifdef HAVE_SECURE_RENEGOTIATION
     23899    if (ssl->secure_renegotiation && ssl->secure_renegotiation->enabled &&
     23900            IsEncryptionOn(ssl, 0)) {
     23901        ssl->secure_renegotiation->startScr = 1;
     23902    }
    2284723903                #endif
    22848                 ssl->options.clientState = CLIENT_KEYEXCHANGE_COMPLETE;
     23904        WOLFSSL_LEAVE("DoClientHello", ret);
     23905        WOLFSSL_END(WC_FUNC_CLIENT_HELLO_DO);
    2284923906
    2285023907                return ret;
    2285123908            }
    22852         }
    22853         return MatchSuite(ssl, &clSuites);
    22854     }
    22855 
    22856 
    22857 #if !defined(NO_RSA) || defined(HAVE_ECC)
     23909
     23910
     23911#if (!defined(NO_RSA) || defined(HAVE_ECC) || defined(HAVE_ED25519)) && \
     23912                                                !defined(WOLFSSL_NO_CLIENT_AUTH)
    2285823913
    2285923914    typedef struct DcvArgs {
    … …  
    2287623931    }
    2287723932
     23933    /* handle processing of certificate_verify (15) */
    2287823934    static int DoCertificateVerify(WOLFSSL* ssl, byte* input,
    2287923935                                word32* inOutIdx, word32 size)
    … …  
    2288823944    #endif
    2288923945
     23946        WOLFSSL_START(WC_FUNC_CERTIFICATE_VERIFY_DO);
    2289023947        WOLFSSL_ENTER("DoCertificateVerify");
    2289123948
    … …  
    2291923976            #ifdef WOLFSSL_CALLBACKS
    2292023977                if (ssl->hsInfoOn)
    22921                     AddPacketName("CertificateVerify", &ssl->handShakeInfo);
     23978                    AddPacketName(ssl, "CertificateVerify");
    2292223979                if (ssl->toInfoOn)
    2292323980                    AddLateName("CertificateVerify", &ssl->timeoutInfo);
    … …  
    2294824005                    args->sigAlgo = ecc_dsa_sa_algo;
    2294924006            #endif
    22950             #ifdef HAVE_ED25519
     24007            #if defined(HAVE_ED25519) && !defined(NO_ED25519_CLIENT_AUTH)
    2295124008                else if (ssl->peerEd25519KeyPresent)
    2295224009                    args->sigAlgo = ed25519_sa_algo;
    22953             #endif
     24010            #endif /* HAVE_ED25519 && !NO_ED25519_CLIENT_AUTH */
    2295424011
    2295524012                if ((args->idx - args->begin) + OPAQUE16_LEN > size) {
    … …  
    2299224049                }
    2299324050            #endif /* HAVE_ECC */
    22994             #ifdef HAVE_ED25519
     24051            #if defined(HAVE_ED25519) && !defined(NO_ED25519_CLIENT_AUTH)
    2299524052                if (ssl->peerEd25519KeyPresent) {
    2299624053                    WOLFSSL_MSG("Doing ED25519 peer cert verify");
    … …  
    2300124058                    }
    2300224059                }
    23003             #endif /* HAVE_ED25519 */
     24060            #endif /* HAVE_ED25519 && !NO_ED25519_CLIENT_AUTH */
    2300424061
    2300524062                /* Advance state and proceed */
    … …  
    2302124078                        ssl->peerRsaKey,
    2302224079                    #ifdef HAVE_PK_CALLBACKS
    23023                         ssl->buffers.peerRsaKey.buffer,
    23024                         ssl->buffers.peerRsaKey.length,
    23025                         ssl->RsaVerifyCtx
     24080                        &ssl->buffers.peerRsaKey
    2302624081                    #else
    23027                         NULL, 0, NULL
     24082                        NULL
    2302824083                    #endif
    2302924084                    );
    … …  
    2304824103                        ssl->peerEccDsaKey,
    2304924104                    #ifdef HAVE_PK_CALLBACKS
    23050                         ssl->buffers.peerEccDsaKey.buffer,
    23051                         ssl->buffers.peerEccDsaKey.length,
    23052                         ssl->EccVerifyCtx
     24105                        &ssl->buffers.peerEccDsaKey
    2305324106                    #else
    23054                         NULL, 0, NULL
     24107                        NULL
    2305524108                    #endif
    2305624109                    );
    2305724110                }
    2305824111            #endif /* HAVE_ECC */
     24112            #if defined(HAVE_ED25519) && !defined(NO_ED25519_CLIENT_AUTH)
     24113                if (ssl->peerEd25519KeyPresent) {
     24114                    WOLFSSL_MSG("Doing Ed25519 peer cert verify");
     24115
     24116                    ret = Ed25519Verify(ssl,
     24117                        input + args->idx, args->sz,
     24118                        ssl->hsHashes->messages, ssl->hsHashes->prevLen,
     24119                        ssl->peerEd25519Key,
     24120                    #ifdef HAVE_PK_CALLBACKS
     24121                        &ssl->buffers.peerEd25519Key
     24122                    #else
     24123                        NULL
     24124                    #endif
     24125                    );
     24126                }
     24127            #endif /* HAVE_ED25519 && !NO_ED25519_CLIENT_AUTH */
    2305924128
    2306024129                /* Check for error */
    … …  
    2308324152                                             HashAlgoToType(args->hashAlgo));
    2308424153                            if (ret != 0)
    23085                                 return ret;
     24154                                goto exit_dcv;
    2308624155                        }
    2308724156                        else
    … …  
    2314124210            case TLS_ASYNC_FINALIZE:
    2314224211            {
     24212                if (IsEncryptionOn(ssl, 0)) {
     24213                    args->idx += ssl->keys.padSz;
     24214                }
     24215
    2314324216                ssl->options.havePeerVerify = 1;
    2314424217
    … …  
    2316224235
    2316324236        WOLFSSL_LEAVE("DoCertificateVerify", ret);
     24237        WOLFSSL_END(WC_FUNC_CERTIFICATE_VERIFY_DO);
    2316424238
    2316524239    #ifdef WOLFSSL_ASYNC_CRYPT
    2316624240        /* Handle async operation */
    2316724241        if (ret == WC_PENDING_E) {
    23168             /* Mark message as not recevied so it can process again */
     24242            /* Mark message as not received so it can process again */
    2316924243            ssl->msgsReceived.got_certificate_verify = 0;
    2317024244
    … …  
    2317224246        }
    2317324247    #endif /* WOLFSSL_ASYNC_CRYPT */
    23174 
     24248    #ifdef OPENSSL_EXTRA
     24249        if (ret != 0){
     24250             SendAlert(ssl, alert_fatal, bad_certificate);
     24251        }
     24252    #endif
    2317524253        /* Digest is not allocated, so do this to prevent free */
    2317624254        ssl->buffers.digest.buffer = NULL;
    … …  
    2318424262    }
    2318524263
    23186 #endif /* !NO_RSA || HAVE_ECC */
    23187 
     24264#endif /* (!NO_RSA || HAVE_ECC || HAVE_ED25519) && !WOLFSSL_NO_CLIENT_AUTH */
     24265
     24266    /* handle generation of server_hello_done (14) */
    2318824267    int SendServerHelloDone(WOLFSSL* ssl)
    2318924268    {
    … …  
    2319224271        int   ret;
    2319324272
     24273        WOLFSSL_START(WC_FUNC_SERVER_HELLO_DONE_SEND);
     24274        WOLFSSL_ENTER("SendServerHelloDone");
     24275
    2319424276    #ifdef WOLFSSL_DTLS
    2319524277        if (ssl->options.dtls)
    … …  
    2319724279    #endif
    2319824280
     24281        if (IsEncryptionOn(ssl, 1))
     24282            sendSz += MAX_MSG_EXTRA;
     24283
    2319924284        /* check for available size */
    2320024285        if ((ret = CheckAvailableSize(ssl, sendSz)) != 0)
    … …  
    2320724292        AddHeaders(output, 0, server_hello_done, ssl);
    2320824293
     24294        if (IsEncryptionOn(ssl, 1)) {
     24295            byte* input;
     24296            int   inputSz = HANDSHAKE_HEADER_SZ; /* build msg adds rec hdr */
     24297
     24298            input = (byte*)XMALLOC(inputSz, ssl->heap, DYNAMIC_TYPE_IN_BUFFER);
     24299            if (input == NULL)
     24300                return MEMORY_E;
     24301
     24302            XMEMCPY(input, output + RECORD_HEADER_SZ, inputSz);
     24303            sendSz = BuildMessage(ssl, output, sendSz, input, inputSz,
     24304                                  handshake, 1, 0, 0);
     24305            XFREE(input, ssl->heap, DYNAMIC_TYPE_IN_BUFFER);
     24306
     24307            if (sendSz < 0)
     24308                return sendSz;
     24309        } else {
    2320924310    #ifdef WOLFSSL_DTLS
    2321024311        if (IsDtlsNotSctpMode(ssl)) {
    2321124312            if ((ret = DtlsMsgPoolSave(ssl, output, sendSz)) != 0)
    23212                 return 0;
    23213         }
    23214 
     24313                        return ret;
     24314        }
    2321524315        if (ssl->options.dtls)
    2321624316            DtlsSEQIncrement(ssl, CUR_ORDER);
    2321724317    #endif
    23218 
    2321924318        ret = HashOutput(ssl, output, sendSz, 0);
    2322024319            if (ret != 0)
    2322124320                return ret;
    23222 
    23223     #ifdef WOLFSSL_CALLBACKS
     24321        }
     24322
     24323    #if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
    2322424324        if (ssl->hsInfoOn)
    23225             AddPacketName("ServerHelloDone", &ssl->handShakeInfo);
     24325            AddPacketName(ssl, "ServerHelloDone");
    2322624326        if (ssl->toInfoOn)
    23227             AddPacketInfo("ServerHelloDone", &ssl->timeoutInfo, output, sendSz,
    23228                           ssl->heap);
     24327            AddPacketInfo(ssl, "ServerHelloDone", handshake, output, sendSz,
     24328                    WRITE_PROTO, ssl->heap);
    2322924329    #endif
    2323024330        ssl->options.serverState = SERVER_HELLODONE_COMPLETE;
    … …  
    2323224332        ssl->buffers.outputBuffer.length += sendSz;
    2323324333
    23234         return SendBuffered(ssl);
    23235     }
    23236 
     24334        ret = SendBuffered(ssl);
     24335
     24336        WOLFSSL_LEAVE("SendServerHelloDone", ret);
     24337        WOLFSSL_END(WC_FUNC_SERVER_HELLO_DONE_SEND);
     24338
     24339        return ret;
     24340    }
     24341
     24342#endif /* !WOLFSSL_NO_TLS12 */
    2323724343
    2323824344#ifdef HAVE_SESSION_TICKET
    … …  
    2325124357#ifdef WOLFSSL_TLS13
    2325224358        word32          ageAdd;                /* Obfuscation of age */
    23253         byte            namedGroup;            /* Named group used */
     24359        word16          namedGroup;            /* Named group used */
     24360    #ifndef WOLFSSL_TLS13_DRAFT_18
     24361        TicketNonce     ticketNonce;           /* Ticket nonce */
     24362    #endif
    2325424363    #ifdef WOLFSSL_EARLY_DATA
    2325524364        word32          maxEarlyDataSz;        /* Max size of early data */
    … …  
    2330724416            /* Resumption master secret. */
    2330824417            XMEMCPY(it.msecret, ssl->session.masterSecret, SECRET_LEN);
     24418    #ifndef WOLFSSL_TLS13_DRAFT_18
     24419            XMEMCPY(&it.ticketNonce, &ssl->session.ticketNonce,
     24420                                                           sizeof(TicketNonce));
     24421    #endif
    2330924422#endif
    2331024423        }
    … …  
    2337524488        word16          inLen;
    2337624489
     24490        WOLFSSL_START(WC_FUNC_TICKET_DO);
     24491        WOLFSSL_ENTER("DoClientTicket");
     24492
    2337724493        if (len > SESSION_TICKET_LEN ||
    2337824494             len < (word32)(sizeof(InternalTicket) + WOLFSSL_TICKET_FIXED_SZ)) {
    … …  
    2340124517        /* get master secret */
    2340224518        if (ret == WOLFSSL_TICKET_RET_OK || ret == WOLFSSL_TICKET_RET_CREATE) {
     24519            if (ssl->version.minor < it->pv.minor) {
     24520                WOLFSSL_MSG("Ticket has greater version");
     24521                return VERSION_ERROR;
     24522            }
     24523            else if (ssl->version.minor > it->pv.minor) {
     24524                if (!ssl->options.downgrade) {
     24525                    WOLFSSL_MSG("Ticket has lesser version");
     24526                    return VERSION_ERROR;
     24527                }
     24528
     24529                WOLFSSL_MSG("Downgrading protocol due to ticket");
     24530
     24531                if (it->pv.minor < ssl->options.minDowngrade)
     24532                    return VERSION_ERROR;
     24533                ssl->version.minor = it->pv.minor;
     24534            }
     24535
    2340324536            if (!IsAtLeastTLSv1_3(ssl->version)) {
    2340424537                XMEMCPY(ssl->arrays->masterSecret, it->msecret, SECRET_LEN);
    … …  
    2341924552                /* Resumption master secret. */
    2342024553                XMEMCPY(ssl->session.masterSecret, it->msecret, SECRET_LEN);
     24554    #ifndef WOLFSSL_TLS13_DRAFT_18
     24555                XMEMCPY(&ssl->session.ticketNonce, &it->ticketNonce,
     24556                                                           sizeof(TicketNonce));
     24557    #endif
    2342124558                ssl->session.namedGroup = it->namedGroup;
    2342224559#endif
    2342324560            }
    2342424561        }
     24562
     24563        WOLFSSL_LEAVE("DoClientTicket", ret);
     24564        WOLFSSL_END(WC_FUNC_TICKET_DO);
    2342524565
    2342624566        return ret;
    … …  
    2343724577        word32             idx    = RECORD_HEADER_SZ + HANDSHAKE_HEADER_SZ;
    2343824578
     24579        WOLFSSL_START(WC_FUNC_TICKET_SEND);
     24580        WOLFSSL_ENTER("SendTicket");
     24581
    2343924582        if (ssl->options.createTicket) {
    2344024583            ret = CreateTicket(ssl);
    … …  
    2344524588        sendSz = length + HANDSHAKE_HEADER_SZ + RECORD_HEADER_SZ;
    2344624589
     24590        if (!ssl->options.dtls) {
     24591            if (IsEncryptionOn(ssl, 1) && ssl->options.handShakeDone)
     24592                sendSz += MAX_MSG_EXTRA;
     24593        }
     24594        else {
    2344724595        #ifdef WOLFSSL_DTLS
    23448         if (ssl->options.dtls) {
    2344924596            sendSz += DTLS_RECORD_EXTRA + DTLS_HANDSHAKE_EXTRA;
    2345024597            idx    += DTLS_RECORD_EXTRA + DTLS_HANDSHAKE_EXTRA;
    23451         }
    2345224598        #endif
     24599        }
    2345324600        /* check for available size */
    2345424601        if ((ret = CheckAvailableSize(ssl, sendSz)) != 0)
    … …  
    2347124618        /* ticket */
    2347224619        XMEMCPY(output + idx, ssl->session.ticket, ssl->session.ticketLen);
    23473         /* idx += ssl->session.ticketLen; */
    23474 
     24620        idx += ssl->session.ticketLen;
     24621
     24622        if (IsEncryptionOn(ssl, 1) && ssl->options.handShakeDone) {
     24623            byte* input;
     24624            int   inputSz = idx - RECORD_HEADER_SZ; /* build msg adds rec hdr */
     24625
     24626            input = (byte*)XMALLOC(inputSz, ssl->heap, DYNAMIC_TYPE_IN_BUFFER);
     24627            if (input == NULL)
     24628                return MEMORY_E;
     24629
     24630            XMEMCPY(input, output + RECORD_HEADER_SZ, inputSz);
     24631            sendSz = BuildMessage(ssl, output, sendSz, input, inputSz,
     24632                                  handshake, 1, 0, 0);
     24633            XFREE(input, ssl->heap, DYNAMIC_TYPE_IN_BUFFER);
     24634
     24635            if (sendSz < 0)
     24636                return sendSz;
     24637        }
     24638        else {
    2347524639        #ifdef WOLFSSL_DTLS
    2347624640        if (ssl->options.dtls) {
    … …  
    2348124645        }
    2348224646        #endif
    23483 
    2348424647        ret = HashOutput(ssl, output, sendSz, 0);
    23485         if (ret != 0) return ret;
     24648            if (ret != 0)
     24649                return ret;
     24650        }
     24651
    2348624652        ssl->buffers.outputBuffer.length += sendSz;
    2348724653
    23488         return SendBuffered(ssl);
     24654        ret = SendBuffered(ssl);
     24655
     24656        WOLFSSL_LEAVE("SendTicket", ret);
     24657        WOLFSSL_END(WC_FUNC_TICKET_SEND);
     24658
     24659        return ret;
    2348924660    }
    2349024661
    2349124662#endif /* HAVE_SESSION_TICKET */
    2349224663
     24664#ifndef WOLFSSL_NO_TLS12
     24665
     24666#if defined(HAVE_SECURE_RENEGOTIATION) && \
     24667    defined(HAVE_SERVER_RENEGOTIATION_INFO) && \
     24668    !defined(WOLFSSL_NO_SERVER)
     24669
     24670    /* handle generation of server's hello_request (0) */
     24671    int SendHelloRequest(WOLFSSL* ssl)
     24672    {
     24673        byte* output;
     24674        int sendSz = RECORD_HEADER_SZ + HANDSHAKE_HEADER_SZ;
     24675        int ret;
     24676
     24677        WOLFSSL_START(WC_FUNC_HELLO_REQUEST_SEND);
     24678        WOLFSSL_ENTER("SendHelloRequest");
     24679
     24680        if (IsEncryptionOn(ssl, 1))
     24681            sendSz += MAX_MSG_EXTRA;
     24682
     24683        /* check for available size */
     24684        if ((ret = CheckAvailableSize(ssl, sendSz)) != 0)
     24685            return ret;
     24686
     24687        /* get output buffer */
     24688        output = ssl->buffers.outputBuffer.buffer +
     24689                 ssl->buffers.outputBuffer.length;
     24690
     24691        AddHeaders(output, 0, hello_request, ssl);
     24692
     24693        if (IsEncryptionOn(ssl, 1)) {
     24694            byte* input;
     24695            int   inputSz = HANDSHAKE_HEADER_SZ; /* build msg adds rec hdr */
     24696
     24697            input = (byte*)XMALLOC(inputSz, ssl->heap, DYNAMIC_TYPE_IN_BUFFER);
     24698            if (input == NULL)
     24699                return MEMORY_E;
     24700
     24701            XMEMCPY(input, output + RECORD_HEADER_SZ, inputSz);
     24702            sendSz = BuildMessage(ssl, output, sendSz, input, inputSz,
     24703                                  handshake, 0, 0, 0);
     24704            XFREE(input, ssl->heap, DYNAMIC_TYPE_IN_BUFFER);
     24705
     24706            if (sendSz < 0)
     24707                return sendSz;
     24708        }
     24709
     24710        ssl->buffers.outputBuffer.length += sendSz;
     24711
     24712        ret = SendBuffered(ssl);
     24713
     24714        WOLFSSL_LEAVE("SendHelloRequest", ret);
     24715        WOLFSSL_END(WC_FUNC_HELLO_REQUEST_SEND);
     24716
     24717        return ret;
     24718    }
     24719
     24720#endif /* HAVE_SECURE_RENEGOTIATION && HAVE_SERVER_RENEGOTIATION_INFO */
    2349324721
    2349424722#ifdef WOLFSSL_DTLS
     24723    /* handle generation of DTLS hello_verify_request (3) */
    2349524724    static int SendHelloVerifyRequest(WOLFSSL* ssl,
    2349624725                                      const byte* cookie, byte cookieSz)
    … …  
    2353024759        XMEMCPY(output + idx, cookie, cookieSz);
    2353124760
    23532 #ifdef WOLFSSL_CALLBACKS
     24761#if defined(WOLFSSL_CALLBACKS) || defined(OPENSSL_EXTRA)
    2353324762        if (ssl->hsInfoOn)
    23534             AddPacketName("HelloVerifyRequest", &ssl->handShakeInfo);
     24763            AddPacketName(ssl, "HelloVerifyRequest");
    2353524764        if (ssl->toInfoOn)
    23536             AddPacketInfo("HelloVerifyRequest", &ssl->timeoutInfo, output,
    23537                           sendSz, ssl->heap);
     24765            AddPacketInfo(ssl, "HelloVerifyRequest", handshake, output,
     24766                          sendSz, WRITE_PROTO, ssl->heap);
    2353824767#endif
    2353924768
    … …  
    2355024779        word32 begin;
    2355124780        word32 sigSz;
     24781    #ifndef NO_RSA
     24782        int    lastErr;
     24783    #endif
    2355224784    } DckeArgs;
    2355324785
    … …  
    2356024792    }
    2356124793
     24794    /* handle processing client_key_exchange (16) */
    2356224795    static int DoClientKeyExchange(WOLFSSL* ssl, byte* input, word32* inOutIdx,
    2356324796                                                                    word32 size)
    … …  
    2357224805    #endif
    2357324806
     24807        (void)size;
     24808        (void)input;
     24809
     24810        WOLFSSL_START(WC_FUNC_CLIENT_KEY_EXCHANGE_DO);
    2357424811        WOLFSSL_ENTER("DoClientKeyExchange");
    2357524812
    … …  
    2363024867            #endif /* !NO_CERTS */
    2363124868
    23632             #ifdef WOLFSSL_CALLBACKS
     24869            #if defined(WOLFSSL_CALLBACKS)
    2363324870                if (ssl->hsInfoOn) {
    23634                     AddPacketName("ClientKeyExchange", &ssl->handShakeInfo);
     24871                    AddPacketName(ssl, "ClientKeyExchange");
    2363524872                }
    2363624873                if (ssl->toInfoOn) {
    … …  
    2363924876            #endif
    2364024877
     24878                if (ssl->arrays->preMasterSecret == NULL) {
     24879                    ssl->arrays->preMasterSecret = (byte*)XMALLOC(ENCRYPT_LEN,
     24880                                                ssl->heap, DYNAMIC_TYPE_SECRET);
     24881                    if (ssl->arrays->preMasterSecret == NULL) {
     24882                        ERROR_OUT(MEMORY_E, exit_dcke);
     24883                    }
     24884                    XMEMSET(ssl->arrays->preMasterSecret, 0, ENCRYPT_LEN);
     24885                }
     24886
    2364124887                switch (ssl->specs.kea) {
    2364224888                #ifndef NO_RSA
    2364324889                    case rsa_kea:
    2364424890                    {
    23645                         /* make sure private key exists */
    23646                         if (ssl->buffers.key == NULL ||
    23647                                             ssl->buffers.key->buffer == NULL) {
    23648                             ERROR_OUT(NO_PRIVATE_KEY, exit_dcke);
    23649                         }
    2365024891                        break;
    2365124892                    } /* rsa_kea */
    … …  
    2367324914                    }
    2367424915                #endif /* HAVE_NTRU */
    23675                 #ifdef HAVE_ECC
     24916                #if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
    2367624917                    case ecc_diffie_hellman_kea:
    2367724918                    {
    2367824919                        break;
    2367924920                    }
    23680                 #endif /* HAVE_ECC */
     24921                #endif /* HAVE_ECC || HAVE_CURVE25519 */
    2368124922                #ifndef NO_DH
    2368224923                    case diffie_hellman_kea:
    … …  
    2369624937                    }
    2369724938                #endif /* !NO_DH && !NO_PSK */
    23698                 #if defined(HAVE_ECC) && !defined(NO_PSK)
     24939                #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     24940                                                                !defined(NO_PSK)
    2369924941                    case ecdhe_psk_kea:
    2370024942                    {
    … …  
    2370624948                        break;
    2370724949                    }
    23708                 #endif /* HAVE_ECC && !NO_PSK */
     24950                #endif /* (HAVE_ECC || HAVE_CURVE25519) && !NO_PSK */
    2370924951                    default:
    2371024952                        WOLFSSL_MSG("Bad kea type");
    … …  
    2377325015                            WOLFSSL_MSG("RSA message too big");
    2377425016                            ERROR_OUT(BUFFER_ERROR, exit_dcke);
     25017                        }
     25018
     25019                        /* pre-load PreMasterSecret with RNG data */
     25020                        ret = wc_RNG_GenerateBlock(ssl->rng,
     25021                            &ssl->arrays->preMasterSecret[VERSION_SZ],
     25022                            SECRET_LEN - VERSION_SZ);
     25023                        if (ret != 0) {
     25024                            goto exit_dcke;
    2377525025                        }
    2377625026
    … …  
    2408725337                    }
    2408825338                #endif /* !NO_DH && !NO_PSK */
    24089                 #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && !defined(NO_PSK)
     25339                #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     25340                                                                !defined(NO_PSK)
    2409025341                    case ecdhe_psk_kea:
    2409125342                    {
    … …  
    2422525476                    {
    2422625477                        RsaKey* key = (RsaKey*)ssl->hsKey;
     25478
    2422725479                        ret = RsaDec(ssl,
    2422825480                            input + args->idx,
    … …  
    2423125483                            &args->sigSz,
    2423225484                            key,
    24233                         #if defined(HAVE_PK_CALLBACKS)
    24234                             ssl->buffers.key->buffer,
    24235                             ssl->buffers.key->length,
    24236                             ssl->RsaDecCtx
     25485                        #ifdef HAVE_PK_CALLBACKS
     25486                            ssl->buffers.key
    2423725487                        #else
    24238                             NULL, 0, NULL
     25488                            NULL
    2423925489                        #endif
    2424025490                        );
     25491
     25492                        /*  Errors that can occur here that should be
     25493                         *  indistinguishable:
     25494                         *       RSA_BUFFER_E, RSA_PAD_E and RSA_PRIVATE_ERROR
     25495                         */
     25496                        if (ret < 0 && ret != BAD_FUNC_ARG) {
     25497                        #ifdef WOLFSSL_ASYNC_CRYPT
     25498                            if (ret == WC_PENDING_E)
     25499                                goto exit_dcke;
     25500                        #endif
     25501                            /* store error code for handling below */
     25502                            args->lastErr = ret;
     25503                            ret = 0;
     25504                        }
    2424125505                        break;
    2424225506                    } /* rsa_kea */
    … …  
    2425825522                    {
    2425925523                        void* private_key = ssl->eccTempKey;
     25524                        (void)private_key;
    2426025525
    2426125526                    #ifdef HAVE_CURVE25519
    … …  
    2426725532                                ssl->arrays->preMasterSecret,
    2426825533                                &ssl->arrays->preMasterSz,
    24269                                 WOLFSSL_SERVER_END,
    24270                             #ifdef HAVE_PK_CALLBACKS
    24271                                 ssl->EccSharedSecretCtx
    24272                             #else
    24273                                 NULL
    24274                             #endif
     25534                                WOLFSSL_SERVER_END
    2427525535                            );
    2427625536                            break;
    … …  
    2428825548                            ssl->arrays->preMasterSecret,
    2428925549                            &ssl->arrays->preMasterSz,
    24290                             WOLFSSL_SERVER_END,
    24291                         #ifdef HAVE_PK_CALLBACKS
    24292                             ssl->EccSharedSecretCtx
    24293                         #else
    24294                             NULL
    24295                         #endif
     25550                            WOLFSSL_SERVER_END
    2429625551                        );
     25552                    #ifdef WOLFSSL_ASYNC_CRYPT
     25553                        if (ret != WC_PENDING_E)
     25554                    #endif
     25555                        {
     25556                            FreeKey(ssl, DYNAMIC_TYPE_ECC,
     25557                                                      (void**)&ssl->peerEccKey);
     25558                            ssl->peerEccKeyPresent = 0;
     25559                        }
    2429725560                    #endif
    2429825561                        break;
    … …  
    2432525588                    }
    2432625589                #endif /* !NO_DH && !NO_PSK */
    24327                 #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && !defined(NO_PSK)
     25590                #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     25591                                                                !defined(NO_PSK)
    2432825592                    case ecdhe_psk_kea:
    2432925593                    {
    … …  
    2433625600                                ssl->arrays->preMasterSecret + OPAQUE16_LEN,
    2433725601                                &args->sigSz,
    24338                                 WOLFSSL_SERVER_END,
    24339                             #ifdef HAVE_PK_CALLBACKS
    24340                                 ssl->EccSharedSecretCtx
    24341                             #else
    24342                                 NULL
    24343                             #endif
     25602                                WOLFSSL_SERVER_END
    2434425603                            );
     25604                        #ifdef WOLFSSL_ASYNC_CRYPT
     25605                            if (ret != WC_PENDING_E)
     25606                        #endif
     25607                            {
     25608                                FreeKey(ssl, DYNAMIC_TYPE_CURVE25519,
     25609                                                   (void**)&ssl->peerX25519Key);
     25610                                ssl->peerX25519KeyPresent = 0;
     25611                            }
    2434525612                            break;
    2434625613                        }
    … …  
    2435225619                            ssl->arrays->preMasterSecret + OPAQUE16_LEN,
    2435325620                            &args->sigSz,
    24354                             WOLFSSL_SERVER_END,
    24355                         #ifdef HAVE_PK_CALLBACKS
    24356                             ssl->EccSharedSecretCtx
    24357                         #else
    24358                             NULL
    24359                         #endif
     25621                            WOLFSSL_SERVER_END
    2436025622                        );
     25623                        if (!ssl->specs.static_ecdh
     25624                    #ifdef WOLFSSL_ASYNC_CRYPT
     25625                            && ret != WC_PENDING_E
     25626                    #endif
     25627                        ) {
     25628                            FreeKey(ssl, DYNAMIC_TYPE_ECC,
     25629                                                      (void**)&ssl->peerEccKey);
     25630                            ssl->peerEccKeyPresent = 0;
     25631                        }
    2436125632                        break;
    2436225633                    }
    … …  
    2438525656                        args->idx += args->length;
    2438625657
    24387                         if (args->sigSz == SECRET_LEN && args->output != NULL) {
    24388                             XMEMCPY(ssl->arrays->preMasterSecret, args->output, SECRET_LEN);
    24389                             if (ssl->arrays->preMasterSecret[0] != ssl->chVersion.major ||
    24390                                 ssl->arrays->preMasterSecret[1] != ssl->chVersion.minor) {
    24391                                 ERROR_OUT(PMS_VERSION_ERROR, exit_dcke);
    24392                             }
     25658                    #ifdef DEBUG_WOLFSSL
     25659                        /* check version (debug warning message only) */
     25660                        if (args->output != NULL) {
     25661                            if (args->output[0] != ssl->chVersion.major ||
     25662                                args->output[1] != ssl->chVersion.minor) {
     25663                                WOLFSSL_MSG("preMasterSecret version mismatch");
    2439325664                        }
    24394                         else {
    24395                             ERROR_OUT(RSA_PRIVATE_ERROR, exit_dcke);
    2439625665                        }
     25666                    #endif
     25667
     25668                        /* RFC5246 7.4.7.1:
     25669                         * Treat incorrectly formatted message blocks and/or
     25670                         * mismatched version numbers in a manner
     25671                         * indistinguishable from correctly formatted RSA blocks
     25672                         */
     25673
     25674                        args->lastErr = 0; /* reset */
     25675
     25676                        /* build PreMasterSecret */
     25677                        ssl->arrays->preMasterSecret[0] = ssl->chVersion.major;
     25678                        ssl->arrays->preMasterSecret[1] = ssl->chVersion.minor;
     25679                        if (args->output != NULL) {
     25680                            XMEMCPY(&ssl->arrays->preMasterSecret[VERSION_SZ],
     25681                                    &args->output[VERSION_SZ],
     25682                                    SECRET_LEN - VERSION_SZ);
     25683                        }
     25684                        /* preMasterSecret has RNG and version set
     25685                         * return proper length and ignore error
     25686                         * error will be caught as decryption error
     25687                         */
     25688                        args->sigSz = SECRET_LEN;
     25689                        ret = 0;
    2439725690                        break;
    2439825691                    } /* rsa_kea */
    … …  
    2441025703                    }
    2441125704                #endif /* HAVE_NTRU */
    24412                 #ifdef HAVE_ECC
     25705                #if defined(HAVE_ECC) || defined(HAVE_CURVE25519)
    2441325706                    case ecc_diffie_hellman_kea:
    2441425707                    {
    … …  
    2441725710                        break;
    2441825711                    }
    24419                 #endif /* HAVE_ECC */
     25712                #endif /* HAVE_ECC || HAVE_CURVE25519 */
    2442025713                #ifndef NO_DH
    2442125714                    case diffie_hellman_kea:
    … …  
    2445725750                    }
    2445825751                #endif /* !NO_DH && !NO_PSK */
    24459                 #if defined(HAVE_ECC) && !defined(NO_PSK)
     25752                #if (defined(HAVE_ECC) || defined(HAVE_CURVE25519)) && \
     25753                                                                !defined(NO_PSK)
    2446025754                    case ecdhe_psk_kea:
    2446125755                    {
    … …  
    2449025784                        break;
    2449125785                    }
    24492                 #endif /* HAVE_ECC && !NO_PSK */
     25786                #endif /* (HAVE_ECC || HAVE_CURVE25519) && !NO_PSK */
    2449325787                    default:
    2449425788                        ret = BAD_KEA_TYPE_E;
    … …  
    2450725801            case TLS_ASYNC_FINALIZE:
    2450825802            {
     25803                if (IsEncryptionOn(ssl, 0)) {
     25804                    args->idx += ssl->keys.padSz;
     25805                }
     25806
    2450925807            #ifdef HAVE_QSH
    2451025808                word16 name;
    … …  
    2456425862
    2456525863        WOLFSSL_LEAVE("DoClientKeyExchange", ret);
     25864        WOLFSSL_END(WC_FUNC_CLIENT_KEY_EXCHANGE_DO);
    2456625865
    2456725866    #ifdef WOLFSSL_ASYNC_CRYPT
    2456825867        /* Handle async operation */
    2456925868        if (ret == WC_PENDING_E) {
    24570             /* Mark message as not recevied so it can process again */
     25869            /* Mark message as not received so it can process again */
    2457125870            ssl->msgsReceived.got_client_key_exchange = 0;
    2457225871
    … …  
    2457625875
    2457725876        /* Cleanup PMS */
     25877        if (ssl->arrays->preMasterSecret != NULL) {
    2457825878        ForceZero(ssl->arrays->preMasterSecret, ssl->arrays->preMasterSz);
     25879        }
    2457925880        ssl->arrays->preMasterSz = 0;
    2458025881
    … …  
    2458625887    }
    2458725888
    24588 
    24589 #if defined(HAVE_STUNNEL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY)
     25889#endif /* !WOLFSSL_NO_TLS12 */
     25890
     25891#if defined(OPENSSL_ALL) || defined(HAVE_STUNNEL) || defined(WOLFSSL_NGINX) || \
     25892    defined(WOLFSSL_HAPROXY)
    2459025893    int SNI_Callback(WOLFSSL* ssl)
    2459125894    {
    … …  
    2460325906        return 0;
    2460425907    }
    24605 #endif /* HAVE_STUNNEL || WOLGSSL_NGINX */
     25908#endif /* OPENSSL_ALL || HAVE_STUNNEL || WOLFSSL_NGINX || WOLFSSL_HAPROXY */
     25909
    2460625910#endif /* NO_WOLFSSL_SERVER */
    2460725911
    … …  
    2469926003
    2470026004
     26005/* return the max record size */
     26006int wolfSSL_GetMaxRecordSize(WOLFSSL* ssl, int maxFragment)
     26007{
     26008    (void) ssl; /* Avoid compiler warnings */
     26009
     26010    if (maxFragment > MAX_RECORD_SIZE) {
     26011        maxFragment = MAX_RECORD_SIZE;
     26012    }
     26013
     26014#ifdef HAVE_MAX_FRAGMENT
     26015    if ((ssl->max_fragment != 0) && (maxFragment > ssl->max_fragment)) {
     26016        maxFragment = ssl->max_fragment;
     26017    }
     26018#endif /* HAVE_MAX_FRAGMENT */
     26019#ifdef WOLFSSL_DTLS
     26020    if ((ssl->options.dtls) && (maxFragment > MAX_UDP_SIZE)) {
     26021        maxFragment = MAX_UDP_SIZE;
     26022    }
     26023#endif
     26024
     26025    return maxFragment;
     26026}
     26027
     26028
    2470126029#undef ERROR_OUT
    2470226030
Note: See TracChangeset for help on using the changeset viewer.