wolf SSL / CyaSSL-2.9.4

Dependents:  

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers keys.c Source File

keys.c

00001 /* keys.c
00002  *
00003  * Copyright (C) 2006-2013 wolfSSL Inc.
00004  *
00005  * This file is part of CyaSSL.
00006  *
00007  * CyaSSL is free software; you can redistribute it and/or modify
00008  * it under the terms of the GNU General Public License as published by
00009  * the Free Software Foundation; either version 2 of the License, or
00010  * (at your option) any later version.
00011  *
00012  * CyaSSL is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015  * GNU General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU General Public License
00018  * along with this program; if not, write to the Free Software
00019  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
00020  */
00021 
00022 
00023 #ifdef HAVE_CONFIG_H
00024     #include <config.h>
00025 #endif
00026 
00027 #include <cyassl/ctaocrypt/settings.h>
00028 
00029 #include <cyassl/internal.h>
00030 #include <cyassl/error-ssl.h>
00031 #ifdef SHOW_SECRETS
00032     #ifdef FREESCALE_MQX
00033         #include <fio.h>
00034     #else
00035         #include <stdio.h>
00036     #endif
00037 #endif
00038 
00039 
00040 int SetCipherSpecs(CYASSL* ssl)
00041 {
00042     /* ECC extensions, or AES-CCM */
00043     if (ssl->options.cipherSuite0 == ECC_BYTE) {
00044     
00045     switch (ssl->options.cipherSuite) {
00046 
00047 #ifdef HAVE_ECC
00048 
00049 #ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
00050     case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 :
00051         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00052         ssl->specs.cipher_type           = block;
00053         ssl->specs.mac_algorithm         = sha256_mac;
00054         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00055         ssl->specs.sig_algo              = rsa_sa_algo;
00056         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00057         ssl->specs.pad_size              = PAD_SHA;
00058         ssl->specs.static_ecdh           = 0;
00059         ssl->specs.key_size              = AES_128_KEY_SIZE;
00060         ssl->specs.iv_size               = AES_IV_SIZE;
00061         ssl->specs.block_size            = AES_BLOCK_SIZE;
00062     break;
00063 #endif
00064 
00065 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
00066     case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 :
00067         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00068         ssl->specs.cipher_type           = block;
00069         ssl->specs.mac_algorithm         = sha256_mac;
00070         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00071         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00072         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00073         ssl->specs.pad_size              = PAD_SHA;
00074         ssl->specs.static_ecdh           = 0;
00075         ssl->specs.key_size              = AES_128_KEY_SIZE;
00076         ssl->specs.iv_size               = AES_IV_SIZE;
00077         ssl->specs.block_size            = AES_BLOCK_SIZE;
00078     break;
00079 #endif
00080 
00081 #ifdef BUILD_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256
00082     case TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 :
00083         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00084         ssl->specs.cipher_type           = block;
00085         ssl->specs.mac_algorithm         = sha256_mac;
00086         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00087         ssl->specs.sig_algo              = rsa_sa_algo;
00088         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00089         ssl->specs.pad_size              = PAD_SHA;
00090         ssl->specs.static_ecdh           = 1;
00091         ssl->specs.key_size              = AES_128_KEY_SIZE;
00092         ssl->specs.iv_size               = AES_IV_SIZE;
00093         ssl->specs.block_size            = AES_BLOCK_SIZE;
00094     break;
00095 #endif
00096 
00097 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256
00098     case TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 :
00099         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00100         ssl->specs.cipher_type           = block;
00101         ssl->specs.mac_algorithm         = sha256_mac;
00102         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00103         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00104         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00105         ssl->specs.pad_size              = PAD_SHA;
00106         ssl->specs.static_ecdh           = 1;
00107         ssl->specs.key_size              = AES_128_KEY_SIZE;
00108         ssl->specs.iv_size               = AES_IV_SIZE;
00109         ssl->specs.block_size            = AES_BLOCK_SIZE;
00110     break;
00111 #endif
00112 
00113 #ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384
00114     case TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 :
00115         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00116         ssl->specs.cipher_type           = block;
00117         ssl->specs.mac_algorithm         = sha384_mac;
00118         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00119         ssl->specs.sig_algo              = rsa_sa_algo;
00120         ssl->specs.hash_size             = SHA384_DIGEST_SIZE;
00121         ssl->specs.pad_size              = PAD_SHA;
00122         ssl->specs.static_ecdh           = 0;
00123         ssl->specs.key_size              = AES_256_KEY_SIZE;
00124         ssl->specs.iv_size               = AES_IV_SIZE;
00125         ssl->specs.block_size            = AES_BLOCK_SIZE;
00126     break;
00127 #endif
00128 
00129 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
00130     case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 :
00131         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00132         ssl->specs.cipher_type           = block;
00133         ssl->specs.mac_algorithm         = sha384_mac;
00134         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00135         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00136         ssl->specs.hash_size             = SHA384_DIGEST_SIZE;
00137         ssl->specs.pad_size              = PAD_SHA;
00138         ssl->specs.static_ecdh           = 0;
00139         ssl->specs.key_size              = AES_256_KEY_SIZE;
00140         ssl->specs.iv_size               = AES_IV_SIZE;
00141         ssl->specs.block_size            = AES_BLOCK_SIZE;
00142     break;
00143 #endif
00144 
00145 #ifdef BUILD_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384
00146     case TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 :
00147         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00148         ssl->specs.cipher_type           = block;
00149         ssl->specs.mac_algorithm         = sha384_mac;
00150         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00151         ssl->specs.sig_algo              = rsa_sa_algo;
00152         ssl->specs.hash_size             = SHA384_DIGEST_SIZE;
00153         ssl->specs.pad_size              = PAD_SHA;
00154         ssl->specs.static_ecdh           = 1;
00155         ssl->specs.key_size              = AES_256_KEY_SIZE;
00156         ssl->specs.iv_size               = AES_IV_SIZE;
00157         ssl->specs.block_size            = AES_BLOCK_SIZE;
00158     break;
00159 #endif
00160 
00161 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384
00162     case TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 :
00163         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00164         ssl->specs.cipher_type           = block;
00165         ssl->specs.mac_algorithm         = sha384_mac;
00166         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00167         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00168         ssl->specs.hash_size             = SHA384_DIGEST_SIZE;
00169         ssl->specs.pad_size              = PAD_SHA;
00170         ssl->specs.static_ecdh           = 1;
00171         ssl->specs.key_size              = AES_256_KEY_SIZE;
00172         ssl->specs.iv_size               = AES_IV_SIZE;
00173         ssl->specs.block_size            = AES_BLOCK_SIZE;
00174     break;
00175 #endif
00176 
00177 #ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
00178     case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA :
00179         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00180         ssl->specs.cipher_type           = block;
00181         ssl->specs.mac_algorithm         = sha_mac;
00182         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00183         ssl->specs.sig_algo              = rsa_sa_algo;
00184         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00185         ssl->specs.pad_size              = PAD_SHA;
00186         ssl->specs.static_ecdh           = 0;
00187         ssl->specs.key_size              = AES_128_KEY_SIZE;
00188         ssl->specs.block_size            = AES_BLOCK_SIZE;
00189         ssl->specs.iv_size               = AES_IV_SIZE;
00190 
00191         break;
00192 #endif
00193 
00194 #ifdef BUILD_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA
00195     case TLS_ECDH_RSA_WITH_AES_128_CBC_SHA :
00196         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00197         ssl->specs.cipher_type           = block;
00198         ssl->specs.mac_algorithm         = sha_mac;
00199         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00200         ssl->specs.sig_algo              = rsa_sa_algo;
00201         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00202         ssl->specs.pad_size              = PAD_SHA;
00203         ssl->specs.static_ecdh           = 1;
00204         ssl->specs.key_size              = AES_128_KEY_SIZE;
00205         ssl->specs.block_size            = AES_BLOCK_SIZE;
00206         ssl->specs.iv_size               = AES_IV_SIZE;
00207 
00208         break;
00209 #endif
00210 
00211 #ifdef BUILD_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA
00212     case TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA :
00213         ssl->specs.bulk_cipher_algorithm = cyassl_triple_des;
00214         ssl->specs.cipher_type           = block;
00215         ssl->specs.mac_algorithm         = sha_mac;
00216         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00217         ssl->specs.sig_algo              = rsa_sa_algo;
00218         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00219         ssl->specs.pad_size              = PAD_SHA;
00220         ssl->specs.static_ecdh           = 0;
00221         ssl->specs.key_size              = DES3_KEY_SIZE;
00222         ssl->specs.block_size            = DES_BLOCK_SIZE;
00223         ssl->specs.iv_size               = DES_IV_SIZE;
00224 
00225         break;
00226 #endif
00227 
00228 #ifdef BUILD_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA
00229     case TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA :
00230         ssl->specs.bulk_cipher_algorithm = cyassl_triple_des;
00231         ssl->specs.cipher_type           = block;
00232         ssl->specs.mac_algorithm         = sha_mac;
00233         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00234         ssl->specs.sig_algo              = rsa_sa_algo;
00235         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00236         ssl->specs.pad_size              = PAD_SHA;
00237         ssl->specs.static_ecdh           = 1;
00238         ssl->specs.key_size              = DES3_KEY_SIZE;
00239         ssl->specs.block_size            = DES_BLOCK_SIZE;
00240         ssl->specs.iv_size               = DES_IV_SIZE;
00241 
00242         break;
00243 #endif
00244 
00245 #ifdef BUILD_TLS_ECDHE_RSA_WITH_RC4_128_SHA
00246     case TLS_ECDHE_RSA_WITH_RC4_128_SHA :
00247         ssl->specs.bulk_cipher_algorithm = cyassl_rc4;
00248         ssl->specs.cipher_type           = stream;
00249         ssl->specs.mac_algorithm         = sha_mac;
00250         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00251         ssl->specs.sig_algo              = rsa_sa_algo;
00252         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00253         ssl->specs.pad_size              = PAD_SHA;
00254         ssl->specs.static_ecdh           = 0;
00255         ssl->specs.key_size              = RC4_KEY_SIZE;
00256         ssl->specs.iv_size               = 0;
00257         ssl->specs.block_size            = 0;
00258 
00259         break;
00260 #endif
00261 
00262 #ifdef BUILD_TLS_ECDH_RSA_WITH_RC4_128_SHA
00263     case TLS_ECDH_RSA_WITH_RC4_128_SHA :
00264         ssl->specs.bulk_cipher_algorithm = cyassl_rc4;
00265         ssl->specs.cipher_type           = stream;
00266         ssl->specs.mac_algorithm         = sha_mac;
00267         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00268         ssl->specs.sig_algo              = rsa_sa_algo;
00269         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00270         ssl->specs.pad_size              = PAD_SHA;
00271         ssl->specs.static_ecdh           = 1;
00272         ssl->specs.key_size              = RC4_KEY_SIZE;
00273         ssl->specs.iv_size               = 0;
00274         ssl->specs.block_size            = 0;
00275 
00276         break;
00277 #endif
00278 
00279 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA
00280     case TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA :
00281         ssl->specs.bulk_cipher_algorithm = cyassl_triple_des;
00282         ssl->specs.cipher_type           = block;
00283         ssl->specs.mac_algorithm         = sha_mac;
00284         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00285         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00286         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00287         ssl->specs.pad_size              = PAD_SHA;
00288         ssl->specs.static_ecdh           = 0;
00289         ssl->specs.key_size              = DES3_KEY_SIZE;
00290         ssl->specs.block_size            = DES_BLOCK_SIZE;
00291         ssl->specs.iv_size               = DES_IV_SIZE;
00292 
00293         break;
00294 #endif
00295 
00296 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA
00297     case TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA :
00298         ssl->specs.bulk_cipher_algorithm = cyassl_triple_des;
00299         ssl->specs.cipher_type           = block;
00300         ssl->specs.mac_algorithm         = sha_mac;
00301         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00302         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00303         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00304         ssl->specs.pad_size              = PAD_SHA;
00305         ssl->specs.static_ecdh           = 1;
00306         ssl->specs.key_size              = DES3_KEY_SIZE;
00307         ssl->specs.block_size            = DES_BLOCK_SIZE;
00308         ssl->specs.iv_size               = DES_IV_SIZE;
00309 
00310         break;
00311 #endif
00312 
00313 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA
00314     case TLS_ECDHE_ECDSA_WITH_RC4_128_SHA :
00315         ssl->specs.bulk_cipher_algorithm = cyassl_rc4;
00316         ssl->specs.cipher_type           = stream;
00317         ssl->specs.mac_algorithm         = sha_mac;
00318         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00319         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00320         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00321         ssl->specs.pad_size              = PAD_SHA;
00322         ssl->specs.static_ecdh           = 0;
00323         ssl->specs.key_size              = RC4_KEY_SIZE;
00324         ssl->specs.iv_size               = 0;
00325         ssl->specs.block_size            = 0;
00326 
00327         break;
00328 #endif
00329 
00330 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_RC4_128_SHA
00331     case TLS_ECDH_ECDSA_WITH_RC4_128_SHA :
00332         ssl->specs.bulk_cipher_algorithm = cyassl_rc4;
00333         ssl->specs.cipher_type           = stream;
00334         ssl->specs.mac_algorithm         = sha_mac;
00335         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00336         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00337         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00338         ssl->specs.pad_size              = PAD_SHA;
00339         ssl->specs.static_ecdh           = 1;
00340         ssl->specs.key_size              = RC4_KEY_SIZE;
00341         ssl->specs.iv_size               = 0;
00342         ssl->specs.block_size            = 0;
00343 
00344         break;
00345 #endif
00346 
00347 #ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
00348     case TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA :
00349         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00350         ssl->specs.cipher_type           = block;
00351         ssl->specs.mac_algorithm         = sha_mac;
00352         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00353         ssl->specs.sig_algo              = rsa_sa_algo;
00354         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00355         ssl->specs.pad_size              = PAD_SHA;
00356         ssl->specs.static_ecdh           = 0;
00357         ssl->specs.key_size              = AES_256_KEY_SIZE;
00358         ssl->specs.block_size            = AES_BLOCK_SIZE;
00359         ssl->specs.iv_size               = AES_IV_SIZE;
00360 
00361         break;
00362 #endif
00363 
00364 #ifdef BUILD_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA
00365     case TLS_ECDH_RSA_WITH_AES_256_CBC_SHA :
00366         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00367         ssl->specs.cipher_type           = block;
00368         ssl->specs.mac_algorithm         = sha_mac;
00369         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00370         ssl->specs.sig_algo              = rsa_sa_algo;
00371         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00372         ssl->specs.pad_size              = PAD_SHA;
00373         ssl->specs.static_ecdh           = 1;
00374         ssl->specs.key_size              = AES_256_KEY_SIZE;
00375         ssl->specs.block_size            = AES_BLOCK_SIZE;
00376         ssl->specs.iv_size               = AES_IV_SIZE;
00377 
00378         break;
00379 #endif
00380 
00381 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
00382     case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA :
00383         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00384         ssl->specs.cipher_type           = block;
00385         ssl->specs.mac_algorithm         = sha_mac;
00386         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00387         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00388         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00389         ssl->specs.pad_size              = PAD_SHA;
00390         ssl->specs.static_ecdh           = 0;
00391         ssl->specs.key_size              = AES_128_KEY_SIZE;
00392         ssl->specs.block_size            = AES_BLOCK_SIZE;
00393         ssl->specs.iv_size               = AES_IV_SIZE;
00394 
00395         break;
00396 #endif
00397 
00398 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA
00399     case TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA :
00400         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00401         ssl->specs.cipher_type           = block;
00402         ssl->specs.mac_algorithm         = sha_mac;
00403         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00404         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00405         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00406         ssl->specs.pad_size              = PAD_SHA;
00407         ssl->specs.static_ecdh           = 1;
00408         ssl->specs.key_size              = AES_128_KEY_SIZE;
00409         ssl->specs.block_size            = AES_BLOCK_SIZE;
00410         ssl->specs.iv_size               = AES_IV_SIZE;
00411 
00412         break;
00413 #endif
00414 
00415 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
00416     case TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA :
00417         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00418         ssl->specs.cipher_type           = block;
00419         ssl->specs.mac_algorithm         = sha_mac;
00420         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00421         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00422         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00423         ssl->specs.pad_size              = PAD_SHA;
00424         ssl->specs.static_ecdh           = 0;
00425         ssl->specs.key_size              = AES_256_KEY_SIZE;
00426         ssl->specs.block_size            = AES_BLOCK_SIZE;
00427         ssl->specs.iv_size               = AES_IV_SIZE;
00428 
00429         break;
00430 #endif
00431 
00432 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA
00433     case TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA :
00434         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00435         ssl->specs.cipher_type           = block;
00436         ssl->specs.mac_algorithm         = sha_mac;
00437         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00438         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00439         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00440         ssl->specs.pad_size              = PAD_SHA;
00441         ssl->specs.static_ecdh           = 1;
00442         ssl->specs.key_size              = AES_256_KEY_SIZE;
00443         ssl->specs.block_size            = AES_BLOCK_SIZE;
00444         ssl->specs.iv_size               = AES_IV_SIZE;
00445 
00446         break;
00447 #endif
00448 
00449 #ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
00450     case TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 :
00451         ssl->specs.bulk_cipher_algorithm = cyassl_aes_gcm;
00452         ssl->specs.cipher_type           = aead;
00453         ssl->specs.mac_algorithm         = sha256_mac;
00454         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00455         ssl->specs.sig_algo              = rsa_sa_algo;
00456         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00457         ssl->specs.pad_size              = PAD_SHA;
00458         ssl->specs.static_ecdh           = 0;
00459         ssl->specs.key_size              = AES_128_KEY_SIZE;
00460         ssl->specs.block_size            = AES_BLOCK_SIZE;
00461         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
00462         ssl->specs.aead_mac_size         = AES_GCM_AUTH_SZ;
00463 
00464         break;
00465 #endif
00466 
00467 #ifdef BUILD_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
00468     case TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 :
00469         ssl->specs.bulk_cipher_algorithm = cyassl_aes_gcm;
00470         ssl->specs.cipher_type           = aead;
00471         ssl->specs.mac_algorithm         = sha384_mac;
00472         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00473         ssl->specs.sig_algo              = rsa_sa_algo;
00474         ssl->specs.hash_size             = SHA384_DIGEST_SIZE;
00475         ssl->specs.pad_size              = PAD_SHA;
00476         ssl->specs.static_ecdh           = 0;
00477         ssl->specs.key_size              = AES_256_KEY_SIZE;
00478         ssl->specs.block_size            = AES_BLOCK_SIZE;
00479         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
00480         ssl->specs.aead_mac_size         = AES_GCM_AUTH_SZ;
00481 
00482         break;
00483 #endif
00484 
00485 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
00486     case TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 :
00487         ssl->specs.bulk_cipher_algorithm = cyassl_aes_gcm;
00488         ssl->specs.cipher_type           = aead;
00489         ssl->specs.mac_algorithm         = sha256_mac;
00490         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00491         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00492         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00493         ssl->specs.pad_size              = PAD_SHA;
00494         ssl->specs.static_ecdh           = 0;
00495         ssl->specs.key_size              = AES_128_KEY_SIZE;
00496         ssl->specs.block_size            = AES_BLOCK_SIZE;
00497         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
00498         ssl->specs.aead_mac_size         = AES_GCM_AUTH_SZ;
00499 
00500         break;
00501 #endif
00502 
00503 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
00504     case TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 :
00505         ssl->specs.bulk_cipher_algorithm = cyassl_aes_gcm;
00506         ssl->specs.cipher_type           = aead;
00507         ssl->specs.mac_algorithm         = sha384_mac;
00508         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00509         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00510         ssl->specs.hash_size             = SHA384_DIGEST_SIZE;
00511         ssl->specs.pad_size              = PAD_SHA;
00512         ssl->specs.static_ecdh           = 0;
00513         ssl->specs.key_size              = AES_256_KEY_SIZE;
00514         ssl->specs.block_size            = AES_BLOCK_SIZE;
00515         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
00516         ssl->specs.aead_mac_size         = AES_GCM_AUTH_SZ;
00517 
00518         break;
00519 #endif
00520 
00521 #ifdef BUILD_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256
00522     case TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 :
00523         ssl->specs.bulk_cipher_algorithm = cyassl_aes_gcm;
00524         ssl->specs.cipher_type           = aead;
00525         ssl->specs.mac_algorithm         = sha256_mac;
00526         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00527         ssl->specs.sig_algo              = rsa_sa_algo;
00528         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00529         ssl->specs.pad_size              = PAD_SHA;
00530         ssl->specs.static_ecdh           = 1;
00531         ssl->specs.key_size              = AES_128_KEY_SIZE;
00532         ssl->specs.block_size            = AES_BLOCK_SIZE;
00533         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
00534         ssl->specs.aead_mac_size         = AES_GCM_AUTH_SZ;
00535 
00536         break;
00537 #endif
00538 
00539 #ifdef BUILD_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384
00540     case TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 :
00541         ssl->specs.bulk_cipher_algorithm = cyassl_aes_gcm;
00542         ssl->specs.cipher_type           = aead;
00543         ssl->specs.mac_algorithm         = sha384_mac;
00544         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00545         ssl->specs.sig_algo              = rsa_sa_algo;
00546         ssl->specs.hash_size             = SHA384_DIGEST_SIZE;
00547         ssl->specs.pad_size              = PAD_SHA;
00548         ssl->specs.static_ecdh           = 1;
00549         ssl->specs.key_size              = AES_256_KEY_SIZE;
00550         ssl->specs.block_size            = AES_BLOCK_SIZE;
00551         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
00552         ssl->specs.aead_mac_size         = AES_GCM_AUTH_SZ;
00553 
00554         break;
00555 #endif
00556 
00557 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256
00558     case TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 :
00559         ssl->specs.bulk_cipher_algorithm = cyassl_aes_gcm;
00560         ssl->specs.cipher_type           = aead;
00561         ssl->specs.mac_algorithm         = sha256_mac;
00562         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00563         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00564         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00565         ssl->specs.pad_size              = PAD_SHA;
00566         ssl->specs.static_ecdh           = 1;
00567         ssl->specs.key_size              = AES_128_KEY_SIZE;
00568         ssl->specs.block_size            = AES_BLOCK_SIZE;
00569         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
00570         ssl->specs.aead_mac_size         = AES_GCM_AUTH_SZ;
00571 
00572         break;
00573 #endif
00574 
00575 #ifdef BUILD_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384
00576     case TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 :
00577         ssl->specs.bulk_cipher_algorithm = cyassl_aes_gcm;
00578         ssl->specs.cipher_type           = aead;
00579         ssl->specs.mac_algorithm         = sha384_mac;
00580         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00581         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00582         ssl->specs.hash_size             = SHA384_DIGEST_SIZE;
00583         ssl->specs.pad_size              = PAD_SHA;
00584         ssl->specs.static_ecdh           = 1;
00585         ssl->specs.key_size              = AES_256_KEY_SIZE;
00586         ssl->specs.block_size            = AES_BLOCK_SIZE;
00587         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
00588         ssl->specs.aead_mac_size         = AES_GCM_AUTH_SZ;
00589 
00590         break;
00591 #endif
00592 
00593 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8
00594     case TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 :
00595         ssl->specs.bulk_cipher_algorithm = cyassl_aes_ccm;
00596         ssl->specs.cipher_type           = aead;
00597         ssl->specs.mac_algorithm         = sha256_mac;
00598         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00599         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00600         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00601         ssl->specs.pad_size              = PAD_SHA;
00602         ssl->specs.static_ecdh           = 0;
00603         ssl->specs.key_size              = AES_128_KEY_SIZE;
00604         ssl->specs.block_size            = AES_BLOCK_SIZE;
00605         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
00606         ssl->specs.aead_mac_size         = AES_CCM_8_AUTH_SZ;
00607 
00608         break;
00609 #endif
00610 
00611 #ifdef BUILD_TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8
00612     case TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8 :
00613         ssl->specs.bulk_cipher_algorithm = cyassl_aes_ccm;
00614         ssl->specs.cipher_type           = aead;
00615         ssl->specs.mac_algorithm         = sha256_mac;
00616         ssl->specs.kea                   = ecc_diffie_hellman_kea;
00617         ssl->specs.sig_algo              = ecc_dsa_sa_algo;
00618         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00619         ssl->specs.pad_size              = PAD_SHA;
00620         ssl->specs.static_ecdh           = 0;
00621         ssl->specs.key_size              = AES_256_KEY_SIZE;
00622         ssl->specs.block_size            = AES_BLOCK_SIZE;
00623         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
00624         ssl->specs.aead_mac_size         = AES_CCM_8_AUTH_SZ;
00625 
00626         break;
00627 #endif
00628 #endif /* HAVE_ECC */
00629 
00630 #ifdef BUILD_TLS_RSA_WITH_AES_128_CCM_8
00631     case TLS_RSA_WITH_AES_128_CCM_8 :
00632         ssl->specs.bulk_cipher_algorithm = cyassl_aes_ccm;
00633         ssl->specs.cipher_type           = aead;
00634         ssl->specs.mac_algorithm         = sha256_mac;
00635         ssl->specs.kea                   = rsa_kea;
00636         ssl->specs.sig_algo              = rsa_sa_algo;
00637         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00638         ssl->specs.pad_size              = PAD_SHA;
00639         ssl->specs.static_ecdh           = 0;
00640         ssl->specs.key_size              = AES_128_KEY_SIZE;
00641         ssl->specs.block_size            = AES_BLOCK_SIZE;
00642         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
00643         ssl->specs.aead_mac_size         = AES_CCM_8_AUTH_SZ;
00644 
00645         break;
00646 #endif
00647 
00648 #ifdef BUILD_TLS_RSA_WITH_AES_256_CCM_8
00649     case TLS_RSA_WITH_AES_256_CCM_8 :
00650         ssl->specs.bulk_cipher_algorithm = cyassl_aes_ccm;
00651         ssl->specs.cipher_type           = aead;
00652         ssl->specs.mac_algorithm         = sha256_mac;
00653         ssl->specs.kea                   = rsa_kea;
00654         ssl->specs.sig_algo              = rsa_sa_algo;
00655         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00656         ssl->specs.pad_size              = PAD_SHA;
00657         ssl->specs.static_ecdh           = 0;
00658         ssl->specs.key_size              = AES_256_KEY_SIZE;
00659         ssl->specs.block_size            = AES_BLOCK_SIZE;
00660         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
00661         ssl->specs.aead_mac_size         = AES_CCM_8_AUTH_SZ;
00662 
00663         break;
00664 #endif
00665 
00666 #ifdef BUILD_TLS_PSK_WITH_AES_128_CCM_8
00667     case TLS_PSK_WITH_AES_128_CCM_8 :
00668         ssl->specs.bulk_cipher_algorithm = cyassl_aes_ccm;
00669         ssl->specs.cipher_type           = aead;
00670         ssl->specs.mac_algorithm         = sha256_mac;
00671         ssl->specs.kea                   = psk_kea;
00672         ssl->specs.sig_algo              = anonymous_sa_algo;
00673         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00674         ssl->specs.pad_size              = PAD_SHA;
00675         ssl->specs.static_ecdh           = 0;
00676         ssl->specs.key_size              = AES_128_KEY_SIZE;
00677         ssl->specs.block_size            = AES_BLOCK_SIZE;
00678         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
00679         ssl->specs.aead_mac_size         = AES_CCM_8_AUTH_SZ;
00680 
00681         ssl->options.usingPSK_cipher     = 1;
00682         break;
00683 #endif
00684 
00685 #ifdef BUILD_TLS_PSK_WITH_AES_256_CCM_8
00686     case TLS_PSK_WITH_AES_256_CCM_8 :
00687         ssl->specs.bulk_cipher_algorithm = cyassl_aes_ccm;
00688         ssl->specs.cipher_type           = aead;
00689         ssl->specs.mac_algorithm         = sha256_mac;
00690         ssl->specs.kea                   = psk_kea;
00691         ssl->specs.sig_algo              = anonymous_sa_algo;
00692         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00693         ssl->specs.pad_size              = PAD_SHA;
00694         ssl->specs.static_ecdh           = 0;
00695         ssl->specs.key_size              = AES_256_KEY_SIZE;
00696         ssl->specs.block_size            = AES_BLOCK_SIZE;
00697         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
00698         ssl->specs.aead_mac_size         = AES_CCM_8_AUTH_SZ;
00699 
00700         ssl->options.usingPSK_cipher     = 1;
00701         break;
00702 #endif
00703 
00704     default:
00705         CYASSL_MSG("Unsupported cipher suite, SetCipherSpecs ECC");
00706         return UNSUPPORTED_SUITE;
00707     }   /* switch */
00708     }   /* if     */
00709     if (ssl->options.cipherSuite0 != ECC_BYTE) {   /* normal suites */
00710     switch (ssl->options.cipherSuite) {
00711 
00712 #ifdef BUILD_SSL_RSA_WITH_RC4_128_SHA
00713     case SSL_RSA_WITH_RC4_128_SHA :
00714         ssl->specs.bulk_cipher_algorithm = cyassl_rc4;
00715         ssl->specs.cipher_type           = stream;
00716         ssl->specs.mac_algorithm         = sha_mac;
00717         ssl->specs.kea                   = rsa_kea;
00718         ssl->specs.sig_algo              = rsa_sa_algo;
00719         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00720         ssl->specs.pad_size              = PAD_SHA;
00721         ssl->specs.static_ecdh           = 0;
00722         ssl->specs.key_size              = RC4_KEY_SIZE;
00723         ssl->specs.iv_size               = 0;
00724         ssl->specs.block_size            = 0;
00725 
00726         break;
00727 #endif
00728 
00729 #ifdef BUILD_TLS_NTRU_RSA_WITH_RC4_128_SHA
00730     case TLS_NTRU_RSA_WITH_RC4_128_SHA :
00731         ssl->specs.bulk_cipher_algorithm = cyassl_rc4;
00732         ssl->specs.cipher_type           = stream;
00733         ssl->specs.mac_algorithm         = sha_mac;
00734         ssl->specs.kea                   = ntru_kea;
00735         ssl->specs.sig_algo              = rsa_sa_algo;
00736         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00737         ssl->specs.pad_size              = PAD_SHA;
00738         ssl->specs.static_ecdh           = 0;
00739         ssl->specs.key_size              = RC4_KEY_SIZE;
00740         ssl->specs.iv_size               = 0;
00741         ssl->specs.block_size            = 0;
00742 
00743         break;
00744 #endif
00745 
00746 #ifdef BUILD_SSL_RSA_WITH_RC4_128_MD5
00747     case SSL_RSA_WITH_RC4_128_MD5 :
00748         ssl->specs.bulk_cipher_algorithm = cyassl_rc4;
00749         ssl->specs.cipher_type           = stream;
00750         ssl->specs.mac_algorithm         = md5_mac;
00751         ssl->specs.kea                   = rsa_kea;
00752         ssl->specs.sig_algo              = rsa_sa_algo;
00753         ssl->specs.hash_size             = MD5_DIGEST_SIZE;
00754         ssl->specs.pad_size              = PAD_MD5;
00755         ssl->specs.static_ecdh           = 0;
00756         ssl->specs.key_size              = RC4_KEY_SIZE;
00757         ssl->specs.iv_size               = 0;
00758         ssl->specs.block_size            = 0;
00759 
00760         break;
00761 #endif
00762 
00763 #ifdef BUILD_SSL_RSA_WITH_3DES_EDE_CBC_SHA
00764     case SSL_RSA_WITH_3DES_EDE_CBC_SHA :
00765         ssl->specs.bulk_cipher_algorithm = cyassl_triple_des;
00766         ssl->specs.cipher_type           = block;
00767         ssl->specs.mac_algorithm         = sha_mac;
00768         ssl->specs.kea                   = rsa_kea;
00769         ssl->specs.sig_algo              = rsa_sa_algo;
00770         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00771         ssl->specs.pad_size              = PAD_SHA;
00772         ssl->specs.static_ecdh           = 0;
00773         ssl->specs.key_size              = DES3_KEY_SIZE;
00774         ssl->specs.block_size            = DES_BLOCK_SIZE;
00775         ssl->specs.iv_size               = DES_IV_SIZE;
00776 
00777         break;
00778 #endif
00779 
00780 #ifdef BUILD_TLS_NTRU_RSA_WITH_3DES_EDE_CBC_SHA
00781     case TLS_NTRU_RSA_WITH_3DES_EDE_CBC_SHA :
00782         ssl->specs.bulk_cipher_algorithm = cyassl_triple_des;
00783         ssl->specs.cipher_type           = block;
00784         ssl->specs.mac_algorithm         = sha_mac;
00785         ssl->specs.kea                   = ntru_kea;
00786         ssl->specs.sig_algo              = rsa_sa_algo;
00787         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00788         ssl->specs.pad_size              = PAD_SHA;
00789         ssl->specs.static_ecdh           = 0;
00790         ssl->specs.key_size              = DES3_KEY_SIZE;
00791         ssl->specs.block_size            = DES_BLOCK_SIZE;
00792         ssl->specs.iv_size               = DES_IV_SIZE;
00793 
00794         break;
00795 #endif
00796 
00797 #ifdef BUILD_TLS_RSA_WITH_AES_128_CBC_SHA
00798     case TLS_RSA_WITH_AES_128_CBC_SHA :
00799         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00800         ssl->specs.cipher_type           = block;
00801         ssl->specs.mac_algorithm         = sha_mac;
00802         ssl->specs.kea                   = rsa_kea;
00803         ssl->specs.sig_algo              = rsa_sa_algo;
00804         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00805         ssl->specs.pad_size              = PAD_SHA;
00806         ssl->specs.static_ecdh           = 0;
00807         ssl->specs.key_size              = AES_128_KEY_SIZE;
00808         ssl->specs.block_size            = AES_BLOCK_SIZE;
00809         ssl->specs.iv_size               = AES_IV_SIZE;
00810 
00811         break;
00812 #endif
00813 
00814 #ifdef BUILD_TLS_RSA_WITH_AES_128_CBC_SHA256
00815     case TLS_RSA_WITH_AES_128_CBC_SHA256 :
00816         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00817         ssl->specs.cipher_type           = block;
00818         ssl->specs.mac_algorithm         = sha256_mac;
00819         ssl->specs.kea                   = rsa_kea;
00820         ssl->specs.sig_algo              = rsa_sa_algo;
00821         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00822         ssl->specs.pad_size              = PAD_SHA;
00823         ssl->specs.static_ecdh           = 0;
00824         ssl->specs.key_size              = AES_128_KEY_SIZE;
00825         ssl->specs.block_size            = AES_BLOCK_SIZE;
00826         ssl->specs.iv_size               = AES_IV_SIZE;
00827 
00828         break;
00829 #endif
00830 
00831 #ifdef BUILD_TLS_RSA_WITH_NULL_SHA
00832     case TLS_RSA_WITH_NULL_SHA :
00833         ssl->specs.bulk_cipher_algorithm = cyassl_cipher_null;
00834         ssl->specs.cipher_type           = stream;
00835         ssl->specs.mac_algorithm         = sha_mac;
00836         ssl->specs.kea                   = rsa_kea;
00837         ssl->specs.sig_algo              = rsa_sa_algo;
00838         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00839         ssl->specs.pad_size              = PAD_SHA;
00840         ssl->specs.static_ecdh           = 0;
00841         ssl->specs.key_size              = 0;
00842         ssl->specs.block_size            = 0;
00843         ssl->specs.iv_size               = 0;
00844 
00845         break;
00846 #endif
00847 
00848 #ifdef BUILD_TLS_RSA_WITH_NULL_SHA256
00849     case TLS_RSA_WITH_NULL_SHA256 :
00850         ssl->specs.bulk_cipher_algorithm = cyassl_cipher_null;
00851         ssl->specs.cipher_type           = stream;
00852         ssl->specs.mac_algorithm         = sha256_mac;
00853         ssl->specs.kea                   = rsa_kea;
00854         ssl->specs.sig_algo              = rsa_sa_algo;
00855         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00856         ssl->specs.pad_size              = PAD_SHA;
00857         ssl->specs.static_ecdh           = 0;
00858         ssl->specs.key_size              = 0;
00859         ssl->specs.block_size            = 0;
00860         ssl->specs.iv_size               = 0;
00861 
00862         break;
00863 #endif
00864 
00865 #ifdef BUILD_TLS_NTRU_RSA_WITH_AES_128_CBC_SHA
00866     case TLS_NTRU_RSA_WITH_AES_128_CBC_SHA :
00867         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00868         ssl->specs.cipher_type           = block;
00869         ssl->specs.mac_algorithm         = sha_mac;
00870         ssl->specs.kea                   = ntru_kea;
00871         ssl->specs.sig_algo              = rsa_sa_algo;
00872         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00873         ssl->specs.pad_size              = PAD_SHA;
00874         ssl->specs.static_ecdh           = 0;
00875         ssl->specs.key_size              = AES_128_KEY_SIZE;
00876         ssl->specs.block_size            = AES_BLOCK_SIZE;
00877         ssl->specs.iv_size               = AES_IV_SIZE;
00878 
00879         break;
00880 #endif
00881 
00882 #ifdef BUILD_TLS_RSA_WITH_AES_256_CBC_SHA
00883     case TLS_RSA_WITH_AES_256_CBC_SHA :
00884         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00885         ssl->specs.cipher_type           = block;
00886         ssl->specs.mac_algorithm         = sha_mac;
00887         ssl->specs.kea                   = rsa_kea;
00888         ssl->specs.sig_algo              = rsa_sa_algo;
00889         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00890         ssl->specs.pad_size              = PAD_SHA;
00891         ssl->specs.static_ecdh           = 0;
00892         ssl->specs.key_size              = AES_256_KEY_SIZE;
00893         ssl->specs.block_size            = AES_BLOCK_SIZE;
00894         ssl->specs.iv_size               = AES_IV_SIZE;
00895 
00896         break;
00897 #endif
00898 
00899 #ifdef BUILD_TLS_RSA_WITH_AES_256_CBC_SHA256
00900     case TLS_RSA_WITH_AES_256_CBC_SHA256 :
00901         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00902         ssl->specs.cipher_type           = block;
00903         ssl->specs.mac_algorithm         = sha256_mac;
00904         ssl->specs.kea                   = rsa_kea;
00905         ssl->specs.sig_algo              = rsa_sa_algo;
00906         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00907         ssl->specs.pad_size              = PAD_SHA;
00908         ssl->specs.static_ecdh           = 0;
00909         ssl->specs.key_size              = AES_256_KEY_SIZE;
00910         ssl->specs.block_size            = AES_BLOCK_SIZE;
00911         ssl->specs.iv_size               = AES_IV_SIZE;
00912 
00913         break;
00914 #endif
00915 
00916 #ifdef BUILD_TLS_NTRU_RSA_WITH_AES_256_CBC_SHA
00917     case TLS_NTRU_RSA_WITH_AES_256_CBC_SHA :
00918         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00919         ssl->specs.cipher_type           = block;
00920         ssl->specs.mac_algorithm         = sha_mac;
00921         ssl->specs.kea                   = ntru_kea;
00922         ssl->specs.sig_algo              = rsa_sa_algo;
00923         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00924         ssl->specs.pad_size              = PAD_SHA;
00925         ssl->specs.static_ecdh           = 0;
00926         ssl->specs.key_size              = AES_256_KEY_SIZE;
00927         ssl->specs.block_size            = AES_BLOCK_SIZE;
00928         ssl->specs.iv_size               = AES_IV_SIZE;
00929 
00930         break;
00931 #endif
00932 
00933 #ifdef BUILD_TLS_PSK_WITH_AES_128_CBC_SHA256
00934     case TLS_PSK_WITH_AES_128_CBC_SHA256 :
00935         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00936         ssl->specs.cipher_type           = block;
00937         ssl->specs.mac_algorithm         = sha256_mac;
00938         ssl->specs.kea                   = psk_kea;
00939         ssl->specs.sig_algo              = anonymous_sa_algo;
00940         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00941         ssl->specs.pad_size              = PAD_SHA;
00942         ssl->specs.static_ecdh           = 0;
00943         ssl->specs.key_size              = AES_128_KEY_SIZE;
00944         ssl->specs.block_size            = AES_BLOCK_SIZE;
00945         ssl->specs.iv_size               = AES_IV_SIZE;
00946 
00947         ssl->options.usingPSK_cipher     = 1;
00948         break;
00949 #endif
00950 
00951 #ifdef BUILD_TLS_PSK_WITH_AES_128_CBC_SHA
00952     case TLS_PSK_WITH_AES_128_CBC_SHA :
00953         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00954         ssl->specs.cipher_type           = block;
00955         ssl->specs.mac_algorithm         = sha_mac;
00956         ssl->specs.kea                   = psk_kea;
00957         ssl->specs.sig_algo              = anonymous_sa_algo;
00958         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00959         ssl->specs.pad_size              = PAD_SHA;
00960         ssl->specs.static_ecdh           = 0;
00961         ssl->specs.key_size              = AES_128_KEY_SIZE;
00962         ssl->specs.block_size            = AES_BLOCK_SIZE;
00963         ssl->specs.iv_size               = AES_IV_SIZE;
00964 
00965         ssl->options.usingPSK_cipher     = 1;
00966         break;
00967 #endif
00968 
00969 #ifdef BUILD_TLS_PSK_WITH_AES_256_CBC_SHA
00970     case TLS_PSK_WITH_AES_256_CBC_SHA :
00971         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
00972         ssl->specs.cipher_type           = block;
00973         ssl->specs.mac_algorithm         = sha_mac;
00974         ssl->specs.kea                   = psk_kea;
00975         ssl->specs.sig_algo              = anonymous_sa_algo;
00976         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
00977         ssl->specs.pad_size              = PAD_SHA;
00978         ssl->specs.static_ecdh           = 0;
00979         ssl->specs.key_size              = AES_256_KEY_SIZE;
00980         ssl->specs.block_size            = AES_BLOCK_SIZE;
00981         ssl->specs.iv_size               = AES_IV_SIZE;
00982 
00983         ssl->options.usingPSK_cipher     = 1;
00984         break;
00985 #endif
00986 
00987 #ifdef BUILD_TLS_PSK_WITH_NULL_SHA256
00988     case TLS_PSK_WITH_NULL_SHA256 :
00989         ssl->specs.bulk_cipher_algorithm = cyassl_cipher_null;
00990         ssl->specs.cipher_type           = stream;
00991         ssl->specs.mac_algorithm         = sha256_mac;
00992         ssl->specs.kea                   = psk_kea;
00993         ssl->specs.sig_algo              = anonymous_sa_algo;
00994         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
00995         ssl->specs.pad_size              = PAD_SHA;
00996         ssl->specs.static_ecdh           = 0;
00997         ssl->specs.key_size              = 0;
00998         ssl->specs.block_size            = 0;
00999         ssl->specs.iv_size               = 0;
01000 
01001         ssl->options.usingPSK_cipher     = 1;
01002         break;
01003 #endif
01004 
01005 #ifdef BUILD_TLS_PSK_WITH_NULL_SHA
01006     case TLS_PSK_WITH_NULL_SHA :
01007         ssl->specs.bulk_cipher_algorithm = cyassl_cipher_null;
01008         ssl->specs.cipher_type           = stream;
01009         ssl->specs.mac_algorithm         = sha_mac;
01010         ssl->specs.kea                   = psk_kea;
01011         ssl->specs.sig_algo              = anonymous_sa_algo;
01012         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
01013         ssl->specs.pad_size              = PAD_SHA;
01014         ssl->specs.static_ecdh           = 0;
01015         ssl->specs.key_size              = 0;
01016         ssl->specs.block_size            = 0;
01017         ssl->specs.iv_size               = 0;
01018 
01019         ssl->options.usingPSK_cipher     = 1;
01020         break;
01021 #endif
01022 
01023 #ifdef BUILD_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
01024     case TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 :
01025         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
01026         ssl->specs.cipher_type           = block;
01027         ssl->specs.mac_algorithm         = sha256_mac;
01028         ssl->specs.kea                   = diffie_hellman_kea;
01029         ssl->specs.sig_algo              = rsa_sa_algo;
01030         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
01031         ssl->specs.pad_size              = PAD_SHA;
01032         ssl->specs.static_ecdh           = 0;
01033         ssl->specs.key_size              = AES_128_KEY_SIZE;
01034         ssl->specs.block_size            = AES_BLOCK_SIZE;
01035         ssl->specs.iv_size               = AES_IV_SIZE;
01036 
01037         break;
01038 #endif
01039 
01040 #ifdef BUILD_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
01041     case TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 :
01042         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
01043         ssl->specs.cipher_type           = block;
01044         ssl->specs.mac_algorithm         = sha256_mac;
01045         ssl->specs.kea                   = diffie_hellman_kea;
01046         ssl->specs.sig_algo              = rsa_sa_algo;
01047         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
01048         ssl->specs.pad_size              = PAD_SHA;
01049         ssl->specs.static_ecdh           = 0;
01050         ssl->specs.key_size              = AES_256_KEY_SIZE;
01051         ssl->specs.block_size            = AES_BLOCK_SIZE;
01052         ssl->specs.iv_size               = AES_IV_SIZE;
01053 
01054         break;
01055 #endif
01056 
01057 #ifdef BUILD_TLS_DHE_RSA_WITH_AES_128_CBC_SHA
01058     case TLS_DHE_RSA_WITH_AES_128_CBC_SHA :
01059         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
01060         ssl->specs.cipher_type           = block;
01061         ssl->specs.mac_algorithm         = sha_mac;
01062         ssl->specs.kea                   = diffie_hellman_kea;
01063         ssl->specs.sig_algo              = rsa_sa_algo;
01064         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
01065         ssl->specs.pad_size              = PAD_SHA;
01066         ssl->specs.static_ecdh           = 0;
01067         ssl->specs.key_size              = AES_128_KEY_SIZE;
01068         ssl->specs.block_size            = AES_BLOCK_SIZE;
01069         ssl->specs.iv_size               = AES_IV_SIZE;
01070 
01071         break;
01072 #endif
01073 
01074 #ifdef BUILD_TLS_DHE_RSA_WITH_AES_256_CBC_SHA
01075     case TLS_DHE_RSA_WITH_AES_256_CBC_SHA :
01076         ssl->specs.bulk_cipher_algorithm = cyassl_aes;
01077         ssl->specs.cipher_type           = block;
01078         ssl->specs.mac_algorithm         = sha_mac;
01079         ssl->specs.kea                   = diffie_hellman_kea;
01080         ssl->specs.sig_algo              = rsa_sa_algo;
01081         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
01082         ssl->specs.pad_size              = PAD_SHA;
01083         ssl->specs.static_ecdh           = 0;
01084         ssl->specs.key_size              = AES_256_KEY_SIZE;
01085         ssl->specs.block_size            = AES_BLOCK_SIZE;
01086         ssl->specs.iv_size               = AES_IV_SIZE;
01087 
01088         break;
01089 #endif
01090 
01091 #ifdef BUILD_TLS_RSA_WITH_HC_128_MD5
01092     case TLS_RSA_WITH_HC_128_MD5 :
01093         ssl->specs.bulk_cipher_algorithm = cyassl_hc128;
01094         ssl->specs.cipher_type           = stream;
01095         ssl->specs.mac_algorithm         = md5_mac;
01096         ssl->specs.kea                   = rsa_kea;
01097         ssl->specs.sig_algo              = rsa_sa_algo;
01098         ssl->specs.hash_size             = MD5_DIGEST_SIZE;
01099         ssl->specs.pad_size              = PAD_MD5;
01100         ssl->specs.static_ecdh           = 0;
01101         ssl->specs.key_size              = HC_128_KEY_SIZE;
01102         ssl->specs.block_size            = 0;
01103         ssl->specs.iv_size               = HC_128_IV_SIZE;
01104 
01105         break;
01106 #endif
01107             
01108 #ifdef BUILD_TLS_RSA_WITH_HC_128_SHA
01109         case TLS_RSA_WITH_HC_128_SHA :
01110             ssl->specs.bulk_cipher_algorithm = cyassl_hc128;
01111             ssl->specs.cipher_type           = stream;
01112             ssl->specs.mac_algorithm         = sha_mac;
01113             ssl->specs.kea                   = rsa_kea;
01114             ssl->specs.sig_algo              = rsa_sa_algo;
01115             ssl->specs.hash_size             = SHA_DIGEST_SIZE;
01116             ssl->specs.pad_size              = PAD_SHA;
01117             ssl->specs.static_ecdh           = 0;
01118             ssl->specs.key_size              = HC_128_KEY_SIZE;
01119             ssl->specs.block_size            = 0;
01120             ssl->specs.iv_size               = HC_128_IV_SIZE;
01121             
01122             break;
01123 #endif
01124 
01125 #ifdef BUILD_TLS_RSA_WITH_HC_128_B2B256
01126         case TLS_RSA_WITH_HC_128_B2B256:
01127             ssl->specs.bulk_cipher_algorithm = cyassl_hc128;
01128             ssl->specs.cipher_type           = stream;
01129             ssl->specs.mac_algorithm         = blake2b_mac;
01130             ssl->specs.kea                   = rsa_kea;
01131             ssl->specs.sig_algo              = rsa_sa_algo;
01132             ssl->specs.hash_size             = BLAKE2B_256;
01133             ssl->specs.pad_size              = PAD_SHA;
01134             ssl->specs.static_ecdh           = 0;
01135             ssl->specs.key_size              = HC_128_KEY_SIZE;
01136             ssl->specs.block_size            = 0;
01137             ssl->specs.iv_size               = HC_128_IV_SIZE;
01138             
01139             break;
01140 #endif
01141 
01142 #ifdef BUILD_TLS_RSA_WITH_AES_128_CBC_B2B256
01143         case TLS_RSA_WITH_AES_128_CBC_B2B256:
01144             ssl->specs.bulk_cipher_algorithm = cyassl_aes;
01145             ssl->specs.cipher_type           = block;
01146             ssl->specs.mac_algorithm         = blake2b_mac;
01147             ssl->specs.kea                   = rsa_kea;
01148             ssl->specs.sig_algo              = rsa_sa_algo;
01149             ssl->specs.hash_size             = BLAKE2B_256;
01150             ssl->specs.pad_size              = PAD_SHA;
01151             ssl->specs.static_ecdh           = 0;
01152             ssl->specs.key_size              = AES_128_KEY_SIZE;
01153             ssl->specs.iv_size               = AES_IV_SIZE;
01154             ssl->specs.block_size            = AES_BLOCK_SIZE;
01155             
01156             break;
01157 #endif
01158 
01159 #ifdef BUILD_TLS_RSA_WITH_AES_256_CBC_B2B256
01160         case TLS_RSA_WITH_AES_256_CBC_B2B256:
01161             ssl->specs.bulk_cipher_algorithm = cyassl_aes;
01162             ssl->specs.cipher_type           = block;
01163             ssl->specs.mac_algorithm         = blake2b_mac;
01164             ssl->specs.kea                   = rsa_kea;
01165             ssl->specs.sig_algo              = rsa_sa_algo;
01166             ssl->specs.hash_size             = BLAKE2B_256;
01167             ssl->specs.pad_size              = PAD_SHA;
01168             ssl->specs.static_ecdh           = 0;
01169             ssl->specs.key_size              = AES_256_KEY_SIZE;
01170             ssl->specs.iv_size               = AES_IV_SIZE;
01171             ssl->specs.block_size            = AES_BLOCK_SIZE;
01172             
01173             break;
01174 #endif
01175 
01176 #ifdef BUILD_TLS_RSA_WITH_RABBIT_SHA
01177     case TLS_RSA_WITH_RABBIT_SHA :
01178         ssl->specs.bulk_cipher_algorithm = cyassl_rabbit;
01179         ssl->specs.cipher_type           = stream;
01180         ssl->specs.mac_algorithm         = sha_mac;
01181         ssl->specs.kea                   = rsa_kea;
01182         ssl->specs.sig_algo              = rsa_sa_algo;
01183         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
01184         ssl->specs.pad_size              = PAD_SHA;
01185         ssl->specs.static_ecdh           = 0;
01186         ssl->specs.key_size              = RABBIT_KEY_SIZE;
01187         ssl->specs.block_size            = 0;
01188         ssl->specs.iv_size               = RABBIT_IV_SIZE;
01189 
01190         break;
01191 #endif
01192 
01193 #ifdef BUILD_TLS_RSA_WITH_AES_128_GCM_SHA256
01194     case TLS_RSA_WITH_AES_128_GCM_SHA256 :
01195         ssl->specs.bulk_cipher_algorithm = cyassl_aes_gcm;
01196         ssl->specs.cipher_type           = aead;
01197         ssl->specs.mac_algorithm         = sha256_mac;
01198         ssl->specs.kea                   = rsa_kea;
01199         ssl->specs.sig_algo              = rsa_sa_algo;
01200         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
01201         ssl->specs.pad_size              = PAD_SHA;
01202         ssl->specs.static_ecdh           = 0;
01203         ssl->specs.key_size              = AES_128_KEY_SIZE;
01204         ssl->specs.block_size            = AES_BLOCK_SIZE;
01205         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
01206         ssl->specs.aead_mac_size         = AES_GCM_AUTH_SZ;
01207 
01208         break;
01209 #endif
01210 
01211 #ifdef BUILD_TLS_RSA_WITH_AES_256_GCM_SHA384
01212     case TLS_RSA_WITH_AES_256_GCM_SHA384 :
01213         ssl->specs.bulk_cipher_algorithm = cyassl_aes_gcm;
01214         ssl->specs.cipher_type           = aead;
01215         ssl->specs.mac_algorithm         = sha384_mac;
01216         ssl->specs.kea                   = rsa_kea;
01217         ssl->specs.sig_algo              = rsa_sa_algo;
01218         ssl->specs.hash_size             = SHA384_DIGEST_SIZE;
01219         ssl->specs.pad_size              = PAD_SHA;
01220         ssl->specs.static_ecdh           = 0;
01221         ssl->specs.key_size              = AES_256_KEY_SIZE;
01222         ssl->specs.block_size            = AES_BLOCK_SIZE;
01223         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
01224         ssl->specs.aead_mac_size         = AES_GCM_AUTH_SZ;
01225 
01226         break;
01227 #endif
01228 
01229 #ifdef BUILD_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
01230     case TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 :
01231         ssl->specs.bulk_cipher_algorithm = cyassl_aes_gcm;
01232         ssl->specs.cipher_type           = aead;
01233         ssl->specs.mac_algorithm         = sha256_mac;
01234         ssl->specs.kea                   = diffie_hellman_kea;
01235         ssl->specs.sig_algo              = rsa_sa_algo;
01236         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
01237         ssl->specs.pad_size              = PAD_SHA;
01238         ssl->specs.static_ecdh           = 0;
01239         ssl->specs.key_size              = AES_128_KEY_SIZE;
01240         ssl->specs.block_size            = AES_BLOCK_SIZE;
01241         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
01242         ssl->specs.aead_mac_size         = AES_GCM_AUTH_SZ;
01243 
01244         break;
01245 #endif
01246 
01247 #ifdef BUILD_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
01248     case TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 :
01249         ssl->specs.bulk_cipher_algorithm = cyassl_aes_gcm;
01250         ssl->specs.cipher_type           = aead;
01251         ssl->specs.mac_algorithm         = sha384_mac;
01252         ssl->specs.kea                   = diffie_hellman_kea;
01253         ssl->specs.sig_algo              = rsa_sa_algo;
01254         ssl->specs.hash_size             = SHA384_DIGEST_SIZE;
01255         ssl->specs.pad_size              = PAD_SHA;
01256         ssl->specs.static_ecdh           = 0;
01257         ssl->specs.key_size              = AES_256_KEY_SIZE;
01258         ssl->specs.block_size            = AES_BLOCK_SIZE;
01259         ssl->specs.iv_size               = AEAD_IMP_IV_SZ;
01260         ssl->specs.aead_mac_size         = AES_GCM_AUTH_SZ;
01261 
01262         break;
01263 #endif
01264 
01265 #ifdef BUILD_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA
01266     case TLS_RSA_WITH_CAMELLIA_128_CBC_SHA :
01267         ssl->specs.bulk_cipher_algorithm = cyassl_camellia;
01268         ssl->specs.cipher_type           = block;
01269         ssl->specs.mac_algorithm         = sha_mac;
01270         ssl->specs.kea                   = rsa_kea;
01271         ssl->specs.sig_algo              = rsa_sa_algo;
01272         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
01273         ssl->specs.pad_size              = PAD_SHA;
01274         ssl->specs.static_ecdh           = 0;
01275         ssl->specs.key_size              = CAMELLIA_128_KEY_SIZE;
01276         ssl->specs.block_size            = CAMELLIA_BLOCK_SIZE;
01277         ssl->specs.iv_size               = CAMELLIA_IV_SIZE;
01278 
01279         break;
01280 #endif
01281     
01282 #ifdef BUILD_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA
01283     case TLS_RSA_WITH_CAMELLIA_256_CBC_SHA :
01284         ssl->specs.bulk_cipher_algorithm = cyassl_camellia;
01285         ssl->specs.cipher_type           = block;
01286         ssl->specs.mac_algorithm         = sha_mac;
01287         ssl->specs.kea                   = rsa_kea;
01288         ssl->specs.sig_algo              = rsa_sa_algo;
01289         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
01290         ssl->specs.pad_size              = PAD_SHA;
01291         ssl->specs.static_ecdh           = 0;
01292         ssl->specs.key_size              = CAMELLIA_256_KEY_SIZE;
01293         ssl->specs.block_size            = CAMELLIA_BLOCK_SIZE;
01294         ssl->specs.iv_size               = CAMELLIA_IV_SIZE;
01295 
01296         break;
01297 #endif
01298 
01299 #ifdef BUILD_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256
01300     case TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256 :
01301         ssl->specs.bulk_cipher_algorithm = cyassl_camellia;
01302         ssl->specs.cipher_type           = block;
01303         ssl->specs.mac_algorithm         = sha256_mac;
01304         ssl->specs.kea                   = rsa_kea;
01305         ssl->specs.sig_algo              = rsa_sa_algo;
01306         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
01307         ssl->specs.pad_size              = PAD_SHA;
01308         ssl->specs.static_ecdh           = 0;
01309         ssl->specs.key_size              = CAMELLIA_128_KEY_SIZE;
01310         ssl->specs.block_size            = CAMELLIA_BLOCK_SIZE;
01311         ssl->specs.iv_size               = CAMELLIA_IV_SIZE;
01312 
01313         break;
01314 #endif
01315 
01316 #ifdef BUILD_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256
01317     case TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256 :
01318         ssl->specs.bulk_cipher_algorithm = cyassl_camellia;
01319         ssl->specs.cipher_type           = block;
01320         ssl->specs.mac_algorithm         = sha256_mac;
01321         ssl->specs.kea                   = rsa_kea;
01322         ssl->specs.sig_algo              = rsa_sa_algo;
01323         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
01324         ssl->specs.pad_size              = PAD_SHA;
01325         ssl->specs.static_ecdh           = 0;
01326         ssl->specs.key_size              = CAMELLIA_256_KEY_SIZE;
01327         ssl->specs.block_size            = CAMELLIA_BLOCK_SIZE;
01328         ssl->specs.iv_size               = CAMELLIA_IV_SIZE;
01329 
01330         break;
01331 #endif
01332 
01333 #ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA
01334     case TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA :
01335         ssl->specs.bulk_cipher_algorithm = cyassl_camellia;
01336         ssl->specs.cipher_type           = block;
01337         ssl->specs.mac_algorithm         = sha_mac;
01338         ssl->specs.kea                   = diffie_hellman_kea;
01339         ssl->specs.sig_algo              = rsa_sa_algo;
01340         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
01341         ssl->specs.pad_size              = PAD_SHA;
01342         ssl->specs.static_ecdh           = 0;
01343         ssl->specs.key_size              = CAMELLIA_128_KEY_SIZE;
01344         ssl->specs.block_size            = CAMELLIA_BLOCK_SIZE;
01345         ssl->specs.iv_size               = CAMELLIA_IV_SIZE;
01346 
01347         break;
01348 #endif
01349 
01350 #ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA
01351     case TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA :
01352         ssl->specs.bulk_cipher_algorithm = cyassl_camellia;
01353         ssl->specs.cipher_type           = block;
01354         ssl->specs.mac_algorithm         = sha_mac;
01355         ssl->specs.kea                   = diffie_hellman_kea;
01356         ssl->specs.sig_algo              = rsa_sa_algo;
01357         ssl->specs.hash_size             = SHA_DIGEST_SIZE;
01358         ssl->specs.pad_size              = PAD_SHA;
01359         ssl->specs.static_ecdh           = 0;
01360         ssl->specs.key_size              = CAMELLIA_256_KEY_SIZE;
01361         ssl->specs.block_size            = CAMELLIA_BLOCK_SIZE;
01362         ssl->specs.iv_size               = CAMELLIA_IV_SIZE;
01363 
01364         break;
01365 #endif
01366 
01367 #ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256
01368     case TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 :
01369         ssl->specs.bulk_cipher_algorithm = cyassl_camellia;
01370         ssl->specs.cipher_type           = block;
01371         ssl->specs.mac_algorithm         = sha256_mac;
01372         ssl->specs.kea                   = diffie_hellman_kea;
01373         ssl->specs.sig_algo              = rsa_sa_algo;
01374         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
01375         ssl->specs.pad_size              = PAD_SHA;
01376         ssl->specs.static_ecdh           = 0;
01377         ssl->specs.key_size              = CAMELLIA_128_KEY_SIZE;
01378         ssl->specs.block_size            = CAMELLIA_BLOCK_SIZE;
01379         ssl->specs.iv_size               = CAMELLIA_IV_SIZE;
01380 
01381         break;
01382 #endif
01383 
01384 #ifdef BUILD_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256
01385     case TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 :
01386         ssl->specs.bulk_cipher_algorithm = cyassl_camellia;
01387         ssl->specs.cipher_type           = block;
01388         ssl->specs.mac_algorithm         = sha256_mac;
01389         ssl->specs.kea                   = diffie_hellman_kea;
01390         ssl->specs.sig_algo              = rsa_sa_algo;
01391         ssl->specs.hash_size             = SHA256_DIGEST_SIZE;
01392         ssl->specs.pad_size              = PAD_SHA;
01393         ssl->specs.static_ecdh           = 0;
01394         ssl->specs.key_size              = CAMELLIA_256_KEY_SIZE;
01395         ssl->specs.block_size            = CAMELLIA_BLOCK_SIZE;
01396         ssl->specs.iv_size               = CAMELLIA_IV_SIZE;
01397 
01398         break;
01399 #endif
01400 
01401     default:
01402         CYASSL_MSG("Unsupported cipher suite, SetCipherSpecs");
01403         return UNSUPPORTED_SUITE;
01404     }  /* switch */
01405     }  /* if ECC / Normal suites else */
01406 
01407     /* set TLS if it hasn't been turned off */
01408     if (ssl->version.major == 3 && ssl->version.minor >= 1) {
01409 #ifndef NO_TLS
01410         ssl->options.tls = 1;
01411         ssl->hmac = TLS_hmac;
01412         if (ssl->version.minor >= 2)
01413             ssl->options.tls1_1 = 1;
01414 #endif
01415     }
01416 
01417 #ifdef CYASSL_DTLS
01418     if (ssl->options.dtls)
01419         ssl->hmac = TLS_hmac;
01420 #endif
01421 
01422     return 0;
01423 }
01424 
01425 
01426 enum KeyStuff {
01427     MASTER_ROUNDS = 3,
01428     PREFIX        = 3,     /* up to three letters for master prefix */
01429     KEY_PREFIX    = 7      /* up to 7 prefix letters for key rounds */
01430 
01431 
01432 };
01433 
01434 #ifndef NO_OLD_TLS
01435 /* true or false, zero for error */
01436 static int SetPrefix(byte* sha_input, int idx)
01437 {
01438     switch (idx) {
01439     case 0:
01440         XMEMCPY(sha_input, "A", 1);
01441         break;
01442     case 1:
01443         XMEMCPY(sha_input, "BB", 2);
01444         break;
01445     case 2:
01446         XMEMCPY(sha_input, "CCC", 3);
01447         break;
01448     case 3:
01449         XMEMCPY(sha_input, "DDDD", 4);
01450         break;
01451     case 4:
01452         XMEMCPY(sha_input, "EEEEE", 5);
01453         break;
01454     case 5:
01455         XMEMCPY(sha_input, "FFFFFF", 6);
01456         break;
01457     case 6:
01458         XMEMCPY(sha_input, "GGGGGGG", 7);
01459         break;
01460     default:
01461         CYASSL_MSG("Set Prefix error, bad input");
01462         return 0; 
01463     }
01464     return 1;
01465 }
01466 #endif
01467 
01468 
01469 static int SetKeys(Ciphers* enc, Ciphers* dec, Keys* keys, CipherSpecs* specs,
01470                    byte side, void* heap, int devId)
01471 {
01472 #ifdef BUILD_ARC4
01473     word32 sz = specs->key_size;
01474     if (specs->bulk_cipher_algorithm == cyassl_rc4) {
01475         if (enc->arc4 == NULL)
01476             enc->arc4 = (Arc4*)XMALLOC(sizeof(Arc4), heap, DYNAMIC_TYPE_CIPHER);
01477         if (enc->arc4 == NULL)
01478             return MEMORY_E;
01479         if (dec->arc4 == NULL)
01480             dec->arc4 = (Arc4*)XMALLOC(sizeof(Arc4), heap, DYNAMIC_TYPE_CIPHER);
01481         if (dec->arc4 == NULL)
01482             return MEMORY_E;
01483 #ifdef HAVE_CAVIUM
01484         if (devId != NO_CAVIUM_DEVICE) {
01485             if (Arc4InitCavium(enc->arc4, devId) != 0) {
01486                 CYASSL_MSG("Arc4InitCavium failed in SetKeys");
01487                 return CAVIUM_INIT_E;
01488             }
01489             if (Arc4InitCavium(dec->arc4, devId) != 0) {
01490                 CYASSL_MSG("Arc4InitCavium failed in SetKeys");
01491                 return CAVIUM_INIT_E;
01492             }
01493         }
01494 #endif
01495         if (side == CYASSL_CLIENT_END) {
01496             Arc4SetKey(enc->arc4, keys->client_write_key, sz);
01497             Arc4SetKey(dec->arc4, keys->server_write_key, sz);
01498         }
01499         else {
01500             Arc4SetKey(enc->arc4, keys->server_write_key, sz);
01501             Arc4SetKey(dec->arc4, keys->client_write_key, sz);
01502         }
01503         enc->setup = 1;
01504         dec->setup = 1;
01505     }
01506 #endif
01507     
01508 #ifdef HAVE_HC128
01509     if (specs->bulk_cipher_algorithm == cyassl_hc128) {
01510         int hcRet;
01511         if (enc->hc128 == NULL)
01512             enc->hc128 =
01513                       (HC128*)XMALLOC(sizeof(HC128), heap, DYNAMIC_TYPE_CIPHER);
01514         if (enc->hc128 == NULL)
01515             return MEMORY_E;
01516         if (dec->hc128 == NULL)
01517             dec->hc128 =
01518                       (HC128*)XMALLOC(sizeof(HC128), heap, DYNAMIC_TYPE_CIPHER);
01519         if (dec->hc128 == NULL)
01520             return MEMORY_E;
01521         if (side == CYASSL_CLIENT_END) {
01522             hcRet = Hc128_SetKey(enc->hc128, keys->client_write_key,
01523                                  keys->client_write_IV);
01524             if (hcRet != 0) return hcRet;
01525             hcRet = Hc128_SetKey(dec->hc128, keys->server_write_key,
01526                                   keys->server_write_IV);
01527             if (hcRet != 0) return hcRet;
01528         }
01529         else {
01530             hcRet = Hc128_SetKey(enc->hc128, keys->server_write_key,
01531                                   keys->server_write_IV);
01532             if (hcRet != 0) return hcRet;
01533             hcRet = Hc128_SetKey(dec->hc128, keys->client_write_key,
01534                                   keys->client_write_IV);
01535             if (hcRet != 0) return hcRet;
01536         }
01537         enc->setup = 1;
01538         dec->setup = 1;
01539     }
01540 #endif
01541     
01542 #ifdef BUILD_RABBIT
01543     if (specs->bulk_cipher_algorithm == cyassl_rabbit) {
01544         int rabRet;
01545         if (enc->rabbit == NULL)
01546             enc->rabbit =
01547                     (Rabbit*)XMALLOC(sizeof(Rabbit), heap, DYNAMIC_TYPE_CIPHER);
01548         if (enc->rabbit == NULL)
01549             return MEMORY_E;
01550         if (dec->rabbit == NULL)
01551             dec->rabbit =
01552                     (Rabbit*)XMALLOC(sizeof(Rabbit), heap, DYNAMIC_TYPE_CIPHER);
01553         if (dec->rabbit == NULL)
01554             return MEMORY_E;
01555         if (side == CYASSL_CLIENT_END) {
01556             rabRet = RabbitSetKey(enc->rabbit, keys->client_write_key,
01557                                   keys->client_write_IV);
01558             if (rabRet != 0) return rabRet;
01559             rabRet = RabbitSetKey(dec->rabbit, keys->server_write_key,
01560                                   keys->server_write_IV);
01561             if (rabRet != 0) return rabRet;
01562         }
01563         else {
01564             rabRet = RabbitSetKey(enc->rabbit, keys->server_write_key,
01565                                            keys->server_write_IV);
01566             if (rabRet != 0) return rabRet;
01567             rabRet = RabbitSetKey(dec->rabbit, keys->client_write_key,
01568                                            keys->client_write_IV);
01569             if (rabRet != 0) return rabRet;
01570         }
01571         enc->setup = 1;
01572         dec->setup = 1;
01573     }
01574 #endif
01575     
01576 #ifdef BUILD_DES3
01577     if (specs->bulk_cipher_algorithm == cyassl_triple_des) {
01578         int desRet = 0;
01579 
01580         if (enc->des3 == NULL)
01581             enc->des3 = (Des3*)XMALLOC(sizeof(Des3), heap, DYNAMIC_TYPE_CIPHER);
01582         if (enc->des3 == NULL)
01583             return MEMORY_E;
01584         if (dec->des3 == NULL)
01585             dec->des3 = (Des3*)XMALLOC(sizeof(Des3), heap, DYNAMIC_TYPE_CIPHER);
01586         if (dec->des3 == NULL)
01587             return MEMORY_E;
01588 #ifdef HAVE_CAVIUM
01589         if (devId != NO_CAVIUM_DEVICE) {
01590             if (Des3_InitCavium(enc->des3, devId) != 0) {
01591                 CYASSL_MSG("Des3_InitCavium failed in SetKeys");
01592                 return CAVIUM_INIT_E;
01593             }
01594             if (Des3_InitCavium(dec->des3, devId) != 0) {
01595                 CYASSL_MSG("Des3_InitCavium failed in SetKeys");
01596                 return CAVIUM_INIT_E;
01597             }
01598         }
01599 #endif
01600         if (side == CYASSL_CLIENT_END) {
01601             desRet = Des3_SetKey(enc->des3, keys->client_write_key,
01602                         keys->client_write_IV, DES_ENCRYPTION);
01603             if (desRet != 0)
01604                 return desRet;
01605             desRet = Des3_SetKey(dec->des3, keys->server_write_key,
01606                         keys->server_write_IV, DES_DECRYPTION);
01607             if (desRet != 0)
01608                 return desRet;
01609         }
01610         else {
01611             desRet = Des3_SetKey(enc->des3, keys->server_write_key,
01612                         keys->server_write_IV, DES_ENCRYPTION);
01613             if (desRet != 0)
01614                 return desRet;
01615             desRet = Des3_SetKey(dec->des3, keys->client_write_key,
01616                 keys->client_write_IV, DES_DECRYPTION);
01617             if (desRet != 0)
01618                 return desRet;
01619         }
01620         enc->setup = 1;
01621         dec->setup = 1;
01622     }
01623 #endif
01624 
01625 #ifdef BUILD_AES
01626     if (specs->bulk_cipher_algorithm == cyassl_aes) {
01627         int aesRet = 0;
01628 
01629         if (enc->aes == NULL)
01630             enc->aes = (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_CIPHER);
01631         if (enc->aes == NULL)
01632             return MEMORY_E;
01633         if (dec->aes == NULL)
01634             dec->aes = (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_CIPHER);
01635         if (dec->aes == NULL)
01636             return MEMORY_E;
01637 #ifdef HAVE_CAVIUM
01638         if (devId != NO_CAVIUM_DEVICE) {
01639             if (AesInitCavium(enc->aes, devId) != 0) {
01640                 CYASSL_MSG("AesInitCavium failed in SetKeys");
01641                 return CAVIUM_INIT_E;
01642             }
01643             if (AesInitCavium(dec->aes, devId) != 0) {
01644                 CYASSL_MSG("AesInitCavium failed in SetKeys");
01645                 return CAVIUM_INIT_E;
01646             }
01647         }
01648 #endif
01649         if (side == CYASSL_CLIENT_END) {
01650             aesRet = AesSetKey(enc->aes, keys->client_write_key,
01651                                specs->key_size, keys->client_write_IV,
01652                                AES_ENCRYPTION);
01653             if (aesRet != 0)
01654                 return aesRet;
01655             aesRet = AesSetKey(dec->aes, keys->server_write_key,
01656                                specs->key_size, keys->server_write_IV,
01657                                AES_DECRYPTION);
01658             if (aesRet != 0)
01659                 return aesRet;
01660         }
01661         else {
01662             aesRet = AesSetKey(enc->aes, keys->server_write_key,
01663                                specs->key_size, keys->server_write_IV,
01664                                AES_ENCRYPTION);
01665             if (aesRet != 0)
01666                 return aesRet;
01667             aesRet = AesSetKey(dec->aes, keys->client_write_key,
01668                                specs->key_size, keys->client_write_IV,
01669                                AES_DECRYPTION);
01670             if (aesRet != 0)
01671                 return aesRet;
01672         }
01673         enc->setup = 1;
01674         dec->setup = 1;
01675     }
01676 #endif
01677 
01678 #ifdef BUILD_AESGCM
01679     if (specs->bulk_cipher_algorithm == cyassl_aes_gcm) {
01680         if (enc->aes == NULL)
01681             enc->aes = (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_CIPHER);
01682         if (enc->aes == NULL)
01683             return MEMORY_E;
01684         if (dec->aes == NULL)
01685             dec->aes = (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_CIPHER);
01686         if (dec->aes == NULL)
01687             return MEMORY_E;
01688 
01689         if (side == CYASSL_CLIENT_END) {
01690             AesGcmSetKey(enc->aes, keys->client_write_key, specs->key_size);
01691             XMEMCPY(keys->aead_enc_imp_IV,
01692                                      keys->client_write_IV, AEAD_IMP_IV_SZ);
01693             AesGcmSetKey(dec->aes, keys->server_write_key, specs->key_size);
01694             XMEMCPY(keys->aead_dec_imp_IV,
01695                                      keys->server_write_IV, AEAD_IMP_IV_SZ);
01696         }
01697         else {
01698             AesGcmSetKey(enc->aes, keys->server_write_key, specs->key_size);
01699             XMEMCPY(keys->aead_enc_imp_IV,
01700                                      keys->server_write_IV, AEAD_IMP_IV_SZ);
01701             AesGcmSetKey(dec->aes, keys->client_write_key, specs->key_size);
01702             XMEMCPY(keys->aead_dec_imp_IV,
01703                                      keys->client_write_IV, AEAD_IMP_IV_SZ);
01704         }
01705         enc->setup = 1;
01706         dec->setup = 1;
01707     }
01708 #endif
01709 
01710 #ifdef HAVE_AESCCM
01711     if (specs->bulk_cipher_algorithm == cyassl_aes_ccm) {
01712         if (enc->aes == NULL)
01713             enc->aes = (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_CIPHER);
01714         if (enc->aes == NULL)
01715             return MEMORY_E;
01716         if (dec->aes == NULL)
01717             dec->aes = (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_CIPHER);
01718         if (dec->aes == NULL)
01719             return MEMORY_E;
01720 
01721         if (side == CYASSL_CLIENT_END) {
01722             AesCcmSetKey(enc->aes, keys->client_write_key, specs->key_size);
01723             XMEMCPY(keys->aead_enc_imp_IV,
01724                                      keys->client_write_IV, AEAD_IMP_IV_SZ);
01725             AesCcmSetKey(dec->aes, keys->server_write_key, specs->key_size);
01726             XMEMCPY(keys->aead_dec_imp_IV,
01727                                      keys->server_write_IV, AEAD_IMP_IV_SZ);
01728         }
01729         else {
01730             AesCcmSetKey(enc->aes, keys->server_write_key, specs->key_size);
01731             XMEMCPY(keys->aead_enc_imp_IV,
01732                                      keys->server_write_IV, AEAD_IMP_IV_SZ);
01733             AesCcmSetKey(dec->aes, keys->client_write_key, specs->key_size);
01734             XMEMCPY(keys->aead_dec_imp_IV,
01735                                      keys->client_write_IV, AEAD_IMP_IV_SZ);
01736         }
01737         enc->setup = 1;
01738         dec->setup = 1;
01739     }
01740 #endif
01741 
01742 #ifdef HAVE_CAMELLIA
01743     if (specs->bulk_cipher_algorithm == cyassl_camellia) {
01744         if (enc->cam == NULL)
01745             enc->cam =
01746                 (Camellia*)XMALLOC(sizeof(Camellia), heap, DYNAMIC_TYPE_CIPHER);
01747         if (enc->cam == NULL)
01748             return MEMORY_E;
01749         if (dec->cam == NULL)
01750             dec->cam =
01751                 (Camellia*)XMALLOC(sizeof(Camellia), heap, DYNAMIC_TYPE_CIPHER);
01752         if (dec->cam == NULL)
01753             return MEMORY_E;
01754         if (side == CYASSL_CLIENT_END) {
01755             CamelliaSetKey(enc->cam, keys->client_write_key,
01756                       specs->key_size, keys->client_write_IV);
01757             CamelliaSetKey(dec->cam, keys->server_write_key,
01758                       specs->key_size, keys->server_write_IV);
01759         }
01760         else {
01761             CamelliaSetKey(enc->cam, keys->server_write_key,
01762                       specs->key_size, keys->server_write_IV);
01763             CamelliaSetKey(dec->cam, keys->client_write_key,
01764                       specs->key_size, keys->client_write_IV);
01765         }
01766         enc->setup = 1;
01767         dec->setup = 1;
01768     }
01769 #endif
01770 
01771 #ifdef HAVE_NULL_CIPHER
01772     if (specs->bulk_cipher_algorithm == cyassl_cipher_null) {
01773         enc->setup = 1;
01774         dec->setup = 1;
01775     }
01776 #endif
01777 
01778     keys->sequence_number      = 0;
01779     keys->peer_sequence_number = 0;
01780     keys->encryptionOn         = 0;
01781     (void)side;
01782     (void)heap;
01783     (void)enc;
01784     (void)dec;
01785     (void)specs;
01786     (void)devId;
01787 
01788     return 0;
01789 }
01790 
01791 
01792 /* TLS can call too */
01793 int StoreKeys(CYASSL* ssl, const byte* keyData)
01794 {
01795     int sz, i = 0;
01796     int devId = NO_CAVIUM_DEVICE;
01797 
01798 #ifdef HAVE_CAVIUM
01799     devId = ssl->devId;
01800 #endif
01801 
01802     if (ssl->specs.cipher_type != aead) {
01803         sz = ssl->specs.hash_size;
01804         XMEMCPY(ssl->keys.client_write_MAC_secret,&keyData[i], sz);
01805         i += sz;
01806         XMEMCPY(ssl->keys.server_write_MAC_secret,&keyData[i], sz);
01807         i += sz;
01808     }
01809     sz = ssl->specs.key_size;
01810     XMEMCPY(ssl->keys.client_write_key, &keyData[i], sz);
01811     i += sz;
01812     XMEMCPY(ssl->keys.server_write_key, &keyData[i], sz);
01813     i += sz;
01814 
01815     sz = ssl->specs.iv_size;
01816     XMEMCPY(ssl->keys.client_write_IV, &keyData[i], sz);
01817     i += sz;
01818     XMEMCPY(ssl->keys.server_write_IV, &keyData[i], sz);
01819 
01820 #ifdef HAVE_AEAD
01821     if (ssl->specs.cipher_type == aead) {
01822         /* Initialize the AES-GCM/CCM explicit IV to a zero. */
01823         XMEMSET(ssl->keys.aead_exp_IV, 0, AEAD_EXP_IV_SZ);
01824     }
01825 #endif
01826 
01827     return SetKeys(&ssl->encrypt, &ssl->decrypt, &ssl->keys, &ssl->specs,
01828                    ssl->options.side, ssl->heap, devId);
01829 }
01830 
01831 #ifndef NO_OLD_TLS
01832 int DeriveKeys(CYASSL* ssl)
01833 {
01834     int length = 2 * ssl->specs.hash_size + 
01835                  2 * ssl->specs.key_size  +
01836                  2 * ssl->specs.iv_size;
01837     int rounds = (length + MD5_DIGEST_SIZE - 1 ) / MD5_DIGEST_SIZE, i;
01838     int ret = 0;
01839 
01840     byte shaOutput[SHA_DIGEST_SIZE];
01841     byte md5Input[SECRET_LEN + SHA_DIGEST_SIZE];
01842     byte shaInput[KEY_PREFIX + SECRET_LEN + 2 * RAN_LEN];
01843   
01844     Md5 md5;
01845     Sha sha;
01846 
01847     byte keyData[KEY_PREFIX * MD5_DIGEST_SIZE];  /* max size */
01848 
01849     InitMd5(&md5);
01850     ret = InitSha(&sha);
01851     if (ret != 0) 
01852         return ret;
01853 
01854     XMEMCPY(md5Input, ssl->arrays->masterSecret, SECRET_LEN);
01855 
01856     for (i = 0; i < rounds; ++i) {
01857         int j   = i + 1;
01858         int idx = j;
01859 
01860         if (!SetPrefix(shaInput, i)) {
01861             return PREFIX_ERROR;
01862         }
01863 
01864         XMEMCPY(shaInput + idx, ssl->arrays->masterSecret, SECRET_LEN);
01865         idx += SECRET_LEN;
01866         XMEMCPY(shaInput + idx, ssl->arrays->serverRandom, RAN_LEN);
01867         idx += RAN_LEN;
01868         XMEMCPY(shaInput + idx, ssl->arrays->clientRandom, RAN_LEN);
01869 
01870         ShaUpdate(&sha, shaInput, (word32)sizeof(shaInput) - KEY_PREFIX + j);
01871         ShaFinal(&sha, shaOutput);
01872 
01873         XMEMCPY(&md5Input[SECRET_LEN], shaOutput, SHA_DIGEST_SIZE);
01874         Md5Update(&md5, md5Input, sizeof(md5Input));
01875         Md5Final(&md5, keyData + i * MD5_DIGEST_SIZE);
01876     }
01877 
01878     return StoreKeys(ssl, keyData);
01879 }
01880 
01881 
01882 static void CleanPreMaster(CYASSL* ssl)
01883 {
01884     int i, sz = ssl->arrays->preMasterSz;
01885 
01886     for (i = 0; i < sz; i++)
01887         ssl->arrays->preMasterSecret[i] = 0;
01888 
01889     RNG_GenerateBlock(ssl->rng, ssl->arrays->preMasterSecret, sz);
01890 
01891     for (i = 0; i < sz; i++)
01892         ssl->arrays->preMasterSecret[i] = 0;
01893 
01894 }
01895 
01896 
01897 /* Create and store the master secret see page 32, 6.1 */
01898 static int MakeSslMasterSecret(CYASSL* ssl)
01899 {
01900     byte   shaOutput[SHA_DIGEST_SIZE];
01901     byte   md5Input[ENCRYPT_LEN + SHA_DIGEST_SIZE];
01902     byte   shaInput[PREFIX + ENCRYPT_LEN + 2 * RAN_LEN];
01903     int    i, ret;
01904     word32 idx;
01905     word32 pmsSz = ssl->arrays->preMasterSz;
01906 
01907     Md5 md5;
01908     Sha sha;
01909 
01910 #ifdef SHOW_SECRETS
01911     {
01912         word32 j;
01913         printf("pre master secret: ");
01914         for (j = 0; j < pmsSz; j++)
01915             printf("%02x", ssl->arrays->preMasterSecret[j]);
01916         printf("\n");
01917     }
01918 #endif
01919 
01920     InitMd5(&md5);
01921     ret = InitSha(&sha);
01922     if (ret != 0) 
01923         return ret;
01924 
01925     XMEMCPY(md5Input, ssl->arrays->preMasterSecret, pmsSz);
01926 
01927     for (i = 0; i < MASTER_ROUNDS; ++i) {
01928         byte prefix[PREFIX];
01929         if (!SetPrefix(prefix, i)) {
01930             return PREFIX_ERROR;
01931         }
01932 
01933         idx = 0;
01934         XMEMCPY(shaInput, prefix, i + 1);
01935         idx += i + 1;
01936 
01937         XMEMCPY(shaInput + idx, ssl->arrays->preMasterSecret, pmsSz);
01938         idx += pmsSz;
01939         XMEMCPY(shaInput + idx, ssl->arrays->clientRandom, RAN_LEN);
01940         idx += RAN_LEN;
01941         XMEMCPY(shaInput + idx, ssl->arrays->serverRandom, RAN_LEN);
01942         idx += RAN_LEN;
01943         ShaUpdate(&sha, shaInput, idx);
01944         ShaFinal(&sha, shaOutput);
01945 
01946         idx = pmsSz;  /* preSz */
01947         XMEMCPY(md5Input + idx, shaOutput, SHA_DIGEST_SIZE);
01948         idx += SHA_DIGEST_SIZE;
01949         Md5Update(&md5, md5Input, idx);
01950         Md5Final(&md5, &ssl->arrays->masterSecret[i * MD5_DIGEST_SIZE]);
01951     }
01952 
01953 #ifdef SHOW_SECRETS
01954     {
01955         word32 j;
01956         printf("master secret: ");
01957         for (j = 0; j < SECRET_LEN; j++)
01958             printf("%02x", ssl->arrays->masterSecret[j]);
01959         printf("\n");
01960     }
01961 #endif
01962 
01963     ret = DeriveKeys(ssl);
01964     CleanPreMaster(ssl);
01965 
01966     return ret;
01967 }
01968 #endif
01969 
01970 
01971 /* Master wrapper, doesn't use SSL stack space in TLS mode */
01972 int MakeMasterSecret(CYASSL* ssl)
01973 {
01974 #ifdef NO_OLD_TLS
01975     return MakeTlsMasterSecret(ssl);
01976 #elif !defined(NO_TLS)
01977     if (ssl->options.tls) return MakeTlsMasterSecret(ssl);
01978 #endif
01979 
01980 #ifndef NO_OLD_TLS
01981     return MakeSslMasterSecret(ssl);
01982 #endif
01983 }
01984