git.sur5r.net Git - freertos/blob - FreeRTOS-Plus/Source/WolfSSL/src/tls.c

   1 /* tls.c
   2  *
   3  * Copyright (C) 2006-2015 wolfSSL Inc.
   4  *
   5  * This file is part of wolfSSL. (formerly known as CyaSSL)
   6  *
   7  * wolfSSL is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * wolfSSL is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22
  23 #ifdef HAVE_CONFIG_H
  24     #include <config.h>
  25 #endif
  26
  27 #include <wolfssl/wolfcrypt/settings.h>
  28
  29 #include <wolfssl/ssl.h>
  30 #include <wolfssl/internal.h>
  31 #include <wolfssl/error-ssl.h>
  32 #include <wolfssl/wolfcrypt/hmac.h>
  33 #ifdef NO_INLINE
  34     #include <wolfssl/wolfcrypt/misc.h>
  35 #else
  36     #include <wolfcrypt/src/misc.c>
  37 #endif
  38
  39
  40
  41 #ifndef NO_TLS
  42
  43
  44 #ifndef WOLFSSL_HAVE_MIN
  45 #define WOLFSSL_HAVE_MIN
  46
  47     static INLINE word32 min(word32 a, word32 b)
  48     {
  49         return a > b ? b : a;
  50     }
  51
  52 #endif /* WOLFSSL_HAVE_MIN */
  53
  54
  55 #ifdef WOLFSSL_SHA384
  56     #define P_HASH_MAX_SIZE SHA384_DIGEST_SIZE
  57 #else
  58     #define P_HASH_MAX_SIZE SHA256_DIGEST_SIZE
  59 #endif
  60
  61 /* compute p_hash for MD5, SHA-1, SHA-256, or SHA-384 for TLSv1 PRF */
  62 static int p_hash(byte* result, word32 resLen, const byte* secret,
  63                    word32 secLen, const byte* seed, word32 seedLen, int hash)
  64 {
  65     word32 len = P_HASH_MAX_SIZE;
  66     word32 times;
  67     word32 lastLen;
  68     word32 lastTime;
  69     word32 i;
  70     word32 idx = 0;
  71     int    ret = 0;
  72 #ifdef WOLFSSL_SMALL_STACK
  73     byte*  previous;
  74     byte*  current;
  75     Hmac*  hmac;
  76 #else
  77     byte   previous[P_HASH_MAX_SIZE];  /* max size */
  78     byte   current[P_HASH_MAX_SIZE];   /* max size */
  79     Hmac   hmac[1];
  80 #endif
  81
  82 #ifdef WOLFSSL_SMALL_STACK
  83     previous = (byte*)XMALLOC(P_HASH_MAX_SIZE, NULL, DYNAMIC_TYPE_TMP_BUFFER);
  84     current  = (byte*)XMALLOC(P_HASH_MAX_SIZE, NULL, DYNAMIC_TYPE_TMP_BUFFER);
  85     hmac     = (Hmac*)XMALLOC(sizeof(Hmac),    NULL, DYNAMIC_TYPE_TMP_BUFFER);
  86
  87     if (previous == NULL || current == NULL || hmac == NULL) {
  88         if (previous) XFREE(previous, NULL, DYNAMIC_TYPE_TMP_BUFFER);
  89         if (current)  XFREE(current,  NULL, DYNAMIC_TYPE_TMP_BUFFER);
  90         if (hmac)     XFREE(hmac,     NULL, DYNAMIC_TYPE_TMP_BUFFER);
  91
  92         return MEMORY_E;
  93     }
  94 #endif
  95
  96     switch (hash) {
  97         #ifndef NO_MD5
  98             case md5_mac:
  99                 hash = MD5;
 100                 len  = MD5_DIGEST_SIZE;
 101             break;
 102         #endif
 103
 104         #ifndef NO_SHA256
 105             case sha256_mac:
 106                 hash = SHA256;
 107                 len  = SHA256_DIGEST_SIZE;
 108             break;
 109         #endif
 110
 111         #ifdef WOLFSSL_SHA384
 112             case sha384_mac:
 113                 hash = SHA384;
 114                 len  = SHA384_DIGEST_SIZE;
 115             break;
 116         #endif
 117
 118         #ifndef NO_SHA
 119             case sha_mac:
 120             default:
 121                 hash = SHA;
 122                 len  = SHA_DIGEST_SIZE;
 123             break;
 124         #endif
 125     }
 126
 127     times   = resLen / len;
 128     lastLen = resLen % len;
 129
 130     if (lastLen)
 131         times += 1;
 132
 133     lastTime = times - 1;
 134
 135     if ((ret = wc_HmacSetKey(hmac, hash, secret, secLen)) == 0) {
 136         if ((ret = wc_HmacUpdate(hmac, seed, seedLen)) == 0) { /* A0 = seed */
 137             if ((ret = wc_HmacFinal(hmac, previous)) == 0) {   /* A1 */
 138                 for (i = 0; i < times; i++) {
 139                     ret = wc_HmacUpdate(hmac, previous, len);
 140                     if (ret != 0)
 141                         break;
 142                     ret = wc_HmacUpdate(hmac, seed, seedLen);
 143                     if (ret != 0)
 144                         break;
 145                     ret = wc_HmacFinal(hmac, current);
 146                     if (ret != 0)
 147                         break;
 148
 149                     if ((i == lastTime) && lastLen)
 150                         XMEMCPY(&result[idx], current,
 151                                                  min(lastLen, P_HASH_MAX_SIZE));
 152                     else {
 153                         XMEMCPY(&result[idx], current, len);
 154                         idx += len;
 155                         ret = wc_HmacUpdate(hmac, previous, len);
 156                         if (ret != 0)
 157                             break;
 158                         ret = wc_HmacFinal(hmac, previous);
 159                         if (ret != 0)
 160                             break;
 161                     }
 162                 }
 163             }
 164         }
 165     }
 166
 167     ForceZero(previous,  P_HASH_MAX_SIZE);
 168     ForceZero(current,   P_HASH_MAX_SIZE);
 169     ForceZero(hmac,      sizeof(Hmac));
 170
 171 #ifdef WOLFSSL_SMALL_STACK
 172     XFREE(previous, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 173     XFREE(current,  NULL, DYNAMIC_TYPE_TMP_BUFFER);
 174     XFREE(hmac,     NULL, DYNAMIC_TYPE_TMP_BUFFER);
 175 #endif
 176
 177     return ret;
 178 }
 179
 180 #undef P_HASH_MAX_SIZE
 181
 182
 183 #ifndef NO_OLD_TLS
 184
 185 /* calculate XOR for TLSv1 PRF */
 186 static INLINE void get_xor(byte *digest, word32 digLen, byte* md5, byte* sha)
 187 {
 188     word32 i;
 189
 190     for (i = 0; i < digLen; i++)
 191         digest[i] = md5[i] ^ sha[i];
 192 }
 193
 194
 195 /* compute TLSv1 PRF (pseudo random function using HMAC) */
 196 static int doPRF(byte* digest, word32 digLen, const byte* secret,word32 secLen,
 197                  const byte* label, word32 labLen, const byte* seed,
 198                  word32 seedLen)
 199 {
 200     int    ret  = 0;
 201     word32 half = (secLen + 1) / 2;
 202
 203 #ifdef WOLFSSL_SMALL_STACK
 204     byte* md5_half;
 205     byte* sha_half;
 206     byte* labelSeed;
 207     byte* md5_result;
 208     byte* sha_result;
 209 #else
 210     byte  md5_half[MAX_PRF_HALF];     /* half is real size */
 211     byte  sha_half[MAX_PRF_HALF];     /* half is real size */
 212     byte  labelSeed[MAX_PRF_LABSEED]; /* labLen + seedLen is real size */
 213     byte  md5_result[MAX_PRF_DIG];    /* digLen is real size */
 214     byte  sha_result[MAX_PRF_DIG];    /* digLen is real size */
 215 #endif
 216
 217     if (half > MAX_PRF_HALF)
 218         return BUFFER_E;
 219     if (labLen + seedLen > MAX_PRF_LABSEED)
 220         return BUFFER_E;
 221     if (digLen > MAX_PRF_DIG)
 222         return BUFFER_E;
 223
 224 #ifdef WOLFSSL_SMALL_STACK
 225     md5_half   = (byte*)XMALLOC(MAX_PRF_HALF,    NULL, DYNAMIC_TYPE_TMP_BUFFER);
 226     sha_half   = (byte*)XMALLOC(MAX_PRF_HALF,    NULL, DYNAMIC_TYPE_TMP_BUFFER);
 227     labelSeed  = (byte*)XMALLOC(MAX_PRF_LABSEED, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 228     md5_result = (byte*)XMALLOC(MAX_PRF_DIG,     NULL, DYNAMIC_TYPE_TMP_BUFFER);
 229     sha_result = (byte*)XMALLOC(MAX_PRF_DIG,     NULL, DYNAMIC_TYPE_TMP_BUFFER);
 230
 231     if (md5_half == NULL || sha_half == NULL || labelSeed == NULL ||
 232                                      md5_result == NULL || sha_result == NULL) {
 233         if (md5_half)   XFREE(md5_half,   NULL, DYNAMIC_TYPE_TMP_BUFFER);
 234         if (sha_half)   XFREE(sha_half,   NULL, DYNAMIC_TYPE_TMP_BUFFER);
 235         if (labelSeed)  XFREE(labelSeed,  NULL, DYNAMIC_TYPE_TMP_BUFFER);
 236         if (md5_result) XFREE(md5_result, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 237         if (sha_result) XFREE(sha_result, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 238
 239         return MEMORY_E;
 240     }
 241 #endif
 242
 243     XMEMSET(md5_result, 0, digLen);
 244     XMEMSET(sha_result, 0, digLen);
 245
 246     XMEMCPY(md5_half, secret, half);
 247     XMEMCPY(sha_half, secret + half - secLen % 2, half);
 248
 249     XMEMCPY(labelSeed, label, labLen);
 250     XMEMCPY(labelSeed + labLen, seed, seedLen);
 251
 252     if ((ret = p_hash(md5_result, digLen, md5_half, half, labelSeed,
 253                                              labLen + seedLen, md5_mac)) == 0) {
 254         if ((ret = p_hash(sha_result, digLen, sha_half, half, labelSeed,
 255                                              labLen + seedLen, sha_mac)) == 0) {
 256             get_xor(digest, digLen, md5_result, sha_result);
 257         }
 258     }
 259
 260 #ifdef WOLFSSL_SMALL_STACK
 261     XFREE(md5_half,   NULL, DYNAMIC_TYPE_TMP_BUFFER);
 262     XFREE(sha_half,   NULL, DYNAMIC_TYPE_TMP_BUFFER);
 263     XFREE(labelSeed,  NULL, DYNAMIC_TYPE_TMP_BUFFER);
 264     XFREE(md5_result, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 265     XFREE(sha_result, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 266 #endif
 267
 268     return ret;
 269 }
 270
 271 #endif
 272
 273
 274 /* Wrapper to call straight thru to p_hash in TSL 1.2 cases to remove stack
 275    use */
 276 static int PRF(byte* digest, word32 digLen, const byte* secret, word32 secLen,
 277             const byte* label, word32 labLen, const byte* seed, word32 seedLen,
 278             int useAtLeastSha256, int hash_type)
 279 {
 280     int ret = 0;
 281
 282     if (useAtLeastSha256) {
 283 #ifdef WOLFSSL_SMALL_STACK
 284         byte* labelSeed;
 285 #else
 286         byte labelSeed[MAX_PRF_LABSEED]; /* labLen + seedLen is real size */
 287 #endif
 288
 289         if (labLen + seedLen > MAX_PRF_LABSEED)
 290             return BUFFER_E;
 291
 292 #ifdef WOLFSSL_SMALL_STACK
 293         labelSeed = (byte*)XMALLOC(MAX_PRF_LABSEED, NULL,
 294                                                        DYNAMIC_TYPE_TMP_BUFFER);
 295         if (labelSeed == NULL)
 296            return MEMORY_E;
 297 #endif
 298
 299         XMEMCPY(labelSeed, label, labLen);
 300         XMEMCPY(labelSeed + labLen, seed, seedLen);
 301
 302         /* If a cipher suite wants an algorithm better than sha256, it
 303          * should use better. */
 304         if (hash_type < sha256_mac)
 305             hash_type = sha256_mac;
 306         ret = p_hash(digest, digLen, secret, secLen, labelSeed,
 307                      labLen + seedLen, hash_type);
 308
 309 #ifdef WOLFSSL_SMALL_STACK
 310         XFREE(labelSeed, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 311 #endif
 312     }
 313 #ifndef NO_OLD_TLS
 314     else {
 315         ret = doPRF(digest, digLen, secret, secLen, label, labLen, seed,
 316                     seedLen);
 317     }
 318 #endif
 319
 320     return ret;
 321 }
 322
 323
 324 #ifdef WOLFSSL_SHA384
 325     #define HSHASH_SZ SHA384_DIGEST_SIZE
 326 #else
 327     #define HSHASH_SZ FINISHED_SZ
 328 #endif
 329
 330
 331 int BuildTlsFinished(WOLFSSL* ssl, Hashes* hashes, const byte* sender)
 332 {
 333     const byte* side;
 334     byte        handshake_hash[HSHASH_SZ];
 335     word32      hashSz = FINISHED_SZ;
 336
 337 #ifndef NO_OLD_TLS
 338     wc_Md5GetHash(&ssl->hsHashes->hashMd5, handshake_hash);
 339     wc_ShaGetHash(&ssl->hsHashes->hashSha, &handshake_hash[MD5_DIGEST_SIZE]);
 340 #endif
 341
 342     if (IsAtLeastTLSv1_2(ssl)) {
 343 #ifndef NO_SHA256
 344         if (ssl->specs.mac_algorithm <= sha256_mac) {
 345             int ret = wc_Sha256GetHash(&ssl->hsHashes->hashSha256,handshake_hash);
 346
 347             if (ret != 0)
 348                 return ret;
 349
 350             hashSz = SHA256_DIGEST_SIZE;
 351         }
 352 #endif
 353 #ifdef WOLFSSL_SHA384
 354         if (ssl->specs.mac_algorithm == sha384_mac) {
 355             int ret = wc_Sha384Final(&ssl->hsHashes->hashSha384,handshake_hash);
 356
 357             if (ret != 0)
 358                 return ret;
 359
 360             hashSz = SHA384_DIGEST_SIZE;
 361         }
 362 #endif
 363     }
 364
 365     if ( XSTRNCMP((const char*)sender, (const char*)client, SIZEOF_SENDER) == 0)
 366         side = tls_client;
 367     else
 368         side = tls_server;
 369
 370     return PRF((byte*)hashes, TLS_FINISHED_SZ, ssl->arrays->masterSecret,
 371                SECRET_LEN, side, FINISHED_LABEL_SZ, handshake_hash, hashSz,
 372                IsAtLeastTLSv1_2(ssl), ssl->specs.mac_algorithm);
 373 }
 374
 375
 376 #ifndef NO_OLD_TLS
 377
 378 ProtocolVersion MakeTLSv1(void)
 379 {
 380     ProtocolVersion pv;
 381     pv.major = SSLv3_MAJOR;
 382     pv.minor = TLSv1_MINOR;
 383
 384     return pv;
 385 }
 386
 387
 388 ProtocolVersion MakeTLSv1_1(void)
 389 {
 390     ProtocolVersion pv;
 391     pv.major = SSLv3_MAJOR;
 392     pv.minor = TLSv1_1_MINOR;
 393
 394     return pv;
 395 }
 396
 397 #endif
 398
 399
 400 ProtocolVersion MakeTLSv1_2(void)
 401 {
 402     ProtocolVersion pv;
 403     pv.major = SSLv3_MAJOR;
 404     pv.minor = TLSv1_2_MINOR;
 405
 406     return pv;
 407 }
 408
 409
 410 static const byte master_label[MASTER_LABEL_SZ + 1] = "master secret";
 411 static const byte key_label   [KEY_LABEL_SZ + 1]    = "key expansion";
 412
 413
 414 /* External facing wrapper so user can call as well, 0 on success */
 415 int wolfSSL_DeriveTlsKeys(byte* key_data, word32 keyLen,
 416                          const byte* ms, word32 msLen,
 417                          const byte* sr, const byte* cr,
 418                          int tls1_2, int hash_type)
 419 {
 420     byte  seed[SEED_LEN];
 421
 422     XMEMCPY(seed,           sr, RAN_LEN);
 423     XMEMCPY(seed + RAN_LEN, cr, RAN_LEN);
 424
 425     return PRF(key_data, keyLen, ms, msLen, key_label, KEY_LABEL_SZ,
 426                seed, SEED_LEN, tls1_2, hash_type);
 427 }
 428
 429
 430 int DeriveTlsKeys(WOLFSSL* ssl)
 431 {
 432     int   ret;
 433     int   length = 2 * ssl->specs.hash_size +
 434                    2 * ssl->specs.key_size  +
 435                    2 * ssl->specs.iv_size;
 436 #ifdef WOLFSSL_SMALL_STACK
 437     byte* key_data;
 438 #else
 439     byte  key_data[MAX_PRF_DIG];
 440 #endif
 441
 442 #ifdef WOLFSSL_SMALL_STACK
 443     key_data = (byte*)XMALLOC(MAX_PRF_DIG, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 444     if (key_data == NULL) {
 445         return MEMORY_E;
 446     }
 447 #endif
 448
 449     ret = wolfSSL_DeriveTlsKeys(key_data, length,
 450                            ssl->arrays->masterSecret, SECRET_LEN,
 451                            ssl->arrays->serverRandom, ssl->arrays->clientRandom,
 452                            IsAtLeastTLSv1_2(ssl), ssl->specs.mac_algorithm);
 453     if (ret == 0)
 454         ret = StoreKeys(ssl, key_data);
 455
 456 #ifdef WOLFSSL_SMALL_STACK
 457     XFREE(key_data, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 458 #endif
 459
 460     return ret;
 461 }
 462
 463
 464 /* External facing wrapper so user can call as well, 0 on success */
 465 int wolfSSL_MakeTlsMasterSecret(byte* ms, word32 msLen,
 466                                const byte* pms, word32 pmsLen,
 467                                const byte* cr, const byte* sr,
 468                                int tls1_2, int hash_type)
 469 {
 470     byte  seed[SEED_LEN];
 471
 472     XMEMCPY(seed,           cr, RAN_LEN);
 473     XMEMCPY(seed + RAN_LEN, sr, RAN_LEN);
 474
 475     return PRF(ms, msLen, pms, pmsLen, master_label, MASTER_LABEL_SZ,
 476                seed, SEED_LEN, tls1_2, hash_type);
 477 }
 478
 479
 480 int MakeTlsMasterSecret(WOLFSSL* ssl)
 481 {
 482     int   ret;
 483
 484     ret = wolfSSL_MakeTlsMasterSecret(ssl->arrays->masterSecret, SECRET_LEN,
 485               ssl->arrays->preMasterSecret, ssl->arrays->preMasterSz,
 486               ssl->arrays->clientRandom, ssl->arrays->serverRandom,
 487               IsAtLeastTLSv1_2(ssl), ssl->specs.mac_algorithm);
 488
 489     if (ret == 0) {
 490     #ifdef SHOW_SECRETS
 491         int i;
 492
 493         printf("master secret: ");
 494         for (i = 0; i < SECRET_LEN; i++)
 495             printf("%02x", ssl->arrays->masterSecret[i]);
 496         printf("\n");
 497     #endif
 498
 499         ret = DeriveTlsKeys(ssl);
 500     }
 501
 502     return ret;
 503 }
 504
 505
 506 /* Used by EAP-TLS and EAP-TTLS to derive keying material from
 507  * the master_secret. */
 508 int wolfSSL_make_eap_keys(WOLFSSL* ssl, void* msk, unsigned int len,
 509                                                               const char* label)
 510 {
 511     int   ret;
 512 #ifdef WOLFSSL_SMALL_STACK
 513     byte* seed;
 514 #else
 515     byte  seed[SEED_LEN];
 516 #endif
 517
 518 #ifdef WOLFSSL_SMALL_STACK
 519     seed = (byte*)XMALLOC(SEED_LEN, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 520     if (seed == NULL)
 521         return MEMORY_E;
 522 #endif
 523
 524     /*
 525      * As per RFC-5281, the order of the client and server randoms is reversed
 526      * from that used by the TLS protocol to derive keys.
 527      */
 528     XMEMCPY(seed,           ssl->arrays->clientRandom, RAN_LEN);
 529     XMEMCPY(seed + RAN_LEN, ssl->arrays->serverRandom, RAN_LEN);
 530
 531     ret = PRF((byte*)msk, len, ssl->arrays->masterSecret, SECRET_LEN,
 532               (const byte *)label, (word32)strlen(label), seed, SEED_LEN,
 533               IsAtLeastTLSv1_2(ssl), ssl->specs.mac_algorithm);
 534
 535 #ifdef WOLFSSL_SMALL_STACK
 536     XFREE(seed, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 537 #endif
 538
 539     return ret;
 540 }
 541
 542
 543 /*** next for static INLINE s copied internal.c ***/
 544
 545 /* convert 16 bit integer to opaque */
 546 static INLINE void c16toa(word16 u16, byte* c)
 547 {
 548     c[0] = (u16 >> 8) & 0xff;
 549     c[1] =  u16 & 0xff;
 550 }
 551
 552 #ifdef HAVE_TLS_EXTENSIONS
 553 /* convert opaque to 16 bit integer */
 554 static INLINE void ato16(const byte* c, word16* u16)
 555 {
 556     *u16 = (c[0] << 8) | (c[1]);
 557 }
 558
 559 #ifdef HAVE_SNI
 560 /* convert a 24 bit integer into a 32 bit one */
 561 static INLINE void c24to32(const word24 u24, word32* u32)
 562 {
 563     *u32 = (u24[0] << 16) | (u24[1] << 8) | u24[2];
 564 }
 565 #endif
 566 #endif
 567
 568 /* convert 32 bit integer to opaque */
 569 static INLINE void c32toa(word32 u32, byte* c)
 570 {
 571     c[0] = (u32 >> 24) & 0xff;
 572     c[1] = (u32 >> 16) & 0xff;
 573     c[2] = (u32 >>  8) & 0xff;
 574     c[3] =  u32 & 0xff;
 575 }
 576
 577
 578 static INLINE word32 GetSEQIncrement(WOLFSSL* ssl, int verify)
 579 {
 580 #ifdef WOLFSSL_DTLS
 581     if (ssl->options.dtls) {
 582         if (verify)
 583             return ssl->keys.dtls_state.curSeq; /* explicit from peer */
 584         else
 585             return ssl->keys.dtls_sequence_number - 1; /* already incremented */
 586     }
 587 #endif
 588     if (verify)
 589         return ssl->keys.peer_sequence_number++;
 590     else
 591         return ssl->keys.sequence_number++;
 592 }
 593
 594
 595 #ifdef WOLFSSL_DTLS
 596
 597 static INLINE word32 GetEpoch(WOLFSSL* ssl, int verify)
 598 {
 599     if (verify)
 600         return ssl->keys.dtls_state.curEpoch;
 601     else
 602         return ssl->keys.dtls_epoch;
 603 }
 604
 605 #endif /* WOLFSSL_DTLS */
 606
 607
 608 /*** end copy ***/
 609
 610
 611 /* return HMAC digest type in wolfSSL format */
 612 int wolfSSL_GetHmacType(WOLFSSL* ssl)
 613 {
 614     if (ssl == NULL)
 615         return BAD_FUNC_ARG;
 616
 617     switch (ssl->specs.mac_algorithm) {
 618         #ifndef NO_MD5
 619         case md5_mac:
 620         {
 621             return MD5;
 622         }
 623         #endif
 624         #ifndef NO_SHA256
 625         case sha256_mac:
 626         {
 627             return SHA256;
 628         }
 629         #endif
 630         #ifdef WOLFSSL_SHA384
 631         case sha384_mac:
 632         {
 633             return SHA384;
 634         }
 635
 636         #endif
 637         #ifndef NO_SHA
 638         case sha_mac:
 639         {
 640             return SHA;
 641         }
 642         #endif
 643         #ifdef HAVE_BLAKE2
 644         case blake2b_mac:
 645         {
 646             return BLAKE2B_ID;
 647         }
 648         #endif
 649         default:
 650         {
 651             return SSL_FATAL_ERROR;
 652         }
 653     }
 654 }
 655
 656
 657 int wolfSSL_SetTlsHmacInner(WOLFSSL* ssl, byte* inner, word32 sz, int content,
 658                            int verify)
 659 {
 660     if (ssl == NULL || inner == NULL)
 661         return BAD_FUNC_ARG;
 662
 663     XMEMSET(inner, 0, WOLFSSL_TLS_HMAC_INNER_SZ);
 664
 665 #ifdef WOLFSSL_DTLS
 666     if (ssl->options.dtls)
 667         c16toa((word16)GetEpoch(ssl, verify), inner);
 668 #endif
 669     c32toa(GetSEQIncrement(ssl, verify), &inner[sizeof(word32)]);
 670     inner[SEQ_SZ] = (byte)content;
 671     inner[SEQ_SZ + ENUM_LEN]            = ssl->version.major;
 672     inner[SEQ_SZ + ENUM_LEN + ENUM_LEN] = ssl->version.minor;
 673     c16toa((word16)sz, inner + SEQ_SZ + ENUM_LEN + VERSION_SZ);
 674
 675     return 0;
 676 }
 677
 678
 679 /* TLS type HMAC */
 680 int TLS_hmac(WOLFSSL* ssl, byte* digest, const byte* in, word32 sz,
 681               int content, int verify)
 682 {
 683     Hmac hmac;
 684     int  ret;
 685     byte myInner[WOLFSSL_TLS_HMAC_INNER_SZ];
 686
 687     if (ssl == NULL)
 688         return BAD_FUNC_ARG;
 689
 690 #ifdef HAVE_FUZZER
 691     if (ssl->fuzzerCb)
 692         ssl->fuzzerCb(ssl, in, sz, FUZZ_HMAC, ssl->fuzzerCtx);
 693 #endif
 694
 695     wolfSSL_SetTlsHmacInner(ssl, myInner, sz, content, verify);
 696
 697     ret = wc_HmacSetKey(&hmac, wolfSSL_GetHmacType(ssl),
 698                      wolfSSL_GetMacSecret(ssl, verify), ssl->specs.hash_size);
 699     if (ret != 0)
 700         return ret;
 701     ret = wc_HmacUpdate(&hmac, myInner, sizeof(myInner));
 702     if (ret != 0)
 703         return ret;
 704     ret = wc_HmacUpdate(&hmac, in, sz);                                /* content */
 705     if (ret != 0)
 706         return ret;
 707     ret = wc_HmacFinal(&hmac, digest);
 708     if (ret != 0)
 709         return ret;
 710
 711     return 0;
 712 }
 713
 714 #ifdef HAVE_TLS_EXTENSIONS
 715
 716
 717 /** Supports up to 64 flags. Update as needed. */
 718 #define SEMAPHORE_SIZE 8
 719
 720
 721 static INLINE word16 TLSX_ToSemaphore(word16 type)
 722 {
 723     switch (type) {
 724         case SECURE_RENEGOTIATION:
 725             return 63;
 726
 727         default:
 728             if (type > 62) {
 729                 /* This message SHOULD only happens during the adding of
 730                    new TLS extensions in which its IANA number overflows
 731                    the current semaphore's range, or if its number already
 732                    is assigned to be used by another extension.
 733                    Use this check value for the new extension and decrement
 734                    the check value by one. */
 735                 WOLFSSL_MSG("### TLSX semaphore colision or overflow detected!");
 736             }
 737     }
 738
 739     return type;
 740 }
 741
 742
 743 #define IS_OFF(semaphore, light) \
 744     ((semaphore)[(light) / 8] ^  (byte) (0x01 << ((light) % 8)))
 745
 746
 747 #define TURN_ON(semaphore, light) \
 748     ((semaphore)[(light) / 8] |= (byte) (0x01 << ((light) % 8)))
 749
 750
 751 static int TLSX_Push(TLSX** list, TLSX_Type type, void* data)
 752 {
 753     TLSX* extension;
 754
 755     extension = (TLSX*)XMALLOC(sizeof(TLSX), 0, DYNAMIC_TYPE_TLSX);
 756     if (extension == NULL)
 757         return MEMORY_E;
 758
 759     extension->type = type;
 760     extension->data = data;
 761     extension->resp = 0;
 762     extension->next = *list;
 763     *list = extension;
 764
 765     /* remove duplicated extensions, there should be only one of each type. */
 766     do {
 767         if (extension->next && extension->next->type == type) {
 768             TLSX *next = extension->next;
 769
 770             extension->next = next->next;
 771             next->next = NULL;
 772
 773             TLSX_FreeAll(next);
 774
 775             /* there is no way to occur more than */
 776             /* two extensions of the same type.   */
 777             break;
 778         }
 779     } while ((extension = extension->next));
 780
 781     return 0;
 782 }
 783
 784
 785 #ifndef NO_WOLFSSL_SERVER
 786
 787 void TLSX_SetResponse(WOLFSSL* ssl, TLSX_Type type);
 788
 789 void TLSX_SetResponse(WOLFSSL* ssl, TLSX_Type type)
 790 {
 791     TLSX *ext = TLSX_Find(ssl->extensions, type);
 792
 793     if (ext)
 794         ext->resp = 1;
 795 }
 796
 797 #endif
 798
 799 /* SNI - Server Name Indication */
 800
 801 #ifdef HAVE_SNI
 802
 803 static void TLSX_SNI_Free(SNI* sni)
 804 {
 805     if (sni) {
 806         switch (sni->type) {
 807             case WOLFSSL_SNI_HOST_NAME:
 808                 XFREE(sni->data.host_name, 0, DYNAMIC_TYPE_TLSX);
 809             break;
 810         }
 811
 812         XFREE(sni, 0, DYNAMIC_TYPE_TLSX);
 813     }
 814 }
 815
 816 static void TLSX_SNI_FreeAll(SNI* list)
 817 {
 818     SNI* sni;
 819
 820     while ((sni = list)) {
 821         list = sni->next;
 822         TLSX_SNI_Free(sni);
 823     }
 824 }
 825
 826 static int TLSX_SNI_Append(SNI** list, byte type, const void* data, word16 size)
 827 {
 828     SNI* sni;
 829
 830     if (list == NULL)
 831         return BAD_FUNC_ARG;
 832
 833     if ((sni = XMALLOC(sizeof(SNI), 0, DYNAMIC_TYPE_TLSX)) == NULL)
 834         return MEMORY_E;
 835
 836     switch (type) {
 837         case WOLFSSL_SNI_HOST_NAME: {
 838             sni->data.host_name = XMALLOC(size + 1, 0, DYNAMIC_TYPE_TLSX);
 839
 840             if (sni->data.host_name) {
 841                 XSTRNCPY(sni->data.host_name, (const char*)data, size);
 842                 sni->data.host_name[size] = 0;
 843             } else {
 844                 XFREE(sni, 0, DYNAMIC_TYPE_TLSX);
 845                 return MEMORY_E;
 846             }
 847         }
 848         break;
 849
 850         default: /* invalid type */
 851             XFREE(sni, 0, DYNAMIC_TYPE_TLSX);
 852             return BAD_FUNC_ARG;
 853     }
 854
 855     sni->type = type;
 856     sni->next = *list;
 857
 858 #ifndef NO_WOLFSSL_SERVER
 859     sni->options = 0;
 860     sni->status  = WOLFSSL_SNI_NO_MATCH;
 861 #endif
 862
 863     *list = sni;
 864
 865     return 0;
 866 }
 867
 868 static word16 TLSX_SNI_GetSize(SNI* list)
 869 {
 870     SNI* sni;
 871     word16 length = OPAQUE16_LEN; /* list length */
 872
 873     while ((sni = list)) {
 874         list = sni->next;
 875
 876         length += ENUM_LEN + OPAQUE16_LEN; /* sni type + sni length */
 877
 878         switch (sni->type) {
 879             case WOLFSSL_SNI_HOST_NAME:
 880                 length += XSTRLEN((char*)sni->data.host_name);
 881             break;
 882         }
 883     }
 884
 885     return length;
 886 }
 887
 888 static word16 TLSX_SNI_Write(SNI* list, byte* output)
 889 {
 890     SNI* sni;
 891     word16 length = 0;
 892     word16 offset = OPAQUE16_LEN; /* list length offset */
 893
 894     while ((sni = list)) {
 895         list = sni->next;
 896
 897         output[offset++] = sni->type; /* sni type */
 898
 899         switch (sni->type) {
 900             case WOLFSSL_SNI_HOST_NAME:
 901                 length = XSTRLEN((char*)sni->data.host_name);
 902
 903                 c16toa(length, output + offset); /* sni length */
 904                 offset += OPAQUE16_LEN;
 905
 906                 XMEMCPY(output + offset, sni->data.host_name, length);
 907
 908                 offset += length;
 909             break;
 910         }
 911     }
 912
 913     c16toa(offset - OPAQUE16_LEN, output); /* writing list length */
 914
 915     return offset;
 916 }
 917
 918 static SNI* TLSX_SNI_Find(SNI *list, byte type)
 919 {
 920     SNI *sni = list;
 921
 922     while (sni && sni->type != type)
 923         sni = sni->next;
 924
 925     return sni;
 926 }
 927
 928 #ifndef NO_WOLFSSL_SERVER
 929 static void TLSX_SNI_SetStatus(TLSX* extensions, byte type, byte status)
 930 {
 931     TLSX* extension = TLSX_Find(extensions, SERVER_NAME_INDICATION);
 932     SNI* sni = TLSX_SNI_Find(extension ? extension->data : NULL, type);
 933
 934     if (sni) {
 935         sni->status = status;
 936         WOLFSSL_MSG("SNI did match!");
 937     }
 938 }
 939
 940 byte TLSX_SNI_Status(TLSX* extensions, byte type)
 941 {
 942     TLSX* extension = TLSX_Find(extensions, SERVER_NAME_INDICATION);
 943     SNI* sni = TLSX_SNI_Find(extension ? extension->data : NULL, type);
 944
 945     if (sni)
 946         return sni->status;
 947
 948     return 0;
 949 }
 950 #endif
 951
 952 static int TLSX_SNI_Parse(WOLFSSL* ssl, byte* input, word16 length,
 953                                                                  byte isRequest)
 954 {
 955 #ifndef NO_WOLFSSL_SERVER
 956     word16 size = 0;
 957     word16 offset = 0;
 958 #endif
 959
 960     TLSX *extension = TLSX_Find(ssl->extensions, SERVER_NAME_INDICATION);
 961
 962     if (!extension)
 963         extension = TLSX_Find(ssl->ctx->extensions, SERVER_NAME_INDICATION);
 964
 965     if (!extension || !extension->data)
 966         return isRequest ? 0 : BUFFER_ERROR; /* not using SNI OR unexpected
 967                                                 SNI response from server. */
 968
 969     if (!isRequest)
 970         return length ? BUFFER_ERROR : 0; /* SNI response must be empty!
 971                                              Nothing else to do. */
 972
 973 #ifndef NO_WOLFSSL_SERVER
 974
 975     if (OPAQUE16_LEN > length)
 976         return BUFFER_ERROR;
 977
 978     ato16(input, &size);
 979     offset += OPAQUE16_LEN;
 980
 981     /* validating sni list length */
 982     if (length != OPAQUE16_LEN + size)
 983         return BUFFER_ERROR;
 984
 985     for (size = 0; offset < length; offset += size) {
 986         SNI *sni;
 987         byte type = input[offset++];
 988
 989         if (offset + OPAQUE16_LEN > length)
 990             return BUFFER_ERROR;
 991
 992         ato16(input + offset, &size);
 993         offset += OPAQUE16_LEN;
 994
 995         if (offset + size > length)
 996             return BUFFER_ERROR;
 997
 998         if (!(sni = TLSX_SNI_Find((SNI*)extension->data, type))) {
 999             continue; /* not using this SNI type */
1000         }
1001
1002         switch(type) {
1003             case WOLFSSL_SNI_HOST_NAME: {
1004                 byte matched = (XSTRLEN(sni->data.host_name) == size)
1005                             && (XSTRNCMP(sni->data.host_name,
1006                                        (const char*)input + offset, size) == 0);
1007
1008                 if (matched || sni->options & WOLFSSL_SNI_ANSWER_ON_MISMATCH) {
1009                     int r = TLSX_UseSNI(&ssl->extensions,
1010                                                     type, input + offset, size);
1011
1012                     if (r != SSL_SUCCESS) return r; /* throw error */
1013
1014                     TLSX_SNI_SetStatus(ssl->extensions, type,
1015                       matched ? WOLFSSL_SNI_REAL_MATCH : WOLFSSL_SNI_FAKE_MATCH);
1016
1017                 } else if (!(sni->options & WOLFSSL_SNI_CONTINUE_ON_MISMATCH)) {
1018                     SendAlert(ssl, alert_fatal, unrecognized_name);
1019
1020                     return UNKNOWN_SNI_HOST_NAME_E;
1021                 }
1022                 break;
1023             }
1024         }
1025
1026         TLSX_SetResponse(ssl, SERVER_NAME_INDICATION);
1027     }
1028
1029 #endif
1030
1031     return 0;
1032 }
1033
1034 int TLSX_UseSNI(TLSX** extensions, byte type, const void* data, word16 size)
1035 {
1036     TLSX* extension = TLSX_Find(*extensions, SERVER_NAME_INDICATION);
1037     SNI*  sni       = NULL;
1038     int   ret       = 0;
1039
1040     if (extensions == NULL || data == NULL)
1041         return BAD_FUNC_ARG;
1042
1043     if ((ret = TLSX_SNI_Append(&sni, type, data, size)) != 0)
1044         return ret;
1045
1046     if (!extension) {
1047         if ((ret = TLSX_Push(extensions, SERVER_NAME_INDICATION, (void*)sni))
1048                                                                          != 0) {
1049             TLSX_SNI_Free(sni);
1050             return ret;
1051         }
1052     }
1053     else {
1054         /* push new SNI object to extension data. */
1055         sni->next = (SNI*)extension->data;
1056         extension->data = (void*)sni;
1057
1058         /* look for another server name of the same type to remove */
1059         do {
1060             if (sni->next && sni->next->type == type) {
1061                 SNI *next = sni->next;
1062
1063                 sni->next = next->next;
1064                 TLSX_SNI_Free(next);
1065
1066                 break;
1067             }
1068         } while ((sni = sni->next));
1069     }
1070
1071     return SSL_SUCCESS;
1072 }
1073
1074 #ifndef NO_WOLFSSL_SERVER
1075 word16 TLSX_SNI_GetRequest(TLSX* extensions, byte type, void** data)
1076 {
1077     TLSX* extension = TLSX_Find(extensions, SERVER_NAME_INDICATION);
1078     SNI* sni = TLSX_SNI_Find(extension ? extension->data : NULL, type);
1079
1080     if (sni && sni->status != WOLFSSL_SNI_NO_MATCH) {
1081         switch (sni->type) {
1082             case WOLFSSL_SNI_HOST_NAME:
1083                 *data = sni->data.host_name;
1084                 return XSTRLEN(*data);
1085         }
1086     }
1087
1088     return 0;
1089 }
1090
1091 void TLSX_SNI_SetOptions(TLSX* extensions, byte type, byte options)
1092 {
1093     TLSX* extension = TLSX_Find(extensions, SERVER_NAME_INDICATION);
1094     SNI* sni = TLSX_SNI_Find(extension ? extension->data : NULL, type);
1095
1096     if (sni)
1097         sni->options = options;
1098 }
1099
1100 int TLSX_SNI_GetFromBuffer(const byte* clientHello, word32 helloSz,
1101                            byte type, byte* sni, word32* inOutSz)
1102 {
1103     word32 offset = 0;
1104     word32 len32  = 0;
1105     word16 len16  = 0;
1106
1107     if (helloSz < RECORD_HEADER_SZ + HANDSHAKE_HEADER_SZ + CLIENT_HELLO_FIRST)
1108         return INCOMPLETE_DATA;
1109
1110     /* TLS record header */
1111     if ((enum ContentType) clientHello[offset++] != handshake)
1112         return BUFFER_ERROR;
1113
1114     if (clientHello[offset++] != SSLv3_MAJOR)
1115         return BUFFER_ERROR;
1116
1117     if (clientHello[offset++] < TLSv1_MINOR)
1118         return SNI_UNSUPPORTED;
1119
1120     ato16(clientHello + offset, &len16);
1121     offset += OPAQUE16_LEN;
1122
1123     if (offset + len16 > helloSz)
1124         return INCOMPLETE_DATA;
1125
1126     /* Handshake header */
1127     if ((enum HandShakeType) clientHello[offset] != client_hello)
1128         return BUFFER_ERROR;
1129
1130     c24to32(clientHello + offset + 1, &len32);
1131     offset += HANDSHAKE_HEADER_SZ;
1132
1133     if (offset + len32 > helloSz)
1134         return BUFFER_ERROR;
1135
1136     /* client hello */
1137     offset += VERSION_SZ + RAN_LEN; /* version, random */
1138
1139     if (helloSz < offset + clientHello[offset])
1140         return BUFFER_ERROR;
1141
1142     offset += ENUM_LEN + clientHello[offset]; /* skip session id */
1143
1144     /* cypher suites */
1145     if (helloSz < offset + OPAQUE16_LEN)
1146         return BUFFER_ERROR;
1147
1148     ato16(clientHello + offset, &len16);
1149     offset += OPAQUE16_LEN;
1150
1151     if (helloSz < offset + len16)
1152         return BUFFER_ERROR;
1153
1154     offset += len16; /* skip cypher suites */
1155
1156     /* compression methods */
1157     if (helloSz < offset + 1)
1158         return BUFFER_ERROR;
1159
1160     if (helloSz < offset + clientHello[offset])
1161         return BUFFER_ERROR;
1162
1163     offset += ENUM_LEN + clientHello[offset]; /* skip compression methods */
1164
1165     /* extensions */
1166     if (helloSz < offset + OPAQUE16_LEN)
1167         return 0; /* no extensions in client hello. */
1168
1169     ato16(clientHello + offset, &len16);
1170     offset += OPAQUE16_LEN;
1171
1172     if (helloSz < offset + len16)
1173         return BUFFER_ERROR;
1174
1175     while (len16 >= OPAQUE16_LEN + OPAQUE16_LEN) {
1176         word16 extType;
1177         word16 extLen;
1178
1179         ato16(clientHello + offset, &extType);
1180         offset += OPAQUE16_LEN;
1181
1182         ato16(clientHello + offset, &extLen);
1183         offset += OPAQUE16_LEN;
1184
1185         if (helloSz < offset + extLen)
1186             return BUFFER_ERROR;
1187
1188         if (extType != SERVER_NAME_INDICATION) {
1189             offset += extLen; /* skip extension */
1190         } else {
1191             word16 listLen;
1192
1193             ato16(clientHello + offset, &listLen);
1194             offset += OPAQUE16_LEN;
1195
1196             if (helloSz < offset + listLen)
1197                 return BUFFER_ERROR;
1198
1199             while (listLen > ENUM_LEN + OPAQUE16_LEN) {
1200                 byte   sniType = clientHello[offset++];
1201                 word16 sniLen;
1202
1203                 ato16(clientHello + offset, &sniLen);
1204                 offset += OPAQUE16_LEN;
1205
1206                 if (helloSz < offset + sniLen)
1207                     return BUFFER_ERROR;
1208
1209                 if (sniType != type) {
1210                     offset  += sniLen;
1211                     listLen -= min(ENUM_LEN + OPAQUE16_LEN + sniLen, listLen);
1212                     continue;
1213                 }
1214
1215                 *inOutSz = min(sniLen, *inOutSz);
1216                 XMEMCPY(sni, clientHello + offset, *inOutSz);
1217
1218                 return SSL_SUCCESS;
1219             }
1220         }
1221
1222         len16 -= min(2 * OPAQUE16_LEN + extLen, len16);
1223     }
1224
1225     return len16 ? BUFFER_ERROR : 0;
1226 }
1227
1228 #endif
1229
1230 #define SNI_FREE_ALL TLSX_SNI_FreeAll
1231 #define SNI_GET_SIZE TLSX_SNI_GetSize
1232 #define SNI_WRITE    TLSX_SNI_Write
1233 #define SNI_PARSE    TLSX_SNI_Parse
1234
1235 #else
1236
1237 #define SNI_FREE_ALL(list)
1238 #define SNI_GET_SIZE(list)    0
1239 #define SNI_WRITE(a, b)       0
1240 #define SNI_PARSE(a, b, c, d) 0
1241
1242 #endif /* HAVE_SNI */
1243
1244 #ifdef HAVE_MAX_FRAGMENT
1245
1246 static word16 TLSX_MFL_Write(byte* data, byte* output)
1247 {
1248     output[0] = data[0];
1249
1250     return ENUM_LEN;
1251 }
1252
1253 static int TLSX_MFL_Parse(WOLFSSL* ssl, byte* input, word16 length,
1254                                                                  byte isRequest)
1255 {
1256     if (length != ENUM_LEN)
1257         return BUFFER_ERROR;
1258
1259     switch (*input) {
1260         case WOLFSSL_MFL_2_9 : ssl->max_fragment =  512; break;
1261         case WOLFSSL_MFL_2_10: ssl->max_fragment = 1024; break;
1262         case WOLFSSL_MFL_2_11: ssl->max_fragment = 2048; break;
1263         case WOLFSSL_MFL_2_12: ssl->max_fragment = 4096; break;
1264         case WOLFSSL_MFL_2_13: ssl->max_fragment = 8192; break;
1265
1266         default:
1267             SendAlert(ssl, alert_fatal, illegal_parameter);
1268
1269             return UNKNOWN_MAX_FRAG_LEN_E;
1270     }
1271
1272 #ifndef NO_WOLFSSL_SERVER
1273     if (isRequest) {
1274         int r = TLSX_UseMaxFragment(&ssl->extensions, *input);
1275
1276         if (r != SSL_SUCCESS) return r; /* throw error */
1277
1278         TLSX_SetResponse(ssl, MAX_FRAGMENT_LENGTH);
1279     }
1280 #endif
1281
1282     return 0;
1283 }
1284
1285 int TLSX_UseMaxFragment(TLSX** extensions, byte mfl)
1286 {
1287     byte* data = NULL;
1288     int   ret  = 0;
1289
1290     if (extensions == NULL)
1291         return BAD_FUNC_ARG;
1292
1293     if (mfl < WOLFSSL_MFL_2_9 || WOLFSSL_MFL_2_13 < mfl)
1294         return BAD_FUNC_ARG;
1295
1296     if ((data = XMALLOC(ENUM_LEN, 0, DYNAMIC_TYPE_TLSX)) == NULL)
1297         return MEMORY_E;
1298
1299     data[0] = mfl;
1300
1301     /* push new MFL extension. */
1302     if ((ret = TLSX_Push(extensions, MAX_FRAGMENT_LENGTH, data)) != 0) {
1303         XFREE(data, 0, DYNAMIC_TYPE_TLSX);
1304         return ret;
1305     }
1306
1307     return SSL_SUCCESS;
1308 }
1309
1310
1311 #define MFL_FREE_ALL(data) XFREE(data, 0, DYNAMIC_TYPE_TLSX)
1312 #define MFL_GET_SIZE(data) ENUM_LEN
1313 #define MFL_WRITE          TLSX_MFL_Write
1314 #define MFL_PARSE          TLSX_MFL_Parse
1315
1316 #else
1317
1318 #define MFL_FREE_ALL(a)
1319 #define MFL_GET_SIZE(a)       0
1320 #define MFL_WRITE(a, b)       0
1321 #define MFL_PARSE(a, b, c, d) 0
1322
1323 #endif /* HAVE_MAX_FRAGMENT */
1324
1325 #ifdef HAVE_TRUNCATED_HMAC
1326
1327 static int TLSX_THM_Parse(WOLFSSL* ssl, byte* input, word16 length,
1328                                                                  byte isRequest)
1329 {
1330     if (length != 0 || input == NULL)
1331         return BUFFER_ERROR;
1332
1333 #ifndef NO_WOLFSSL_SERVER
1334     if (isRequest) {
1335         int r = TLSX_UseTruncatedHMAC(&ssl->extensions);
1336
1337         if (r != SSL_SUCCESS) return r; /* throw error */
1338
1339         TLSX_SetResponse(ssl, TRUNCATED_HMAC);
1340     }
1341 #endif
1342
1343     ssl->truncated_hmac = 1;
1344
1345     return 0;
1346 }
1347
1348 int TLSX_UseTruncatedHMAC(TLSX** extensions)
1349 {
1350     int ret = 0;
1351
1352     if (extensions == NULL)
1353         return BAD_FUNC_ARG;
1354
1355     if ((ret = TLSX_Push(extensions, TRUNCATED_HMAC, NULL)) != 0)
1356         return ret;
1357
1358     return SSL_SUCCESS;
1359 }
1360
1361 #define THM_PARSE TLSX_THM_Parse
1362
1363 #else
1364
1365 #define THM_PARSE(a, b, c, d) 0
1366
1367 #endif /* HAVE_TRUNCATED_HMAC */
1368
1369 #ifdef HAVE_SUPPORTED_CURVES
1370
1371 #ifndef HAVE_ECC
1372 #error Elliptic Curves Extension requires Elliptic Curve Cryptography. \
1373        Use --enable-ecc in the configure script or define HAVE_ECC.
1374 #endif
1375
1376 static void TLSX_EllipticCurve_FreeAll(EllipticCurve* list)
1377 {
1378     EllipticCurve* curve;
1379
1380     while ((curve = list)) {
1381         list = curve->next;
1382         XFREE(curve, 0, DYNAMIC_TYPE_TLSX);
1383     }
1384 }
1385
1386 static int TLSX_EllipticCurve_Append(EllipticCurve** list, word16 name)
1387 {
1388     EllipticCurve* curve;
1389
1390     if (list == NULL)
1391         return BAD_FUNC_ARG;
1392
1393     if ((curve = XMALLOC(sizeof(EllipticCurve), 0, DYNAMIC_TYPE_TLSX)) == NULL)
1394         return MEMORY_E;
1395
1396     curve->name = name;
1397     curve->next = *list;
1398
1399     *list = curve;
1400
1401     return 0;
1402 }
1403
1404 #ifndef NO_WOLFSSL_CLIENT
1405
1406 static void TLSX_EllipticCurve_ValidateRequest(WOLFSSL* ssl, byte* semaphore)
1407 {
1408     int i;
1409
1410     for (i = 0; i < ssl->suites->suiteSz; i+= 2)
1411         if (ssl->suites->suites[i] == ECC_BYTE)
1412             return;
1413
1414     /* No elliptic curve suite found */
1415     TURN_ON(semaphore, TLSX_ToSemaphore(ELLIPTIC_CURVES));
1416 }
1417
1418 static word16 TLSX_EllipticCurve_GetSize(EllipticCurve* list)
1419 {
1420     EllipticCurve* curve;
1421     word16 length = OPAQUE16_LEN; /* list length */
1422
1423     while ((curve = list)) {
1424         list = curve->next;
1425         length += OPAQUE16_LEN; /* curve length */
1426     }
1427
1428     return length;
1429 }
1430
1431 static word16 TLSX_EllipticCurve_WriteR(EllipticCurve* curve, byte* output);
1432 static word16 TLSX_EllipticCurve_WriteR(EllipticCurve* curve, byte* output)
1433 {
1434     word16 offset = 0;
1435
1436     if (!curve)
1437         return offset;
1438
1439     offset = TLSX_EllipticCurve_WriteR(curve->next, output);
1440     c16toa(curve->name, output + offset);
1441
1442     return OPAQUE16_LEN + offset;
1443 }
1444
1445 static word16 TLSX_EllipticCurve_Write(EllipticCurve* list, byte* output)
1446 {
1447     word16 length = TLSX_EllipticCurve_WriteR(list, output + OPAQUE16_LEN);
1448
1449     c16toa(length, output); /* writing list length */
1450
1451     return OPAQUE16_LEN + length;
1452 }
1453
1454 #endif /* NO_WOLFSSL_CLIENT */
1455 #ifndef NO_WOLFSSL_SERVER
1456
1457 static int TLSX_EllipticCurve_Parse(WOLFSSL* ssl, byte* input, word16 length,
1458                                                                  byte isRequest)
1459 {
1460     word16 offset;
1461     word16 name;
1462     int r;
1463
1464     (void) isRequest; /* shut up compiler! */
1465
1466     if (OPAQUE16_LEN > length || length % OPAQUE16_LEN)
1467         return BUFFER_ERROR;
1468
1469     ato16(input, &offset);
1470
1471     /* validating curve list length */
1472     if (length != OPAQUE16_LEN + offset)
1473         return BUFFER_ERROR;
1474
1475     while (offset) {
1476         ato16(input + offset, &name);
1477         offset -= OPAQUE16_LEN;
1478
1479         r = TLSX_UseSupportedCurve(&ssl->extensions, name);
1480
1481         if (r != SSL_SUCCESS) return r; /* throw error */
1482     }
1483
1484     return 0;
1485 }
1486
1487 int TLSX_ValidateEllipticCurves(WOLFSSL* ssl, byte first, byte second) {
1488     TLSX*          extension = (first == ECC_BYTE)
1489                              ? TLSX_Find(ssl->extensions, ELLIPTIC_CURVES)
1490                              : NULL;
1491     EllipticCurve* curve     = NULL;
1492     word32         oid       = 0;
1493     word16         octets    = 0; /* acording to 'ecc_set_type ecc_sets[];' */
1494     int            sig       = 0; /* valitade signature */
1495     int            key       = 0; /* validate key       */
1496
1497     (void)oid;
1498     (void)octets;
1499
1500     if (!extension)
1501         return 1; /* no suite restriction */
1502
1503     for (curve = extension->data; curve && !(sig && key); curve = curve->next) {
1504
1505         switch (curve->name) {
1506 #if defined(HAVE_ALL_CURVES) || defined(HAVE_ECC160)
1507             case WOLFSSL_ECC_SECP160R1: oid = ECC_160R1; octets = 20; break;
1508 #endif
1509 #if defined(HAVE_ALL_CURVES) || defined(HAVE_ECC192)
1510             case WOLFSSL_ECC_SECP192R1: oid = ECC_192R1; octets = 24; break;
1511 #endif
1512 #if defined(HAVE_ALL_CURVES) || defined(HAVE_ECC224)
1513             case WOLFSSL_ECC_SECP224R1: oid = ECC_224R1; octets = 28; break;
1514 #endif
1515 #if defined(HAVE_ALL_CURVES) || !defined(NO_ECC256)
1516             case WOLFSSL_ECC_SECP256R1: oid = ECC_256R1; octets = 32; break;
1517 #endif
1518 #if defined(HAVE_ALL_CURVES) || defined(HAVE_ECC384)
1519             case WOLFSSL_ECC_SECP384R1: oid = ECC_384R1; octets = 48; break;
1520 #endif
1521 #if defined(HAVE_ALL_CURVES) || defined(HAVE_ECC521)
1522             case WOLFSSL_ECC_SECP521R1: oid = ECC_521R1; octets = 66; break;
1523 #endif
1524             default: continue; /* unsupported curve */
1525         }
1526
1527         switch (second) {
1528 #ifndef NO_DSA
1529             /* ECDHE_ECDSA */
1530             case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA:
1531             case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA:
1532             case TLS_ECDHE_ECDSA_WITH_RC4_128_SHA:
1533             case TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA:
1534             case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256:
1535             case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384:
1536             case TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:
1537             case TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384:
1538             case TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8:
1539             case TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8:
1540                 sig |= ssl->pkCurveOID == oid;
1541                 key |= ssl->eccTempKeySz == octets;
1542             break;
1543
1544             /* ECDH_ECDSA */
1545             case TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA:
1546             case TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA:
1547             case TLS_ECDH_ECDSA_WITH_RC4_128_SHA:
1548             case TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA:
1549             case TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256:
1550             case TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384:
1551             case TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256:
1552             case TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384:
1553                 sig |= ssl->pkCurveOID == oid;
1554                 key |= ssl->pkCurveOID == oid;
1555             break;
1556 #endif
1557 #ifndef NO_RSA
1558             /* ECDHE_RSA */
1559             case TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA:
1560             case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA:
1561             case TLS_ECDHE_RSA_WITH_RC4_128_SHA:
1562             case TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA:
1563             case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256:
1564             case TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384:
1565             case TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:
1566             case TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:
1567                 sig = 1;
1568                 key |= ssl->eccTempKeySz == octets;
1569             break;
1570
1571             /* ECDH_RSA */
1572             case TLS_ECDH_RSA_WITH_AES_256_CBC_SHA:
1573             case TLS_ECDH_RSA_WITH_AES_128_CBC_SHA:
1574             case TLS_ECDH_RSA_WITH_RC4_128_SHA:
1575             case TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA:
1576             case TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256:
1577             case TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384:
1578             case TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256:
1579             case TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384:
1580                 sig = 1;
1581                 key |= ssl->pkCurveOID == oid;
1582             break;
1583 #endif
1584             default:
1585                 sig = 1;
1586                 key = 1;
1587             break;
1588         }
1589     }
1590
1591     return sig && key;
1592 }
1593
1594 #endif /* NO_WOLFSSL_SERVER */
1595
1596 int TLSX_UseSupportedCurve(TLSX** extensions, word16 name)
1597 {
1598     TLSX*          extension = TLSX_Find(*extensions, ELLIPTIC_CURVES);
1599     EllipticCurve* curve     = NULL;
1600     int            ret       = 0;
1601
1602     if (extensions == NULL)
1603         return BAD_FUNC_ARG;
1604
1605     if ((ret = TLSX_EllipticCurve_Append(&curve, name)) != 0)
1606         return ret;
1607
1608     if (!extension) {
1609         if ((ret = TLSX_Push(extensions, ELLIPTIC_CURVES, curve)) != 0) {
1610             XFREE(curve, 0, DYNAMIC_TYPE_TLSX);
1611             return ret;
1612         }
1613     }
1614     else {
1615         /* push new EllipticCurve object to extension data. */
1616         curve->next = (EllipticCurve*)extension->data;
1617         extension->data = (void*)curve;
1618
1619         /* look for another curve of the same name to remove (replacement) */
1620         do {
1621             if (curve->next && curve->next->name == name) {
1622                 EllipticCurve *next = curve->next;
1623
1624                 curve->next = next->next;
1625                 XFREE(next, 0, DYNAMIC_TYPE_TLSX);
1626
1627                 break;
1628             }
1629         } while ((curve = curve->next));
1630     }
1631
1632     return SSL_SUCCESS;
1633 }
1634
1635 #define EC_FREE_ALL         TLSX_EllipticCurve_FreeAll
1636 #define EC_VALIDATE_REQUEST TLSX_EllipticCurve_ValidateRequest
1637
1638 #ifndef NO_WOLFSSL_CLIENT
1639 #define EC_GET_SIZE TLSX_EllipticCurve_GetSize
1640 #define EC_WRITE    TLSX_EllipticCurve_Write
1641 #else
1642 #define EC_GET_SIZE(list)         0
1643 #define EC_WRITE(a, b)            0
1644 #endif
1645
1646 #ifndef NO_WOLFSSL_SERVER
1647 #define EC_PARSE TLSX_EllipticCurve_Parse
1648 #else
1649 #define EC_PARSE(a, b, c, d)      0
1650 #endif
1651
1652 #else
1653
1654 #define EC_FREE_ALL(list)
1655 #define EC_GET_SIZE(list)         0
1656 #define EC_WRITE(a, b)            0
1657 #define EC_PARSE(a, b, c, d)      0
1658 #define EC_VALIDATE_REQUEST(a, b)
1659
1660 #endif /* HAVE_SUPPORTED_CURVES */
1661
1662 #ifdef HAVE_SECURE_RENEGOTIATION
1663
1664 static byte TLSX_SecureRenegotiation_GetSize(SecureRenegotiation* data,
1665                                                                   int isRequest)
1666 {
1667     byte length = OPAQUE8_LEN; /* empty info length */
1668
1669     if (data->enabled) {
1670         /* client sends client_verify_data only */
1671         length += TLS_FINISHED_SZ;
1672
1673         /* server also sends server_verify_data */
1674         if (!isRequest)
1675             length += TLS_FINISHED_SZ;
1676     }
1677
1678     return length;
1679 }
1680
1681 static word16 TLSX_SecureRenegotiation_Write(SecureRenegotiation* data,
1682                                                     byte* output, int isRequest)
1683 {
1684     word16 offset = OPAQUE8_LEN; /* RenegotiationInfo length */
1685
1686     if (data->enabled) {
1687         /* client sends client_verify_data only */
1688         XMEMCPY(output + offset, data->client_verify_data, TLS_FINISHED_SZ);
1689         offset += TLS_FINISHED_SZ;
1690
1691         /* server also sends server_verify_data */
1692         if (!isRequest) {
1693             XMEMCPY(output + offset, data->server_verify_data, TLS_FINISHED_SZ);
1694             offset += TLS_FINISHED_SZ;
1695         }
1696     }
1697
1698     output[0] = offset - 1;  /* info length - self */
1699
1700     return offset;
1701 }
1702
1703 static int TLSX_SecureRenegotiation_Parse(WOLFSSL* ssl, byte* input,
1704                                                   word16 length, byte isRequest)
1705 {
1706     int ret = SECURE_RENEGOTIATION_E;
1707
1708     if (length >= OPAQUE8_LEN) {
1709         if (ssl->secure_renegotiation == NULL) {
1710         #ifndef NO_WOLFSSL_SERVER
1711             if (isRequest && *input == 0) {
1712                 ret = 0;  /* don't reply, user didn't enable */
1713             }
1714         #endif
1715         }
1716         else if (isRequest) {
1717         #ifndef NO_WOLFSSL_SERVER
1718             if (*input == TLS_FINISHED_SZ) {
1719                 /* TODO compare client_verify_data */
1720                 ret = 0;
1721             }
1722         #endif
1723         }
1724         else {
1725         #ifndef NO_WOLFSSL_CLIENT
1726             if (!ssl->secure_renegotiation->enabled) {
1727                 if (*input == 0) {
1728                     ssl->secure_renegotiation->enabled = 1;
1729                     ret = 0;
1730                 }
1731             }
1732             else if (*input == 2 * TLS_FINISHED_SZ) {
1733                 /* TODO compare client_verify_data and server_verify_data */
1734                 ret = 0;
1735             }
1736         #endif
1737         }
1738     }
1739
1740     if (ret != 0) {
1741         /* TODO: turn on fatal error at ssl level too */
1742         SendAlert(ssl, alert_fatal, handshake_failure);
1743     }
1744
1745     return ret;
1746 }
1747
1748 int TLSX_UseSecureRenegotiation(TLSX** extensions)
1749 {
1750     int ret = 0;
1751     SecureRenegotiation* data = NULL;
1752
1753     data = (SecureRenegotiation*)XMALLOC(sizeof(SecureRenegotiation), NULL,
1754                                                              DYNAMIC_TYPE_TLSX);
1755     if (data == NULL)
1756         return MEMORY_E;
1757
1758     XMEMSET(data, 0, sizeof(SecureRenegotiation));
1759
1760     ret = TLSX_Push(extensions, SECURE_RENEGOTIATION, data);
1761     if (ret != 0) {
1762         XFREE(data, 0, DYNAMIC_TYPE_TLSX);
1763         return ret;
1764     }
1765
1766     return SSL_SUCCESS;
1767 }
1768
1769
1770 #define SCR_FREE_ALL(data) XFREE(data, NULL, DYNAMIC_TYPE_TLSX)
1771 #define SCR_GET_SIZE       TLSX_SecureRenegotiation_GetSize
1772 #define SCR_WRITE          TLSX_SecureRenegotiation_Write
1773 #define SCR_PARSE          TLSX_SecureRenegotiation_Parse
1774
1775 #else
1776
1777 #define SCR_FREE_ALL(a)
1778 #define SCR_GET_SIZE(a, b)    0
1779 #define SCR_WRITE(a, b, c)    0
1780 #define SCR_PARSE(a, b, c, d) 0
1781
1782 #endif /* HAVE_SECURE_RENEGOTIATION */
1783
1784 #ifdef HAVE_SESSION_TICKET
1785
1786 static void TLSX_SessionTicket_ValidateRequest(WOLFSSL* ssl)
1787 {
1788     TLSX*          extension = TLSX_Find(ssl->extensions, SESSION_TICKET);
1789     SessionTicket* ticket    = extension ? extension->data : NULL;
1790
1791     if (ticket) {
1792         /* TODO validate ticket timeout here! */
1793         if (ticket->lifetime == 0xfffffff) {
1794             /* send empty ticket on timeout */
1795             TLSX_UseSessionTicket(&ssl->extensions, NULL);
1796         }
1797     }
1798 }
1799
1800
1801 static word16 TLSX_SessionTicket_GetSize(SessionTicket* ticket, int isRequest)
1802 {
1803     (void)isRequest;
1804     return ticket ? ticket->size : 0;
1805 }
1806
1807 static word16 TLSX_SessionTicket_Write(SessionTicket* ticket, byte* output,
1808                                                                   int isRequest)
1809 {
1810     word16 offset = 0; /* empty ticket */
1811
1812     if (isRequest && ticket) {
1813         XMEMCPY(output + offset, ticket->data, ticket->size);
1814         offset += ticket->size;
1815     }
1816
1817     return offset;
1818 }
1819
1820
1821 static int TLSX_SessionTicket_Parse(WOLFSSL* ssl, byte* input, word16 length,
1822                                                                  byte isRequest)
1823 {
1824     int ret = 0;
1825
1826     if (!isRequest) {
1827         /* client side */
1828         if (length != 0)
1829             return BUFFER_ERROR;
1830
1831         ssl->expect_session_ticket = 1;
1832     }
1833 #ifndef NO_WOLFSSL_SERVER
1834     else {
1835         /* server side */
1836         if (ssl->ctx->ticketEncCb == NULL) {
1837             WOLFSSL_MSG("Client sent session ticket, server has no callback");
1838             return 0;
1839         }
1840
1841         if (length == 0) {
1842             /* blank ticket */
1843             ret = TLSX_UseSessionTicket(&ssl->extensions, NULL);
1844             if (ret == SSL_SUCCESS) {
1845                 ret = 0;
1846                 TLSX_SetResponse(ssl, SESSION_TICKET);  /* send blank ticket */
1847                 ssl->options.createTicket = 1;  /* will send ticket msg */
1848                 ssl->options.useTicket    = 1;
1849             }
1850         } else {
1851             /* got actual ticket from client */
1852             ret = DoClientTicket(ssl, input, length);
1853             if (ret == WOLFSSL_TICKET_RET_OK) {    /* use ticket to resume */
1854                 WOLFSSL_MSG("Using exisitng client ticket");
1855                 ssl->options.useTicket = 1;
1856                 ssl->options.resuming  = 1;
1857             } else if (ret == WOLFSSL_TICKET_RET_CREATE) {
1858                 WOLFSSL_MSG("Using existing client ticket, creating new one");
1859                 ret = TLSX_UseSessionTicket(&ssl->extensions, NULL);
1860                 if (ret == SSL_SUCCESS) {
1861                     ret = 0;
1862                     TLSX_SetResponse(ssl, SESSION_TICKET);
1863                                                     /* send blank ticket */
1864                     ssl->options.createTicket = 1;  /* will send ticket msg */
1865                     ssl->options.useTicket    = 1;
1866                     ssl->options.resuming     = 1;
1867                 }
1868             } else if (ret == WOLFSSL_TICKET_RET_REJECT) {
1869                 WOLFSSL_MSG("Process client ticket rejected, not using");
1870                 ret = 0;  /* not fatal */
1871             } else if (ret == WOLFSSL_TICKET_RET_FATAL || ret < 0) {
1872                 WOLFSSL_MSG("Process client ticket fatal error, not using");
1873             }
1874         }
1875     }
1876 #endif /* NO_WOLFSSL_SERVER */
1877
1878     return ret;
1879 }
1880
1881 WOLFSSL_LOCAL SessionTicket* TLSX_SessionTicket_Create(word32 lifetime,
1882                                                        byte* data, word16 size)
1883 {
1884     SessionTicket* ticket = (SessionTicket*)XMALLOC(sizeof(SessionTicket),
1885                                                        NULL, DYNAMIC_TYPE_TLSX);
1886     if (ticket) {
1887         ticket->data = (byte*)XMALLOC(size, NULL, DYNAMIC_TYPE_TLSX);
1888         if (ticket->data == NULL) {
1889             XFREE(ticket, NULL, DYNAMIC_TYPE_TLSX);
1890             return NULL;
1891         }
1892
1893         XMEMCPY(ticket->data, data, size);
1894         ticket->size     = size;
1895         ticket->lifetime = lifetime;
1896     }
1897
1898     return ticket;
1899 }
1900 WOLFSSL_LOCAL void TLSX_SessionTicket_Free(SessionTicket* ticket)
1901 {
1902     if (ticket) {
1903         XFREE(ticket->data, NULL, DYNAMIC_TYPE_TLSX);
1904         XFREE(ticket,       NULL, DYNAMIC_TYPE_TLSX);
1905     }
1906 }
1907
1908 int TLSX_UseSessionTicket(TLSX** extensions, SessionTicket* ticket)
1909 {
1910     int ret = 0;
1911
1912     if (extensions == NULL)
1913         return BAD_FUNC_ARG;
1914
1915     /* If the ticket is NULL, the client will request a new ticket from the
1916        server. Otherwise, the client will use it in the next client hello. */
1917     if ((ret = TLSX_Push(extensions, SESSION_TICKET, (void*)ticket)) != 0)
1918         return ret;
1919
1920     return SSL_SUCCESS;
1921 }
1922
1923 #define STK_VALIDATE_REQUEST TLSX_SessionTicket_ValidateRequest
1924 #define STK_GET_SIZE         TLSX_SessionTicket_GetSize
1925 #define STK_WRITE            TLSX_SessionTicket_Write
1926 #define STK_PARSE            TLSX_SessionTicket_Parse
1927
1928 #else
1929
1930 #define STK_VALIDATE_REQUEST(a)
1931 #define STK_GET_SIZE(a, b)      0
1932 #define STK_WRITE(a, b, c)      0
1933 #define STK_PARSE(a, b, c, d)   0
1934
1935 #endif /* HAVE_SESSION_TICKET */
1936
1937
1938 TLSX* TLSX_Find(TLSX* list, TLSX_Type type)
1939 {
1940     TLSX* extension = list;
1941
1942     while (extension && extension->type != type)
1943         extension = extension->next;
1944
1945     return extension;
1946 }
1947
1948 void TLSX_FreeAll(TLSX* list)
1949 {
1950     TLSX* extension;
1951
1952     while ((extension = list)) {
1953         list = extension->next;
1954
1955         switch (extension->type) {
1956             case SERVER_NAME_INDICATION:
1957                 SNI_FREE_ALL((SNI*)extension->data);
1958                 break;
1959
1960             case MAX_FRAGMENT_LENGTH:
1961                 MFL_FREE_ALL(extension->data);
1962                 break;
1963
1964             case TRUNCATED_HMAC:
1965                 /* Nothing to do. */
1966                 break;
1967
1968             case ELLIPTIC_CURVES:
1969                 EC_FREE_ALL(extension->data);
1970                 break;
1971
1972             case SECURE_RENEGOTIATION:
1973                 SCR_FREE_ALL(extension->data);
1974                 break;
1975
1976             case SESSION_TICKET:
1977                 /* Nothing to do. */
1978                 break;
1979         }
1980
1981         XFREE(extension, 0, DYNAMIC_TYPE_TLSX);
1982     }
1983 }
1984
1985 int TLSX_SupportExtensions(WOLFSSL* ssl) {
1986     return ssl && (IsTLS(ssl) || ssl->version.major == DTLS_MAJOR);
1987 }
1988
1989 static word16 TLSX_GetSize(TLSX* list, byte* semaphore, byte isRequest)
1990 {
1991     TLSX* extension;
1992     word16 length = 0;
1993
1994     while ((extension = list)) {
1995         list = extension->next;
1996
1997         if (!isRequest && !extension->resp)
1998             continue; /* skip! */
1999
2000         if (!IS_OFF(semaphore, TLSX_ToSemaphore(extension->type)))
2001             continue; /* skip! */
2002
2003         /* type + data length */
2004         length += HELLO_EXT_TYPE_SZ + OPAQUE16_LEN;
2005
2006         switch (extension->type) {
2007             case SERVER_NAME_INDICATION:
2008                 if (isRequest)
2009                     length += SNI_GET_SIZE(extension->data);
2010                 break;
2011             case MAX_FRAGMENT_LENGTH:
2012                 length += MFL_GET_SIZE(extension->data);
2013                 break;
2014
2015             case TRUNCATED_HMAC:
2016                 /* empty extension. */
2017                 break;
2018
2019             case ELLIPTIC_CURVES:
2020                 length += EC_GET_SIZE(extension->data);
2021                 break;
2022
2023             case SECURE_RENEGOTIATION:
2024                 length += SCR_GET_SIZE(extension->data, isRequest);
2025                 break;
2026
2027             case SESSION_TICKET:
2028                 length += STK_GET_SIZE(extension->data, isRequest);
2029                 break;
2030         }
2031
2032         TURN_ON(semaphore, TLSX_ToSemaphore(extension->type));
2033     }
2034
2035     return length;
2036 }
2037
2038 static word16 TLSX_Write(TLSX* list, byte* output, byte* semaphore,
2039                                                                  byte isRequest)
2040 {
2041     TLSX* extension;
2042     word16 offset = 0;
2043     word16 length_offset = 0;
2044
2045     while ((extension = list)) {
2046         list = extension->next;
2047
2048         if (!isRequest && !extension->resp)
2049             continue; /* skip! */
2050
2051         if (!IS_OFF(semaphore, TLSX_ToSemaphore(extension->type)))
2052             continue; /* skip! */
2053
2054         /* extension type */
2055         c16toa(extension->type, output + offset);
2056         offset += HELLO_EXT_TYPE_SZ + OPAQUE16_LEN;
2057         length_offset = offset;
2058
2059         /* extension data should be written internally */
2060         switch (extension->type) {
2061             case SERVER_NAME_INDICATION:
2062                 if (isRequest)
2063                     offset += SNI_WRITE(extension->data, output + offset);
2064                 break;
2065
2066             case MAX_FRAGMENT_LENGTH:
2067                 offset += MFL_WRITE(extension->data, output + offset);
2068                 break;
2069
2070             case TRUNCATED_HMAC:
2071                 /* empty extension. */
2072                 break;
2073
2074             case ELLIPTIC_CURVES:
2075                 offset += EC_WRITE(extension->data, output + offset);
2076                 break;
2077
2078             case SECURE_RENEGOTIATION:
2079                 offset += SCR_WRITE(extension->data, output + offset,
2080                                                                      isRequest);
2081                 break;
2082
2083             case SESSION_TICKET:
2084                 offset += STK_WRITE(extension->data, output + offset,
2085                                                                      isRequest);
2086                 break;
2087         }
2088
2089         /* writing extension data length */
2090         c16toa(offset - length_offset, output + length_offset - OPAQUE16_LEN);
2091
2092         TURN_ON(semaphore, TLSX_ToSemaphore(extension->type));
2093     }
2094
2095     return offset;
2096 }
2097
2098 #ifndef NO_WOLFSSL_CLIENT
2099
2100 word16 TLSX_GetRequestSize(WOLFSSL* ssl)
2101 {
2102     word16 length = 0;
2103
2104     if (TLSX_SupportExtensions(ssl)) {
2105         byte semaphore[SEMAPHORE_SIZE] = {0};
2106
2107         EC_VALIDATE_REQUEST(ssl, semaphore);
2108         STK_VALIDATE_REQUEST(ssl);
2109
2110         if (ssl->extensions)
2111             length += TLSX_GetSize(ssl->extensions, semaphore, 1);
2112
2113         if (ssl->ctx && ssl->ctx->extensions)
2114             length += TLSX_GetSize(ssl->ctx->extensions, semaphore, 1);
2115
2116         if (IsAtLeastTLSv1_2(ssl) && ssl->suites->hashSigAlgoSz)
2117             length += ssl->suites->hashSigAlgoSz + HELLO_EXT_LEN;
2118     }
2119
2120     if (length)
2121         length += OPAQUE16_LEN; /* for total length storage */
2122
2123     return length;
2124 }
2125
2126 word16 TLSX_WriteRequest(WOLFSSL* ssl, byte* output)
2127 {
2128     word16 offset = 0;
2129
2130     if (TLSX_SupportExtensions(ssl) && output) {
2131         byte semaphore[SEMAPHORE_SIZE] = {0};
2132
2133         offset += OPAQUE16_LEN; /* extensions length */
2134
2135         EC_VALIDATE_REQUEST(ssl, semaphore);
2136
2137         if (ssl->extensions)
2138             offset += TLSX_Write(ssl->extensions, output + offset,
2139                                                                   semaphore, 1);
2140
2141         if (ssl->ctx && ssl->ctx->extensions)
2142             offset += TLSX_Write(ssl->ctx->extensions, output + offset,
2143                                                                   semaphore, 1);
2144
2145         if (IsAtLeastTLSv1_2(ssl) && ssl->suites->hashSigAlgoSz)
2146         {
2147             int i;
2148             /* extension type */
2149             c16toa(HELLO_EXT_SIG_ALGO, output + offset);
2150             offset += HELLO_EXT_TYPE_SZ;
2151
2152             /* extension data length */
2153             c16toa(OPAQUE16_LEN + ssl->suites->hashSigAlgoSz, output + offset);
2154             offset += OPAQUE16_LEN;
2155
2156             /* sig algos length */
2157             c16toa(ssl->suites->hashSigAlgoSz, output + offset);
2158             offset += OPAQUE16_LEN;
2159
2160             /* sig algos */
2161             for (i = 0; i < ssl->suites->hashSigAlgoSz; i++, offset++)
2162                 output[offset] = ssl->suites->hashSigAlgo[i];
2163         }
2164
2165         if (offset > OPAQUE16_LEN)
2166             c16toa(offset - OPAQUE16_LEN, output); /* extensions length */
2167     }
2168
2169     return offset;
2170 }
2171
2172 #endif /* NO_WOLFSSL_CLIENT */
2173
2174 #ifndef NO_WOLFSSL_SERVER
2175
2176 word16 TLSX_GetResponseSize(WOLFSSL* ssl)
2177 {
2178     word16 length = 0;
2179     byte semaphore[SEMAPHORE_SIZE] = {0};
2180
2181     if (TLSX_SupportExtensions(ssl))
2182         length += TLSX_GetSize(ssl->extensions, semaphore, 0);
2183
2184     /* All the response data is set at the ssl object only, so no ctx here. */
2185
2186     if (length)
2187         length += OPAQUE16_LEN; /* for total length storage */
2188
2189     return length;
2190 }
2191
2192 word16 TLSX_WriteResponse(WOLFSSL *ssl, byte* output)
2193 {
2194     word16 offset = 0;
2195
2196     if (TLSX_SupportExtensions(ssl) && output) {
2197         byte semaphore[SEMAPHORE_SIZE] = {0};
2198
2199         offset += OPAQUE16_LEN; /* extensions length */
2200
2201         offset += TLSX_Write(ssl->extensions, output + offset, semaphore, 0);
2202
2203         if (offset > OPAQUE16_LEN)
2204             c16toa(offset - OPAQUE16_LEN, output); /* extensions length */
2205     }
2206
2207     return offset;
2208 }
2209
2210 #endif /* NO_WOLFSSL_SERVER */
2211
2212 int TLSX_Parse(WOLFSSL* ssl, byte* input, word16 length, byte isRequest,
2213                                                                  Suites *suites)
2214 {
2215     int ret = 0;
2216     word16 offset = 0;
2217
2218     if (!ssl || !input || (isRequest && !suites))
2219         return BAD_FUNC_ARG;
2220
2221     while (ret == 0 && offset < length) {
2222         word16 type;
2223         word16 size;
2224
2225         if (length - offset < HELLO_EXT_TYPE_SZ + OPAQUE16_LEN)
2226             return BUFFER_ERROR;
2227
2228         ato16(input + offset, &type);
2229         offset += HELLO_EXT_TYPE_SZ;
2230
2231         ato16(input + offset, &size);
2232         offset += OPAQUE16_LEN;
2233
2234         if (offset + size > length)
2235             return BUFFER_ERROR;
2236
2237         switch (type) {
2238             case SERVER_NAME_INDICATION:
2239                 WOLFSSL_MSG("SNI extension received");
2240
2241                 ret = SNI_PARSE(ssl, input + offset, size, isRequest);
2242                 break;
2243
2244             case MAX_FRAGMENT_LENGTH:
2245                 WOLFSSL_MSG("Max Fragment Length extension received");
2246
2247                 ret = MFL_PARSE(ssl, input + offset, size, isRequest);
2248                 break;
2249
2250             case TRUNCATED_HMAC:
2251                 WOLFSSL_MSG("Truncated HMAC extension received");
2252
2253                 ret = THM_PARSE(ssl, input + offset, size, isRequest);
2254                 break;
2255
2256             case ELLIPTIC_CURVES:
2257                 WOLFSSL_MSG("Elliptic Curves extension received");
2258
2259                 ret = EC_PARSE(ssl, input + offset, size, isRequest);
2260                 break;
2261
2262             case SECURE_RENEGOTIATION:
2263                 WOLFSSL_MSG("Secure Renegotiation extension received");
2264
2265                 ret = SCR_PARSE(ssl, input + offset, size, isRequest);
2266                 break;
2267
2268             case SESSION_TICKET:
2269                 WOLFSSL_MSG("Session Ticket extension received");
2270
2271                 ret = STK_PARSE(ssl, input + offset, size, isRequest);
2272                 break;
2273
2274             case HELLO_EXT_SIG_ALGO:
2275                 if (isRequest) {
2276                     /* do not mess with offset inside the switch! */
2277                     if (IsAtLeastTLSv1_2(ssl)) {
2278                         ato16(input + offset, &suites->hashSigAlgoSz);
2279
2280                         if (suites->hashSigAlgoSz > size - OPAQUE16_LEN)
2281                             return BUFFER_ERROR;
2282
2283                         XMEMCPY(suites->hashSigAlgo,
2284                                 input + offset + OPAQUE16_LEN,
2285                                 min(suites->hashSigAlgoSz,
2286                                                         HELLO_EXT_SIGALGO_MAX));
2287                     }
2288                 } else {
2289                     WOLFSSL_MSG("Servers MUST NOT send SIG ALGO extension.");
2290                 }
2291
2292                 break;
2293         }
2294
2295         /* offset should be updated here! */
2296         offset += size;
2297     }
2298
2299     return ret;
2300 }
2301
2302 /* undefining semaphore macros */
2303 #undef IS_OFF
2304 #undef TURN_ON
2305 #undef SEMAPHORE_SIZE
2306
2307 #endif
2308
2309
2310 #ifndef NO_WOLFSSL_CLIENT
2311
2312 #ifndef NO_OLD_TLS
2313
2314     WOLFSSL_METHOD* wolfTLSv1_client_method(void)
2315     {
2316         WOLFSSL_METHOD* method =
2317                              (WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
2318                                                       DYNAMIC_TYPE_METHOD);
2319         if (method)
2320             InitSSL_Method(method, MakeTLSv1());
2321         return method;
2322     }
2323
2324
2325     WOLFSSL_METHOD* wolfTLSv1_1_client_method(void)
2326     {
2327         WOLFSSL_METHOD* method =
2328                               (WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
2329                                                        DYNAMIC_TYPE_METHOD);
2330         if (method)
2331             InitSSL_Method(method, MakeTLSv1_1());
2332         return method;
2333     }
2334
2335 #endif /* !NO_OLD_TLS */
2336
2337 #ifndef NO_SHA256   /* can't use without SHA256 */
2338
2339     WOLFSSL_METHOD* wolfTLSv1_2_client_method(void)
2340     {
2341         WOLFSSL_METHOD* method =
2342                               (WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
2343                                                        DYNAMIC_TYPE_METHOD);
2344         if (method)
2345             InitSSL_Method(method, MakeTLSv1_2());
2346         return method;
2347     }
2348
2349 #endif
2350
2351
2352     WOLFSSL_METHOD* wolfSSLv23_client_method(void)
2353     {
2354         WOLFSSL_METHOD* method =
2355                               (WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
2356                                                        DYNAMIC_TYPE_METHOD);
2357         if (method) {
2358 #ifndef NO_SHA256         /* 1.2 requires SHA256 */
2359             InitSSL_Method(method, MakeTLSv1_2());
2360 #else
2361             InitSSL_Method(method, MakeTLSv1_1());
2362 #endif
2363 #ifndef NO_OLD_TLS
2364             method->downgrade = 1;
2365 #endif
2366         }
2367         return method;
2368     }
2369
2370
2371 #endif /* NO_WOLFSSL_CLIENT */
2372
2373
2374
2375 #ifndef NO_WOLFSSL_SERVER
2376
2377 #ifndef NO_OLD_TLS
2378
2379     WOLFSSL_METHOD* wolfTLSv1_server_method(void)
2380     {
2381         WOLFSSL_METHOD* method =
2382                               (WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
2383                                                        DYNAMIC_TYPE_METHOD);
2384         if (method) {
2385             InitSSL_Method(method, MakeTLSv1());
2386             method->side = WOLFSSL_SERVER_END;
2387         }
2388         return method;
2389     }
2390
2391
2392     WOLFSSL_METHOD* wolfTLSv1_1_server_method(void)
2393     {
2394         WOLFSSL_METHOD* method =
2395                               (WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
2396                                                        DYNAMIC_TYPE_METHOD);
2397         if (method) {
2398             InitSSL_Method(method, MakeTLSv1_1());
2399             method->side = WOLFSSL_SERVER_END;
2400         }
2401         return method;
2402     }
2403
2404 #endif /* !NO_OLD_TLS */
2405
2406 #ifndef NO_SHA256   /* can't use without SHA256 */
2407
2408     WOLFSSL_METHOD* wolfTLSv1_2_server_method(void)
2409     {
2410         WOLFSSL_METHOD* method =
2411                               (WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
2412                                                        DYNAMIC_TYPE_METHOD);
2413         if (method) {
2414             InitSSL_Method(method, MakeTLSv1_2());
2415             method->side = WOLFSSL_SERVER_END;
2416         }
2417         return method;
2418     }
2419
2420 #endif
2421
2422
2423     WOLFSSL_METHOD* wolfSSLv23_server_method(void)
2424     {
2425         WOLFSSL_METHOD* method =
2426                               (WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
2427                                                        DYNAMIC_TYPE_METHOD);
2428         if (method) {
2429 #ifndef NO_SHA256         /* 1.2 requires SHA256 */
2430             InitSSL_Method(method, MakeTLSv1_2());
2431 #else
2432             InitSSL_Method(method, MakeTLSv1_1());
2433 #endif
2434             method->side      = WOLFSSL_SERVER_END;
2435 #ifndef NO_OLD_TLS
2436             method->downgrade = 1;
2437 #endif /* !NO_OLD_TLS */
2438         }
2439         return method;
2440     }
2441
2442
2443
2444 #endif /* NO_WOLFSSL_SERVER */
2445 #endif /* NO_TLS */
2446