Ignore:
Timestamp:
Jun 22, 2021, 9:00:19 PM (3 years ago)
Author:
coas-nagasima
Message:

WolfSSLとAzure IoT SDKを更新

Location:
azure_iot_hub_f767zi/trunk/wolfssl-4.7.0
Files:
1 edited
1 moved

Legend:

Unmodified
Added
Removed

  • azure_iot_hub_f767zi/trunk/wolfssl-4.7.0/src/tls.c

    r457 r464  
    6060#endif /* HAVE_QSH */
    6161
    62 #if (!defined(NO_WOLFSSL_SERVER) && defined(WOLFSSL_TLS13) && \
    63         !defined(WOLFSSL_NO_SERVER_GROUPS_EXT)) || \
    64     (defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES))
     62#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
    6563static int TLSX_KeyShare_IsSupported(int namedGroup);
    6664#endif
    6765
    68 #if ((!defined(NO_WOLFSSL_SERVER) && defined(WOLFSSL_TLS13) && \
    69         !defined(WOLFSSL_NO_SERVER_GROUPS_EXT)) || \
    70     (defined(WOLFSSL_TLS13) && !defined(HAVE_ECC) && !defined(HAVE_CURVE25519) \
    71         && !defined(HAVE_CURVE448) && defined(HAVE_SUPPORTED_CURVES)) || \
    72     ((defined(HAVE_ECC) || defined(HAVE_CURVE25519) || \
    73         defined(HAVE_CURVE448)) && defined(HAVE_SUPPORTED_CURVES))) && \
    74      defined(HAVE_TLS_EXTENSIONS)
     66#ifdef HAVE_SUPPORTED_CURVES
    7567static int TLSX_PopulateSupportedGroups(WOLFSSL* ssl, TLSX** extensions);
    7668#endif
    … …  
    135127
    136128#ifdef WOLFSSL_RENESAS_TSIP_TLS
     129   
     130    #if (WOLFSSL_RENESAS_TSIP_VER >=109)
     131
     132    int tsip_generateMasterSecretEx(
     133            byte        cipherSuiteFirst,
     134            byte        cipherSuite,
     135            const byte* pr,                 /* pre-master    */
     136            const byte* cr,                 /* client random */
     137            const byte* sr,                 /* server random */
     138            byte*       ms);
     139
     140    #elif (WOLFSSL_RENESAS_TSIP_VER >=106)
     141   
     142    int tsip_generateMasterSecret(
     143            const byte* pre,
     144            const byte* cr,
     145            const byte* sr,
     146            byte*       ms);
     147   
     148    #endif     
     149
    137150    int tsip_useable(const WOLFSSL *ssl);
    138     int tsip_generateMasterSecret(const byte *pre,
    139                                 const byte *cr,const byte *sr,
    140                                 byte *ms/* out */);
    141151    int tsip_generateSeesionKey(WOLFSSL *ssl);
    142     int tsip_generateVerifyData(const byte *ms, const byte *side,
    143                                 const byte *handshake_hash,
    144                                 byte *hashes /* out */);
    145 #endif
     152    int tsip_generateVerifyData(
     153            const byte* ms,
     154            const byte* side,
     155            const byte* handshake_hash,
     156            byte*       hashes);
     157
     158#endif /*WOLFSSL_RENESAS_TSIP_TLS*/
    146159
    147160int BuildTlsHandshakeHash(WOLFSSL* ssl, byte* hash, word32* hashLen)
    … …  
    535548    !defined(NO_WOLFSSL_RENESAS_TSIP_TLS_SESSION)
    536549        if (tsip_useable(ssl)) {
     550           
     551            #if (WOLFSSL_RENESAS_TSIP_VER>=109)
     552
     553            ret = tsip_generateMasterSecretEx(
     554                            ssl->options.cipherSuite0,
     555                            ssl->options.cipherSuite,               
     556                            &ssl->arrays->preMasterSecret[VERSION_SZ],
     557                            ssl->arrays->clientRandom,
     558                            ssl->arrays->serverRandom,
     559                            ssl->arrays->tsip_masterSecret);
     560           
     561            #elif (WOLFSSL_RENESAS_TSIP_VER>=106)
     562
    537563            ret = tsip_generateMasterSecret(
    538564                            &ssl->arrays->preMasterSecret[VERSION_SZ],
    … …  
    540566                            ssl->arrays->serverRandom,
    541567                            ssl->arrays->tsip_masterSecret);
     568
     569            #else
     570
     571            ret = NOT_COMPILED_IN;
     572
     573            #endif
    542574        } else
    543575#endif
    … …  
    642674    return ret;
    643675}
    644 
    645 
    646 static WC_INLINE void GetSEQIncrement(WOLFSSL* ssl, int verify, word32 seq[2])
    647 {
    648     if (verify) {
    649         seq[0] = ssl->keys.peer_sequence_number_hi;
    650         seq[1] = ssl->keys.peer_sequence_number_lo++;
    651         if (seq[1] > ssl->keys.peer_sequence_number_lo) {
    652             /* handle rollover */
    653             ssl->keys.peer_sequence_number_hi++;
    654         }
    655     }
    656     else {
    657         seq[0] = ssl->keys.sequence_number_hi;
    658         seq[1] = ssl->keys.sequence_number_lo++;
    659         if (seq[1] > ssl->keys.sequence_number_lo) {
    660             /* handle rollover */
    661             ssl->keys.sequence_number_hi++;
    662         }
    663     }
    664 }
    665 
    666 
    667 #ifdef WOLFSSL_DTLS
    668 static WC_INLINE void DtlsGetSEQ(WOLFSSL* ssl, int order, word32 seq[2])
    669 {
    670     if (order == PREV_ORDER) {
    671         /* Previous epoch case */
    672         seq[0] = (((word32)ssl->keys.dtls_epoch - 1) << 16) |
    673                  (ssl->keys.dtls_prev_sequence_number_hi & 0xFFFF);
    674         seq[1] = ssl->keys.dtls_prev_sequence_number_lo;
    675     }
    676     else if (order == PEER_ORDER) {
    677         seq[0] = ((word32)ssl->keys.curEpoch << 16) |
    678                  (ssl->keys.curSeq_hi & 0xFFFF);
    679         seq[1] = ssl->keys.curSeq_lo; /* explicit from peer */
    680     }
    681     else {
    682         seq[0] = ((word32)ssl->keys.dtls_epoch << 16) |
    683                  (ssl->keys.dtls_sequence_number_hi & 0xFFFF);
    684         seq[1] = ssl->keys.dtls_sequence_number_lo;
    685     }
    686 }
    687 #endif /* WOLFSSL_DTLS */
    688 
    689 
    690 static WC_INLINE void WriteSEQ(WOLFSSL* ssl, int verifyOrder, byte* out)
    691 {
    692     word32 seq[2] = {0, 0};
    693 
    694     if (!ssl->options.dtls) {
    695         GetSEQIncrement(ssl, verifyOrder, seq);
    696     }
    697     else {
    698 #ifdef WOLFSSL_DTLS
    699         DtlsGetSEQ(ssl, verifyOrder, seq);
    700 #endif
    701     }
    702 
    703     c32toa(seq[0], out);
    704     c32toa(seq[1], out + OPAQUE32_LEN);
    705 }
    706 
    707 
    708 /*** end copy ***/
    709676
    710677
    … …  
    11701137
    11711138int TLS_hmac(WOLFSSL* ssl, byte* digest, const byte* in, word32 sz, int padSz,
    1172              int content, int verify)
     1139             int content, int verify, int epochOrder)
    11731140{
    11741141    Hmac   hmac;
    11751142    byte   myInner[WOLFSSL_TLS_HMAC_INNER_SZ];
    11761143    int    ret = 0;
     1144    const byte* macSecret = NULL;
     1145    word32 hashSz = 0;
     1146
     1147    if (ssl == NULL)
     1148        return BAD_FUNC_ARG;
     1149
    11771150#ifdef HAVE_TRUNCATED_HMAC
    1178     word32 hashSz = ssl->truncated_hmac ? (byte)TRUNCATED_HMAC_SZ
     1151    hashSz = ssl->truncated_hmac ? (byte)TRUNCATED_HMAC_SZ
    11791152                                        : ssl->specs.hash_size;
    11801153#else
    1181     word32 hashSz = ssl->specs.hash_size;
    1182 #endif
    1183 
    1184     if (ssl == NULL)
    1185         return BAD_FUNC_ARG;
     1154    hashSz = ssl->specs.hash_size;
     1155#endif
    11861156
    11871157#ifdef HAVE_FUZZER
    … …  
    11981168#endif
    11991169
    1200     wolfSSL_SetTlsHmacInner(ssl, myInner, sz, content, verify);
     1170    if (!ssl->options.dtls)
     1171        wolfSSL_SetTlsHmacInner(ssl, myInner, sz, content, verify);
     1172    else
     1173        wolfSSL_SetTlsHmacInner(ssl, myInner, sz, content, epochOrder);
    12011174#if defined(WOLFSSL_RENESAS_TSIP_TLS) && \
    12021175    !defined(NO_WOLFSSL_RENESAS_TSIP_TLS_SESSION)
    … …  
    12181191        return ret;
    12191192
     1193
     1194#ifdef WOLFSSL_DTLS
     1195    if (ssl->options.dtls)
     1196        macSecret = wolfSSL_GetDtlsMacSecret(ssl, verify, epochOrder);
     1197    else
     1198        macSecret = wolfSSL_GetMacSecret(ssl, verify);
     1199#else
     1200    macSecret = wolfSSL_GetMacSecret(ssl, verify);
     1201#endif
    12201202    ret = wc_HmacSetKey(&hmac, wolfSSL_GetHmacType(ssl),
    1221                                               wolfSSL_GetMacSecret(ssl, verify),
     1203                                              macSecret,
    12221204                                              ssl->specs.hash_size);
     1205
    12231206    if (ret == 0) {
    12241207        /* Constant time verification required. */
    … …  
    13751358}
    13761359
     1360#ifdef WOLFSSL_TLS13
     1361
     1362/**
     1363 * Creates a new extension and prepend it to the provided list.
     1364 * Checks for duplicate extensions, keeps the newest.
     1365 */
     1366static int TLSX_Prepend(TLSX** list, TLSX_Type type, void* data, void* heap)
     1367{
     1368    TLSX* extension = TLSX_New(type, data, heap);
     1369    TLSX* curr = *list;
     1370
     1371    if (extension == NULL)
     1372        return MEMORY_E;
     1373
     1374    /* remove duplicate extensions, there should be only one of each type. */
     1375    while (curr && curr->next) {
     1376        if (curr->next->type == type) {
     1377            TLSX *next = curr->next;
     1378
     1379            curr->next = next->next;
     1380            next->next = NULL;
     1381
     1382            TLSX_FreeAll(next, heap);
     1383        }
     1384        curr = curr->next;
     1385    }
     1386
     1387    if (curr)
     1388        curr->next = extension;
     1389    else
     1390        *list = extension;
     1391
     1392    return 0;
     1393}
     1394
     1395#endif /* WOLFSSL_TLS13 */
     1396
    13771397#ifndef NO_WOLFSSL_CLIENT
    13781398
    … …  
    29612981{
    29622982    int ret;
     2983#if !defined(NO_WOLFSSL_SERVER)
     2984    byte status_type;
     2985    word16 size = 0;
     2986#if defined(WOLFSSL_TLS13)
     2987    DecodedCert* cert;
     2988#endif
     2989#endif
     2990
     2991#if !defined(NO_WOLFSSL_CLIENT) || !defined(NO_WOLFSSL_SERVER) \
     2992    && defined(WOLFSSL_TLS13)
     2993    OcspRequest* request;
     2994    TLSX* extension;
     2995    CertificateStatusRequest* csr;
     2996#endif
     2997
     2998#if !defined(NO_WOLFSSL_CLIENT) && defined(WOLFSSL_TLS13) \
     2999 || !defined(NO_WOLFSSL_SERVER)
     3000    word32 offset = 0;
     3001#endif
     3002
     3003#if !defined(NO_WOLFSSL_CLIENT) && defined(WOLFSSL_TLS13)
     3004    word32 resp_length;
     3005#endif
    29633006
    29643007    /* shut up compiler warnings */
    … …  
    29673010    if (!isRequest) {
    29683011#ifndef NO_WOLFSSL_CLIENT
    2969         TLSX* extension = TLSX_Find(ssl->extensions, TLSX_STATUS_REQUEST);
    2970         CertificateStatusRequest* csr = extension ?
    2971                               (CertificateStatusRequest*)extension->data : NULL;
     3012        extension = TLSX_Find(ssl->extensions, TLSX_STATUS_REQUEST);
     3013        csr = extension ? (CertificateStatusRequest*)extension->data : NULL;
    29723014
    29733015        if (!csr) {
    … …  
    29903032                    /* propagate nonce */
    29913033                    if (csr->request.ocsp.nonceSz) {
    2992                         OcspRequest* request =
    2993                              (OcspRequest*)TLSX_CSR_GetRequest(ssl->extensions);
     3034                        request =
     3035                            (OcspRequest*)TLSX_CSR_GetRequest(ssl->extensions);
    29943036
    29953037                        if (request) {
    … …  
    30073049    #ifdef WOLFSSL_TLS13
    30083050        if (ssl->options.tls1_3) {
    3009             word32       resp_length;
    3010             word32       offset = 0;
    3011 
    30123051            /* Get the new extension potentially created above. */
    30133052            extension = TLSX_Find(ssl->extensions, TLSX_STATUS_REQUEST);
    … …  
    30273066                    ret = BUFFER_ERROR;
    30283067            }
    3029         #if !defined(NO_WOLFSSL_SERVER)
    30303068            if (ret == 0) {
    30313069                csr->response.buffer = input + offset;
    30323070                csr->response.length = resp_length;
    30333071            }
    3034         #endif
    30353072
    30363073            return ret;
    … …  
    30463083    else {
    30473084#ifndef NO_WOLFSSL_SERVER
    3048         byte   status_type;
    3049         word16 offset = 0;
    3050         word16 size = 0;
    3051 
    30523085        if (length == 0)
    30533086            return 0;
    3054         if (length < ENUM_LEN)
    3055             return BUFFER_ERROR;
    30563087
    30573088        status_type = input[offset++];
    … …  
    30613092
    30623093                /* skip responder_id_list */
    3063                 if (length - offset < OPAQUE16_LEN)
     3094                if ((int)(length - offset) < OPAQUE16_LEN)
    30643095                    return BUFFER_ERROR;
    30653096
    … …  
    30683099
    30693100                /* skip request_extensions */
    3070                 if (length - offset < OPAQUE16_LEN)
     3101                if ((int)(length - offset) < OPAQUE16_LEN)
    30713102                    return BUFFER_ERROR;
    30723103
    … …  
    31003131            return ret; /* throw error */
    31013132
    3102     #if defined(WOLFSSL_TLS13) && !defined(NO_WOLFSSL_SERVER)
     3133    #if defined(WOLFSSL_TLS13)
    31033134        if (ssl->options.tls1_3) {
    3104             OcspRequest* request;
    3105             TLSX* extension = TLSX_Find(ssl->extensions, TLSX_STATUS_REQUEST);
    3106             CertificateStatusRequest* csr = extension ?
     3135            cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), ssl->heap,
     3136                                         DYNAMIC_TYPE_DCERT);
     3137            if (cert == NULL) {
     3138                return MEMORY_E;
     3139            }
     3140            InitDecodedCert(cert, ssl->buffers.certificate->buffer,
     3141                            ssl->buffers.certificate->length, ssl->heap);
     3142            ret = ParseCert(cert, CERT_TYPE, 1, ssl->ctx->cm);
     3143            if (ret != 0 ) {
     3144                XFREE(cert, ssl->heap, DYNAMIC_TYPE_DCERT);
     3145                return ret;
     3146            }
     3147            ret = TLSX_CSR_InitRequest(ssl->extensions, cert, ssl->heap);
     3148            if (ret != 0 ) {
     3149                XFREE(cert, ssl->heap, DYNAMIC_TYPE_DCERT);
     3150                return ret;
     3151            }
     3152            XFREE(cert, ssl->heap, DYNAMIC_TYPE_DCERT);
     3153
     3154            extension = TLSX_Find(ssl->extensions, TLSX_STATUS_REQUEST);
     3155            csr = extension ?
    31073156                (CertificateStatusRequest*)extension->data : NULL;
    31083157            if (csr == NULL)
    … …  
    34543503
    34553504        while (length > offset) {
    3456             if (length - offset < ENUM_LEN + OPAQUE16_LEN)
     3505            if ((int)(length - offset) < ENUM_LEN + OPAQUE16_LEN)
    34573506                return BUFFER_ERROR;
    34583507
    … …  
    34693518                case WOLFSSL_CSR2_OCSP_MULTI:
    34703519                    /* skip responder_id_list */
    3471                     if (length - offset < OPAQUE16_LEN)
     3520                    if ((int)(length - offset) < OPAQUE16_LEN)
    34723521                        return BUFFER_ERROR;
    34733522
    … …  
    34783527                    offset += OPAQUE16_LEN + size;
    34793528                    /* skip request_extensions */
    3480                     if (length - offset < OPAQUE16_LEN)
     3529                    if ((int)(length - offset) < OPAQUE16_LEN)
    34813530                        return BUFFER_ERROR;
    34823531
    … …  
    35073556            #endif
    35083557
    3509             /* accept the first good status_type and return */
    3510             ret = TLSX_UseCertificateStatusRequestV2(&ssl->extensions,
     3558            /* TLS 1.3 servers MUST NOT act upon presence or information in
     3559             * this extension (RFC 8448 Section 4.4.2.1).
     3560             */
     3561            if (!IsAtLeastTLSv1_3(ssl->version)) {
     3562                /* accept the first good status_type and return */
     3563                ret = TLSX_UseCertificateStatusRequestV2(&ssl->extensions,
    35113564                                         status_type, 0, ssl->heap, ssl->devId);
    3512             if (ret != WOLFSSL_SUCCESS)
    3513                 return ret; /* throw error */
    3514 
    3515             TLSX_SetResponse(ssl, TLSX_STATUS_REQUEST_V2);
    3516             ssl->status_request_v2 = status_type;
     3565                if (ret != WOLFSSL_SUCCESS)
     3566                    return ret; /* throw error */
     3567
     3568                TLSX_SetResponse(ssl, TLSX_STATUS_REQUEST_V2);
     3569                ssl->status_request_v2 = status_type;
     3570            }
    35173571
    35183572            return 0;
    … …  
    37083762#error Elliptic Curves Extension requires Elliptic Curve Cryptography. \
    37093763       Use --enable-ecc in the configure script or define HAVE_ECC. \
    3710        Alternatively use FFDHE for DH ciperhsuites.
     3764       Alternatively use FFDHE for DH ciphersuites.
    37113765#endif
    37123766
    … …  
    38543908        #endif
    38553909        }
    3856         else {
    3857         #ifdef HAVE_FFDHE
    3858             return;
    3859         #endif
    3860         }
    3861     }
    3862 
     3910    }
     3911 #ifdef HAVE_FFDHE
     3912        return;
     3913 #endif
    38633914    /* turns semaphore on to avoid sending this extension. */
    38643915    TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_EC_POINT_FORMATS));
    38653916}
    38663917
    3867 #endif
     3918#endif /* WOLFSSL_TLS13 || !NO_WOLFSSL_CLIENT */
    38683919
    38693920#ifndef NO_WOLFSSL_SERVER
    … …  
    38973948}
    38983949
    3899 #endif
     3950#endif /* !NO_WOLFSSL_SERVER */
     3951
    39003952#ifndef NO_WOLFSSL_CLIENT
    39013953
    … …  
    40564108
    40574109    ext = TLSX_Find(priority, TLSX_SUPPORTED_GROUPS);
     4110    if (ext == NULL) {
     4111        WOLFSSL_MSG("Could not find supported groups extension");
     4112        return 0;
     4113    }
     4114
    40584115    curve = (SupportedCurve*)ext->data;
    40594116    name = curve->name;
    … …  
    40814138}
    40824139
    4083 #endif
     4140#endif /* WOLFSSL_TLS13 && !WOLFSSL_NO_SERVER_GROUPS_EXT */
    40844141
    40854142#if defined(HAVE_FFDHE) && !defined(WOLFSSL_NO_TLS12)
    … …  
    41304187
    41314188
    4132     if ((ret = TLSX_PopulateSupportedGroups(ssl, &priority)) != WOLFSSL_SUCCESS)
     4189    if ((ret = TLSX_PopulateSupportedGroups(ssl, &priority)) != WOLFSSL_SUCCESS) {
     4190        TLSX_FreeAll(priority, ssl->heap);
    41334191        return ret;
     4192    }
    41344193    ret = 0;
    41354194
    … …  
    42314290}
    42324291
    4233 #endif
     4292#endif /* HAVE_SUPPORTED_CURVES */
    42344293
    42354294#ifndef NO_WOLFSSL_SERVER
    … …  
    42624321    SupportedCurve* curve     = NULL;
    42634322    word32          oid       = 0;
     4323#if defined(HAVE_ECC) || defined(HAVE_CURVE25519) || defined(HAVE_ED25519) || \
     4324                              defined(HAVE_CURVE448) || defined(HAVE_ED448) || \
     4325                                (!defined(NO_RSA) && defined(WOLFSSL_STATIC_DH))
    42644326    word32          pkOid     = 0;
     4327#endif /* HAVE_ECC || HAVE_ED25519 || HAVE_ED448 || (!NO_RSA && STATIC_DH) */
    42654328    word32          defOid    = 0;
    42664329    word32          defSz     = 80; /* Maximum known curve size is 66. */
    … …  
    42744337
    42754338    (void)oid;
    4276 
     4339    (void)pkOid;
     4340
     4341    if (first == CHACHA_BYTE) {
     4342        switch (second) {
     4343            case TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256:
     4344            case TLS_PSK_WITH_CHACHA20_POLY1305_SHA256:
     4345            case TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256:
     4346            case TLS_DHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256:
     4347                return 1; /* no suite restriction */
     4348            case TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256:
     4349            case TLS_ECDHE_RSA_WITH_CHACHA20_OLD_POLY1305_SHA256:
     4350            case TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256:
     4351                break;
     4352        }
     4353    }
    42774354    if (first == ECC_BYTE || first == CHACHA_BYTE)
    42784355        extension = TLSX_Find(ssl->extensions, TLSX_SUPPORTED_GROUPS);
    … …  
    42964373        switch (curve->name) {
    42974374#ifdef HAVE_ECC
    4298     #if defined(HAVE_ECC160) || defined(HAVE_ALL_CURVES)
     4375    #if (defined(HAVE_ECC160) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 160
    42994376        #ifndef NO_ECC_SECP
    43004377            case WOLFSSL_ECC_SECP160R1:
    … …  
    43154392                break;
    43164393        #endif /* HAVE_ECC_KOBLITZ */
    4317     #endif
    4318     #if defined(HAVE_ECC192) || defined(HAVE_ALL_CURVES)
     4394        #endif
     4395    #if (defined(HAVE_ECC192) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 192
    43194396        #ifndef NO_ECC_SECP
    43204397            case WOLFSSL_ECC_SECP192R1:
    … …  
    43304407        #endif /* HAVE_ECC_KOBLITZ */
    43314408    #endif
    4332     #if defined(HAVE_ECC224) || defined(HAVE_ALL_CURVES)
     4409    #if (defined(HAVE_ECC224) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 224
    43334410        #ifndef NO_ECC_SECP
    43344411            case WOLFSSL_ECC_SECP224R1:
    … …  
    43444421        #endif /* HAVE_ECC_KOBLITZ */
    43454422    #endif
    4346     #if !defined(NO_ECC256) || defined(HAVE_ALL_CURVES)
     4423    #if (!defined(NO_ECC256) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 256
    43474424        #ifndef NO_ECC_SECP
    43484425            case WOLFSSL_ECC_SECP256R1:
    … …  
    43534430    #endif /* !NO_ECC256 || HAVE_ALL_CURVES */
    43544431#endif
    4355         #ifdef HAVE_CURVE25519
     4432        #if (defined(HAVE_CURVE25519) || defined(HAVE_ED25519)) && ECC_MIN_KEY_SZ <= 256
    43564433            case WOLFSSL_ECC_X25519:
    43574434                oid = ECC_X25519_OID;
    … …  
    43654442        #endif /* HAVE_CURVE25519 */
    43664443#ifdef HAVE_ECC
    4367     #if !defined(NO_ECC256) || defined(HAVE_ALL_CURVES)
     4444    #if (!defined(NO_ECC256) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 256
    43684445        #ifdef HAVE_ECC_KOBLITZ
    43694446            case WOLFSSL_ECC_SECP256K1:
    … …  
    43794456        #endif /* HAVE_ECC_BRAINPOOL */
    43804457    #endif
    4381 #endif
    4382         #ifdef HAVE_CURVE448
     4458    #if (defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 384
     4459        #ifndef NO_ECC_SECP
     4460            case WOLFSSL_ECC_SECP384R1:
     4461                pkOid = oid = ECC_SECP384R1_OID;
     4462                octets = 48;
     4463                break;
     4464        #endif /* !NO_ECC_SECP */
     4465        #ifdef HAVE_ECC_BRAINPOOL
     4466            case WOLFSSL_ECC_BRAINPOOLP384R1:
     4467                pkOid = oid = ECC_BRAINPOOLP384R1_OID;
     4468                octets = 48;
     4469                break;
     4470        #endif /* HAVE_ECC_BRAINPOOL */
     4471    #endif
     4472#endif
     4473        #if (defined(HAVE_CURVE448) || defined(HAVE_ED448)) && ECC_MIN_KEY_SZ <= 448
    43834474            case WOLFSSL_ECC_X448:
    43844475                oid = ECC_X448_OID;
    … …  
    43924483        #endif /* HAVE_CURVE448 */
    43934484#ifdef HAVE_ECC
    4394     #if defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)
    4395         #ifndef NO_ECC_SECP
    4396             case WOLFSSL_ECC_SECP384R1:
    4397                 pkOid = oid = ECC_SECP384R1_OID;
    4398                 octets = 48;
    4399                 break;
    4400         #endif /* !NO_ECC_SECP */
    4401         #ifdef HAVE_ECC_BRAINPOOL
    4402             case WOLFSSL_ECC_BRAINPOOLP384R1:
    4403                 pkOid = oid = ECC_BRAINPOOLP384R1_OID;
    4404                 octets = 48;
    4405                 break;
    4406         #endif /* HAVE_ECC_BRAINPOOL */
    4407     #endif
    4408     #if defined(HAVE_ECC512) || defined(HAVE_ALL_CURVES)
     4485    #if (defined(HAVE_ECC512) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 512
    44094486        #ifdef HAVE_ECC_BRAINPOOL
    44104487            case WOLFSSL_ECC_BRAINPOOLP512R1:
    … …  
    44144491        #endif /* HAVE_ECC_BRAINPOOL */
    44154492    #endif
    4416     #if defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)
     4493    #if (defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 521
    44174494        #ifndef NO_ECC_SECP
    44184495            case WOLFSSL_ECC_SECP521R1:
    … …  
    44564533        if (first == ECC_BYTE) {
    44574534            switch (second) {
     4535#if defined(HAVE_ECC) || defined(HAVE_ED25519) || defined(HAVE_ED448)
    44584536                /* ECDHE_ECDSA */
    44594537                case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA:
    … …  
    44724550                break;
    44734551
    4474 #ifdef WOLFSSL_STATIC_DH
     4552    #ifdef WOLFSSL_STATIC_DH
    44754553                /* ECDH_ECDSA */
    44764554                case TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA:
    … …  
    44934571                    key |= ssl->pkCurveOID == oid;
    44944572                break;
    4495 #endif /* WOLFSSL_STATIC_DH */
     4573    #endif /* WOLFSSL_STATIC_DH */
     4574#endif /* HAVE_ECC || HAVE_ED25519 || HAVE_ED448 */
    44964575#ifndef NO_RSA
    44974576                /* ECDHE_RSA */
    … …  
    45094588                break;
    45104589
    4511 #ifdef WOLFSSL_STATIC_DH
     4590    #ifdef WOLFSSL_STATIC_DH
    45124591                /* ECDH_RSA */
    45134592                case TLS_ECDH_RSA_WITH_AES_256_CBC_SHA:
    … …  
    45304609                    key |= ssl->pkCurveOID == pkOid;
    45314610                break;
    4532 #endif /* WOLFSSL_STATIC_DH */
     4611    #endif /* WOLFSSL_STATIC_DH */
    45334612#endif
    45344613                default:
    … …  
    45524631        if (first == CHACHA_BYTE) {
    45534632            switch (second) {
     4633#if defined(HAVE_ECC) || defined(HAVE_ED25519) || defined(HAVE_ED448)
    45544634                /* ECDHE_ECDSA */
    45554635                case TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 :
    … …  
    45594639                    ephmSuite = 1;
    45604640                break;
     4641#endif /* HAVE_ECC || HAVE_ED25519 || HAVE_ED448 */
    45614642#ifndef NO_RSA
    45624643                /* ECDHE_RSA */
    … …  
    48164897        #endif
    48174898        }
    4818         else {
     4899        else if (ssl->secure_renegotiation != NULL) {
    48194900        #ifndef NO_WOLFSSL_CLIENT
    48204901            if (!ssl->secure_renegotiation->enabled) {
    … …  
    49825063        }
    49835064
    4984         if (length == 0) {
     5065        if (length > SESSION_TICKET_LEN) {
     5066            ret = BAD_TICKET_MSG_SZ;
     5067        } else if (IsAtLeastTLSv1_3(ssl->version)) {
     5068            WOLFSSL_MSG("Process client ticket rejected, TLS 1.3 no support");
     5069            ssl->options.rejectTicket = 1;
     5070            ret = 0;  /* not fatal */
     5071        } else if (ssl->options.noTicketTls12) {
     5072            /* ignore ticket request */
     5073        } else if (length == 0) {
    49855074            /* blank ticket */
    49865075            ret = TLSX_UseSessionTicket(&ssl->extensions, NULL, ssl->heap);
    49875076            if (ret == WOLFSSL_SUCCESS) {
    49885077                ret = 0;
    4989                 TLSX_SetResponse(ssl, TLSX_SESSION_TICKET);  /* send blank ticket */
     5078                /* send blank ticket */
     5079                TLSX_SetResponse(ssl, TLSX_SESSION_TICKET);
    49905080                ssl->options.createTicket = 1;  /* will send ticket msg */
    49915081                ssl->options.useTicket    = 1;
    … …  
    50155105                ssl->options.rejectTicket = 1;
    50165106                ret = 0;  /* not fatal */
     5107            } else if (ret == VERSION_ERROR) {
     5108                WOLFSSL_MSG("Process client ticket rejected, bad TLS version");
     5109                ssl->options.rejectTicket = 1;
     5110                ret = 0;  /* not fatal */
    50175111            } else if (ret == WOLFSSL_TICKET_RET_FATAL || ret < 0) {
    50185112                WOLFSSL_MSG("Process client ticket fatal error, not using");
    … …  
    58765970        *pSz += (word16)(OPAQUE8_LEN + cnt * OPAQUE16_LEN);
    58775971    }
    5878 #ifndef WOLFSSL_TLS13_DRAFT_18
    58795972    else if (msgType == server_hello || msgType == hello_retry_request)
    58805973        *pSz += OPAQUE16_LEN;
    5881 #endif
    58825974    else
    58835975        return SANITY_MSG_E;
    … …  
    59576049        *pSz += (word16)(OPAQUE8_LEN + *cnt);
    59586050    }
    5959 #ifndef WOLFSSL_TLS13_DRAFT_18
    59606051    else if (msgType == server_hello || msgType == hello_retry_request) {
    5961     #ifdef WOLFSSL_TLS13_DRAFT
    5962         if (ssl->version.major == SSLv3_MAJOR &&
    5963                                           ssl->version.minor == TLSv1_3_MINOR) {
    5964             output[0] = TLS_DRAFT_MAJOR;
    5965             output[1] = TLS_DRAFT_MINOR;
    5966         }
    5967         else
    5968     #endif
    5969         {
    5970             output[0] = ssl->version.major;
    5971             output[1] = ssl->version.minor;
    5972         }
     6052        output[0] = ssl->version.major;
     6053        output[1] = ssl->version.minor;
    59736054
    59746055        *pSz += OPAQUE16_LEN;
    59756056    }
    5976 #endif
    59776057    else
    59786058        return SANITY_MSG_E;
    … …  
    59986078    int newMinor = 0;
    59996079    int set = 0;
     6080    int ret;
    60006081
    60016082    if (msgType == client_hello) {
    … …  
    60506131                if (!ssl->options.tls1_3) {
    60516132                    ssl->options.tls1_3 = 1;
    6052                     TLSX_Push(&ssl->extensions, TLSX_SUPPORTED_VERSIONS, ssl,
    6053                               ssl->heap);
    6054 #ifndef WOLFSSL_TLS13_DRAFT_18
     6133                    ret = TLSX_Prepend(&ssl->extensions,
     6134                              TLSX_SUPPORTED_VERSIONS, ssl, ssl->heap);
     6135                    if (ret != 0) {
     6136                        return ret;
     6137                    }
    60556138                    TLSX_SetResponse(ssl, TLSX_SUPPORTED_VERSIONS);
    6056 #endif
    60576139                }
    60586140                if (minor > newMinor) {
    … …  
    60756157        }
    60766158    }
    6077 #ifndef WOLFSSL_TLS13_DRAFT_18
    60786159    else if (msgType == server_hello || msgType == hello_retry_request) {
    60796160        /* Must contain one version. */
    … …  
    60846165        minor = input[OPAQUE8_LEN];
    60856166
    6086     #ifdef WOLFSSL_TLS13_DRAFT
    6087         if (major == TLS_DRAFT_MAJOR && minor == TLS_DRAFT_MINOR) {
    6088             major = SSLv3_MAJOR;
    6089             minor = TLSv1_3_MINOR;
    6090         }
    6091     #endif
    6092 
    60936167        if (major != pv.major)
    60946168            return VERSION_ERROR;
    … …  
    61206194        }
    61216195    }
    6122 #endif
    61236196    else
    61246197        return SANITY_MSG_E;
    … …  
    61556228#endif /* WOLFSSL_TLS13 */
    61566229
    6157 #if defined(WOLFSSL_TLS13)
     6230#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_SEND_HRR_COOKIE)
    61586231
    61596232/******************************************************************************/
    … …  
    63026375        XMEMCPY(&cookie->data + len, mac, macSz);
    63036376
     6377    if (extension->data != NULL)
     6378        XFREE(extension->data, ssl->heap, DYNAMIC_TYPE_TLSX);
     6379
    63046380    extension->data = (void*)cookie;
    63056381    extension->resp = (byte)resp;
    … …  
    63216397
    63226398#endif
    6323 #if !defined(WOLFSSL_NO_SIGALG)
     6399#if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    63246400/******************************************************************************/
    63256401/* Signature Algorithms                                                       */
    … …  
    64186494        return BUFFER_ERROR;
    64196495
     6496    /* Sig Algo list size must be even. */
     6497    if (suites->hashSigAlgoSz % 2 != 0)
     6498        return BUFFER_ERROR;
     6499
    64206500    /* truncate hashSigAlgo list if too long */
    64216501    suites->hashSigAlgoSz = len;
    … …  
    64536533/******************************************************************************/
    64546534
    6455 #ifdef WOLFSSL_TLS13
    6456 #if !defined(WOLFSSL_TLS13_DRAFT_18) && !defined(WOLFSSL_TLS13_DRAFT_22)
     6535#if defined(WOLFSSL_TLS13) && !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    64576536/* Return the size of the SignatureAlgorithms extension's data.
    64586537 *
    … …  
    65416620#define SAC_WRITE     TLSX_SignatureAlgorithmsCert_Write
    65426621#define SAC_PARSE     TLSX_SignatureAlgorithmsCert_Parse
    6543 #endif /* !WOLFSSL_TLS13_DRAFT_18 && !WOLFSSL_TLS13_DRAFT_22 */
    65446622#endif /* WOLFSSL_TLS13 */
    65456623
    … …  
    65496627/******************************************************************************/
    65506628
    6551 #ifdef WOLFSSL_TLS13
     6629#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
    65526630/* Create a key share entry using named Diffie-Hellman parameters group.
    65536631 * Generates a key pair.
    … …  
    66236701    }
    66246702
    6625     /* Allocate space for the public key. */
     6703    /* Allocate space for the public key */
    66266704    dataSz = params->p_len;
    66276705    keyData = (byte*)XMALLOC(dataSz, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY);
    … …  
    66306708        goto end;
    66316709    }
    6632     /* Allocate space for the private key. */
     6710    /* Allocate space for the private key */
    66336711    key = (byte*)XMALLOC(keySz, ssl->heap, DYNAMIC_TYPE_PRIVATE_KEY);
    66346712    if (key == NULL) {
    … …  
    66446722        goto end;
    66456723
    6646     /* Generate a new key pair. */
    6647     ret = wc_DhGenerateKeyPair(dhKey, ssl->rng, (byte*)key, &keySz, keyData,
    6648                                &dataSz);
    6649 #ifdef WOLFSSL_ASYNC_CRYPT
    6650     /* TODO: Make this function non-blocking */
    6651     if (ret == WC_PENDING_E) {
    6652         ret = wc_AsyncWait(ret, &dhKey->asyncDev, WC_ASYNC_FLAG_NONE);
    6653     }
    6654 #endif
     6724#if defined(WOLFSSL_STATIC_EPHEMERAL) && defined(WOLFSSL_DH_EXTRA)
     6725    if (ssl->staticKE.dhKey) {
     6726        DerBuffer* keyDer = ssl->staticKE.dhKey;
     6727        word32 idx = 0;
     6728        WOLFSSL_MSG("Using static DH key");
     6729        ret = wc_DhKeyDecode(keyDer->buffer, &idx, dhKey, keyDer->length);
     6730        if (ret == 0) {
     6731            ret = wc_DhExportKeyPair(dhKey, (byte*)key, &keySz, keyData, &dataSz);
     6732        }
     6733    }
     6734    else
     6735#endif
     6736    {
     6737        /* Generate a new key pair */
     6738        ret = wc_DhGenerateKeyPair(dhKey, ssl->rng, (byte*)key, &keySz, keyData,
     6739                                &dataSz);
     6740    #ifdef WOLFSSL_ASYNC_CRYPT
     6741        /* TODO: Make this function non-blocking */
     6742        if (ret == WC_PENDING_E) {
     6743            ret = wc_AsyncWait(ret, &dhKey->asyncDev, WC_ASYNC_FLAG_NONE);
     6744        }
     6745    #endif
     6746    }
    66556747    if (ret != 0)
    66566748        goto end;
    66576749
    66586750    if (params->p_len != dataSz) {
    6659         /* Pad the front of the key data with zeros. */
     6751        /* Zero pad the front of the public key to match prime "p" size */
    66606752        XMEMMOVE(keyData + params->p_len - dataSz, keyData, dataSz);
    66616753        XMEMSET(keyData, 0, params->p_len - dataSz);
    … …  
    68656957    /* Translate named group to a curve id. */
    68666958    switch (kse->group) {
    6867     #if !defined(NO_ECC256)  || defined(HAVE_ALL_CURVES)
     6959    #if (!defined(NO_ECC256)  || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 256
    68686960        #ifndef NO_ECC_SECP
    68696961        case WOLFSSL_ECC_SECP256R1:
    … …  
    68746966        #endif /* !NO_ECC_SECP */
    68756967    #endif
    6876     #if defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)
     6968    #if (defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 384
    68776969        #ifndef NO_ECC_SECP
    68786970        case WOLFSSL_ECC_SECP384R1:
    … …  
    68836975        #endif /* !NO_ECC_SECP */
    68846976    #endif
    6885     #if defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)
     6977    #if (defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 521
    68866978        #ifndef NO_ECC_SECP
    68876979        case WOLFSSL_ECC_SECP521R1:
    … …  
    68926984        #endif /* !NO_ECC_SECP */
    68936985    #endif
    6894     #ifdef HAVE_X448
     6986    #if defined(HAVE_X448) && ECC_MIN_KEY_SZ <= 448
    68956987        case WOLFSSL_ECC_X448:
    68966988            curveId = ECC_X448;
    … …  
    69157007    if (ret != 0)
    69167008        goto end;
    6917     ret = wc_ecc_make_key_ex(ssl->rng, keySize, eccKey, curveId);
    6918 #ifdef WOLFSSL_ASYNC_CRYPT
    6919     /* TODO: Make this function non-blocking */
    6920     if (ret == WC_PENDING_E) {
    6921         ret = wc_AsyncWait(ret, &eccKey->asyncDev, WC_ASYNC_FLAG_NONE);
    6922     }
    6923 #endif
     7009
     7010#ifdef WOLFSSL_STATIC_EPHEMERAL
     7011    if (ssl->staticKE.ecKey) {
     7012        DerBuffer* keyDer = ssl->staticKE.ecKey;
     7013        word32 idx = 0;
     7014        WOLFSSL_MSG("Using static ECDH key");
     7015        ret = wc_EccPrivateKeyDecode(keyDer->buffer, &idx, eccKey, keyDer->length);
     7016    }
     7017    else
     7018#endif
     7019    {
     7020        /* Generate ephemeral ECC key */
     7021        ret = wc_ecc_make_key_ex(ssl->rng, keySize, eccKey, curveId);
     7022    #ifdef WOLFSSL_ASYNC_CRYPT
     7023        /* TODO: Make this function non-blocking */
     7024        if (ret == WC_PENDING_E) {
     7025            ret = wc_AsyncWait(ret, &eccKey->asyncDev, WC_ASYNC_FLAG_NONE);
     7026        }
     7027    #endif
     7028    }
    69247029    if (ret != 0)
    69257030        goto end;
    … …  
    74107515    /* find supported curve */
    74117516    switch (keyShareEntry->group) {
    7412     #if !defined(NO_ECC256)  || defined(HAVE_ALL_CURVES)
     7517    #if (!defined(NO_ECC256)  || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 256
    74137518        #ifndef NO_ECC_SECP
    74147519        case WOLFSSL_ECC_SECP256R1:
    … …  
    74177522        #endif /* !NO_ECC_SECP */
    74187523    #endif
    7419     #if defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)
     7524    #if (defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 384
    74207525        #ifndef NO_ECC_SECP
    74217526        case WOLFSSL_ECC_SECP384R1:
    … …  
    74247529        #endif /* !NO_ECC_SECP */
    74257530    #endif
    7426     #if defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)
     7531    #if (defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 521
    74277532        #ifndef NO_ECC_SECP
    74287533        case WOLFSSL_ECC_SECP521R1:
    … …  
    74317536        #endif /* !NO_ECC_SECP */
    74327537    #endif
    7433     #ifdef HAVE_X448
     7538    #if defined(HAVE_X448) && ECC_MIN_KEY_SZ <= 448
    74347539        case WOLFSSL_ECC_X448:
    74357540            curveId = ECC_X448;
    … …  
    74527557    }
    74537558    ssl->ecdhCurveOID = ssl->peerEccKey->dp->oidSum;
     7559
     7560#if defined(ECC_TIMING_RESISTANT) && (!defined(HAVE_FIPS) || \
     7561    (!defined(HAVE_FIPS_VERSION) || (HAVE_FIPS_VERSION != 2))) && \
     7562    !defined(HAVE_SELFTEST)
     7563    ret = wc_ecc_set_rng(keyShareKey, ssl->rng);
     7564    if (ret != 0) {
     7565        return ret;
     7566    }
     7567#endif
    74547568
    74557569    do {
    … …  
    78978011            break;
    78988012    #endif
    7899     #if !defined(NO_ECC256)  || defined(HAVE_ALL_CURVES)
     8013    #if (!defined(NO_ECC256)  || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 256
    79008014        #ifndef NO_ECC_SECP
    79018015        case WOLFSSL_ECC_SECP256R1:
    … …  
    79038017        #endif /* !NO_ECC_SECP */
    79048018    #endif
    7905     #ifdef HAVE_CURVE25519
     8019    #if defined(HAVE_CURVE25519) && ECC_MIN_KEY_SZ <= 256
    79068020        case WOLFSSL_ECC_X25519:
    79078021            break;
    79088022    #endif
    7909     #ifdef HAVE_CURVE448
     8023    #if defined(HAVE_CURVE448) && ECC_MIN_KEY_SZ <= 448
    79108024        case WOLFSSL_ECC_X448:
    79118025            break;
    79128026    #endif
    7913     #if defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)
     8027    #if (defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 384
    79148028        #ifndef NO_ECC_SECP
    79158029        case WOLFSSL_ECC_SECP384R1:
    … …  
    79178031        #endif /* !NO_ECC_SECP */
    79188032    #endif
    7919     #if defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)
     8033    #if (defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 521
    79208034        #ifndef NO_ECC_SECP
    79218035        case WOLFSSL_ECC_SECP521R1:
    … …  
    79448058    if (ssl->numGroups == 0) {
    79458059#if defined(HAVE_ECC) && defined(HAVE_SUPPORTED_CURVES)
    7946     #if !defined(NO_ECC256)  || defined(HAVE_ALL_CURVES)
     8060    #if (!defined(NO_ECC256)  || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 256
    79478061        #ifndef NO_ECC_SECP
    79488062            ssl->group[ssl->numGroups++] = WOLFSSL_ECC_SECP256R1;
    … …  
    79518065#endif
    79528066    #ifndef HAVE_FIPS
    7953         #if defined(HAVE_CURVE25519)
     8067        #if defined(HAVE_CURVE25519) && ECC_MIN_KEY_SZ <= 256
    79548068            ssl->group[ssl->numGroups++] = WOLFSSL_ECC_X25519;
    79558069        #endif
    79568070    #endif
    79578071    #ifndef HAVE_FIPS
    7958         #if defined(HAVE_CURVE448)
     8072        #if defined(HAVE_CURVE448) && ECC_MIN_KEY_SZ <= 448
    79598073            ssl->group[ssl->numGroups++] = WOLFSSL_ECC_X448;
    79608074        #endif
    79618075    #endif
    79628076#if defined(HAVE_ECC) && defined(HAVE_SUPPORTED_CURVES)
    7963     #if defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)
     8077    #if (defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 384
    79648078        #ifndef NO_ECC_SECP
    79658079            ssl->group[ssl->numGroups++] = WOLFSSL_ECC_SECP384R1;
    79668080        #endif
    79678081    #endif
    7968     #if defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)
     8082    #if (defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 521
    79698083        #ifndef NO_ECC_SECP
    79708084            ssl->group[ssl->numGroups++] = WOLFSSL_ECC_SECP521R1;
    … …  
    80918205            return BAD_KEY_SHARE_DATA;
    80928206
    8093     #ifdef OPENSSL_EXTRA
    80948207        if ((clientKSE->group & NAMED_DH_MASK) == 0) {
     8208            /* Check max value supported. */
     8209            if (clientKSE->group > WOLFSSL_ECC_MAX) {
     8210                continue;
     8211            }
     8212        #ifdef OPENSSL_EXTRA
    80958213            /* Check if server supports group. */
    8096             if (ssl->ctx->disabledCurves & (1 << clientKSE->group))
     8214            if (ssl->ctx->disabledCurves & ((word32)1 << clientKSE->group))
    80978215                continue;
    8098         }
    8099     #endif
     8216        #endif
     8217        }
    81008218        if (!TLSX_KeyShare_IsSupported(clientKSE->group))
    81018219            continue;
    … …  
    84058523
    84068524        /* Length of identities and of binders. */
    8407         if (length - idx < OPAQUE16_LEN + OPAQUE16_LEN)
     8525        if ((int)(length - idx) < OPAQUE16_LEN + OPAQUE16_LEN)
    84088526            return BUFFER_E;
    84098527
    … …  
    89559073 * In messages: ClientHello, EncryptedExtensions and NewSessionTicket.
    89569074 *
    8957  * max      The maximum early data size.
     9075 * maxSz    The maximum early data size.
    89589076 * output   The buffer to write into.
    89599077 * msgType  The type of the message this extension is being written into.
    89609078 * returns the number of bytes written into the buffer.
    89619079 */
    8962 static int TLSX_EarlyData_Write(word32 max, byte* output, byte msgType,
     9080static int TLSX_EarlyData_Write(word32 maxSz, byte* output, byte msgType,
    89639081                                word16* pSz)
    89649082{
    … …  
    89669084        return 0;
    89679085    else if (msgType == session_ticket) {
    8968         c32toa(max, output);
     9086        c32toa(maxSz, output);
    89699087        *pSz += OPAQUE32_LEN;
    89709088        return 0;
    … …  
    90239141/* Use the data to create a new Early Data object in the extensions.
    90249142 *
    9025  * ssl  The SSL/TLS object.
    9026  * max  The maximum early data size.
     9143 * ssl    The SSL/TLS object.
     9144 * maxSz  The maximum early data size.
    90279145 * returns 0 on success and other values indicate failure.
    90289146 */
    9029 int TLSX_EarlyData_Use(WOLFSSL* ssl, word32 max)
     9147int TLSX_EarlyData_Use(WOLFSSL* ssl, word32 maxSz)
    90309148{
    90319149    int   ret = 0;
    … …  
    90469164
    90479165    extension->resp = 1;
    9048     extension->val  = max;
     9166    extension->val  = maxSz;
    90499167
    90509168    return 0;
    … …  
    91069224        switch (extension->type) {
    91079225
     9226#ifdef HAVE_SNI
    91089227            case TLSX_SERVER_NAME:
    91099228                SNI_FREE_ALL((SNI*)extension->data, heap);
    91109229                break;
     9230#endif
    91119231
    91129232            case TLSX_TRUSTED_CA_KEYS:
    … …  
    91189238                break;
    91199239
     9240            case TLSX_EXTENDED_MASTER_SECRET:
    91209241            case TLSX_TRUNCATED_HMAC:
    91219242                /* Nothing to do. */
    … …  
    91549275                ALPN_FREE_ALL((ALPN*)extension->data, heap);
    91559276                break;
    9156 #if !defined(WOLFSSL_NO_SIGALG)
     9277#if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    91579278            case TLSX_SIGNATURE_ALGORITHMS:
    91589279                break;
    … …  
    91669287                break;
    91679288
     9289    #ifdef WOLFSSL_SEND_HRR_COOKIE
    91689290            case TLSX_COOKIE:
    91699291                CKE_FREE_ALL((Cookie*)extension->data, heap);
    91709292                break;
     9293    #endif
    91719294
    91729295    #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    … …  
    91899312    #endif
    91909313
    9191     #if !defined(WOLFSSL_TLS13_DRAFT_18) && !defined(WOLFSSL_TLS13_DRAFT_22)
     9314    #if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    91929315            case TLSX_SIGNATURE_ALGORITHMS_CERT:
    91939316                break;
    … …  
    92359358        length += HELLO_EXT_TYPE_SZ + OPAQUE16_LEN;
    92369359
    9237 
    92389360        switch (extension->type) {
    92399361
     9362#ifdef HAVE_SNI
    92409363            case TLSX_SERVER_NAME:
    92419364                /* SNI only sends the name on the request. */
    … …  
    92439366                    length += SNI_GET_SIZE((SNI*)extension->data);
    92449367                break;
     9368#endif
    92459369
    92469370            case TLSX_TRUSTED_CA_KEYS:
    … …  
    92549378                break;
    92559379
     9380            case TLSX_EXTENDED_MASTER_SECRET:
    92569381            case TLSX_TRUNCATED_HMAC:
    92579382                /* always empty. */
    … …  
    92949419                length += ALPN_GET_SIZE((ALPN*)extension->data);
    92959420                break;
    9296 #if !defined(WOLFSSL_NO_SIGALG)
     9421#if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    92979422            case TLSX_SIGNATURE_ALGORITHMS:
    92989423                length += SA_GET_SIZE(extension->data);
    … …  
    93099434                break;
    93109435
     9436    #ifdef WOLFSSL_SEND_HRR_COOKIE
    93119437            case TLSX_COOKIE:
    93129438                ret = CKE_GET_SIZE((Cookie*)extension->data, msgType, &length);
    93139439                break;
     9440    #endif
    93149441
    93159442    #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    … …  
    93369463    #endif
    93379464
    9338     #if !defined(WOLFSSL_TLS13_DRAFT_18) && !defined(WOLFSSL_TLS13_DRAFT_22)
     9465    #if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    93399466            case TLSX_SIGNATURE_ALGORITHMS_CERT:
    93409467                length += SAC_GET_SIZE(extension->data);
    … …  
    93879514        /* extension data should be written internally. */
    93889515        switch (extension->type) {
     9516#ifdef HAVE_SNI
    93899517            case TLSX_SERVER_NAME:
    93909518                if (isRequest) {
    … …  
    93939521                }
    93949522                break;
     9523#endif
    93959524
    93969525            case TLSX_TRUSTED_CA_KEYS:
    … …  
    94049533                WOLFSSL_MSG("Max Fragment Length extension to write");
    94059534                offset += MFL_WRITE((byte*)extension->data, output + offset);
     9535                break;
     9536
     9537            case TLSX_EXTENDED_MASTER_SECRET:
     9538                WOLFSSL_MSG("Extended Master Secret");
     9539                /* always empty. */
    94069540                break;
    94079541
    … …  
    94619595                offset += ALPN_WRITE((ALPN*)extension->data, output + offset);
    94629596                break;
    9463 #if !defined(WOLFSSL_NO_SIGALG)
     9597#if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    94649598            case TLSX_SIGNATURE_ALGORITHMS:
    94659599                WOLFSSL_MSG("Signature Algorithms extension to write");
    … …  
    94799613                break;
    94809614
     9615    #ifdef WOLFSSL_SEND_HRR_COOKIE
    94819616            case TLSX_COOKIE:
    94829617                WOLFSSL_MSG("Cookie extension to write");
    … …  
    94849619                                msgType, &offset);
    94859620                break;
     9621    #endif
    94869622
    94879623    #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    … …  
    95149650    #endif
    95159651
    9516     #if !defined(WOLFSSL_TLS13_DRAFT_18) && !defined(WOLFSSL_TLS13_DRAFT_22)
     9652    #if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    95179653            case TLSX_SIGNATURE_ALGORITHMS_CERT:
    95189654                WOLFSSL_MSG("Signature Algorithms extension to write");
    … …  
    97339869#endif /* HAVE_QSH */
    97349870
    9735 #if (!defined(NO_WOLFSSL_SERVER) && defined(WOLFSSL_TLS13) && \
    9736         !defined(WOLFSSL_NO_SERVER_GROUPS_EXT)) || \
    9737     (defined(WOLFSSL_TLS13) && !defined(HAVE_ECC) && !defined(HAVE_CURVE25519) \
    9738         && !defined(HAVE_CURVE448) && defined(HAVE_SUPPORTED_CURVES)) || \
    9739     ((defined(HAVE_ECC) || defined(HAVE_CURVE25519) || \
    9740         defined(HAVE_CURVE448)) && defined(HAVE_SUPPORTED_CURVES))
     9871#ifdef HAVE_SUPPORTED_CURVES
    97419872
    97429873/* Populates the default supported groups / curves */
    … …  
    97459876    int ret = WOLFSSL_SUCCESS;
    97469877#ifdef WOLFSSL_TLS13
    9747     int i;
    9748 
    97499878#if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    97509879    if (ssl->options.resuming && ssl->session.namedGroup != 0) {
    … …  
    97559884
    97569885    if (ssl->numGroups != 0) {
     9886        int i;
    97579887        for (i = 0; i < ssl->numGroups; i++) {
    97589888            ret = TLSX_UseSupportedCurve(extensions, ssl->group[i], ssl->heap);
    … …  
    97649894#endif /* WOLFSSL_TLS13 */
    97659895
    9766 #if defined(HAVE_ECC) && defined(HAVE_SUPPORTED_CURVES)
     9896#if defined(HAVE_ECC)
    97679897        /* list in order by strength, since not all servers choose by strength */
    9768         #if defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)
     9898        #if (defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 521
    97699899            #ifndef NO_ECC_SECP
    97709900                ret = TLSX_UseSupportedCurve(extensions,
    … …  
    97739903            #endif
    97749904        #endif
    9775         #if defined(HAVE_ECC512) || defined(HAVE_ALL_CURVES)
     9905        #if (defined(HAVE_ECC512) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 512
    97769906            #ifdef HAVE_ECC_BRAINPOOL
    97779907                ret = TLSX_UseSupportedCurve(extensions,
    … …  
    97809910            #endif
    97819911        #endif
    9782         #if defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)
     9912        #if (defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 384
    97839913            #ifndef NO_ECC_SECP
    97849914                ret = TLSX_UseSupportedCurve(extensions,
    … …  
    97929922            #endif
    97939923        #endif
    9794 #endif /* HAVE_ECC && HAVE_SUPPORTED_CURVES */
     9924#endif /* HAVE_ECC */
    97959925
    97969926        #ifndef HAVE_FIPS
    9797             #if defined(HAVE_CURVE448)
     9927            #if defined(HAVE_CURVE448) && ECC_MIN_KEY_SZ <= 448
    97989928                ret = TLSX_UseSupportedCurve(extensions,
    97999929                                                   WOLFSSL_ECC_X448, ssl->heap);
    … …  
    98039933
    98049934#if defined(HAVE_ECC) && defined(HAVE_SUPPORTED_CURVES)
    9805         #if !defined(NO_ECC256)  || defined(HAVE_ALL_CURVES)
     9935        #if (!defined(NO_ECC256)  || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 256
    98069936            #ifndef NO_ECC_SECP
    98079937                ret = TLSX_UseSupportedCurve(extensions,
    … …  
    98209950            #endif
    98219951        #endif
    9822 #endif /* HAVE_ECC && HAVE_SUPPORTED_CURVES */
     9952#endif /* HAVE_ECC */
    98239953
    98249954        #ifndef HAVE_FIPS
    9825             #if defined(HAVE_CURVE25519)
     9955            #if defined(HAVE_CURVE25519) && ECC_MIN_KEY_SZ <= 256
    98269956                ret = TLSX_UseSupportedCurve(extensions,
    98279957                                                 WOLFSSL_ECC_X25519, ssl->heap);
    … …  
    98319961
    98329962#if defined(HAVE_ECC) && defined(HAVE_SUPPORTED_CURVES)
    9833         #if defined(HAVE_ECC224) || defined(HAVE_ALL_CURVES)
     9963        #if (defined(HAVE_ECC224) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 224
    98349964            #ifndef NO_ECC_SECP
    98359965                ret = TLSX_UseSupportedCurve(extensions,
    … …  
    98459975
    98469976    #ifndef HAVE_FIPS
    9847         #if defined(HAVE_ECC192) || defined(HAVE_ALL_CURVES)
     9977        #if (defined(HAVE_ECC192) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 192
    98489978            #ifndef NO_ECC_SECP
    98499979                ret = TLSX_UseSupportedCurve(extensions,
    … …  
    98579987            #endif
    98589988        #endif
    9859         #if defined(HAVE_ECC160) || defined(HAVE_ALL_CURVES)
     9989        #if (defined(HAVE_ECC160) || defined(HAVE_ALL_CURVES)) && ECC_MIN_KEY_SZ <= 160
    98609990            #ifndef NO_ECC_SECP
    98619991                ret = TLSX_UseSupportedCurve(extensions,
    … …  
    987510005        #endif
    987610006    #endif /* HAVE_FIPS */
    9877 #endif /* HAVE_ECC && HAVE_SUPPORTED_CURVES */
    9878 
    9879                 /* Add FFDHE supported groups. */
     10007#endif /* HAVE_ECC */
     10008
     10009            /* Add FFDHE supported groups. */
    988010010        #ifdef HAVE_FFDHE_8192
    988110011            if (8192/8 >= ssl->options.minDhKeySz &&
    … …  
    993010060}
    993110061
    9932 #endif
     10062#endif /* HAVE_SUPPORTED_CURVES */
     10063
     10064#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
     10065
     10066static const word16 preferredGroup[] = {
     10067#if defined(HAVE_ECC) && (!defined(NO_ECC256) || \
     10068    defined(HAVE_ALL_CURVES)) && !defined(NO_ECC_SECP) && ECC_MIN_KEY_SZ <= 256
     10069    WOLFSSL_ECC_SECP256R1,
     10070#endif
     10071#if defined(HAVE_CURVE25519) && ECC_MIN_KEY_SZ <= 256
     10072    WOLFSSL_ECC_X25519,
     10073#endif
     10074#if defined(HAVE_CURVE448) && ECC_MIN_KEY_SZ <= 448
     10075    WOLFSSL_ECC_X448,
     10076#endif
     10077#if defined(HAVE_ECC) && (!defined(NO_ECC384) || \
     10078    defined(HAVE_ALL_CURVES)) && !defined(NO_ECC_SECP) && ECC_MIN_KEY_SZ <= 384
     10079    WOLFSSL_ECC_SECP384R1,
     10080#endif
     10081#if defined(HAVE_ECC) && (!defined(NO_ECC521) || \
     10082    defined(HAVE_ALL_CURVES)) && !defined(NO_ECC_SECP) && ECC_MIN_KEY_SZ <= 521
     10083    WOLFSSL_ECC_SECP521R1,
     10084#endif
     10085#if defined(HAVE_FFDHE_2048)
     10086    WOLFSSL_FFDHE_2048,
     10087#endif
     10088#if defined(HAVE_FFDHE_3072)
     10089    WOLFSSL_FFDHE_3072,
     10090#endif
     10091#if defined(HAVE_FFDHE_4096)
     10092    WOLFSSL_FFDHE_4096,
     10093#endif
     10094#if defined(HAVE_FFDHE_6144)
     10095    WOLFSSL_FFDHE_6144,
     10096#endif
     10097#if defined(HAVE_FFDHE_8192)
     10098    WOLFSSL_FFDHE_8192,
     10099#endif
     10100};
     10101#define PREFERRED_GROUP_SZ (sizeof(preferredGroup) / sizeof(*preferredGroup))
     10102
     10103#endif /* WOLFSSL_TLS13 && HAVE_SUPPORTED_CURVES */
    993310104
    993410105int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
    … …  
    1005210223    } /* is not server */
    1005310224
    10054 #if !defined(WOLFSSL_NO_SIGALG)
     10225#if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    1005510226    WOLFSSL_MSG("Adding signature algorithms extension");
    1005610227    if ((ret = TLSX_SetSignatureAlgorithms(&ssl->extensions, ssl, ssl->heap))
    … …  
    1006110232    ret = 0;
    1006210233#endif
    10063     #ifdef WOLFSSL_TLS13
     10234#ifdef WOLFSSL_TLS13
    1006410235        if (!isServer && IsAtLeastTLSv1_3(ssl->version)) {
    1006510236            /* Add mandatory TLS v1.3 extension: supported version */
    … …  
    1007910250            ret = 0;
    1008010251        }
    10081     #endif /* (HAVE_ECC || CURVE25519 || CURVE448) && HAVE_SUPPORTED_CURVES */
    10082 
    10083         #if !defined(WOLFSSL_TLS13_DRAFT_18) && !defined(WOLFSSL_TLS13_DRAFT_22)
     10252    #endif /* !(HAVE_ECC || CURVE25519 || CURVE448) && HAVE_SUPPORTED_CURVES */
     10253 
     10254        #if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    1008410255            if (ssl->certHashSigAlgoSz > 0) {
    1008510256                WOLFSSL_MSG("Adding signature algorithms cert extension");
    … …  
    1008910260                }
    1009010261            }
    10091         #endif /* !WOLFSSL_TLS13_DRAFT_18 && !WOLFSSL_TLS13_DRAFT_22 */
    10092 
     10262        #endif
     10263
     10264        #if defined(HAVE_SUPPORTED_CURVES)
    1009310265            if (TLSX_Find(ssl->extensions, TLSX_KEY_SHARE) == NULL) {
    1009410266                word16 namedGroup;
    1009510267
    10096         #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
     10268            #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    1009710269                if (ssl->options.resuming && ssl->session.namedGroup != 0)
    1009810270                    namedGroup = ssl->session.namedGroup;
    1009910271                else
    10100         #endif
    10101                 {
    10102         #if defined(HAVE_ECC) && (!defined(NO_ECC256) || \
    10103                               defined(HAVE_ALL_CURVES)) && !defined(NO_ECC_SECP)
    10104                     namedGroup = WOLFSSL_ECC_SECP256R1;
    10105         #elif defined(HAVE_CURVE25519)
    10106                     namedGroup = WOLFSSL_ECC_X25519;
    10107         #elif defined(HAVE_CURVE448)
    10108                     namedGroup = WOLFSSL_ECC_X448;
    10109         #elif defined(HAVE_ECC) && (!defined(NO_ECC384) || \
    10110                               defined(HAVE_ALL_CURVES)) && !defined(NO_ECC_SECP)
    10111                     namedGroup = WOLFSSL_ECC_SECP384R1;
    10112         #elif defined(HAVE_ECC) && (!defined(NO_ECC521) || \
    10113                               defined(HAVE_ALL_CURVES)) && !defined(NO_ECC_SECP)
    10114                     namedGroup = WOLFSSL_ECC_SECP521R1;
    10115         #elif defined(HAVE_FFDHE_2048)
    10116                     namedGroup = WOLFSSL_FFDHE_2048;
    10117         #elif defined(HAVE_FFDHE_3072)
    10118                     namedGroup = WOLFSSL_FFDHE_3072;
    10119         #elif defined(HAVE_FFDHE_4096)
    10120                     namedGroup = WOLFSSL_FFDHE_4096;
    10121         #elif defined(HAVE_FFDHE_6144)
    10122                     namedGroup = WOLFSSL_FFDHE_6144;
    10123         #elif defined(HAVE_FFDHE_8192)
    10124                     namedGroup = WOLFSSL_FFDHE_8192;
    10125         #else
     10272            #endif
     10273                if (PREFERRED_GROUP_SZ == 0) {
     10274                    WOLFSSL_MSG("No groups in preference list");
    1012610275                    return KEY_SHARE_ERROR;
    10127         #endif
     10276                }
     10277                else if (ssl->numGroups > 0) {
     10278                    int set = 0;
     10279                    int i, j;
     10280
     10281                    /* Default to first group in supported list. */
     10282                    namedGroup = ssl->group[0];
     10283                    /* Try to find preferred in supported list. */
     10284                    for (i = 0; i < (int)PREFERRED_GROUP_SZ && !set; i++) {
     10285                        for (j = 0; j < ssl->numGroups; j++) {
     10286                            if (preferredGroup[i] == ssl->group[j]) {
     10287                                /* Most preferred that is supported. */
     10288                                namedGroup = ssl->group[j];
     10289                                set = 1;
     10290                                break;
     10291                            }
     10292                        }
     10293                    }
     10294                }
     10295                else {
     10296                    /* Choose the most preferred group. */
     10297                    namedGroup = preferredGroup[0];
    1012810298                }
    1012910299                ret = TLSX_KeyShare_Use(ssl, namedGroup, 0, NULL, NULL);
    … …  
    1013110301                    return ret;
    1013210302            }
     10303        #endif
    1013310304
    1013410305        #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    … …  
    1017110342                byte cipherSuite0 = TLS13_BYTE;
    1017210343                byte cipherSuite = WOLFSSL_DEF_PSK_CIPHER;
     10344                int cipherSuiteFlags = WOLFSSL_CIPHER_SUITE_FLAG_NONE;
    1017310345                const char* cipherName = NULL;
    1017410346
    … …  
    1017910351                        ssl->arrays->psk_key, MAX_PSK_KEY_LEN, &cipherName);
    1018010352                    if (GetCipherSuiteFromName(cipherName, &cipherSuite0,
    10181                                                            &cipherSuite) != 0) {
     10353                                               &cipherSuite, &cipherSuiteFlags) != 0) {
    1018210354                        return PSK_KEY_ERROR;
    1018310355                    }
    … …  
    1019310365                }
    1019410366                ssl->arrays->client_identity[MAX_PSK_ID_LEN] = '\0';
    10195                 /* TODO: Callback should be able to change ciphersuite. */
    1019610367                ssl->options.cipherSuite0 = cipherSuite0;
    1019710368                ssl->options.cipherSuite  = cipherSuite;
     10369                (void)cipherSuiteFlags;
    1019810370                ret = SetCipherSpecs(ssl);
    1019910371                if (ret != 0)
    … …  
    1023710409        }
    1023810410
    10239     #endif
     10411#endif
    1024010412
    1024110413    (void)isServer;
    … …  
    1026410436        QSH_VALIDATE_REQUEST(ssl, semaphore);
    1026510437        WOLF_STK_VALIDATE_REQUEST(ssl);
    10266 #if !defined(WOLFSSL_NO_SIGALG)
     10438#if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    1026710439        if (ssl->suites->hashSigAlgoSz == 0)
    1026810440            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_SIGNATURE_ALGORITHMS));
    … …  
    1027110443        if (!IsAtLeastTLSv1_2(ssl))
    1027210444            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_SUPPORTED_VERSIONS));
     10445    #if !defined(WOLFSSL_NO_TLS12) || !defined(NO_OLD_TLS)
    1027310446        if (!IsAtLeastTLSv1_3(ssl->version)) {
    1027410447            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_KEY_SHARE));
    10275     #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
     10448        #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    1027610449            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_PRE_SHARED_KEY));
    1027710450            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_PSK_KEY_EXCHANGE_MODES));
     10451        #endif
     10452        #ifdef WOLFSSL_EARLY_DATA
     10453            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_EARLY_DATA));
     10454        #endif
     10455        #ifdef WOLFSSL_SEND_HRR_COOKIE
     10456            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_COOKIE));
     10457        #endif
     10458        #ifdef WOLFSSL_POST_HANDSHAKE_AUTH
     10459            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_POST_HANDSHAKE_AUTH));
     10460        #endif
     10461        }
    1027810462    #endif
    10279     #ifdef WOLFSSL_EARLY_DATA
    10280             TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_EARLY_DATA));
    10281     #endif
    10282             TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_COOKIE));
    10283     #ifdef WOLFSSL_POST_HANDSHAKE_AUTH
    10284             TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_POST_HANDSHAKE_AUTH));
    10285     #endif
    10286         }
    1028710463#endif
    1028810464    #if defined(HAVE_CERTIFICATE_STATUS_REQUEST) \
    … …  
    1029910475    #ifndef NO_CERTS
    1030010476    else if (msgType == certificate_request) {
     10477        /* Don't send out any extension except those that are turned off. */
    1030110478        XMEMSET(semaphore, 0xff, SEMAPHORE_SIZE);
    10302 #if !defined(WOLFSSL_NO_SIGALG)
     10479#if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    1030310480        TURN_OFF(semaphore, TLSX_ToSemaphore(TLSX_SIGNATURE_ALGORITHMS));
    1030410481#endif
    … …  
    1035310530        WOLF_STK_VALIDATE_REQUEST(ssl);
    1035410531        QSH_VALIDATE_REQUEST(ssl, semaphore);
    10355 #if !defined(WOLFSSL_NO_SIGALG)
     10532#if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    1035610533        if (ssl->suites->hashSigAlgoSz == 0)
    1035710534            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_SIGNATURE_ALGORITHMS));
    … …  
    1036010537        if (!IsAtLeastTLSv1_2(ssl))
    1036110538            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_SUPPORTED_VERSIONS));
     10539    #if !defined(WOLFSSL_NO_TLS12) || !defined(NO_OLD_TLS)
    1036210540        if (!IsAtLeastTLSv1_3(ssl->version)) {
    1036310541            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_KEY_SHARE));
    10364     #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
     10542        #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    1036510543            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_PSK_KEY_EXCHANGE_MODES));
     10544        #endif
     10545        #ifdef WOLFSSL_EARLY_DATA
     10546            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_EARLY_DATA));
     10547        #endif
     10548        #ifdef WOLFSSL_SEND_HRR_COOKIE
     10549            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_COOKIE));
     10550        #endif
     10551        #ifdef WOLFSSL_POST_HANDSHAKE_AUTH
     10552            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_POST_HANDSHAKE_AUTH));
     10553        #endif
     10554        }
    1036610555    #endif
    10367     #ifdef WOLFSSL_EARLY_DATA
    10368             TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_EARLY_DATA));
    10369     #endif
    10370             TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_COOKIE));
    10371     #ifdef WOLFSSL_POST_HANDSHAKE_AUTH
    10372             TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_POST_HANDSHAKE_AUTH));
    10373     #endif
    10374         }
    1037510556    #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    1037610557        /* Must write Pre-shared Key extension at the end in TLS v1.3.
    … …  
    1039310574    #ifndef NO_CERTS
    1039410575    else if (msgType == certificate_request) {
     10576        /* Don't send out any extension except those that are turned off. */
    1039510577        XMEMSET(semaphore, 0xff, SEMAPHORE_SIZE);
    10396 #if !defined(WOLFSSL_NO_SIGALG)
     10578#if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    1039710579        TURN_OFF(semaphore, TLSX_ToSemaphore(TLSX_SIGNATURE_ALGORITHMS));
    1039810580#endif
    … …  
    1046710649                if (IsAtLeastTLSv1_3(ssl->version)) {
    1046810650                    XMEMSET(semaphore, 0xff, SEMAPHORE_SIZE);
    10469         #ifndef WOLFSSL_TLS13_DRAFT_18
    1047010651                    TURN_OFF(semaphore,
    1047110652                                     TLSX_ToSemaphore(TLSX_SUPPORTED_VERSIONS));
    10472         #endif
     10653            #ifdef HAVE_SUPPORTED_CURVES
    1047310654                    if (!ssl->options.noPskDheKe)
    1047410655                        TURN_OFF(semaphore, TLSX_ToSemaphore(TLSX_KEY_SHARE));
     10656            #endif
    1047510657        #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    1047610658                    TURN_OFF(semaphore, TLSX_ToSemaphore(TLSX_PRE_SHARED_KEY));
    1047710659        #endif
    1047810660                }
     10661        #if !defined(WOLFSSL_NO_TLS12) || !defined(NO_OLD_TLS)
    1047910662                else {
     10663            #ifdef HAVE_SUPPORTED_CURVES
    1048010664                    TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_KEY_SHARE));
    10481         #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
     10665            #endif
     10666            #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    1048210667                    TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_PRE_SHARED_KEY));
     10668            #endif
     10669                }
    1048310670        #endif
    10484                 }
    1048510671    #endif
    1048610672            break;
    … …  
    1048910675        case hello_retry_request:
    1049010676            XMEMSET(semaphore, 0xff, SEMAPHORE_SIZE);
    10491         #ifndef WOLFSSL_TLS13_DRAFT_18
    1049210677                TURN_OFF(semaphore, TLSX_ToSemaphore(TLSX_SUPPORTED_VERSIONS));
    10493         #endif
     10678        #ifdef HAVE_SUPPORTED_CURVES
    1049410679            if (!ssl->options.noPskDheKe)
    1049510680                TURN_OFF(semaphore, TLSX_ToSemaphore(TLSX_KEY_SHARE));
     10681        #endif
     10682        #ifdef WOLFSSL_SEND_HRR_COOKIE
    1049610683            TURN_OFF(semaphore, TLSX_ToSemaphore(TLSX_COOKIE));
     10684        #endif
    1049710685            break;
    1049810686    #endif
    … …  
    1050010688    #ifdef WOLFSSL_TLS13
    1050110689        case encrypted_extensions:
     10690            /* Send out all extension except those that are turned on. */
     10691        #ifdef HAVE_ECC
    1050210692            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_EC_POINT_FORMATS));
     10693        #endif
    1050310694            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_SUPPORTED_VERSIONS));
     10695        #ifdef HAVE_SESSION_TICKET
    1050410696            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_SESSION_TICKET));
     10697        #endif
     10698        #ifdef HAVE_SUPPORTED_CURVES
    1050510699            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_KEY_SHARE));
     10700        #endif
    1050610701        #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    1050710702            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_PRE_SHARED_KEY));
    … …  
    1050910704        #ifdef HAVE_CERTIFICATE_STATUS_REQUEST
    1051010705            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_STATUS_REQUEST));
     10706        #endif
     10707        #ifdef HAVE_CERTIFICATE_STATUS_REQUEST_V2
     10708            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_STATUS_REQUEST_V2));
    1051110709        #endif
    1051210710        #if defined(HAVE_SECURE_RENEGOTIATION)
    … …  
    1052910727    #ifndef NO_CERTS
    1053010728        case certificate:
     10729            /* Don't send out any extension except those that are turned off. */
    1053110730            XMEMSET(semaphore, 0xff, SEMAPHORE_SIZE);
    1053210731            TURN_OFF(semaphore, TLSX_ToSemaphore(TLSX_STATUS_REQUEST));
    … …  
    1058710786                if (IsAtLeastTLSv1_3(ssl->version)) {
    1058810787                    XMEMSET(semaphore, 0xff, SEMAPHORE_SIZE);
    10589         #ifndef WOLFSSL_TLS13_DRAFT_18
    1059010788                    TURN_OFF(semaphore,
    1059110789                                     TLSX_ToSemaphore(TLSX_SUPPORTED_VERSIONS));
    10592         #endif
     10790            #ifdef HAVE_SUPPORTED_CURVES
    1059310791                    if (!ssl->options.noPskDheKe)
    1059410792                        TURN_OFF(semaphore, TLSX_ToSemaphore(TLSX_KEY_SHARE));
    10595         #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
     10793            #endif
     10794            #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    1059610795                    TURN_OFF(semaphore, TLSX_ToSemaphore(TLSX_PRE_SHARED_KEY));
     10796            #endif
     10797                }
     10798        #if !defined(WOLFSSL_NO_TLS12) || !defined(NO_OLD_TLS)
     10799                else {
     10800            #ifdef HAVE_SUPPORTED_CURVES
     10801                    TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_KEY_SHARE));
     10802            #endif
     10803            #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
     10804                    TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_PRE_SHARED_KEY));
     10805            #endif
     10806                }
    1059710807        #endif
    10598                 }
    10599                 else {
    10600                     TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_KEY_SHARE));
    10601         #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    10602                     TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_PRE_SHARED_KEY));
    10603         #endif
    10604                 }
    1060510808    #endif
    1060610809                break;
    … …  
    1060910812            case hello_retry_request:
    1061010813                XMEMSET(semaphore, 0xff, SEMAPHORE_SIZE);
    10611         #ifndef WOLFSSL_TLS13_DRAFT_18
    1061210814                TURN_OFF(semaphore, TLSX_ToSemaphore(TLSX_SUPPORTED_VERSIONS));
    10613         #endif
     10815        #ifdef HAVE_SUPPORTED_CURVES
    1061410816                if (!ssl->options.noPskDheKe)
    1061510817                    TURN_OFF(semaphore, TLSX_ToSemaphore(TLSX_KEY_SHARE));
     10818        #endif
    1061610819                /* Cookie is written below as last extension. */
    1061710820                break;
    … …  
    1062010823    #ifdef WOLFSSL_TLS13
    1062110824            case encrypted_extensions:
     10825                /* Send out all extension except those that are turned on. */
     10826        #ifdef HAVE_ECC
    1062210827                TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_EC_POINT_FORMATS));
     10828        #endif
    1062310829                TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_SUPPORTED_VERSIONS));
     10830        #ifdef HAVE_SESSION_TICKET
    1062410831                TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_SESSION_TICKET));
     10832        #endif
     10833        #ifdef HAVE_SUPPORTED_CURVES
    1062510834                TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_KEY_SHARE));
     10835        #endif
    1062610836        #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    1062710837                TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_PRE_SHARED_KEY));
    … …  
    1063010840                TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_STATUS_REQUEST));
    1063110841        #endif
     10842        #ifdef HAVE_CERTIFICATE_STATUS_REQUEST_V2
     10843            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_STATUS_REQUEST_V2));
     10844        #endif
    1063210845        #if defined(HAVE_SECURE_RENEGOTIATION)
    1063310846            TURN_ON(semaphore, TLSX_ToSemaphore(TLSX_RENEGOTIATION_INFO));
    … …  
    1064910862        #ifndef NO_CERTS
    1065010863            case certificate:
     10864                /* Don't send out any extension except those that are turned
     10865                 * off. */
    1065110866                XMEMSET(semaphore, 0xff, SEMAPHORE_SIZE);
    1065210867                TURN_OFF(semaphore, TLSX_ToSemaphore(TLSX_STATUS_REQUEST));
    … …  
    1066610881            return ret;
    1066710882
    10668 #ifdef WOLFSSL_TLS13
     10883#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_SEND_HRR_COOKIE)
    1066910884        if (msgType == hello_retry_request) {
    1067010885            XMEMSET(semaphore, 0xff, SEMAPHORE_SIZE);
    … …  
    1078511000
    1078611001        switch (type) {
     11002#ifdef HAVE_SNI
    1078711003            case TLSX_SERVER_NAME:
    1078811004                WOLFSSL_MSG("SNI extension received");
    … …  
    1079111007            #endif
    1079211008
    10793 #ifdef WOLFSSL_TLS13
     11009#if defined(WOLFSSL_TLS13) && defined(HAVE_SNI)
    1079411010                if (IsAtLeastTLSv1_3(ssl->version) &&
    1079511011                        msgType != client_hello &&
    … …  
    1080511021                ret = SNI_PARSE(ssl, input + offset, size, isRequest);
    1080611022                break;
     11023#endif
    1080711024
    1080811025            case TLSX_TRUSTED_CA_KEYS:
    … …  
    1081211029            #endif
    1081311030
    10814 #ifdef WOLFSSL_TLS13
     11031#if defined(WOLFSSL_TLS13) && defined(HAVE_TRUSTED_CA)
    1081511032                if (IsAtLeastTLSv1_3(ssl->version) &&
    1081611033                        msgType != client_hello &&
    … …  
    1082811045            #endif
    1082911046
    10830 #ifdef WOLFSSL_TLS13
     11047#if defined(WOLFSSL_TLS13) && defined(HAVE_MAX_FRAGMENT)
    1083111048                if (IsAtLeastTLSv1_3(ssl->version) &&
    1083211049                        msgType != client_hello &&
    … …  
    1084811065            #endif
    1084911066
    10850 #ifdef WOLFSSL_TLS13
     11067#if defined(WOLFSSL_TLS13) && defined(HAVE_TRUNCATED_HMAC)
    1085111068                if (IsAtLeastTLSv1_3(ssl->version))
    1085211069                    break;
    … …  
    1086111078            #endif
    1086211079
    10863 #ifdef WOLFSSL_TLS13
     11080#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
    1086411081                if (IsAtLeastTLSv1_3(ssl->version) &&
    1086511082                        msgType != client_hello &&
    … …  
    1088211099            #endif
    1088311100
    10884 #ifdef WOLFSSL_TLS13
     11101#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
    1088511102                if (IsAtLeastTLSv1_3(ssl->version))
    1088611103                    break;
    … …  
    1089511112            #endif
    1089611113
    10897  #ifdef WOLFSSL_TLS13
     11114#if defined(WOLFSSL_TLS13) && defined(HAVE_CERTIFICATE_STATUS_REQUEST)
    1089811115                if (IsAtLeastTLSv1_3(ssl->version) &&
    1089911116                        msgType != client_hello &&
    … …  
    1091211129            #endif
    1091311130
    10914 #ifdef WOLFSSL_TLS13
     11131#if defined(WOLFSSL_TLS13) && defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
    1091511132                if (IsAtLeastTLSv1_3(ssl->version) &&
    1091611133                        msgType != client_hello &&
    … …  
    1093011147            #endif
    1093111148
    10932 #ifdef WOLFSSL_TLS13
     11149#if defined(WOLFSSL_TLS13)
    1093311150                if (IsAtLeastTLSv1_3(ssl->version))
    1093411151                    break;
    … …  
    1095111168            #endif
    1095211169
    10953 #ifdef WOLFSSL_TLS13
     11170#if defined(WOLFSSL_TLS13) && defined(HAVE_SECURE_RENEGOTIATION)
    1095411171                if (IsAtLeastTLSv1_3(ssl->version))
    1095511172                    break;
    … …  
    1096411181            #endif
    1096511182
    10966 #ifdef WOLFSSL_TLS13
     11183#if defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET)
    1096711184                if (IsAtLeastTLSv1_3(ssl->version) &&
    1096811185                        msgType != client_hello) {
    … …  
    1097911196            #endif
    1098011197
    10981 #ifdef WOLFSSL_TLS13
     11198#if defined(WOLFSSL_TLS13) && defined(HAVE_QSH)
    1098211199                if (IsAtLeastTLSv1_3(ssl->version))
    1098311200                    break;
    … …  
    1099311210            #endif
    1099411211
    10995 #ifdef WOLFSSL_TLS13
     11212#if defined(WOLFSSL_TLS13) && defined(HAVE_ALPN)
    1099611213                if (IsAtLeastTLSv1_3(ssl->version) &&
    1099711214                        msgType != client_hello &&
    … …  
    1100711224                ret = ALPN_PARSE(ssl, input + offset, size, isRequest);
    1100811225                break;
    11009 #if !defined(WOLFSSL_NO_SIGALG)
     11226#if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    1101011227            case TLSX_SIGNATURE_ALGORITHMS:
    1101111228                WOLFSSL_MSG("Signature Algorithms extension received");
    … …  
    1101611233                if (!IsAtLeastTLSv1_2(ssl))
    1101711234                    break;
    11018 #ifdef WOLFSSL_TLS13
     11235            #ifdef WOLFSSL_TLS13
    1101911236                if (IsAtLeastTLSv1_3(ssl->version) &&
    1102011237                        msgType != client_hello &&
    … …  
    1102211239                    return EXT_NOT_ALLOWED;
    1102311240                }
    11024 #endif
     11241            #endif
    1102511242                ret = SA_PARSE(ssl, input + offset, size, isRequest, suites);
    1102611243                break;
    … …  
    1104811265                break;
    1104911266
     11267    #ifdef WOLFSSL_SEND_HRR_COOKIE
    1105011268            case TLSX_COOKIE:
    1105111269                WOLFSSL_MSG("Cookie extension received");
    … …  
    1106411282                ret = CKE_PARSE(ssl, input + offset, size, msgType);
    1106511283                break;
     11284    #endif
    1106611285
    1106711286    #if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
    … …  
    1113811357    #endif
    1113911358
    11140     #if !defined(WOLFSSL_TLS13_DRAFT_18) && !defined(WOLFSSL_TLS13_DRAFT_22)
     11359    #if !defined(NO_CERTS) && !defined(WOLFSSL_NO_SIGALG)
    1114111360            case TLSX_SIGNATURE_ALGORITHMS_CERT:
    1114211361                WOLFSSL_MSG("Signature Algorithms extension received");
    … …  
    1116711386            #endif
    1116811387
     11388    #ifdef HAVE_SUPPORTED_CURVES
    1116911389                if (!IsAtLeastTLSv1_3(ssl->version))
    1117011390                    break;
    … …  
    1117411394                    return EXT_NOT_ALLOWED;
    1117511395                }
     11396    #endif
     11397
    1117611398                ret = KS_PARSE(ssl, input + offset, size, msgType);
    1117711399                break;
    … …  
    1163211854
    1163311855#ifndef WOLFSSL_NO_TLS12
     11856    WOLFSSL_ABI
    1163411857    WOLFSSL_METHOD* wolfTLSv1_2_server_method(void)
    1163511858    {
    … …  
    1165611879     * returns the method data for a TLS v1.3 server.
    1165711880     */
     11881    WOLFSSL_ABI
    1165811882    WOLFSSL_METHOD* wolfTLSv1_3_server_method(void)
    1165911883    {
Note: See TracChangeset for help on using the changeset viewer.