Fork of CyaSSL for my specific settings

Dependents:   CyaSSL_Example

Fork of CyaSSL by wolf SSL

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