1 /* 2 * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved. 3 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved 4 * Copyright 2005 Nokia. All rights reserved. 5 * 6 * Licensed under the Apache License 2.0 (the "License"). You may not use 7 * this file except in compliance with the License. You can obtain a copy 8 * in the file LICENSE in the source distribution or at 9 * https://www.openssl.org/source/license.html 10 */ 11 12 #include <stdio.h> 13 #include <ctype.h> 14 #include <openssl/objects.h> 15 #include <openssl/comp.h> 16 #include <openssl/engine.h> 17 #include <openssl/crypto.h> 18 #include <openssl/conf.h> 19 #include <openssl/trace.h> 20 #include "internal/nelem.h" 21 #include "ssl_local.h" 22 #include "internal/thread_once.h" 23 #include "internal/cryptlib.h" 24 25 /* NB: make sure indices in these tables match values above */ 26 27 typedef struct { 28 uint32_t mask; 29 int nid; 30 } ssl_cipher_table; 31 32 /* Table of NIDs for each cipher */ 33 static const ssl_cipher_table ssl_cipher_table_cipher[SSL_ENC_NUM_IDX] = { 34 {SSL_DES, NID_des_cbc}, /* SSL_ENC_DES_IDX 0 */ 35 {SSL_3DES, NID_des_ede3_cbc}, /* SSL_ENC_3DES_IDX 1 */ 36 {SSL_RC4, NID_rc4}, /* SSL_ENC_RC4_IDX 2 */ 37 {SSL_RC2, NID_rc2_cbc}, /* SSL_ENC_RC2_IDX 3 */ 38 {SSL_IDEA, NID_idea_cbc}, /* SSL_ENC_IDEA_IDX 4 */ 39 {SSL_eNULL, NID_undef}, /* SSL_ENC_NULL_IDX 5 */ 40 {SSL_AES128, NID_aes_128_cbc}, /* SSL_ENC_AES128_IDX 6 */ 41 {SSL_AES256, NID_aes_256_cbc}, /* SSL_ENC_AES256_IDX 7 */ 42 {SSL_CAMELLIA128, NID_camellia_128_cbc}, /* SSL_ENC_CAMELLIA128_IDX 8 */ 43 {SSL_CAMELLIA256, NID_camellia_256_cbc}, /* SSL_ENC_CAMELLIA256_IDX 9 */ 44 {SSL_eGOST2814789CNT, NID_gost89_cnt}, /* SSL_ENC_GOST89_IDX 10 */ 45 {SSL_SEED, NID_seed_cbc}, /* SSL_ENC_SEED_IDX 11 */ 46 {SSL_AES128GCM, NID_aes_128_gcm}, /* SSL_ENC_AES128GCM_IDX 12 */ 47 {SSL_AES256GCM, NID_aes_256_gcm}, /* SSL_ENC_AES256GCM_IDX 13 */ 48 {SSL_AES128CCM, NID_aes_128_ccm}, /* SSL_ENC_AES128CCM_IDX 14 */ 49 {SSL_AES256CCM, NID_aes_256_ccm}, /* SSL_ENC_AES256CCM_IDX 15 */ 50 {SSL_AES128CCM8, NID_aes_128_ccm}, /* SSL_ENC_AES128CCM8_IDX 16 */ 51 {SSL_AES256CCM8, NID_aes_256_ccm}, /* SSL_ENC_AES256CCM8_IDX 17 */ 52 {SSL_eGOST2814789CNT12, NID_gost89_cnt_12}, /* SSL_ENC_GOST8912_IDX 18 */ 53 {SSL_CHACHA20POLY1305, NID_chacha20_poly1305}, /* SSL_ENC_CHACHA_IDX 19 */ 54 {SSL_ARIA128GCM, NID_aria_128_gcm}, /* SSL_ENC_ARIA128GCM_IDX 20 */ 55 {SSL_ARIA256GCM, NID_aria_256_gcm}, /* SSL_ENC_ARIA256GCM_IDX 21 */ 56 {SSL_MAGMA, NID_magma_ctr_acpkm}, /* SSL_ENC_MAGMA_IDX */ 57 {SSL_KUZNYECHIK, NID_kuznyechik_ctr_acpkm}, /* SSL_ENC_KUZNYECHIK_IDX */ 58 }; 59 60 #define SSL_COMP_NULL_IDX 0 61 #define SSL_COMP_ZLIB_IDX 1 62 #define SSL_COMP_NUM_IDX 2 63 64 static STACK_OF(SSL_COMP) *ssl_comp_methods = NULL; 65 66 #ifndef OPENSSL_NO_COMP 67 static CRYPTO_ONCE ssl_load_builtin_comp_once = CRYPTO_ONCE_STATIC_INIT; 68 #endif 69 70 /* NB: make sure indices in this table matches values above */ 71 static const ssl_cipher_table ssl_cipher_table_mac[SSL_MD_NUM_IDX] = { 72 {SSL_MD5, NID_md5}, /* SSL_MD_MD5_IDX 0 */ 73 {SSL_SHA1, NID_sha1}, /* SSL_MD_SHA1_IDX 1 */ 74 {SSL_GOST94, NID_id_GostR3411_94}, /* SSL_MD_GOST94_IDX 2 */ 75 {SSL_GOST89MAC, NID_id_Gost28147_89_MAC}, /* SSL_MD_GOST89MAC_IDX 3 */ 76 {SSL_SHA256, NID_sha256}, /* SSL_MD_SHA256_IDX 4 */ 77 {SSL_SHA384, NID_sha384}, /* SSL_MD_SHA384_IDX 5 */ 78 {SSL_GOST12_256, NID_id_GostR3411_2012_256}, /* SSL_MD_GOST12_256_IDX 6 */ 79 {SSL_GOST89MAC12, NID_gost_mac_12}, /* SSL_MD_GOST89MAC12_IDX 7 */ 80 {SSL_GOST12_512, NID_id_GostR3411_2012_512}, /* SSL_MD_GOST12_512_IDX 8 */ 81 {0, NID_md5_sha1}, /* SSL_MD_MD5_SHA1_IDX 9 */ 82 {0, NID_sha224}, /* SSL_MD_SHA224_IDX 10 */ 83 {0, NID_sha512}, /* SSL_MD_SHA512_IDX 11 */ 84 {SSL_MAGMAOMAC, NID_magma_mac}, /* sSL_MD_MAGMAOMAC_IDX */ 85 {SSL_KUZNYECHIKOMAC, NID_kuznyechik_mac} /* SSL_MD_KUZNYECHIKOMAC_IDX */ 86 }; 87 88 /* *INDENT-OFF* */ 89 static const ssl_cipher_table ssl_cipher_table_kx[] = { 90 {SSL_kRSA, NID_kx_rsa}, 91 {SSL_kECDHE, NID_kx_ecdhe}, 92 {SSL_kDHE, NID_kx_dhe}, 93 {SSL_kECDHEPSK, NID_kx_ecdhe_psk}, 94 {SSL_kDHEPSK, NID_kx_dhe_psk}, 95 {SSL_kRSAPSK, NID_kx_rsa_psk}, 96 {SSL_kPSK, NID_kx_psk}, 97 {SSL_kSRP, NID_kx_srp}, 98 {SSL_kGOST, NID_kx_gost}, 99 {SSL_kGOST18, NID_kx_gost18}, 100 {SSL_kANY, NID_kx_any} 101 }; 102 103 static const ssl_cipher_table ssl_cipher_table_auth[] = { 104 {SSL_aRSA, NID_auth_rsa}, 105 {SSL_aECDSA, NID_auth_ecdsa}, 106 {SSL_aPSK, NID_auth_psk}, 107 {SSL_aDSS, NID_auth_dss}, 108 {SSL_aGOST01, NID_auth_gost01}, 109 {SSL_aGOST12, NID_auth_gost12}, 110 {SSL_aSRP, NID_auth_srp}, 111 {SSL_aNULL, NID_auth_null}, 112 {SSL_aANY, NID_auth_any} 113 }; 114 /* *INDENT-ON* */ 115 116 /* Utility function for table lookup */ 117 static int ssl_cipher_info_find(const ssl_cipher_table * table, 118 size_t table_cnt, uint32_t mask) 119 { 120 size_t i; 121 for (i = 0; i < table_cnt; i++, table++) { 122 if (table->mask == mask) 123 return (int)i; 124 } 125 return -1; 126 } 127 128 #define ssl_cipher_info_lookup(table, x) \ 129 ssl_cipher_info_find(table, OSSL_NELEM(table), x) 130 131 /* 132 * PKEY_TYPE for GOST89MAC is known in advance, but, because implementation 133 * is engine-provided, we'll fill it only if corresponding EVP_PKEY_METHOD is 134 * found 135 */ 136 static const int default_mac_pkey_id[SSL_MD_NUM_IDX] = { 137 /* MD5, SHA, GOST94, MAC89 */ 138 EVP_PKEY_HMAC, EVP_PKEY_HMAC, EVP_PKEY_HMAC, NID_undef, 139 /* SHA256, SHA384, GOST2012_256, MAC89-12 */ 140 EVP_PKEY_HMAC, EVP_PKEY_HMAC, EVP_PKEY_HMAC, NID_undef, 141 /* GOST2012_512 */ 142 EVP_PKEY_HMAC, 143 /* MD5/SHA1, SHA224, SHA512, MAGMAOMAC, KUZNYECHIKOMAC */ 144 NID_undef, NID_undef, NID_undef, NID_undef, NID_undef 145 }; 146 147 #define CIPHER_ADD 1 148 #define CIPHER_KILL 2 149 #define CIPHER_DEL 3 150 #define CIPHER_ORD 4 151 #define CIPHER_SPECIAL 5 152 /* 153 * Bump the ciphers to the top of the list. 154 * This rule isn't currently supported by the public cipherstring API. 155 */ 156 #define CIPHER_BUMP 6 157 158 typedef struct cipher_order_st { 159 const SSL_CIPHER *cipher; 160 int active; 161 int dead; 162 struct cipher_order_st *next, *prev; 163 } CIPHER_ORDER; 164 165 static const SSL_CIPHER cipher_aliases[] = { 166 /* "ALL" doesn't include eNULL (must be specifically enabled) */ 167 {0, SSL_TXT_ALL, NULL, 0, 0, 0, ~SSL_eNULL}, 168 /* "COMPLEMENTOFALL" */ 169 {0, SSL_TXT_CMPALL, NULL, 0, 0, 0, SSL_eNULL}, 170 171 /* 172 * "COMPLEMENTOFDEFAULT" (does *not* include ciphersuites not found in 173 * ALL!) 174 */ 175 {0, SSL_TXT_CMPDEF, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_NOT_DEFAULT}, 176 177 /* 178 * key exchange aliases (some of those using only a single bit here 179 * combine multiple key exchange algs according to the RFCs, e.g. kDHE 180 * combines DHE_DSS and DHE_RSA) 181 */ 182 {0, SSL_TXT_kRSA, NULL, 0, SSL_kRSA}, 183 184 {0, SSL_TXT_kEDH, NULL, 0, SSL_kDHE}, 185 {0, SSL_TXT_kDHE, NULL, 0, SSL_kDHE}, 186 {0, SSL_TXT_DH, NULL, 0, SSL_kDHE}, 187 188 {0, SSL_TXT_kEECDH, NULL, 0, SSL_kECDHE}, 189 {0, SSL_TXT_kECDHE, NULL, 0, SSL_kECDHE}, 190 {0, SSL_TXT_ECDH, NULL, 0, SSL_kECDHE}, 191 192 {0, SSL_TXT_kPSK, NULL, 0, SSL_kPSK}, 193 {0, SSL_TXT_kRSAPSK, NULL, 0, SSL_kRSAPSK}, 194 {0, SSL_TXT_kECDHEPSK, NULL, 0, SSL_kECDHEPSK}, 195 {0, SSL_TXT_kDHEPSK, NULL, 0, SSL_kDHEPSK}, 196 {0, SSL_TXT_kSRP, NULL, 0, SSL_kSRP}, 197 {0, SSL_TXT_kGOST, NULL, 0, SSL_kGOST}, 198 {0, SSL_TXT_kGOST18, NULL, 0, SSL_kGOST18}, 199 200 /* server authentication aliases */ 201 {0, SSL_TXT_aRSA, NULL, 0, 0, SSL_aRSA}, 202 {0, SSL_TXT_aDSS, NULL, 0, 0, SSL_aDSS}, 203 {0, SSL_TXT_DSS, NULL, 0, 0, SSL_aDSS}, 204 {0, SSL_TXT_aNULL, NULL, 0, 0, SSL_aNULL}, 205 {0, SSL_TXT_aECDSA, NULL, 0, 0, SSL_aECDSA}, 206 {0, SSL_TXT_ECDSA, NULL, 0, 0, SSL_aECDSA}, 207 {0, SSL_TXT_aPSK, NULL, 0, 0, SSL_aPSK}, 208 {0, SSL_TXT_aGOST01, NULL, 0, 0, SSL_aGOST01}, 209 {0, SSL_TXT_aGOST12, NULL, 0, 0, SSL_aGOST12}, 210 {0, SSL_TXT_aGOST, NULL, 0, 0, SSL_aGOST01 | SSL_aGOST12}, 211 {0, SSL_TXT_aSRP, NULL, 0, 0, SSL_aSRP}, 212 213 /* aliases combining key exchange and server authentication */ 214 {0, SSL_TXT_EDH, NULL, 0, SSL_kDHE, ~SSL_aNULL}, 215 {0, SSL_TXT_DHE, NULL, 0, SSL_kDHE, ~SSL_aNULL}, 216 {0, SSL_TXT_EECDH, NULL, 0, SSL_kECDHE, ~SSL_aNULL}, 217 {0, SSL_TXT_ECDHE, NULL, 0, SSL_kECDHE, ~SSL_aNULL}, 218 {0, SSL_TXT_NULL, NULL, 0, 0, 0, SSL_eNULL}, 219 {0, SSL_TXT_RSA, NULL, 0, SSL_kRSA, SSL_aRSA}, 220 {0, SSL_TXT_ADH, NULL, 0, SSL_kDHE, SSL_aNULL}, 221 {0, SSL_TXT_AECDH, NULL, 0, SSL_kECDHE, SSL_aNULL}, 222 {0, SSL_TXT_PSK, NULL, 0, SSL_PSK}, 223 {0, SSL_TXT_SRP, NULL, 0, SSL_kSRP}, 224 225 /* symmetric encryption aliases */ 226 {0, SSL_TXT_3DES, NULL, 0, 0, 0, SSL_3DES}, 227 {0, SSL_TXT_RC4, NULL, 0, 0, 0, SSL_RC4}, 228 {0, SSL_TXT_RC2, NULL, 0, 0, 0, SSL_RC2}, 229 {0, SSL_TXT_IDEA, NULL, 0, 0, 0, SSL_IDEA}, 230 {0, SSL_TXT_SEED, NULL, 0, 0, 0, SSL_SEED}, 231 {0, SSL_TXT_eNULL, NULL, 0, 0, 0, SSL_eNULL}, 232 {0, SSL_TXT_GOST, NULL, 0, 0, 0, 233 SSL_eGOST2814789CNT | SSL_eGOST2814789CNT12 | SSL_MAGMA | SSL_KUZNYECHIK}, 234 {0, SSL_TXT_AES128, NULL, 0, 0, 0, 235 SSL_AES128 | SSL_AES128GCM | SSL_AES128CCM | SSL_AES128CCM8}, 236 {0, SSL_TXT_AES256, NULL, 0, 0, 0, 237 SSL_AES256 | SSL_AES256GCM | SSL_AES256CCM | SSL_AES256CCM8}, 238 {0, SSL_TXT_AES, NULL, 0, 0, 0, SSL_AES}, 239 {0, SSL_TXT_AES_GCM, NULL, 0, 0, 0, SSL_AES128GCM | SSL_AES256GCM}, 240 {0, SSL_TXT_AES_CCM, NULL, 0, 0, 0, 241 SSL_AES128CCM | SSL_AES256CCM | SSL_AES128CCM8 | SSL_AES256CCM8}, 242 {0, SSL_TXT_AES_CCM_8, NULL, 0, 0, 0, SSL_AES128CCM8 | SSL_AES256CCM8}, 243 {0, SSL_TXT_CAMELLIA128, NULL, 0, 0, 0, SSL_CAMELLIA128}, 244 {0, SSL_TXT_CAMELLIA256, NULL, 0, 0, 0, SSL_CAMELLIA256}, 245 {0, SSL_TXT_CAMELLIA, NULL, 0, 0, 0, SSL_CAMELLIA}, 246 {0, SSL_TXT_CHACHA20, NULL, 0, 0, 0, SSL_CHACHA20}, 247 {0, SSL_TXT_GOST2012_GOST8912_GOST8912, NULL, 0, 0, 0, SSL_eGOST2814789CNT12}, 248 249 {0, SSL_TXT_ARIA, NULL, 0, 0, 0, SSL_ARIA}, 250 {0, SSL_TXT_ARIA_GCM, NULL, 0, 0, 0, SSL_ARIA128GCM | SSL_ARIA256GCM}, 251 {0, SSL_TXT_ARIA128, NULL, 0, 0, 0, SSL_ARIA128GCM}, 252 {0, SSL_TXT_ARIA256, NULL, 0, 0, 0, SSL_ARIA256GCM}, 253 {0, SSL_TXT_CBC, NULL, 0, 0, 0, SSL_CBC}, 254 255 /* MAC aliases */ 256 {0, SSL_TXT_MD5, NULL, 0, 0, 0, 0, SSL_MD5}, 257 {0, SSL_TXT_SHA1, NULL, 0, 0, 0, 0, SSL_SHA1}, 258 {0, SSL_TXT_SHA, NULL, 0, 0, 0, 0, SSL_SHA1}, 259 {0, SSL_TXT_GOST94, NULL, 0, 0, 0, 0, SSL_GOST94}, 260 {0, SSL_TXT_GOST89MAC, NULL, 0, 0, 0, 0, SSL_GOST89MAC | SSL_GOST89MAC12}, 261 {0, SSL_TXT_SHA256, NULL, 0, 0, 0, 0, SSL_SHA256}, 262 {0, SSL_TXT_SHA384, NULL, 0, 0, 0, 0, SSL_SHA384}, 263 {0, SSL_TXT_GOST12, NULL, 0, 0, 0, 0, SSL_GOST12_256}, 264 265 /* protocol version aliases */ 266 {0, SSL_TXT_SSLV3, NULL, 0, 0, 0, 0, 0, SSL3_VERSION}, 267 {0, SSL_TXT_TLSV1, NULL, 0, 0, 0, 0, 0, TLS1_VERSION}, 268 {0, "TLSv1.0", NULL, 0, 0, 0, 0, 0, TLS1_VERSION}, 269 {0, SSL_TXT_TLSV1_2, NULL, 0, 0, 0, 0, 0, TLS1_2_VERSION}, 270 271 /* strength classes */ 272 {0, SSL_TXT_LOW, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_LOW}, 273 {0, SSL_TXT_MEDIUM, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_MEDIUM}, 274 {0, SSL_TXT_HIGH, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_HIGH}, 275 /* FIPS 140-2 approved ciphersuite */ 276 {0, SSL_TXT_FIPS, NULL, 0, 0, 0, ~SSL_eNULL, 0, 0, 0, 0, 0, SSL_FIPS}, 277 278 /* "EDH-" aliases to "DHE-" labels (for backward compatibility) */ 279 {0, SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA, NULL, 0, 280 SSL_kDHE, SSL_aDSS, SSL_3DES, SSL_SHA1, 0, 0, 0, 0, SSL_HIGH | SSL_FIPS}, 281 {0, SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA, NULL, 0, 282 SSL_kDHE, SSL_aRSA, SSL_3DES, SSL_SHA1, 0, 0, 0, 0, SSL_HIGH | SSL_FIPS}, 283 284 }; 285 286 /* 287 * Search for public key algorithm with given name and return its pkey_id if 288 * it is available. Otherwise return 0 289 */ 290 #ifdef OPENSSL_NO_ENGINE 291 292 static int get_optional_pkey_id(const char *pkey_name) 293 { 294 const EVP_PKEY_ASN1_METHOD *ameth; 295 int pkey_id = 0; 296 ameth = EVP_PKEY_asn1_find_str(NULL, pkey_name, -1); 297 if (ameth && EVP_PKEY_asn1_get0_info(&pkey_id, NULL, NULL, NULL, NULL, 298 ameth) > 0) 299 return pkey_id; 300 return 0; 301 } 302 303 #else 304 305 static int get_optional_pkey_id(const char *pkey_name) 306 { 307 const EVP_PKEY_ASN1_METHOD *ameth; 308 ENGINE *tmpeng = NULL; 309 int pkey_id = 0; 310 ameth = EVP_PKEY_asn1_find_str(&tmpeng, pkey_name, -1); 311 if (ameth) { 312 if (EVP_PKEY_asn1_get0_info(&pkey_id, NULL, NULL, NULL, NULL, 313 ameth) <= 0) 314 pkey_id = 0; 315 } 316 tls_engine_finish(tmpeng); 317 return pkey_id; 318 } 319 320 #endif 321 322 int ssl_load_ciphers(SSL_CTX *ctx) 323 { 324 size_t i; 325 const ssl_cipher_table *t; 326 EVP_KEYEXCH *kex = NULL; 327 EVP_SIGNATURE *sig = NULL; 328 329 ctx->disabled_enc_mask = 0; 330 for (i = 0, t = ssl_cipher_table_cipher; i < SSL_ENC_NUM_IDX; i++, t++) { 331 if (t->nid != NID_undef) { 332 const EVP_CIPHER *cipher 333 = ssl_evp_cipher_fetch(ctx->libctx, t->nid, ctx->propq); 334 335 ctx->ssl_cipher_methods[i] = cipher; 336 if (cipher == NULL) 337 ctx->disabled_enc_mask |= t->mask; 338 } 339 } 340 ctx->disabled_mac_mask = 0; 341 for (i = 0, t = ssl_cipher_table_mac; i < SSL_MD_NUM_IDX; i++, t++) { 342 const EVP_MD *md 343 = ssl_evp_md_fetch(ctx->libctx, t->nid, ctx->propq); 344 345 ctx->ssl_digest_methods[i] = md; 346 if (md == NULL) { 347 ctx->disabled_mac_mask |= t->mask; 348 } else { 349 int tmpsize = EVP_MD_get_size(md); 350 if (!ossl_assert(tmpsize >= 0)) 351 return 0; 352 ctx->ssl_mac_secret_size[i] = tmpsize; 353 } 354 } 355 356 ctx->disabled_mkey_mask = 0; 357 ctx->disabled_auth_mask = 0; 358 359 /* 360 * We ignore any errors from the fetches below. They are expected to fail 361 * if theose algorithms are not available. 362 */ 363 ERR_set_mark(); 364 sig = EVP_SIGNATURE_fetch(ctx->libctx, "DSA", ctx->propq); 365 if (sig == NULL) 366 ctx->disabled_auth_mask |= SSL_aDSS; 367 else 368 EVP_SIGNATURE_free(sig); 369 kex = EVP_KEYEXCH_fetch(ctx->libctx, "DH", ctx->propq); 370 if (kex == NULL) 371 ctx->disabled_mkey_mask |= SSL_kDHE | SSL_kDHEPSK; 372 else 373 EVP_KEYEXCH_free(kex); 374 kex = EVP_KEYEXCH_fetch(ctx->libctx, "ECDH", ctx->propq); 375 if (kex == NULL) 376 ctx->disabled_mkey_mask |= SSL_kECDHE | SSL_kECDHEPSK; 377 else 378 EVP_KEYEXCH_free(kex); 379 sig = EVP_SIGNATURE_fetch(ctx->libctx, "ECDSA", ctx->propq); 380 if (sig == NULL) 381 ctx->disabled_auth_mask |= SSL_aECDSA; 382 else 383 EVP_SIGNATURE_free(sig); 384 ERR_pop_to_mark(); 385 386 #ifdef OPENSSL_NO_PSK 387 ctx->disabled_mkey_mask |= SSL_PSK; 388 ctx->disabled_auth_mask |= SSL_aPSK; 389 #endif 390 #ifdef OPENSSL_NO_SRP 391 ctx->disabled_mkey_mask |= SSL_kSRP; 392 #endif 393 394 /* 395 * Check for presence of GOST 34.10 algorithms, and if they are not 396 * present, disable appropriate auth and key exchange 397 */ 398 memcpy(ctx->ssl_mac_pkey_id, default_mac_pkey_id, 399 sizeof(ctx->ssl_mac_pkey_id)); 400 401 ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC_IDX] = 402 get_optional_pkey_id(SN_id_Gost28147_89_MAC); 403 if (ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC_IDX]) 404 ctx->ssl_mac_secret_size[SSL_MD_GOST89MAC_IDX] = 32; 405 else 406 ctx->disabled_mac_mask |= SSL_GOST89MAC; 407 408 ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC12_IDX] = 409 get_optional_pkey_id(SN_gost_mac_12); 410 if (ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC12_IDX]) 411 ctx->ssl_mac_secret_size[SSL_MD_GOST89MAC12_IDX] = 32; 412 else 413 ctx->disabled_mac_mask |= SSL_GOST89MAC12; 414 415 ctx->ssl_mac_pkey_id[SSL_MD_MAGMAOMAC_IDX] = 416 get_optional_pkey_id(SN_magma_mac); 417 if (ctx->ssl_mac_pkey_id[SSL_MD_MAGMAOMAC_IDX]) 418 ctx->ssl_mac_secret_size[SSL_MD_MAGMAOMAC_IDX] = 32; 419 else 420 ctx->disabled_mac_mask |= SSL_MAGMAOMAC; 421 422 ctx->ssl_mac_pkey_id[SSL_MD_KUZNYECHIKOMAC_IDX] = 423 get_optional_pkey_id(SN_kuznyechik_mac); 424 if (ctx->ssl_mac_pkey_id[SSL_MD_KUZNYECHIKOMAC_IDX]) 425 ctx->ssl_mac_secret_size[SSL_MD_KUZNYECHIKOMAC_IDX] = 32; 426 else 427 ctx->disabled_mac_mask |= SSL_KUZNYECHIKOMAC; 428 429 if (!get_optional_pkey_id(SN_id_GostR3410_2001)) 430 ctx->disabled_auth_mask |= SSL_aGOST01 | SSL_aGOST12; 431 if (!get_optional_pkey_id(SN_id_GostR3410_2012_256)) 432 ctx->disabled_auth_mask |= SSL_aGOST12; 433 if (!get_optional_pkey_id(SN_id_GostR3410_2012_512)) 434 ctx->disabled_auth_mask |= SSL_aGOST12; 435 /* 436 * Disable GOST key exchange if no GOST signature algs are available * 437 */ 438 if ((ctx->disabled_auth_mask & (SSL_aGOST01 | SSL_aGOST12)) == 439 (SSL_aGOST01 | SSL_aGOST12)) 440 ctx->disabled_mkey_mask |= SSL_kGOST; 441 442 if ((ctx->disabled_auth_mask & SSL_aGOST12) == SSL_aGOST12) 443 ctx->disabled_mkey_mask |= SSL_kGOST18; 444 445 return 1; 446 } 447 448 #ifndef OPENSSL_NO_COMP 449 450 static int sk_comp_cmp(const SSL_COMP *const *a, const SSL_COMP *const *b) 451 { 452 return ((*a)->id - (*b)->id); 453 } 454 455 DEFINE_RUN_ONCE_STATIC(do_load_builtin_compressions) 456 { 457 SSL_COMP *comp = NULL; 458 COMP_METHOD *method = COMP_zlib(); 459 460 ssl_comp_methods = sk_SSL_COMP_new(sk_comp_cmp); 461 462 if (COMP_get_type(method) != NID_undef && ssl_comp_methods != NULL) { 463 comp = OPENSSL_malloc(sizeof(*comp)); 464 if (comp != NULL) { 465 comp->method = method; 466 comp->id = SSL_COMP_ZLIB_IDX; 467 comp->name = COMP_get_name(method); 468 sk_SSL_COMP_push(ssl_comp_methods, comp); 469 sk_SSL_COMP_sort(ssl_comp_methods); 470 } 471 } 472 return 1; 473 } 474 475 static int load_builtin_compressions(void) 476 { 477 return RUN_ONCE(&ssl_load_builtin_comp_once, do_load_builtin_compressions); 478 } 479 #endif 480 481 int ssl_cipher_get_evp_cipher(SSL_CTX *ctx, const SSL_CIPHER *sslc, 482 const EVP_CIPHER **enc) 483 { 484 int i = ssl_cipher_info_lookup(ssl_cipher_table_cipher, sslc->algorithm_enc); 485 486 if (i == -1) { 487 *enc = NULL; 488 } else { 489 if (i == SSL_ENC_NULL_IDX) { 490 /* 491 * We assume we don't care about this coming from an ENGINE so 492 * just do a normal EVP_CIPHER_fetch instead of 493 * ssl_evp_cipher_fetch() 494 */ 495 *enc = EVP_CIPHER_fetch(ctx->libctx, "NULL", ctx->propq); 496 if (*enc == NULL) 497 return 0; 498 } else { 499 const EVP_CIPHER *cipher = ctx->ssl_cipher_methods[i]; 500 501 if (cipher == NULL 502 || !ssl_evp_cipher_up_ref(cipher)) 503 return 0; 504 *enc = ctx->ssl_cipher_methods[i]; 505 } 506 } 507 return 1; 508 } 509 510 int ssl_cipher_get_evp(SSL_CTX *ctx, const SSL_SESSION *s, 511 const EVP_CIPHER **enc, const EVP_MD **md, 512 int *mac_pkey_type, size_t *mac_secret_size, 513 SSL_COMP **comp, int use_etm) 514 { 515 int i; 516 const SSL_CIPHER *c; 517 518 c = s->cipher; 519 if (c == NULL) 520 return 0; 521 if (comp != NULL) { 522 SSL_COMP ctmp; 523 #ifndef OPENSSL_NO_COMP 524 if (!load_builtin_compressions()) { 525 /* 526 * Currently don't care, since a failure only means that 527 * ssl_comp_methods is NULL, which is perfectly OK 528 */ 529 } 530 #endif 531 *comp = NULL; 532 ctmp.id = s->compress_meth; 533 if (ssl_comp_methods != NULL) { 534 i = sk_SSL_COMP_find(ssl_comp_methods, &ctmp); 535 if (i >= 0) 536 *comp = sk_SSL_COMP_value(ssl_comp_methods, i); 537 } 538 /* If were only interested in comp then return success */ 539 if ((enc == NULL) && (md == NULL)) 540 return 1; 541 } 542 543 if ((enc == NULL) || (md == NULL)) 544 return 0; 545 546 if (!ssl_cipher_get_evp_cipher(ctx, c, enc)) 547 return 0; 548 549 i = ssl_cipher_info_lookup(ssl_cipher_table_mac, c->algorithm_mac); 550 if (i == -1) { 551 *md = NULL; 552 if (mac_pkey_type != NULL) 553 *mac_pkey_type = NID_undef; 554 if (mac_secret_size != NULL) 555 *mac_secret_size = 0; 556 if (c->algorithm_mac == SSL_AEAD) 557 mac_pkey_type = NULL; 558 } else { 559 const EVP_MD *digest = ctx->ssl_digest_methods[i]; 560 561 if (digest == NULL 562 || !ssl_evp_md_up_ref(digest)) { 563 ssl_evp_cipher_free(*enc); 564 return 0; 565 } 566 *md = digest; 567 if (mac_pkey_type != NULL) 568 *mac_pkey_type = ctx->ssl_mac_pkey_id[i]; 569 if (mac_secret_size != NULL) 570 *mac_secret_size = ctx->ssl_mac_secret_size[i]; 571 } 572 573 if ((*enc != NULL) 574 && (*md != NULL 575 || (EVP_CIPHER_get_flags(*enc) & EVP_CIPH_FLAG_AEAD_CIPHER)) 576 && (!mac_pkey_type || *mac_pkey_type != NID_undef)) { 577 const EVP_CIPHER *evp = NULL; 578 579 if (use_etm 580 || s->ssl_version >> 8 != TLS1_VERSION_MAJOR 581 || s->ssl_version < TLS1_VERSION) 582 return 1; 583 584 if (c->algorithm_enc == SSL_RC4 585 && c->algorithm_mac == SSL_MD5) 586 evp = ssl_evp_cipher_fetch(ctx->libctx, NID_rc4_hmac_md5, 587 ctx->propq); 588 else if (c->algorithm_enc == SSL_AES128 589 && c->algorithm_mac == SSL_SHA1) 590 evp = ssl_evp_cipher_fetch(ctx->libctx, 591 NID_aes_128_cbc_hmac_sha1, 592 ctx->propq); 593 else if (c->algorithm_enc == SSL_AES256 594 && c->algorithm_mac == SSL_SHA1) 595 evp = ssl_evp_cipher_fetch(ctx->libctx, 596 NID_aes_256_cbc_hmac_sha1, 597 ctx->propq); 598 else if (c->algorithm_enc == SSL_AES128 599 && c->algorithm_mac == SSL_SHA256) 600 evp = ssl_evp_cipher_fetch(ctx->libctx, 601 NID_aes_128_cbc_hmac_sha256, 602 ctx->propq); 603 else if (c->algorithm_enc == SSL_AES256 604 && c->algorithm_mac == SSL_SHA256) 605 evp = ssl_evp_cipher_fetch(ctx->libctx, 606 NID_aes_256_cbc_hmac_sha256, 607 ctx->propq); 608 609 if (evp != NULL) { 610 ssl_evp_cipher_free(*enc); 611 ssl_evp_md_free(*md); 612 *enc = evp; 613 *md = NULL; 614 } 615 return 1; 616 } 617 618 return 0; 619 } 620 621 const EVP_MD *ssl_md(SSL_CTX *ctx, int idx) 622 { 623 idx &= SSL_HANDSHAKE_MAC_MASK; 624 if (idx < 0 || idx >= SSL_MD_NUM_IDX) 625 return NULL; 626 return ctx->ssl_digest_methods[idx]; 627 } 628 629 const EVP_MD *ssl_handshake_md(SSL *s) 630 { 631 return ssl_md(s->ctx, ssl_get_algorithm2(s)); 632 } 633 634 const EVP_MD *ssl_prf_md(SSL *s) 635 { 636 return ssl_md(s->ctx, ssl_get_algorithm2(s) >> TLS1_PRF_DGST_SHIFT); 637 } 638 639 #define ITEM_SEP(a) \ 640 (((a) == ':') || ((a) == ' ') || ((a) == ';') || ((a) == ',')) 641 642 static void ll_append_tail(CIPHER_ORDER **head, CIPHER_ORDER *curr, 643 CIPHER_ORDER **tail) 644 { 645 if (curr == *tail) 646 return; 647 if (curr == *head) 648 *head = curr->next; 649 if (curr->prev != NULL) 650 curr->prev->next = curr->next; 651 if (curr->next != NULL) 652 curr->next->prev = curr->prev; 653 (*tail)->next = curr; 654 curr->prev = *tail; 655 curr->next = NULL; 656 *tail = curr; 657 } 658 659 static void ll_append_head(CIPHER_ORDER **head, CIPHER_ORDER *curr, 660 CIPHER_ORDER **tail) 661 { 662 if (curr == *head) 663 return; 664 if (curr == *tail) 665 *tail = curr->prev; 666 if (curr->next != NULL) 667 curr->next->prev = curr->prev; 668 if (curr->prev != NULL) 669 curr->prev->next = curr->next; 670 (*head)->prev = curr; 671 curr->next = *head; 672 curr->prev = NULL; 673 *head = curr; 674 } 675 676 static void ssl_cipher_collect_ciphers(const SSL_METHOD *ssl_method, 677 int num_of_ciphers, 678 uint32_t disabled_mkey, 679 uint32_t disabled_auth, 680 uint32_t disabled_enc, 681 uint32_t disabled_mac, 682 CIPHER_ORDER *co_list, 683 CIPHER_ORDER **head_p, 684 CIPHER_ORDER **tail_p) 685 { 686 int i, co_list_num; 687 const SSL_CIPHER *c; 688 689 /* 690 * We have num_of_ciphers descriptions compiled in, depending on the 691 * method selected (SSLv3, TLSv1 etc). 692 * These will later be sorted in a linked list with at most num 693 * entries. 694 */ 695 696 /* Get the initial list of ciphers */ 697 co_list_num = 0; /* actual count of ciphers */ 698 for (i = 0; i < num_of_ciphers; i++) { 699 c = ssl_method->get_cipher(i); 700 /* drop those that use any of that is not available */ 701 if (c == NULL || !c->valid) 702 continue; 703 if ((c->algorithm_mkey & disabled_mkey) || 704 (c->algorithm_auth & disabled_auth) || 705 (c->algorithm_enc & disabled_enc) || 706 (c->algorithm_mac & disabled_mac)) 707 continue; 708 if (((ssl_method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) == 0) && 709 c->min_tls == 0) 710 continue; 711 if (((ssl_method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) != 0) && 712 c->min_dtls == 0) 713 continue; 714 715 co_list[co_list_num].cipher = c; 716 co_list[co_list_num].next = NULL; 717 co_list[co_list_num].prev = NULL; 718 co_list[co_list_num].active = 0; 719 co_list_num++; 720 } 721 722 /* 723 * Prepare linked list from list entries 724 */ 725 if (co_list_num > 0) { 726 co_list[0].prev = NULL; 727 728 if (co_list_num > 1) { 729 co_list[0].next = &co_list[1]; 730 731 for (i = 1; i < co_list_num - 1; i++) { 732 co_list[i].prev = &co_list[i - 1]; 733 co_list[i].next = &co_list[i + 1]; 734 } 735 736 co_list[co_list_num - 1].prev = &co_list[co_list_num - 2]; 737 } 738 739 co_list[co_list_num - 1].next = NULL; 740 741 *head_p = &co_list[0]; 742 *tail_p = &co_list[co_list_num - 1]; 743 } 744 } 745 746 static void ssl_cipher_collect_aliases(const SSL_CIPHER **ca_list, 747 int num_of_group_aliases, 748 uint32_t disabled_mkey, 749 uint32_t disabled_auth, 750 uint32_t disabled_enc, 751 uint32_t disabled_mac, 752 CIPHER_ORDER *head) 753 { 754 CIPHER_ORDER *ciph_curr; 755 const SSL_CIPHER **ca_curr; 756 int i; 757 uint32_t mask_mkey = ~disabled_mkey; 758 uint32_t mask_auth = ~disabled_auth; 759 uint32_t mask_enc = ~disabled_enc; 760 uint32_t mask_mac = ~disabled_mac; 761 762 /* 763 * First, add the real ciphers as already collected 764 */ 765 ciph_curr = head; 766 ca_curr = ca_list; 767 while (ciph_curr != NULL) { 768 *ca_curr = ciph_curr->cipher; 769 ca_curr++; 770 ciph_curr = ciph_curr->next; 771 } 772 773 /* 774 * Now we add the available ones from the cipher_aliases[] table. 775 * They represent either one or more algorithms, some of which 776 * in any affected category must be supported (set in enabled_mask), 777 * or represent a cipher strength value (will be added in any case because algorithms=0). 778 */ 779 for (i = 0; i < num_of_group_aliases; i++) { 780 uint32_t algorithm_mkey = cipher_aliases[i].algorithm_mkey; 781 uint32_t algorithm_auth = cipher_aliases[i].algorithm_auth; 782 uint32_t algorithm_enc = cipher_aliases[i].algorithm_enc; 783 uint32_t algorithm_mac = cipher_aliases[i].algorithm_mac; 784 785 if (algorithm_mkey) 786 if ((algorithm_mkey & mask_mkey) == 0) 787 continue; 788 789 if (algorithm_auth) 790 if ((algorithm_auth & mask_auth) == 0) 791 continue; 792 793 if (algorithm_enc) 794 if ((algorithm_enc & mask_enc) == 0) 795 continue; 796 797 if (algorithm_mac) 798 if ((algorithm_mac & mask_mac) == 0) 799 continue; 800 801 *ca_curr = (SSL_CIPHER *)(cipher_aliases + i); 802 ca_curr++; 803 } 804 805 *ca_curr = NULL; /* end of list */ 806 } 807 808 static void ssl_cipher_apply_rule(uint32_t cipher_id, uint32_t alg_mkey, 809 uint32_t alg_auth, uint32_t alg_enc, 810 uint32_t alg_mac, int min_tls, 811 uint32_t algo_strength, int rule, 812 int32_t strength_bits, CIPHER_ORDER **head_p, 813 CIPHER_ORDER **tail_p) 814 { 815 CIPHER_ORDER *head, *tail, *curr, *next, *last; 816 const SSL_CIPHER *cp; 817 int reverse = 0; 818 819 OSSL_TRACE_BEGIN(TLS_CIPHER){ 820 BIO_printf(trc_out, 821 "Applying rule %d with %08x/%08x/%08x/%08x/%08x %08x (%d)\n", 822 rule, alg_mkey, alg_auth, alg_enc, alg_mac, min_tls, 823 algo_strength, strength_bits); 824 } 825 826 if (rule == CIPHER_DEL || rule == CIPHER_BUMP) 827 reverse = 1; /* needed to maintain sorting between currently 828 * deleted ciphers */ 829 830 head = *head_p; 831 tail = *tail_p; 832 833 if (reverse) { 834 next = tail; 835 last = head; 836 } else { 837 next = head; 838 last = tail; 839 } 840 841 curr = NULL; 842 for (;;) { 843 if (curr == last) 844 break; 845 846 curr = next; 847 848 if (curr == NULL) 849 break; 850 851 next = reverse ? curr->prev : curr->next; 852 853 cp = curr->cipher; 854 855 /* 856 * Selection criteria is either the value of strength_bits 857 * or the algorithms used. 858 */ 859 if (strength_bits >= 0) { 860 if (strength_bits != cp->strength_bits) 861 continue; 862 } else { 863 if (trc_out != NULL) { 864 BIO_printf(trc_out, 865 "\nName: %s:" 866 "\nAlgo = %08x/%08x/%08x/%08x/%08x Algo_strength = %08x\n", 867 cp->name, cp->algorithm_mkey, cp->algorithm_auth, 868 cp->algorithm_enc, cp->algorithm_mac, cp->min_tls, 869 cp->algo_strength); 870 } 871 if (cipher_id != 0 && (cipher_id != cp->id)) 872 continue; 873 if (alg_mkey && !(alg_mkey & cp->algorithm_mkey)) 874 continue; 875 if (alg_auth && !(alg_auth & cp->algorithm_auth)) 876 continue; 877 if (alg_enc && !(alg_enc & cp->algorithm_enc)) 878 continue; 879 if (alg_mac && !(alg_mac & cp->algorithm_mac)) 880 continue; 881 if (min_tls && (min_tls != cp->min_tls)) 882 continue; 883 if ((algo_strength & SSL_STRONG_MASK) 884 && !(algo_strength & SSL_STRONG_MASK & cp->algo_strength)) 885 continue; 886 if ((algo_strength & SSL_DEFAULT_MASK) 887 && !(algo_strength & SSL_DEFAULT_MASK & cp->algo_strength)) 888 continue; 889 } 890 891 if (trc_out != NULL) 892 BIO_printf(trc_out, "Action = %d\n", rule); 893 894 /* add the cipher if it has not been added yet. */ 895 if (rule == CIPHER_ADD) { 896 /* reverse == 0 */ 897 if (!curr->active) { 898 ll_append_tail(&head, curr, &tail); 899 curr->active = 1; 900 } 901 } 902 /* Move the added cipher to this location */ 903 else if (rule == CIPHER_ORD) { 904 /* reverse == 0 */ 905 if (curr->active) { 906 ll_append_tail(&head, curr, &tail); 907 } 908 } else if (rule == CIPHER_DEL) { 909 /* reverse == 1 */ 910 if (curr->active) { 911 /* 912 * most recently deleted ciphersuites get best positions for 913 * any future CIPHER_ADD (note that the CIPHER_DEL loop works 914 * in reverse to maintain the order) 915 */ 916 ll_append_head(&head, curr, &tail); 917 curr->active = 0; 918 } 919 } else if (rule == CIPHER_BUMP) { 920 if (curr->active) 921 ll_append_head(&head, curr, &tail); 922 } else if (rule == CIPHER_KILL) { 923 /* reverse == 0 */ 924 if (head == curr) 925 head = curr->next; 926 else 927 curr->prev->next = curr->next; 928 if (tail == curr) 929 tail = curr->prev; 930 curr->active = 0; 931 if (curr->next != NULL) 932 curr->next->prev = curr->prev; 933 if (curr->prev != NULL) 934 curr->prev->next = curr->next; 935 curr->next = NULL; 936 curr->prev = NULL; 937 } 938 } 939 940 *head_p = head; 941 *tail_p = tail; 942 943 OSSL_TRACE_END(TLS_CIPHER); 944 } 945 946 static int ssl_cipher_strength_sort(CIPHER_ORDER **head_p, 947 CIPHER_ORDER **tail_p) 948 { 949 int32_t max_strength_bits; 950 int i, *number_uses; 951 CIPHER_ORDER *curr; 952 953 /* 954 * This routine sorts the ciphers with descending strength. The sorting 955 * must keep the pre-sorted sequence, so we apply the normal sorting 956 * routine as '+' movement to the end of the list. 957 */ 958 max_strength_bits = 0; 959 curr = *head_p; 960 while (curr != NULL) { 961 if (curr->active && (curr->cipher->strength_bits > max_strength_bits)) 962 max_strength_bits = curr->cipher->strength_bits; 963 curr = curr->next; 964 } 965 966 number_uses = OPENSSL_zalloc(sizeof(int) * (max_strength_bits + 1)); 967 if (number_uses == NULL) { 968 ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE); 969 return 0; 970 } 971 972 /* 973 * Now find the strength_bits values actually used 974 */ 975 curr = *head_p; 976 while (curr != NULL) { 977 if (curr->active) 978 number_uses[curr->cipher->strength_bits]++; 979 curr = curr->next; 980 } 981 /* 982 * Go through the list of used strength_bits values in descending 983 * order. 984 */ 985 for (i = max_strength_bits; i >= 0; i--) 986 if (number_uses[i] > 0) 987 ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_ORD, i, head_p, 988 tail_p); 989 990 OPENSSL_free(number_uses); 991 return 1; 992 } 993 994 static int ssl_cipher_process_rulestr(const char *rule_str, 995 CIPHER_ORDER **head_p, 996 CIPHER_ORDER **tail_p, 997 const SSL_CIPHER **ca_list, CERT *c) 998 { 999 uint32_t alg_mkey, alg_auth, alg_enc, alg_mac, algo_strength; 1000 int min_tls; 1001 const char *l, *buf; 1002 int j, multi, found, rule, retval, ok, buflen; 1003 uint32_t cipher_id = 0; 1004 char ch; 1005 1006 retval = 1; 1007 l = rule_str; 1008 for ( ; ; ) { 1009 ch = *l; 1010 1011 if (ch == '\0') 1012 break; /* done */ 1013 if (ch == '-') { 1014 rule = CIPHER_DEL; 1015 l++; 1016 } else if (ch == '+') { 1017 rule = CIPHER_ORD; 1018 l++; 1019 } else if (ch == '!') { 1020 rule = CIPHER_KILL; 1021 l++; 1022 } else if (ch == '@') { 1023 rule = CIPHER_SPECIAL; 1024 l++; 1025 } else { 1026 rule = CIPHER_ADD; 1027 } 1028 1029 if (ITEM_SEP(ch)) { 1030 l++; 1031 continue; 1032 } 1033 1034 alg_mkey = 0; 1035 alg_auth = 0; 1036 alg_enc = 0; 1037 alg_mac = 0; 1038 min_tls = 0; 1039 algo_strength = 0; 1040 1041 for (;;) { 1042 ch = *l; 1043 buf = l; 1044 buflen = 0; 1045 #ifndef CHARSET_EBCDIC 1046 while (((ch >= 'A') && (ch <= 'Z')) || 1047 ((ch >= '0') && (ch <= '9')) || 1048 ((ch >= 'a') && (ch <= 'z')) || 1049 (ch == '-') || (ch == '.') || (ch == '=')) 1050 #else 1051 while (isalnum((unsigned char)ch) || (ch == '-') || (ch == '.') 1052 || (ch == '=')) 1053 #endif 1054 { 1055 ch = *(++l); 1056 buflen++; 1057 } 1058 1059 if (buflen == 0) { 1060 /* 1061 * We hit something we cannot deal with, 1062 * it is no command or separator nor 1063 * alphanumeric, so we call this an error. 1064 */ 1065 ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_COMMAND); 1066 return 0; 1067 } 1068 1069 if (rule == CIPHER_SPECIAL) { 1070 found = 0; /* unused -- avoid compiler warning */ 1071 break; /* special treatment */ 1072 } 1073 1074 /* check for multi-part specification */ 1075 if (ch == '+') { 1076 multi = 1; 1077 l++; 1078 } else { 1079 multi = 0; 1080 } 1081 1082 /* 1083 * Now search for the cipher alias in the ca_list. Be careful 1084 * with the strncmp, because the "buflen" limitation 1085 * will make the rule "ADH:SOME" and the cipher 1086 * "ADH-MY-CIPHER" look like a match for buflen=3. 1087 * So additionally check whether the cipher name found 1088 * has the correct length. We can save a strlen() call: 1089 * just checking for the '\0' at the right place is 1090 * sufficient, we have to strncmp() anyway. (We cannot 1091 * use strcmp(), because buf is not '\0' terminated.) 1092 */ 1093 j = found = 0; 1094 cipher_id = 0; 1095 while (ca_list[j]) { 1096 if (strncmp(buf, ca_list[j]->name, buflen) == 0 1097 && (ca_list[j]->name[buflen] == '\0')) { 1098 found = 1; 1099 break; 1100 } else 1101 j++; 1102 } 1103 1104 if (!found) 1105 break; /* ignore this entry */ 1106 1107 if (ca_list[j]->algorithm_mkey) { 1108 if (alg_mkey) { 1109 alg_mkey &= ca_list[j]->algorithm_mkey; 1110 if (!alg_mkey) { 1111 found = 0; 1112 break; 1113 } 1114 } else { 1115 alg_mkey = ca_list[j]->algorithm_mkey; 1116 } 1117 } 1118 1119 if (ca_list[j]->algorithm_auth) { 1120 if (alg_auth) { 1121 alg_auth &= ca_list[j]->algorithm_auth; 1122 if (!alg_auth) { 1123 found = 0; 1124 break; 1125 } 1126 } else { 1127 alg_auth = ca_list[j]->algorithm_auth; 1128 } 1129 } 1130 1131 if (ca_list[j]->algorithm_enc) { 1132 if (alg_enc) { 1133 alg_enc &= ca_list[j]->algorithm_enc; 1134 if (!alg_enc) { 1135 found = 0; 1136 break; 1137 } 1138 } else { 1139 alg_enc = ca_list[j]->algorithm_enc; 1140 } 1141 } 1142 1143 if (ca_list[j]->algorithm_mac) { 1144 if (alg_mac) { 1145 alg_mac &= ca_list[j]->algorithm_mac; 1146 if (!alg_mac) { 1147 found = 0; 1148 break; 1149 } 1150 } else { 1151 alg_mac = ca_list[j]->algorithm_mac; 1152 } 1153 } 1154 1155 if (ca_list[j]->algo_strength & SSL_STRONG_MASK) { 1156 if (algo_strength & SSL_STRONG_MASK) { 1157 algo_strength &= 1158 (ca_list[j]->algo_strength & SSL_STRONG_MASK) | 1159 ~SSL_STRONG_MASK; 1160 if (!(algo_strength & SSL_STRONG_MASK)) { 1161 found = 0; 1162 break; 1163 } 1164 } else { 1165 algo_strength = ca_list[j]->algo_strength & SSL_STRONG_MASK; 1166 } 1167 } 1168 1169 if (ca_list[j]->algo_strength & SSL_DEFAULT_MASK) { 1170 if (algo_strength & SSL_DEFAULT_MASK) { 1171 algo_strength &= 1172 (ca_list[j]->algo_strength & SSL_DEFAULT_MASK) | 1173 ~SSL_DEFAULT_MASK; 1174 if (!(algo_strength & SSL_DEFAULT_MASK)) { 1175 found = 0; 1176 break; 1177 } 1178 } else { 1179 algo_strength |= 1180 ca_list[j]->algo_strength & SSL_DEFAULT_MASK; 1181 } 1182 } 1183 1184 if (ca_list[j]->valid) { 1185 /* 1186 * explicit ciphersuite found; its protocol version does not 1187 * become part of the search pattern! 1188 */ 1189 1190 cipher_id = ca_list[j]->id; 1191 } else { 1192 /* 1193 * not an explicit ciphersuite; only in this case, the 1194 * protocol version is considered part of the search pattern 1195 */ 1196 1197 if (ca_list[j]->min_tls) { 1198 if (min_tls != 0 && min_tls != ca_list[j]->min_tls) { 1199 found = 0; 1200 break; 1201 } else { 1202 min_tls = ca_list[j]->min_tls; 1203 } 1204 } 1205 } 1206 1207 if (!multi) 1208 break; 1209 } 1210 1211 /* 1212 * Ok, we have the rule, now apply it 1213 */ 1214 if (rule == CIPHER_SPECIAL) { /* special command */ 1215 ok = 0; 1216 if ((buflen == 8) && strncmp(buf, "STRENGTH", 8) == 0) { 1217 ok = ssl_cipher_strength_sort(head_p, tail_p); 1218 } else if (buflen == 10 && strncmp(buf, "SECLEVEL=", 9) == 0) { 1219 int level = buf[9] - '0'; 1220 if (level < 0 || level > 5) { 1221 ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_COMMAND); 1222 } else { 1223 c->sec_level = level; 1224 ok = 1; 1225 } 1226 } else { 1227 ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_COMMAND); 1228 } 1229 if (ok == 0) 1230 retval = 0; 1231 /* 1232 * We do not support any "multi" options 1233 * together with "@", so throw away the 1234 * rest of the command, if any left, until 1235 * end or ':' is found. 1236 */ 1237 while ((*l != '\0') && !ITEM_SEP(*l)) 1238 l++; 1239 } else if (found) { 1240 ssl_cipher_apply_rule(cipher_id, 1241 alg_mkey, alg_auth, alg_enc, alg_mac, 1242 min_tls, algo_strength, rule, -1, head_p, 1243 tail_p); 1244 } else { 1245 while ((*l != '\0') && !ITEM_SEP(*l)) 1246 l++; 1247 } 1248 if (*l == '\0') 1249 break; /* done */ 1250 } 1251 1252 return retval; 1253 } 1254 1255 static int check_suiteb_cipher_list(const SSL_METHOD *meth, CERT *c, 1256 const char **prule_str) 1257 { 1258 unsigned int suiteb_flags = 0, suiteb_comb2 = 0; 1259 if (strncmp(*prule_str, "SUITEB128ONLY", 13) == 0) { 1260 suiteb_flags = SSL_CERT_FLAG_SUITEB_128_LOS_ONLY; 1261 } else if (strncmp(*prule_str, "SUITEB128C2", 11) == 0) { 1262 suiteb_comb2 = 1; 1263 suiteb_flags = SSL_CERT_FLAG_SUITEB_128_LOS; 1264 } else if (strncmp(*prule_str, "SUITEB128", 9) == 0) { 1265 suiteb_flags = SSL_CERT_FLAG_SUITEB_128_LOS; 1266 } else if (strncmp(*prule_str, "SUITEB192", 9) == 0) { 1267 suiteb_flags = SSL_CERT_FLAG_SUITEB_192_LOS; 1268 } 1269 1270 if (suiteb_flags) { 1271 c->cert_flags &= ~SSL_CERT_FLAG_SUITEB_128_LOS; 1272 c->cert_flags |= suiteb_flags; 1273 } else { 1274 suiteb_flags = c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS; 1275 } 1276 1277 if (!suiteb_flags) 1278 return 1; 1279 /* Check version: if TLS 1.2 ciphers allowed we can use Suite B */ 1280 1281 if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_TLS1_2_CIPHERS)) { 1282 ERR_raise(ERR_LIB_SSL, SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE); 1283 return 0; 1284 } 1285 1286 switch (suiteb_flags) { 1287 case SSL_CERT_FLAG_SUITEB_128_LOS: 1288 if (suiteb_comb2) 1289 *prule_str = "ECDHE-ECDSA-AES256-GCM-SHA384"; 1290 else 1291 *prule_str = 1292 "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384"; 1293 break; 1294 case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY: 1295 *prule_str = "ECDHE-ECDSA-AES128-GCM-SHA256"; 1296 break; 1297 case SSL_CERT_FLAG_SUITEB_192_LOS: 1298 *prule_str = "ECDHE-ECDSA-AES256-GCM-SHA384"; 1299 break; 1300 } 1301 return 1; 1302 } 1303 1304 static int ciphersuite_cb(const char *elem, int len, void *arg) 1305 { 1306 STACK_OF(SSL_CIPHER) *ciphersuites = (STACK_OF(SSL_CIPHER) *)arg; 1307 const SSL_CIPHER *cipher; 1308 /* Arbitrary sized temp buffer for the cipher name. Should be big enough */ 1309 char name[80]; 1310 1311 if (len > (int)(sizeof(name) - 1)) 1312 /* Anyway return 1 so we can parse rest of the list */ 1313 return 1; 1314 1315 memcpy(name, elem, len); 1316 name[len] = '\0'; 1317 1318 cipher = ssl3_get_cipher_by_std_name(name); 1319 if (cipher == NULL) 1320 /* Ciphersuite not found but return 1 to parse rest of the list */ 1321 return 1; 1322 1323 if (!sk_SSL_CIPHER_push(ciphersuites, cipher)) { 1324 ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); 1325 return 0; 1326 } 1327 1328 return 1; 1329 } 1330 1331 static __owur int set_ciphersuites(STACK_OF(SSL_CIPHER) **currciphers, const char *str) 1332 { 1333 STACK_OF(SSL_CIPHER) *newciphers = sk_SSL_CIPHER_new_null(); 1334 1335 if (newciphers == NULL) 1336 return 0; 1337 1338 /* Parse the list. We explicitly allow an empty list */ 1339 if (*str != '\0' 1340 && (CONF_parse_list(str, ':', 1, ciphersuite_cb, newciphers) <= 0 1341 || sk_SSL_CIPHER_num(newciphers) == 0)) { 1342 ERR_raise(ERR_LIB_SSL, SSL_R_NO_CIPHER_MATCH); 1343 sk_SSL_CIPHER_free(newciphers); 1344 return 0; 1345 } 1346 sk_SSL_CIPHER_free(*currciphers); 1347 *currciphers = newciphers; 1348 1349 return 1; 1350 } 1351 1352 static int update_cipher_list_by_id(STACK_OF(SSL_CIPHER) **cipher_list_by_id, 1353 STACK_OF(SSL_CIPHER) *cipherstack) 1354 { 1355 STACK_OF(SSL_CIPHER) *tmp_cipher_list = sk_SSL_CIPHER_dup(cipherstack); 1356 1357 if (tmp_cipher_list == NULL) { 1358 return 0; 1359 } 1360 1361 sk_SSL_CIPHER_free(*cipher_list_by_id); 1362 *cipher_list_by_id = tmp_cipher_list; 1363 1364 (void)sk_SSL_CIPHER_set_cmp_func(*cipher_list_by_id, ssl_cipher_ptr_id_cmp); 1365 sk_SSL_CIPHER_sort(*cipher_list_by_id); 1366 1367 return 1; 1368 } 1369 1370 static int update_cipher_list(SSL_CTX *ctx, 1371 STACK_OF(SSL_CIPHER) **cipher_list, 1372 STACK_OF(SSL_CIPHER) **cipher_list_by_id, 1373 STACK_OF(SSL_CIPHER) *tls13_ciphersuites) 1374 { 1375 int i; 1376 STACK_OF(SSL_CIPHER) *tmp_cipher_list = sk_SSL_CIPHER_dup(*cipher_list); 1377 1378 if (tmp_cipher_list == NULL) 1379 return 0; 1380 1381 /* 1382 * Delete any existing TLSv1.3 ciphersuites. These are always first in the 1383 * list. 1384 */ 1385 while (sk_SSL_CIPHER_num(tmp_cipher_list) > 0 1386 && sk_SSL_CIPHER_value(tmp_cipher_list, 0)->min_tls 1387 == TLS1_3_VERSION) 1388 (void)sk_SSL_CIPHER_delete(tmp_cipher_list, 0); 1389 1390 /* Insert the new TLSv1.3 ciphersuites */ 1391 for (i = sk_SSL_CIPHER_num(tls13_ciphersuites) - 1; i >= 0; i--) { 1392 const SSL_CIPHER *sslc = sk_SSL_CIPHER_value(tls13_ciphersuites, i); 1393 1394 /* Don't include any TLSv1.3 ciphersuites that are disabled */ 1395 if ((sslc->algorithm_enc & ctx->disabled_enc_mask) == 0 1396 && (ssl_cipher_table_mac[sslc->algorithm2 1397 & SSL_HANDSHAKE_MAC_MASK].mask 1398 & ctx->disabled_mac_mask) == 0) { 1399 sk_SSL_CIPHER_unshift(tmp_cipher_list, sslc); 1400 } 1401 } 1402 1403 if (!update_cipher_list_by_id(cipher_list_by_id, tmp_cipher_list)) { 1404 sk_SSL_CIPHER_free(tmp_cipher_list); 1405 return 0; 1406 } 1407 1408 sk_SSL_CIPHER_free(*cipher_list); 1409 *cipher_list = tmp_cipher_list; 1410 1411 return 1; 1412 } 1413 1414 int SSL_CTX_set_ciphersuites(SSL_CTX *ctx, const char *str) 1415 { 1416 int ret = set_ciphersuites(&(ctx->tls13_ciphersuites), str); 1417 1418 if (ret && ctx->cipher_list != NULL) 1419 return update_cipher_list(ctx, &ctx->cipher_list, &ctx->cipher_list_by_id, 1420 ctx->tls13_ciphersuites); 1421 1422 return ret; 1423 } 1424 1425 int SSL_set_ciphersuites(SSL *s, const char *str) 1426 { 1427 STACK_OF(SSL_CIPHER) *cipher_list; 1428 int ret = set_ciphersuites(&(s->tls13_ciphersuites), str); 1429 1430 if (s->cipher_list == NULL) { 1431 if ((cipher_list = SSL_get_ciphers(s)) != NULL) 1432 s->cipher_list = sk_SSL_CIPHER_dup(cipher_list); 1433 } 1434 if (ret && s->cipher_list != NULL) 1435 return update_cipher_list(s->ctx, &s->cipher_list, &s->cipher_list_by_id, 1436 s->tls13_ciphersuites); 1437 1438 return ret; 1439 } 1440 1441 STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx, 1442 STACK_OF(SSL_CIPHER) *tls13_ciphersuites, 1443 STACK_OF(SSL_CIPHER) **cipher_list, 1444 STACK_OF(SSL_CIPHER) **cipher_list_by_id, 1445 const char *rule_str, 1446 CERT *c) 1447 { 1448 int ok, num_of_ciphers, num_of_alias_max, num_of_group_aliases, i; 1449 uint32_t disabled_mkey, disabled_auth, disabled_enc, disabled_mac; 1450 STACK_OF(SSL_CIPHER) *cipherstack; 1451 const char *rule_p; 1452 CIPHER_ORDER *co_list = NULL, *head = NULL, *tail = NULL, *curr; 1453 const SSL_CIPHER **ca_list = NULL; 1454 const SSL_METHOD *ssl_method = ctx->method; 1455 1456 /* 1457 * Return with error if nothing to do. 1458 */ 1459 if (rule_str == NULL || cipher_list == NULL || cipher_list_by_id == NULL) 1460 return NULL; 1461 1462 if (!check_suiteb_cipher_list(ssl_method, c, &rule_str)) 1463 return NULL; 1464 1465 /* 1466 * To reduce the work to do we only want to process the compiled 1467 * in algorithms, so we first get the mask of disabled ciphers. 1468 */ 1469 1470 disabled_mkey = ctx->disabled_mkey_mask; 1471 disabled_auth = ctx->disabled_auth_mask; 1472 disabled_enc = ctx->disabled_enc_mask; 1473 disabled_mac = ctx->disabled_mac_mask; 1474 1475 /* 1476 * Now we have to collect the available ciphers from the compiled 1477 * in ciphers. We cannot get more than the number compiled in, so 1478 * it is used for allocation. 1479 */ 1480 num_of_ciphers = ssl_method->num_ciphers(); 1481 1482 co_list = OPENSSL_malloc(sizeof(*co_list) * num_of_ciphers); 1483 if (co_list == NULL) { 1484 ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE); 1485 return NULL; /* Failure */ 1486 } 1487 1488 ssl_cipher_collect_ciphers(ssl_method, num_of_ciphers, 1489 disabled_mkey, disabled_auth, disabled_enc, 1490 disabled_mac, co_list, &head, &tail); 1491 1492 /* Now arrange all ciphers by preference. */ 1493 1494 /* 1495 * Everything else being equal, prefer ephemeral ECDH over other key 1496 * exchange mechanisms. 1497 * For consistency, prefer ECDSA over RSA (though this only matters if the 1498 * server has both certificates, and is using the DEFAULT, or a client 1499 * preference). 1500 */ 1501 ssl_cipher_apply_rule(0, SSL_kECDHE, SSL_aECDSA, 0, 0, 0, 0, CIPHER_ADD, 1502 -1, &head, &tail); 1503 ssl_cipher_apply_rule(0, SSL_kECDHE, 0, 0, 0, 0, 0, CIPHER_ADD, -1, &head, 1504 &tail); 1505 ssl_cipher_apply_rule(0, SSL_kECDHE, 0, 0, 0, 0, 0, CIPHER_DEL, -1, &head, 1506 &tail); 1507 1508 /* Within each strength group, we prefer GCM over CHACHA... */ 1509 ssl_cipher_apply_rule(0, 0, 0, SSL_AESGCM, 0, 0, 0, CIPHER_ADD, -1, 1510 &head, &tail); 1511 ssl_cipher_apply_rule(0, 0, 0, SSL_CHACHA20, 0, 0, 0, CIPHER_ADD, -1, 1512 &head, &tail); 1513 1514 /* 1515 * ...and generally, our preferred cipher is AES. 1516 * Note that AEADs will be bumped to take preference after sorting by 1517 * strength. 1518 */ 1519 ssl_cipher_apply_rule(0, 0, 0, SSL_AES ^ SSL_AESGCM, 0, 0, 0, CIPHER_ADD, 1520 -1, &head, &tail); 1521 1522 /* Temporarily enable everything else for sorting */ 1523 ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_ADD, -1, &head, &tail); 1524 1525 /* Low priority for MD5 */ 1526 ssl_cipher_apply_rule(0, 0, 0, 0, SSL_MD5, 0, 0, CIPHER_ORD, -1, &head, 1527 &tail); 1528 1529 /* 1530 * Move anonymous ciphers to the end. Usually, these will remain 1531 * disabled. (For applications that allow them, they aren't too bad, but 1532 * we prefer authenticated ciphers.) 1533 */ 1534 ssl_cipher_apply_rule(0, 0, SSL_aNULL, 0, 0, 0, 0, CIPHER_ORD, -1, &head, 1535 &tail); 1536 1537 ssl_cipher_apply_rule(0, SSL_kRSA, 0, 0, 0, 0, 0, CIPHER_ORD, -1, &head, 1538 &tail); 1539 ssl_cipher_apply_rule(0, SSL_kPSK, 0, 0, 0, 0, 0, CIPHER_ORD, -1, &head, 1540 &tail); 1541 1542 /* RC4 is sort-of broken -- move to the end */ 1543 ssl_cipher_apply_rule(0, 0, 0, SSL_RC4, 0, 0, 0, CIPHER_ORD, -1, &head, 1544 &tail); 1545 1546 /* 1547 * Now sort by symmetric encryption strength. The above ordering remains 1548 * in force within each class 1549 */ 1550 if (!ssl_cipher_strength_sort(&head, &tail)) { 1551 OPENSSL_free(co_list); 1552 return NULL; 1553 } 1554 1555 /* 1556 * Partially overrule strength sort to prefer TLS 1.2 ciphers/PRFs. 1557 */ 1558 ssl_cipher_apply_rule(0, 0, 0, 0, 0, TLS1_2_VERSION, 0, CIPHER_BUMP, -1, 1559 &head, &tail); 1560 1561 /* 1562 * Irrespective of strength, enforce the following order: 1563 * (EC)DHE + AEAD > (EC)DHE > rest of AEAD > rest. 1564 * Within each group, ciphers remain sorted by strength and previous 1565 * preference, i.e., 1566 * 1) ECDHE > DHE 1567 * 2) GCM > CHACHA 1568 * 3) AES > rest 1569 * 4) TLS 1.2 > legacy 1570 * 1571 * Because we now bump ciphers to the top of the list, we proceed in 1572 * reverse order of preference. 1573 */ 1574 ssl_cipher_apply_rule(0, 0, 0, 0, SSL_AEAD, 0, 0, CIPHER_BUMP, -1, 1575 &head, &tail); 1576 ssl_cipher_apply_rule(0, SSL_kDHE | SSL_kECDHE, 0, 0, 0, 0, 0, 1577 CIPHER_BUMP, -1, &head, &tail); 1578 ssl_cipher_apply_rule(0, SSL_kDHE | SSL_kECDHE, 0, 0, SSL_AEAD, 0, 0, 1579 CIPHER_BUMP, -1, &head, &tail); 1580 1581 /* Now disable everything (maintaining the ordering!) */ 1582 ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_DEL, -1, &head, &tail); 1583 1584 /* 1585 * We also need cipher aliases for selecting based on the rule_str. 1586 * There might be two types of entries in the rule_str: 1) names 1587 * of ciphers themselves 2) aliases for groups of ciphers. 1588 * For 1) we need the available ciphers and for 2) the cipher 1589 * groups of cipher_aliases added together in one list (otherwise 1590 * we would be happy with just the cipher_aliases table). 1591 */ 1592 num_of_group_aliases = OSSL_NELEM(cipher_aliases); 1593 num_of_alias_max = num_of_ciphers + num_of_group_aliases + 1; 1594 ca_list = OPENSSL_malloc(sizeof(*ca_list) * num_of_alias_max); 1595 if (ca_list == NULL) { 1596 OPENSSL_free(co_list); 1597 ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE); 1598 return NULL; /* Failure */ 1599 } 1600 ssl_cipher_collect_aliases(ca_list, num_of_group_aliases, 1601 disabled_mkey, disabled_auth, disabled_enc, 1602 disabled_mac, head); 1603 1604 /* 1605 * If the rule_string begins with DEFAULT, apply the default rule 1606 * before using the (possibly available) additional rules. 1607 */ 1608 ok = 1; 1609 rule_p = rule_str; 1610 if (strncmp(rule_str, "DEFAULT", 7) == 0) { 1611 ok = ssl_cipher_process_rulestr(OSSL_default_cipher_list(), 1612 &head, &tail, ca_list, c); 1613 rule_p += 7; 1614 if (*rule_p == ':') 1615 rule_p++; 1616 } 1617 1618 if (ok && (rule_p[0] != '\0')) 1619 ok = ssl_cipher_process_rulestr(rule_p, &head, &tail, ca_list, c); 1620 1621 OPENSSL_free(ca_list); /* Not needed anymore */ 1622 1623 if (!ok) { /* Rule processing failure */ 1624 OPENSSL_free(co_list); 1625 return NULL; 1626 } 1627 1628 /* 1629 * Allocate new "cipherstack" for the result, return with error 1630 * if we cannot get one. 1631 */ 1632 if ((cipherstack = sk_SSL_CIPHER_new_null()) == NULL) { 1633 OPENSSL_free(co_list); 1634 return NULL; 1635 } 1636 1637 /* Add TLSv1.3 ciphers first - we always prefer those if possible */ 1638 for (i = 0; i < sk_SSL_CIPHER_num(tls13_ciphersuites); i++) { 1639 const SSL_CIPHER *sslc = sk_SSL_CIPHER_value(tls13_ciphersuites, i); 1640 1641 /* Don't include any TLSv1.3 ciphers that are disabled */ 1642 if ((sslc->algorithm_enc & disabled_enc) != 0 1643 || (ssl_cipher_table_mac[sslc->algorithm2 1644 & SSL_HANDSHAKE_MAC_MASK].mask 1645 & ctx->disabled_mac_mask) != 0) { 1646 sk_SSL_CIPHER_delete(tls13_ciphersuites, i); 1647 i--; 1648 continue; 1649 } 1650 1651 if (!sk_SSL_CIPHER_push(cipherstack, sslc)) { 1652 OPENSSL_free(co_list); 1653 sk_SSL_CIPHER_free(cipherstack); 1654 return NULL; 1655 } 1656 } 1657 1658 OSSL_TRACE_BEGIN(TLS_CIPHER) { 1659 BIO_printf(trc_out, "cipher selection:\n"); 1660 } 1661 /* 1662 * The cipher selection for the list is done. The ciphers are added 1663 * to the resulting precedence to the STACK_OF(SSL_CIPHER). 1664 */ 1665 for (curr = head; curr != NULL; curr = curr->next) { 1666 if (curr->active) { 1667 if (!sk_SSL_CIPHER_push(cipherstack, curr->cipher)) { 1668 OPENSSL_free(co_list); 1669 sk_SSL_CIPHER_free(cipherstack); 1670 OSSL_TRACE_CANCEL(TLS_CIPHER); 1671 return NULL; 1672 } 1673 if (trc_out != NULL) 1674 BIO_printf(trc_out, "<%s>\n", curr->cipher->name); 1675 } 1676 } 1677 OPENSSL_free(co_list); /* Not needed any longer */ 1678 OSSL_TRACE_END(TLS_CIPHER); 1679 1680 if (!update_cipher_list_by_id(cipher_list_by_id, cipherstack)) { 1681 sk_SSL_CIPHER_free(cipherstack); 1682 return NULL; 1683 } 1684 sk_SSL_CIPHER_free(*cipher_list); 1685 *cipher_list = cipherstack; 1686 1687 return cipherstack; 1688 } 1689 1690 char *SSL_CIPHER_description(const SSL_CIPHER *cipher, char *buf, int len) 1691 { 1692 const char *ver; 1693 const char *kx, *au, *enc, *mac; 1694 uint32_t alg_mkey, alg_auth, alg_enc, alg_mac; 1695 static const char *format = "%-30s %-7s Kx=%-8s Au=%-5s Enc=%-22s Mac=%-4s\n"; 1696 1697 if (buf == NULL) { 1698 len = 128; 1699 if ((buf = OPENSSL_malloc(len)) == NULL) { 1700 ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE); 1701 return NULL; 1702 } 1703 } else if (len < 128) { 1704 return NULL; 1705 } 1706 1707 alg_mkey = cipher->algorithm_mkey; 1708 alg_auth = cipher->algorithm_auth; 1709 alg_enc = cipher->algorithm_enc; 1710 alg_mac = cipher->algorithm_mac; 1711 1712 ver = ssl_protocol_to_string(cipher->min_tls); 1713 1714 switch (alg_mkey) { 1715 case SSL_kRSA: 1716 kx = "RSA"; 1717 break; 1718 case SSL_kDHE: 1719 kx = "DH"; 1720 break; 1721 case SSL_kECDHE: 1722 kx = "ECDH"; 1723 break; 1724 case SSL_kPSK: 1725 kx = "PSK"; 1726 break; 1727 case SSL_kRSAPSK: 1728 kx = "RSAPSK"; 1729 break; 1730 case SSL_kECDHEPSK: 1731 kx = "ECDHEPSK"; 1732 break; 1733 case SSL_kDHEPSK: 1734 kx = "DHEPSK"; 1735 break; 1736 case SSL_kSRP: 1737 kx = "SRP"; 1738 break; 1739 case SSL_kGOST: 1740 kx = "GOST"; 1741 break; 1742 case SSL_kGOST18: 1743 kx = "GOST18"; 1744 break; 1745 case SSL_kANY: 1746 kx = "any"; 1747 break; 1748 default: 1749 kx = "unknown"; 1750 } 1751 1752 switch (alg_auth) { 1753 case SSL_aRSA: 1754 au = "RSA"; 1755 break; 1756 case SSL_aDSS: 1757 au = "DSS"; 1758 break; 1759 case SSL_aNULL: 1760 au = "None"; 1761 break; 1762 case SSL_aECDSA: 1763 au = "ECDSA"; 1764 break; 1765 case SSL_aPSK: 1766 au = "PSK"; 1767 break; 1768 case SSL_aSRP: 1769 au = "SRP"; 1770 break; 1771 case SSL_aGOST01: 1772 au = "GOST01"; 1773 break; 1774 /* New GOST ciphersuites have both SSL_aGOST12 and SSL_aGOST01 bits */ 1775 case (SSL_aGOST12 | SSL_aGOST01): 1776 au = "GOST12"; 1777 break; 1778 case SSL_aANY: 1779 au = "any"; 1780 break; 1781 default: 1782 au = "unknown"; 1783 break; 1784 } 1785 1786 switch (alg_enc) { 1787 case SSL_DES: 1788 enc = "DES(56)"; 1789 break; 1790 case SSL_3DES: 1791 enc = "3DES(168)"; 1792 break; 1793 case SSL_RC4: 1794 enc = "RC4(128)"; 1795 break; 1796 case SSL_RC2: 1797 enc = "RC2(128)"; 1798 break; 1799 case SSL_IDEA: 1800 enc = "IDEA(128)"; 1801 break; 1802 case SSL_eNULL: 1803 enc = "None"; 1804 break; 1805 case SSL_AES128: 1806 enc = "AES(128)"; 1807 break; 1808 case SSL_AES256: 1809 enc = "AES(256)"; 1810 break; 1811 case SSL_AES128GCM: 1812 enc = "AESGCM(128)"; 1813 break; 1814 case SSL_AES256GCM: 1815 enc = "AESGCM(256)"; 1816 break; 1817 case SSL_AES128CCM: 1818 enc = "AESCCM(128)"; 1819 break; 1820 case SSL_AES256CCM: 1821 enc = "AESCCM(256)"; 1822 break; 1823 case SSL_AES128CCM8: 1824 enc = "AESCCM8(128)"; 1825 break; 1826 case SSL_AES256CCM8: 1827 enc = "AESCCM8(256)"; 1828 break; 1829 case SSL_CAMELLIA128: 1830 enc = "Camellia(128)"; 1831 break; 1832 case SSL_CAMELLIA256: 1833 enc = "Camellia(256)"; 1834 break; 1835 case SSL_ARIA128GCM: 1836 enc = "ARIAGCM(128)"; 1837 break; 1838 case SSL_ARIA256GCM: 1839 enc = "ARIAGCM(256)"; 1840 break; 1841 case SSL_SEED: 1842 enc = "SEED(128)"; 1843 break; 1844 case SSL_eGOST2814789CNT: 1845 case SSL_eGOST2814789CNT12: 1846 enc = "GOST89(256)"; 1847 break; 1848 case SSL_MAGMA: 1849 enc = "MAGMA"; 1850 break; 1851 case SSL_KUZNYECHIK: 1852 enc = "KUZNYECHIK"; 1853 break; 1854 case SSL_CHACHA20POLY1305: 1855 enc = "CHACHA20/POLY1305(256)"; 1856 break; 1857 default: 1858 enc = "unknown"; 1859 break; 1860 } 1861 1862 switch (alg_mac) { 1863 case SSL_MD5: 1864 mac = "MD5"; 1865 break; 1866 case SSL_SHA1: 1867 mac = "SHA1"; 1868 break; 1869 case SSL_SHA256: 1870 mac = "SHA256"; 1871 break; 1872 case SSL_SHA384: 1873 mac = "SHA384"; 1874 break; 1875 case SSL_AEAD: 1876 mac = "AEAD"; 1877 break; 1878 case SSL_GOST89MAC: 1879 case SSL_GOST89MAC12: 1880 mac = "GOST89"; 1881 break; 1882 case SSL_GOST94: 1883 mac = "GOST94"; 1884 break; 1885 case SSL_GOST12_256: 1886 case SSL_GOST12_512: 1887 mac = "GOST2012"; 1888 break; 1889 default: 1890 mac = "unknown"; 1891 break; 1892 } 1893 1894 BIO_snprintf(buf, len, format, cipher->name, ver, kx, au, enc, mac); 1895 1896 return buf; 1897 } 1898 1899 const char *SSL_CIPHER_get_version(const SSL_CIPHER *c) 1900 { 1901 if (c == NULL) 1902 return "(NONE)"; 1903 1904 /* 1905 * Backwards-compatibility crutch. In almost all contexts we report TLS 1906 * 1.0 as "TLSv1", but for ciphers we report "TLSv1.0". 1907 */ 1908 if (c->min_tls == TLS1_VERSION) 1909 return "TLSv1.0"; 1910 return ssl_protocol_to_string(c->min_tls); 1911 } 1912 1913 /* return the actual cipher being used */ 1914 const char *SSL_CIPHER_get_name(const SSL_CIPHER *c) 1915 { 1916 if (c != NULL) 1917 return c->name; 1918 return "(NONE)"; 1919 } 1920 1921 /* return the actual cipher being used in RFC standard name */ 1922 const char *SSL_CIPHER_standard_name(const SSL_CIPHER *c) 1923 { 1924 if (c != NULL) 1925 return c->stdname; 1926 return "(NONE)"; 1927 } 1928 1929 /* return the OpenSSL name based on given RFC standard name */ 1930 const char *OPENSSL_cipher_name(const char *stdname) 1931 { 1932 const SSL_CIPHER *c; 1933 1934 if (stdname == NULL) 1935 return "(NONE)"; 1936 c = ssl3_get_cipher_by_std_name(stdname); 1937 return SSL_CIPHER_get_name(c); 1938 } 1939 1940 /* number of bits for symmetric cipher */ 1941 int SSL_CIPHER_get_bits(const SSL_CIPHER *c, int *alg_bits) 1942 { 1943 int ret = 0; 1944 1945 if (c != NULL) { 1946 if (alg_bits != NULL) 1947 *alg_bits = (int)c->alg_bits; 1948 ret = (int)c->strength_bits; 1949 } 1950 return ret; 1951 } 1952 1953 uint32_t SSL_CIPHER_get_id(const SSL_CIPHER *c) 1954 { 1955 return c->id; 1956 } 1957 1958 uint16_t SSL_CIPHER_get_protocol_id(const SSL_CIPHER *c) 1959 { 1960 return c->id & 0xFFFF; 1961 } 1962 1963 SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n) 1964 { 1965 SSL_COMP *ctmp; 1966 int i, nn; 1967 1968 if ((n == 0) || (sk == NULL)) 1969 return NULL; 1970 nn = sk_SSL_COMP_num(sk); 1971 for (i = 0; i < nn; i++) { 1972 ctmp = sk_SSL_COMP_value(sk, i); 1973 if (ctmp->id == n) 1974 return ctmp; 1975 } 1976 return NULL; 1977 } 1978 1979 #ifdef OPENSSL_NO_COMP 1980 STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void) 1981 { 1982 return NULL; 1983 } 1984 1985 STACK_OF(SSL_COMP) *SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP) 1986 *meths) 1987 { 1988 return meths; 1989 } 1990 1991 int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm) 1992 { 1993 return 1; 1994 } 1995 1996 #else 1997 STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void) 1998 { 1999 load_builtin_compressions(); 2000 return ssl_comp_methods; 2001 } 2002 2003 STACK_OF(SSL_COMP) *SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP) 2004 *meths) 2005 { 2006 STACK_OF(SSL_COMP) *old_meths = ssl_comp_methods; 2007 ssl_comp_methods = meths; 2008 return old_meths; 2009 } 2010 2011 static void cmeth_free(SSL_COMP *cm) 2012 { 2013 OPENSSL_free(cm); 2014 } 2015 2016 void ssl_comp_free_compression_methods_int(void) 2017 { 2018 STACK_OF(SSL_COMP) *old_meths = ssl_comp_methods; 2019 ssl_comp_methods = NULL; 2020 sk_SSL_COMP_pop_free(old_meths, cmeth_free); 2021 } 2022 2023 int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm) 2024 { 2025 SSL_COMP *comp; 2026 2027 if (cm == NULL || COMP_get_type(cm) == NID_undef) 2028 return 1; 2029 2030 /*- 2031 * According to draft-ietf-tls-compression-04.txt, the 2032 * compression number ranges should be the following: 2033 * 2034 * 0 to 63: methods defined by the IETF 2035 * 64 to 192: external party methods assigned by IANA 2036 * 193 to 255: reserved for private use 2037 */ 2038 if (id < 193 || id > 255) { 2039 ERR_raise(ERR_LIB_SSL, SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE); 2040 return 1; 2041 } 2042 2043 comp = OPENSSL_malloc(sizeof(*comp)); 2044 if (comp == NULL) { 2045 ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE); 2046 return 1; 2047 } 2048 2049 comp->id = id; 2050 comp->method = cm; 2051 load_builtin_compressions(); 2052 if (ssl_comp_methods && sk_SSL_COMP_find(ssl_comp_methods, comp) >= 0) { 2053 OPENSSL_free(comp); 2054 ERR_raise(ERR_LIB_SSL, SSL_R_DUPLICATE_COMPRESSION_ID); 2055 return 1; 2056 } 2057 if (ssl_comp_methods == NULL || !sk_SSL_COMP_push(ssl_comp_methods, comp)) { 2058 OPENSSL_free(comp); 2059 ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE); 2060 return 1; 2061 } 2062 return 0; 2063 } 2064 #endif 2065 2066 const char *SSL_COMP_get_name(const COMP_METHOD *comp) 2067 { 2068 #ifndef OPENSSL_NO_COMP 2069 return comp ? COMP_get_name(comp) : NULL; 2070 #else 2071 return NULL; 2072 #endif 2073 } 2074 2075 const char *SSL_COMP_get0_name(const SSL_COMP *comp) 2076 { 2077 #ifndef OPENSSL_NO_COMP 2078 return comp->name; 2079 #else 2080 return NULL; 2081 #endif 2082 } 2083 2084 int SSL_COMP_get_id(const SSL_COMP *comp) 2085 { 2086 #ifndef OPENSSL_NO_COMP 2087 return comp->id; 2088 #else 2089 return -1; 2090 #endif 2091 } 2092 2093 const SSL_CIPHER *ssl_get_cipher_by_char(SSL *ssl, const unsigned char *ptr, 2094 int all) 2095 { 2096 const SSL_CIPHER *c = ssl->method->get_cipher_by_char(ptr); 2097 2098 if (c == NULL || (!all && c->valid == 0)) 2099 return NULL; 2100 return c; 2101 } 2102 2103 const SSL_CIPHER *SSL_CIPHER_find(SSL *ssl, const unsigned char *ptr) 2104 { 2105 return ssl->method->get_cipher_by_char(ptr); 2106 } 2107 2108 int SSL_CIPHER_get_cipher_nid(const SSL_CIPHER *c) 2109 { 2110 int i; 2111 if (c == NULL) 2112 return NID_undef; 2113 i = ssl_cipher_info_lookup(ssl_cipher_table_cipher, c->algorithm_enc); 2114 if (i == -1) 2115 return NID_undef; 2116 return ssl_cipher_table_cipher[i].nid; 2117 } 2118 2119 int SSL_CIPHER_get_digest_nid(const SSL_CIPHER *c) 2120 { 2121 int i = ssl_cipher_info_lookup(ssl_cipher_table_mac, c->algorithm_mac); 2122 2123 if (i == -1) 2124 return NID_undef; 2125 return ssl_cipher_table_mac[i].nid; 2126 } 2127 2128 int SSL_CIPHER_get_kx_nid(const SSL_CIPHER *c) 2129 { 2130 int i = ssl_cipher_info_lookup(ssl_cipher_table_kx, c->algorithm_mkey); 2131 2132 if (i == -1) 2133 return NID_undef; 2134 return ssl_cipher_table_kx[i].nid; 2135 } 2136 2137 int SSL_CIPHER_get_auth_nid(const SSL_CIPHER *c) 2138 { 2139 int i = ssl_cipher_info_lookup(ssl_cipher_table_auth, c->algorithm_auth); 2140 2141 if (i == -1) 2142 return NID_undef; 2143 return ssl_cipher_table_auth[i].nid; 2144 } 2145 2146 const EVP_MD *SSL_CIPHER_get_handshake_digest(const SSL_CIPHER *c) 2147 { 2148 int idx = c->algorithm2 & SSL_HANDSHAKE_MAC_MASK; 2149 2150 if (idx < 0 || idx >= SSL_MD_NUM_IDX) 2151 return NULL; 2152 return EVP_get_digestbynid(ssl_cipher_table_mac[idx].nid); 2153 } 2154 2155 int SSL_CIPHER_is_aead(const SSL_CIPHER *c) 2156 { 2157 return (c->algorithm_mac & SSL_AEAD) ? 1 : 0; 2158 } 2159 2160 int ssl_cipher_get_overhead(const SSL_CIPHER *c, size_t *mac_overhead, 2161 size_t *int_overhead, size_t *blocksize, 2162 size_t *ext_overhead) 2163 { 2164 size_t mac = 0, in = 0, blk = 0, out = 0; 2165 2166 /* Some hard-coded numbers for the CCM/Poly1305 MAC overhead 2167 * because there are no handy #defines for those. */ 2168 if (c->algorithm_enc & (SSL_AESGCM | SSL_ARIAGCM)) { 2169 out = EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN; 2170 } else if (c->algorithm_enc & (SSL_AES128CCM | SSL_AES256CCM)) { 2171 out = EVP_CCM_TLS_EXPLICIT_IV_LEN + 16; 2172 } else if (c->algorithm_enc & (SSL_AES128CCM8 | SSL_AES256CCM8)) { 2173 out = EVP_CCM_TLS_EXPLICIT_IV_LEN + 8; 2174 } else if (c->algorithm_enc & SSL_CHACHA20POLY1305) { 2175 out = 16; 2176 } else if (c->algorithm_mac & SSL_AEAD) { 2177 /* We're supposed to have handled all the AEAD modes above */ 2178 return 0; 2179 } else { 2180 /* Non-AEAD modes. Calculate MAC/cipher overhead separately */ 2181 int digest_nid = SSL_CIPHER_get_digest_nid(c); 2182 const EVP_MD *e_md = EVP_get_digestbynid(digest_nid); 2183 2184 if (e_md == NULL) 2185 return 0; 2186 2187 mac = EVP_MD_get_size(e_md); 2188 if (c->algorithm_enc != SSL_eNULL) { 2189 int cipher_nid = SSL_CIPHER_get_cipher_nid(c); 2190 const EVP_CIPHER *e_ciph = EVP_get_cipherbynid(cipher_nid); 2191 2192 /* If it wasn't AEAD or SSL_eNULL, we expect it to be a 2193 known CBC cipher. */ 2194 if (e_ciph == NULL || 2195 EVP_CIPHER_get_mode(e_ciph) != EVP_CIPH_CBC_MODE) 2196 return 0; 2197 2198 in = 1; /* padding length byte */ 2199 out = EVP_CIPHER_get_iv_length(e_ciph); 2200 blk = EVP_CIPHER_get_block_size(e_ciph); 2201 } 2202 } 2203 2204 *mac_overhead = mac; 2205 *int_overhead = in; 2206 *blocksize = blk; 2207 *ext_overhead = out; 2208 2209 return 1; 2210 } 2211 2212 int ssl_cert_is_disabled(SSL_CTX *ctx, size_t idx) 2213 { 2214 const SSL_CERT_LOOKUP *cl = ssl_cert_lookup_by_idx(idx); 2215 2216 if (cl == NULL || (cl->amask & ctx->disabled_auth_mask) != 0) 2217 return 1; 2218 return 0; 2219 } 2220 2221 /* 2222 * Default list of TLSv1.2 (and earlier) ciphers 2223 * SSL_DEFAULT_CIPHER_LIST deprecated in 3.0.0 2224 * Update both macro and function simultaneously 2225 */ 2226 const char *OSSL_default_cipher_list(void) 2227 { 2228 return "ALL:!COMPLEMENTOFDEFAULT:!eNULL"; 2229 } 2230 2231 /* 2232 * Default list of TLSv1.3 (and later) ciphers 2233 * TLS_DEFAULT_CIPHERSUITES deprecated in 3.0.0 2234 * Update both macro and function simultaneously 2235 */ 2236 const char *OSSL_default_ciphersuites(void) 2237 { 2238 return "TLS_AES_256_GCM_SHA384:" 2239 "TLS_CHACHA20_POLY1305_SHA256:" 2240 "TLS_AES_128_GCM_SHA256"; 2241 } 2242