| OLD | NEW |
|---|
| (Empty) | |
| 1 /* ssl/ssl_ciph.c */ |
| 2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) |
| 3 * All rights reserved. |
| 4 * |
| 5 * This package is an SSL implementation written |
| 6 * by Eric Young (eay@cryptsoft.com). |
| 7 * The implementation was written so as to conform with Netscapes SSL. |
| 8 * |
| 9 * This library is free for commercial and non-commercial use as long as |
| 10 * the following conditions are aheared to. The following conditions |
| 11 * apply to all code found in this distribution, be it the RC4, RSA, |
| 12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation |
| 13 * included with this distribution is covered by the same copyright terms |
| 14 * except that the holder is Tim Hudson (tjh@cryptsoft.com). |
| 15 * |
| 16 * Copyright remains Eric Young's, and as such any Copyright notices in |
| 17 * the code are not to be removed. |
| 18 * If this package is used in a product, Eric Young should be given attribution |
| 19 * as the author of the parts of the library used. |
| 20 * This can be in the form of a textual message at program startup or |
| 21 * in documentation (online or textual) provided with the package. |
| 22 * |
| 23 * Redistribution and use in source and binary forms, with or without |
| 24 * modification, are permitted provided that the following conditions |
| 25 * are met: |
| 26 * 1. Redistributions of source code must retain the copyright |
| 27 * notice, this list of conditions and the following disclaimer. |
| 28 * 2. Redistributions in binary form must reproduce the above copyright |
| 29 * notice, this list of conditions and the following disclaimer in the |
| 30 * documentation and/or other materials provided with the distribution. |
| 31 * 3. All advertising materials mentioning features or use of this software |
| 32 * must display the following acknowledgement: |
| 33 * "This product includes cryptographic software written by |
| 34 * Eric Young (eay@cryptsoft.com)" |
| 35 * The word 'cryptographic' can be left out if the rouines from the library |
| 36 * being used are not cryptographic related :-). |
| 37 * 4. If you include any Windows specific code (or a derivative thereof) from |
| 38 * the apps directory (application code) you must include an acknowledgement: |
| 39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
| 40 * |
| 41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
| 42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
| 45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| 46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| 47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| 49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| 50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 51 * SUCH DAMAGE. |
| 52 * |
| 53 * The licence and distribution terms for any publically available version or |
| 54 * derivative of this code cannot be changed. i.e. this code cannot simply be |
| 55 * copied and put under another distribution licence |
| 56 * [including the GNU Public Licence.] |
| 57 */ |
| 58 /* ==================================================================== |
| 59 * Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved. |
| 60 * |
| 61 * Redistribution and use in source and binary forms, with or without |
| 62 * modification, are permitted provided that the following conditions |
| 63 * are met: |
| 64 * |
| 65 * 1. Redistributions of source code must retain the above copyright |
| 66 * notice, this list of conditions and the following disclaimer. |
| 67 * |
| 68 * 2. Redistributions in binary form must reproduce the above copyright |
| 69 * notice, this list of conditions and the following disclaimer in |
| 70 * the documentation and/or other materials provided with the |
| 71 * distribution. |
| 72 * |
| 73 * 3. All advertising materials mentioning features or use of this |
| 74 * software must display the following acknowledgment: |
| 75 * "This product includes software developed by the OpenSSL Project |
| 76 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" |
| 77 * |
| 78 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to |
| 79 * endorse or promote products derived from this software without |
| 80 * prior written permission. For written permission, please contact |
| 81 * openssl-core@openssl.org. |
| 82 * |
| 83 * 5. Products derived from this software may not be called "OpenSSL" |
| 84 * nor may "OpenSSL" appear in their names without prior written |
| 85 * permission of the OpenSSL Project. |
| 86 * |
| 87 * 6. Redistributions of any form whatsoever must retain the following |
| 88 * acknowledgment: |
| 89 * "This product includes software developed by the OpenSSL Project |
| 90 * for use in the OpenSSL Toolkit (http://www.openssl.org/)" |
| 91 * |
| 92 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY |
| 93 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 94 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| 95 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR |
| 96 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 97 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| 98 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| 99 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 100 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
| 101 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| 102 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
| 103 * OF THE POSSIBILITY OF SUCH DAMAGE. |
| 104 * ==================================================================== |
| 105 * |
| 106 * This product includes cryptographic software written by Eric Young |
| 107 * (eay@cryptsoft.com). This product includes software written by Tim |
| 108 * Hudson (tjh@cryptsoft.com). |
| 109 * |
| 110 */ |
| 111 /* ==================================================================== |
| 112 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. |
| 113 * ECC cipher suite support in OpenSSL originally developed by |
| 114 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. |
| 115 */ |
| 116 /* ==================================================================== |
| 117 * Copyright 2005 Nokia. All rights reserved. |
| 118 * |
| 119 * The portions of the attached software ("Contribution") is developed by |
| 120 * Nokia Corporation and is licensed pursuant to the OpenSSL open source |
| 121 * license. |
| 122 * |
| 123 * The Contribution, originally written by Mika Kousa and Pasi Eronen of |
| 124 * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites |
| 125 * support (see RFC 4279) to OpenSSL. |
| 126 * |
| 127 * No patent licenses or other rights except those expressly stated in |
| 128 * the OpenSSL open source license shall be deemed granted or received |
| 129 * expressly, by implication, estoppel, or otherwise. |
| 130 * |
| 131 * No assurances are provided by Nokia that the Contribution does not |
| 132 * infringe the patent or other intellectual property rights of any third |
| 133 * party or that the license provides you with all the necessary rights |
| 134 * to make use of the Contribution. |
| 135 * |
| 136 * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN |
| 137 * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA |
| 138 * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY |
| 139 * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR |
| 140 * OTHERWISE. |
| 141 */ |
| 142 |
| 143 #include <stdio.h> |
| 144 #include <openssl/objects.h> |
| 145 #ifndef OPENSSL_NO_COMP |
| 146 #include <openssl/comp.h> |
| 147 #endif |
| 148 #ifndef OPENSSL_NO_ENGINE |
| 149 #include <openssl/engine.h> |
| 150 #endif |
| 151 #include "ssl_locl.h" |
| 152 |
| 153 #define SSL_ENC_DES_IDX 0 |
| 154 #define SSL_ENC_3DES_IDX 1 |
| 155 #define SSL_ENC_RC4_IDX 2 |
| 156 #define SSL_ENC_RC2_IDX 3 |
| 157 #define SSL_ENC_IDEA_IDX 4 |
| 158 #define SSL_ENC_NULL_IDX 5 |
| 159 #define SSL_ENC_AES128_IDX 6 |
| 160 #define SSL_ENC_AES256_IDX 7 |
| 161 #define SSL_ENC_CAMELLIA128_IDX 8 |
| 162 #define SSL_ENC_CAMELLIA256_IDX 9 |
| 163 #define SSL_ENC_GOST89_IDX 10 |
| 164 #define SSL_ENC_SEED_IDX 11 |
| 165 #define SSL_ENC_NUM_IDX 12 |
| 166 |
| 167 |
| 168 static const EVP_CIPHER *ssl_cipher_methods[SSL_ENC_NUM_IDX]={ |
| 169 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, |
| 170 }; |
| 171 |
| 172 #define SSL_COMP_NULL_IDX 0 |
| 173 #define SSL_COMP_ZLIB_IDX 1 |
| 174 #define SSL_COMP_NUM_IDX 2 |
| 175 |
| 176 static STACK_OF(SSL_COMP) *ssl_comp_methods=NULL; |
| 177 |
| 178 #define SSL_MD_MD5_IDX 0 |
| 179 #define SSL_MD_SHA1_IDX 1 |
| 180 #define SSL_MD_GOST94_IDX 2 |
| 181 #define SSL_MD_GOST89MAC_IDX 3 |
| 182 /*Constant SSL_MAX_DIGEST equal to size of digests array should be |
| 183 * defined in the |
| 184 * ssl_locl.h */ |
| 185 #define SSL_MD_NUM_IDX SSL_MAX_DIGEST |
| 186 static const EVP_MD *ssl_digest_methods[SSL_MD_NUM_IDX]={ |
| 187 NULL,NULL,NULL,NULL |
| 188 }; |
| 189 /* PKEY_TYPE for GOST89MAC is known in advance, but, because |
| 190 * implementation is engine-provided, we'll fill it only if |
| 191 * corresponding EVP_PKEY_METHOD is found |
| 192 */ |
| 193 static int ssl_mac_pkey_id[SSL_MD_NUM_IDX]={ |
| 194 EVP_PKEY_HMAC,EVP_PKEY_HMAC,EVP_PKEY_HMAC,NID_undef |
| 195 }; |
| 196 |
| 197 static int ssl_mac_secret_size[SSL_MD_NUM_IDX]={ |
| 198 0,0,0,0 |
| 199 }; |
| 200 |
| 201 static int ssl_handshake_digest_flag[SSL_MD_NUM_IDX]={ |
| 202 SSL_HANDSHAKE_MAC_MD5,SSL_HANDSHAKE_MAC_SHA, |
| 203 SSL_HANDSHAKE_MAC_GOST94,0 |
| 204 }; |
| 205 |
| 206 #define CIPHER_ADD 1 |
| 207 #define CIPHER_KILL 2 |
| 208 #define CIPHER_DEL 3 |
| 209 #define CIPHER_ORD 4 |
| 210 #define CIPHER_SPECIAL 5 |
| 211 |
| 212 typedef struct cipher_order_st |
| 213 { |
| 214 const SSL_CIPHER *cipher; |
| 215 int active; |
| 216 int dead; |
| 217 struct cipher_order_st *next,*prev; |
| 218 } CIPHER_ORDER; |
| 219 |
| 220 static const SSL_CIPHER cipher_aliases[]={ |
| 221 /* "ALL" doesn't include eNULL (must be specifically enabled) */ |
| 222 {0,SSL_TXT_ALL,0, 0,0,~SSL_eNULL,0,0,0,0,0,0}, |
| 223 /* "COMPLEMENTOFALL" */ |
| 224 {0,SSL_TXT_CMPALL,0, 0,0,SSL_eNULL,0,0,0,0,0,0}, |
| 225 |
| 226 /* "COMPLEMENTOFDEFAULT" (does *not* include ciphersuites not found in A
LL!) */ |
| 227 {0,SSL_TXT_CMPDEF,0, SSL_kEDH|SSL_kEECDH,SSL_aNULL,~SSL_eNULL,0,0,0,0,0
,0}, |
| 228 |
| 229 /* key exchange aliases |
| 230 * (some of those using only a single bit here combine |
| 231 * multiple key exchange algs according to the RFCs, |
| 232 * e.g. kEDH combines DHE_DSS and DHE_RSA) */ |
| 233 {0,SSL_TXT_kRSA,0, SSL_kRSA, 0,0,0,0,0,0,0,0}, |
| 234 |
| 235 {0,SSL_TXT_kDHr,0, SSL_kDHr, 0,0,0,0,0,0,0,0}, /* no such ciphersuit
es supported! */ |
| 236 {0,SSL_TXT_kDHd,0, SSL_kDHd, 0,0,0,0,0,0,0,0}, /* no such ciphersuit
es supported! */ |
| 237 {0,SSL_TXT_kDH,0, SSL_kDHr|SSL_kDHd,0,0,0,0,0,0,0,0}, /* no such cip
hersuites supported! */ |
| 238 {0,SSL_TXT_kEDH,0, SSL_kEDH, 0,0,0,0,0,0,0,0}, |
| 239 {0,SSL_TXT_DH,0, SSL_kDHr|SSL_kDHd|SSL_kEDH,0,0,0,0,0,0,0,0}, |
| 240 |
| 241 {0,SSL_TXT_kKRB5,0, SSL_kKRB5, 0,0,0,0,0,0,0,0}, |
| 242 |
| 243 {0,SSL_TXT_kECDHr,0, SSL_kECDHr,0,0,0,0,0,0,0,0}, |
| 244 {0,SSL_TXT_kECDHe,0, SSL_kECDHe,0,0,0,0,0,0,0,0}, |
| 245 {0,SSL_TXT_kECDH,0, SSL_kECDHr|SSL_kECDHe,0,0,0,0,0,0,0,0}, |
| 246 {0,SSL_TXT_kEECDH,0, SSL_kEECDH,0,0,0,0,0,0,0,0}, |
| 247 {0,SSL_TXT_ECDH,0, SSL_kECDHr|SSL_kECDHe|SSL_kEECDH,0,0,0,0,0,0,0,0}, |
| 248 |
| 249 {0,SSL_TXT_kPSK,0, SSL_kPSK, 0,0,0,0,0,0,0,0}, |
| 250 {0,SSL_TXT_kGOST,0, SSL_kGOST,0,0,0,0,0,0,0,0}, |
| 251 |
| 252 /* server authentication aliases */ |
| 253 {0,SSL_TXT_aRSA,0, 0,SSL_aRSA, 0,0,0,0,0,0,0}, |
| 254 {0,SSL_TXT_aDSS,0, 0,SSL_aDSS, 0,0,0,0,0,0,0}, |
| 255 {0,SSL_TXT_DSS,0, 0,SSL_aDSS, 0,0,0,0,0,0,0}, |
| 256 {0,SSL_TXT_aKRB5,0, 0,SSL_aKRB5, 0,0,0,0,0,0,0}, |
| 257 {0,SSL_TXT_aNULL,0, 0,SSL_aNULL, 0,0,0,0,0,0,0}, |
| 258 {0,SSL_TXT_aDH,0, 0,SSL_aDH, 0,0,0,0,0,0,0}, /* no such ciphersuit
es supported! */ |
| 259 {0,SSL_TXT_aECDH,0, 0,SSL_aECDH, 0,0,0,0,0,0,0}, |
| 260 {0,SSL_TXT_aECDSA,0, 0,SSL_aECDSA,0,0,0,0,0,0,0}, |
| 261 {0,SSL_TXT_ECDSA,0, 0,SSL_aECDSA, 0,0,0,0,0,0,0}, |
| 262 {0,SSL_TXT_aPSK,0, 0,SSL_aPSK, 0,0,0,0,0,0,0}, |
| 263 {0,SSL_TXT_aGOST94,0,0,SSL_aGOST94,0,0,0,0,0,0,0}, |
| 264 {0,SSL_TXT_aGOST01,0,0,SSL_aGOST01,0,0,0,0,0,0,0}, |
| 265 {0,SSL_TXT_aGOST,0,0,SSL_aGOST94|SSL_aGOST01,0,0,0,0,0,0,0}, |
| 266 |
| 267 /* aliases combining key exchange and server authentication */ |
| 268 {0,SSL_TXT_EDH,0, SSL_kEDH,~SSL_aNULL,0,0,0,0,0,0,0}, |
| 269 {0,SSL_TXT_EECDH,0, SSL_kEECDH,~SSL_aNULL,0,0,0,0,0,0,0}, |
| 270 {0,SSL_TXT_NULL,0, 0,0,SSL_eNULL, 0,0,0,0,0,0}, |
| 271 {0,SSL_TXT_KRB5,0, SSL_kKRB5,SSL_aKRB5,0,0,0,0,0,0,0}, |
| 272 {0,SSL_TXT_RSA,0, SSL_kRSA,SSL_aRSA,0,0,0,0,0,0,0}, |
| 273 {0,SSL_TXT_ADH,0, SSL_kEDH,SSL_aNULL,0,0,0,0,0,0,0}, |
| 274 {0,SSL_TXT_AECDH,0, SSL_kEECDH,SSL_aNULL,0,0,0,0,0,0,0}, |
| 275 {0,SSL_TXT_PSK,0, SSL_kPSK,SSL_aPSK,0,0,0,0,0,0,0}, |
| 276 |
| 277 |
| 278 /* symmetric encryption aliases */ |
| 279 {0,SSL_TXT_DES,0, 0,0,SSL_DES, 0,0,0,0,0,0}, |
| 280 {0,SSL_TXT_3DES,0, 0,0,SSL_3DES, 0,0,0,0,0,0}, |
| 281 {0,SSL_TXT_RC4,0, 0,0,SSL_RC4, 0,0,0,0,0,0}, |
| 282 {0,SSL_TXT_RC2,0, 0,0,SSL_RC2, 0,0,0,0,0,0}, |
| 283 {0,SSL_TXT_IDEA,0, 0,0,SSL_IDEA, 0,0,0,0,0,0}, |
| 284 {0,SSL_TXT_SEED,0, 0,0,SSL_SEED, 0,0,0,0,0,0}, |
| 285 {0,SSL_TXT_eNULL,0, 0,0,SSL_eNULL, 0,0,0,0,0,0}, |
| 286 {0,SSL_TXT_AES128,0, 0,0,SSL_AES128,0,0,0,0,0,0}, |
| 287 {0,SSL_TXT_AES256,0, 0,0,SSL_AES256,0,0,0,0,0,0}, |
| 288 {0,SSL_TXT_AES,0, 0,0,SSL_AES128|SSL_AES256,0,0,0,0,0,0}, |
| 289 {0,SSL_TXT_CAMELLIA128,0,0,0,SSL_CAMELLIA128,0,0,0,0,0,0}, |
| 290 {0,SSL_TXT_CAMELLIA256,0,0,0,SSL_CAMELLIA256,0,0,0,0,0,0}, |
| 291 {0,SSL_TXT_CAMELLIA ,0,0,0,SSL_CAMELLIA128|SSL_CAMELLIA256,0,0,0,0,0,0
}, |
| 292 |
| 293 /* MAC aliases */ |
| 294 {0,SSL_TXT_MD5,0, 0,0,0,SSL_MD5, 0,0,0,0,0}, |
| 295 {0,SSL_TXT_SHA1,0, 0,0,0,SSL_SHA1, 0,0,0,0,0}, |
| 296 {0,SSL_TXT_SHA,0, 0,0,0,SSL_SHA1, 0,0,0,0,0}, |
| 297 {0,SSL_TXT_GOST94,0, 0,0,0,SSL_GOST94, 0,0,0,0,0}, |
| 298 {0,SSL_TXT_GOST89MAC,0, 0,0,0,SSL_GOST89MAC, 0,0,0,0,0}, |
| 299 |
| 300 /* protocol version aliases */ |
| 301 {0,SSL_TXT_SSLV2,0, 0,0,0,0,SSL_SSLV2, 0,0,0,0}, |
| 302 {0,SSL_TXT_SSLV3,0, 0,0,0,0,SSL_SSLV3, 0,0,0,0}, |
| 303 {0,SSL_TXT_TLSV1,0, 0,0,0,0,SSL_TLSV1, 0,0,0,0}, |
| 304 |
| 305 /* export flag */ |
| 306 {0,SSL_TXT_EXP,0, 0,0,0,0,0,SSL_EXPORT,0,0,0}, |
| 307 {0,SSL_TXT_EXPORT,0, 0,0,0,0,0,SSL_EXPORT,0,0,0}, |
| 308 |
| 309 /* strength classes */ |
| 310 {0,SSL_TXT_EXP40,0, 0,0,0,0,0,SSL_EXP40, 0,0,0}, |
| 311 {0,SSL_TXT_EXP56,0, 0,0,0,0,0,SSL_EXP56, 0,0,0}, |
| 312 {0,SSL_TXT_LOW,0, 0,0,0,0,0,SSL_LOW, 0,0,0}, |
| 313 {0,SSL_TXT_MEDIUM,0, 0,0,0,0,0,SSL_MEDIUM,0,0,0}, |
| 314 {0,SSL_TXT_HIGH,0, 0,0,0,0,0,SSL_HIGH, 0,0,0}, |
| 315 /* FIPS 140-2 approved ciphersuite */ |
| 316 {0,SSL_TXT_FIPS,0, 0,0,~SSL_eNULL,0,0,SSL_FIPS, 0,0,0}, |
| 317 }; |
| 318 /* Search for public key algorithm with given name and |
| 319 * return its pkey_id if it is available. Otherwise return 0 |
| 320 */ |
| 321 #ifdef OPENSSL_NO_ENGINE |
| 322 |
| 323 static int get_optional_pkey_id(const char *pkey_name) |
| 324 { |
| 325 const EVP_PKEY_ASN1_METHOD *ameth; |
| 326 int pkey_id=0; |
| 327 ameth = EVP_PKEY_asn1_find_str(NULL,pkey_name,-1); |
| 328 if (ameth) |
| 329 { |
| 330 EVP_PKEY_asn1_get0_info(&pkey_id, NULL,NULL,NULL,NULL,ameth); |
| 331 } |
| 332 return pkey_id; |
| 333 } |
| 334 |
| 335 #else |
| 336 |
| 337 static int get_optional_pkey_id(const char *pkey_name) |
| 338 { |
| 339 const EVP_PKEY_ASN1_METHOD *ameth; |
| 340 ENGINE *tmpeng = NULL; |
| 341 int pkey_id=0; |
| 342 ameth = EVP_PKEY_asn1_find_str(&tmpeng,pkey_name,-1); |
| 343 if (ameth) |
| 344 { |
| 345 EVP_PKEY_asn1_get0_info(&pkey_id, NULL,NULL,NULL,NULL,ameth); |
| 346 } |
| 347 if (tmpeng) ENGINE_finish(tmpeng); |
| 348 return pkey_id; |
| 349 } |
| 350 |
| 351 #endif |
| 352 |
| 353 void ssl_load_ciphers(void) |
| 354 { |
| 355 ssl_cipher_methods[SSL_ENC_DES_IDX]= |
| 356 EVP_get_cipherbyname(SN_des_cbc); |
| 357 ssl_cipher_methods[SSL_ENC_3DES_IDX]= |
| 358 EVP_get_cipherbyname(SN_des_ede3_cbc); |
| 359 ssl_cipher_methods[SSL_ENC_RC4_IDX]= |
| 360 EVP_get_cipherbyname(SN_rc4); |
| 361 ssl_cipher_methods[SSL_ENC_RC2_IDX]= |
| 362 EVP_get_cipherbyname(SN_rc2_cbc); |
| 363 #ifndef OPENSSL_NO_IDEA |
| 364 ssl_cipher_methods[SSL_ENC_IDEA_IDX]= |
| 365 EVP_get_cipherbyname(SN_idea_cbc); |
| 366 #else |
| 367 ssl_cipher_methods[SSL_ENC_IDEA_IDX]= NULL; |
| 368 #endif |
| 369 ssl_cipher_methods[SSL_ENC_AES128_IDX]= |
| 370 EVP_get_cipherbyname(SN_aes_128_cbc); |
| 371 ssl_cipher_methods[SSL_ENC_AES256_IDX]= |
| 372 EVP_get_cipherbyname(SN_aes_256_cbc); |
| 373 ssl_cipher_methods[SSL_ENC_CAMELLIA128_IDX]= |
| 374 EVP_get_cipherbyname(SN_camellia_128_cbc); |
| 375 ssl_cipher_methods[SSL_ENC_CAMELLIA256_IDX]= |
| 376 EVP_get_cipherbyname(SN_camellia_256_cbc); |
| 377 ssl_cipher_methods[SSL_ENC_GOST89_IDX]= |
| 378 EVP_get_cipherbyname(SN_gost89_cnt); |
| 379 ssl_cipher_methods[SSL_ENC_SEED_IDX]= |
| 380 EVP_get_cipherbyname(SN_seed_cbc); |
| 381 |
| 382 ssl_digest_methods[SSL_MD_MD5_IDX]= |
| 383 EVP_get_digestbyname(SN_md5); |
| 384 ssl_mac_secret_size[SSL_MD_MD5_IDX]= |
| 385 EVP_MD_size(ssl_digest_methods[SSL_MD_MD5_IDX]); |
| 386 OPENSSL_assert(ssl_mac_secret_size[SSL_MD_MD5_IDX] >= 0); |
| 387 ssl_digest_methods[SSL_MD_SHA1_IDX]= |
| 388 EVP_get_digestbyname(SN_sha1); |
| 389 ssl_mac_secret_size[SSL_MD_SHA1_IDX]= |
| 390 EVP_MD_size(ssl_digest_methods[SSL_MD_SHA1_IDX]); |
| 391 OPENSSL_assert(ssl_mac_secret_size[SSL_MD_SHA1_IDX] >= 0); |
| 392 ssl_digest_methods[SSL_MD_GOST94_IDX]= |
| 393 EVP_get_digestbyname(SN_id_GostR3411_94); |
| 394 if (ssl_digest_methods[SSL_MD_GOST94_IDX]) |
| 395 { |
| 396 ssl_mac_secret_size[SSL_MD_GOST94_IDX]= |
| 397 EVP_MD_size(ssl_digest_methods[SSL_MD_GOST94_IDX]); |
| 398 OPENSSL_assert(ssl_mac_secret_size[SSL_MD_GOST94_IDX] >= 0); |
| 399 } |
| 400 ssl_digest_methods[SSL_MD_GOST89MAC_IDX]= |
| 401 EVP_get_digestbyname(SN_id_Gost28147_89_MAC); |
| 402 ssl_mac_pkey_id[SSL_MD_GOST89MAC_IDX] = get_optional_pkey_id("go
st-mac"); |
| 403 if (ssl_mac_pkey_id[SSL_MD_GOST89MAC_IDX]) { |
| 404 ssl_mac_secret_size[SSL_MD_GOST89MAC_IDX]=32; |
| 405 } |
| 406 |
| 407 } |
| 408 #ifndef OPENSSL_NO_COMP |
| 409 |
| 410 static int sk_comp_cmp(const SSL_COMP * const *a, |
| 411 const SSL_COMP * const *b) |
| 412 { |
| 413 return((*a)->id-(*b)->id); |
| 414 } |
| 415 |
| 416 static void load_builtin_compressions(void) |
| 417 { |
| 418 int got_write_lock = 0; |
| 419 |
| 420 CRYPTO_r_lock(CRYPTO_LOCK_SSL); |
| 421 if (ssl_comp_methods == NULL) |
| 422 { |
| 423 CRYPTO_r_unlock(CRYPTO_LOCK_SSL); |
| 424 CRYPTO_w_lock(CRYPTO_LOCK_SSL); |
| 425 got_write_lock = 1; |
| 426 |
| 427 if (ssl_comp_methods == NULL) |
| 428 { |
| 429 SSL_COMP *comp = NULL; |
| 430 |
| 431 MemCheck_off(); |
| 432 ssl_comp_methods=sk_SSL_COMP_new(sk_comp_cmp); |
| 433 if (ssl_comp_methods != NULL) |
| 434 { |
| 435 comp=(SSL_COMP *)OPENSSL_malloc(sizeof(SSL_COMP)
); |
| 436 if (comp != NULL) |
| 437 { |
| 438 comp->method=COMP_zlib(); |
| 439 if (comp->method |
| 440 && comp->method->type == NID_und
ef) |
| 441 OPENSSL_free(comp); |
| 442 else |
| 443 { |
| 444 comp->id=SSL_COMP_ZLIB_IDX; |
| 445 comp->name=comp->method->name; |
| 446 sk_SSL_COMP_push(ssl_comp_method
s,comp); |
| 447 } |
| 448 } |
| 449 sk_SSL_COMP_sort(ssl_comp_methods); |
| 450 } |
| 451 MemCheck_on(); |
| 452 } |
| 453 } |
| 454 |
| 455 if (got_write_lock) |
| 456 CRYPTO_w_unlock(CRYPTO_LOCK_SSL); |
| 457 else |
| 458 CRYPTO_r_unlock(CRYPTO_LOCK_SSL); |
| 459 } |
| 460 #endif |
| 461 |
| 462 int ssl_cipher_get_evp(const SSL_SESSION *s, const EVP_CIPHER **enc, |
| 463 const EVP_MD **md, int *mac_pkey_type, int *mac_secret_size,SSL_COM
P **comp) |
| 464 { |
| 465 int i; |
| 466 const SSL_CIPHER *c; |
| 467 |
| 468 c=s->cipher; |
| 469 if (c == NULL) return(0); |
| 470 if (comp != NULL) |
| 471 { |
| 472 SSL_COMP ctmp; |
| 473 #ifndef OPENSSL_NO_COMP |
| 474 load_builtin_compressions(); |
| 475 #endif |
| 476 |
| 477 *comp=NULL; |
| 478 ctmp.id=s->compress_meth; |
| 479 if (ssl_comp_methods != NULL) |
| 480 { |
| 481 i=sk_SSL_COMP_find(ssl_comp_methods,&ctmp); |
| 482 if (i >= 0) |
| 483 *comp=sk_SSL_COMP_value(ssl_comp_methods,i); |
| 484 else |
| 485 *comp=NULL; |
| 486 } |
| 487 } |
| 488 |
| 489 if ((enc == NULL) || (md == NULL)) return(0); |
| 490 |
| 491 switch (c->algorithm_enc) |
| 492 { |
| 493 case SSL_DES: |
| 494 i=SSL_ENC_DES_IDX; |
| 495 break; |
| 496 case SSL_3DES: |
| 497 i=SSL_ENC_3DES_IDX; |
| 498 break; |
| 499 case SSL_RC4: |
| 500 i=SSL_ENC_RC4_IDX; |
| 501 break; |
| 502 case SSL_RC2: |
| 503 i=SSL_ENC_RC2_IDX; |
| 504 break; |
| 505 case SSL_IDEA: |
| 506 i=SSL_ENC_IDEA_IDX; |
| 507 break; |
| 508 case SSL_eNULL: |
| 509 i=SSL_ENC_NULL_IDX; |
| 510 break; |
| 511 case SSL_AES128: |
| 512 i=SSL_ENC_AES128_IDX; |
| 513 break; |
| 514 case SSL_AES256: |
| 515 i=SSL_ENC_AES256_IDX; |
| 516 break; |
| 517 case SSL_CAMELLIA128: |
| 518 i=SSL_ENC_CAMELLIA128_IDX; |
| 519 break; |
| 520 case SSL_CAMELLIA256: |
| 521 i=SSL_ENC_CAMELLIA256_IDX; |
| 522 break; |
| 523 case SSL_eGOST2814789CNT: |
| 524 i=SSL_ENC_GOST89_IDX; |
| 525 break; |
| 526 case SSL_SEED: |
| 527 i=SSL_ENC_SEED_IDX; |
| 528 break; |
| 529 default: |
| 530 i= -1; |
| 531 break; |
| 532 } |
| 533 |
| 534 if ((i < 0) || (i > SSL_ENC_NUM_IDX)) |
| 535 *enc=NULL; |
| 536 else |
| 537 { |
| 538 if (i == SSL_ENC_NULL_IDX) |
| 539 *enc=EVP_enc_null(); |
| 540 else |
| 541 *enc=ssl_cipher_methods[i]; |
| 542 } |
| 543 |
| 544 switch (c->algorithm_mac) |
| 545 { |
| 546 case SSL_MD5: |
| 547 i=SSL_MD_MD5_IDX; |
| 548 break; |
| 549 case SSL_SHA1: |
| 550 i=SSL_MD_SHA1_IDX; |
| 551 break; |
| 552 case SSL_GOST94: |
| 553 i = SSL_MD_GOST94_IDX; |
| 554 break; |
| 555 case SSL_GOST89MAC: |
| 556 i = SSL_MD_GOST89MAC_IDX; |
| 557 break; |
| 558 default: |
| 559 i= -1; |
| 560 break; |
| 561 } |
| 562 if ((i < 0) || (i > SSL_MD_NUM_IDX)) |
| 563 { |
| 564 *md=NULL; |
| 565 if (mac_pkey_type!=NULL) *mac_pkey_type = NID_undef; |
| 566 if (mac_secret_size!=NULL) *mac_secret_size = 0; |
| 567 |
| 568 } |
| 569 else |
| 570 { |
| 571 *md=ssl_digest_methods[i]; |
| 572 if (mac_pkey_type!=NULL) *mac_pkey_type = ssl_mac_pkey_id[i]; |
| 573 if (mac_secret_size!=NULL) *mac_secret_size = ssl_mac_secret_siz
e[i]; |
| 574 } |
| 575 |
| 576 if ((*enc != NULL) && (*md != NULL) && (!mac_pkey_type||*mac_pkey_type !
= NID_undef)) |
| 577 return(1); |
| 578 else |
| 579 return(0); |
| 580 } |
| 581 |
| 582 int ssl_get_handshake_digest(int idx, long *mask, const EVP_MD **md) |
| 583 { |
| 584 if (idx <0||idx>=SSL_MD_NUM_IDX) |
| 585 { |
| 586 return 0; |
| 587 } |
| 588 if (ssl_handshake_digest_flag[idx]==0) return 0; |
| 589 *mask = ssl_handshake_digest_flag[idx]; |
| 590 *md = ssl_digest_methods[idx]; |
| 591 return 1; |
| 592 } |
| 593 |
| 594 #define ITEM_SEP(a) \ |
| 595 (((a) == ':') || ((a) == ' ') || ((a) == ';') || ((a) == ',')) |
| 596 |
| 597 static void ll_append_tail(CIPHER_ORDER **head, CIPHER_ORDER *curr, |
| 598 CIPHER_ORDER **tail) |
| 599 { |
| 600 if (curr == *tail) return; |
| 601 if (curr == *head) |
| 602 *head=curr->next; |
| 603 if (curr->prev != NULL) |
| 604 curr->prev->next=curr->next; |
| 605 if (curr->next != NULL) |
| 606 curr->next->prev=curr->prev; |
| 607 (*tail)->next=curr; |
| 608 curr->prev= *tail; |
| 609 curr->next=NULL; |
| 610 *tail=curr; |
| 611 } |
| 612 |
| 613 static void ll_append_head(CIPHER_ORDER **head, CIPHER_ORDER *curr, |
| 614 CIPHER_ORDER **tail) |
| 615 { |
| 616 if (curr == *head) return; |
| 617 if (curr == *tail) |
| 618 *tail=curr->prev; |
| 619 if (curr->next != NULL) |
| 620 curr->next->prev=curr->prev; |
| 621 if (curr->prev != NULL) |
| 622 curr->prev->next=curr->next; |
| 623 (*head)->prev=curr; |
| 624 curr->next= *head; |
| 625 curr->prev=NULL; |
| 626 *head=curr; |
| 627 } |
| 628 |
| 629 static void ssl_cipher_get_disabled(unsigned long *mkey, unsigned long *auth, un
signed long *enc, unsigned long *mac, unsigned long *ssl) |
| 630 { |
| 631 *mkey = 0; |
| 632 *auth = 0; |
| 633 *enc = 0; |
| 634 *mac = 0; |
| 635 *ssl = 0; |
| 636 |
| 637 #ifdef OPENSSL_NO_RSA |
| 638 *mkey |= SSL_kRSA; |
| 639 *auth |= SSL_aRSA; |
| 640 #endif |
| 641 #ifdef OPENSSL_NO_DSA |
| 642 *auth |= SSL_aDSS; |
| 643 #endif |
| 644 *mkey |= SSL_kDHr|SSL_kDHd; /* no such ciphersuites supported! */ |
| 645 *auth |= SSL_aDH; |
| 646 #ifdef OPENSSL_NO_DH |
| 647 *mkey |= SSL_kDHr|SSL_kDHd|SSL_kEDH; |
| 648 *auth |= SSL_aDH; |
| 649 #endif |
| 650 #ifdef OPENSSL_NO_KRB5 |
| 651 *mkey |= SSL_kKRB5; |
| 652 *auth |= SSL_aKRB5; |
| 653 #endif |
| 654 #ifdef OPENSSL_NO_ECDSA |
| 655 *auth |= SSL_aECDSA; |
| 656 #endif |
| 657 #ifdef OPENSSL_NO_ECDH |
| 658 *mkey |= SSL_kECDHe|SSL_kECDHr; |
| 659 *auth |= SSL_aECDH; |
| 660 #endif |
| 661 #ifdef OPENSSL_NO_PSK |
| 662 *mkey |= SSL_kPSK; |
| 663 *auth |= SSL_aPSK; |
| 664 #endif |
| 665 /* Check for presence of GOST 34.10 algorithms, and if they |
| 666 * do not present, disable appropriate auth and key exchange */ |
| 667 if (!get_optional_pkey_id("gost94")) { |
| 668 *auth |= SSL_aGOST94; |
| 669 } |
| 670 if (!get_optional_pkey_id("gost2001")) { |
| 671 *auth |= SSL_aGOST01; |
| 672 } |
| 673 /* Disable GOST key exchange if no GOST signature algs are available * *
/ |
| 674 if ((*auth & (SSL_aGOST94|SSL_aGOST01)) == (SSL_aGOST94|SSL_aGOST01)) { |
| 675 *mkey |= SSL_kGOST; |
| 676 } |
| 677 #ifdef SSL_FORBID_ENULL |
| 678 *enc |= SSL_eNULL; |
| 679 #endif |
| 680 |
| 681 |
| 682 |
| 683 *enc |= (ssl_cipher_methods[SSL_ENC_DES_IDX ] == NULL) ? SSL_DES :0; |
| 684 *enc |= (ssl_cipher_methods[SSL_ENC_3DES_IDX] == NULL) ? SSL_3DES:0; |
| 685 *enc |= (ssl_cipher_methods[SSL_ENC_RC4_IDX ] == NULL) ? SSL_RC4 :0; |
| 686 *enc |= (ssl_cipher_methods[SSL_ENC_RC2_IDX ] == NULL) ? SSL_RC2 :0; |
| 687 *enc |= (ssl_cipher_methods[SSL_ENC_IDEA_IDX] == NULL) ? SSL_IDEA:0; |
| 688 *enc |= (ssl_cipher_methods[SSL_ENC_AES128_IDX] == NULL) ? SSL_AES128:0; |
| 689 *enc |= (ssl_cipher_methods[SSL_ENC_AES256_IDX] == NULL) ? SSL_AES256:0; |
| 690 *enc |= (ssl_cipher_methods[SSL_ENC_CAMELLIA128_IDX] == NULL) ? SSL_CAME
LLIA128:0; |
| 691 *enc |= (ssl_cipher_methods[SSL_ENC_CAMELLIA256_IDX] == NULL) ? SSL_CAME
LLIA256:0; |
| 692 *enc |= (ssl_cipher_methods[SSL_ENC_GOST89_IDX] == NULL) ? SSL_eGOST2814
789CNT:0; |
| 693 *enc |= (ssl_cipher_methods[SSL_ENC_SEED_IDX] == NULL) ? SSL_SEED:0; |
| 694 |
| 695 *mac |= (ssl_digest_methods[SSL_MD_MD5_IDX ] == NULL) ? SSL_MD5 :0; |
| 696 *mac |= (ssl_digest_methods[SSL_MD_SHA1_IDX] == NULL) ? SSL_SHA1:0; |
| 697 *mac |= (ssl_digest_methods[SSL_MD_GOST94_IDX] == NULL) ? SSL_GOST94:0; |
| 698 *mac |= (ssl_digest_methods[SSL_MD_GOST89MAC_IDX] == NULL || ssl_mac_pke
y_id[SSL_MD_GOST89MAC_IDX]==NID_undef)? SSL_GOST89MAC:0; |
| 699 |
| 700 } |
| 701 |
| 702 static void ssl_cipher_collect_ciphers(const SSL_METHOD *ssl_method, |
| 703 int num_of_ciphers, |
| 704 unsigned long disabled_mkey, unsigned long disabled_auth, |
| 705 unsigned long disabled_enc, unsigned long disabled_mac, |
| 706 unsigned long disabled_ssl, |
| 707 CIPHER_ORDER *co_list, |
| 708 CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p) |
| 709 { |
| 710 int i, co_list_num; |
| 711 const SSL_CIPHER *c; |
| 712 |
| 713 /* |
| 714 * We have num_of_ciphers descriptions compiled in, depending on the |
| 715 * method selected (SSLv2 and/or SSLv3, TLSv1 etc). |
| 716 * These will later be sorted in a linked list with at most num |
| 717 * entries. |
| 718 */ |
| 719 |
| 720 /* Get the initial list of ciphers */ |
| 721 co_list_num = 0; /* actual count of ciphers */ |
| 722 for (i = 0; i < num_of_ciphers; i++) |
| 723 { |
| 724 c = ssl_method->get_cipher(i); |
| 725 /* drop those that use any of that is not available */ |
| 726 if ((c != NULL) && c->valid && |
| 727 !(c->algorithm_mkey & disabled_mkey) && |
| 728 !(c->algorithm_auth & disabled_auth) && |
| 729 !(c->algorithm_enc & disabled_enc) && |
| 730 !(c->algorithm_mac & disabled_mac) && |
| 731 !(c->algorithm_ssl & disabled_ssl)) |
| 732 { |
| 733 co_list[co_list_num].cipher = c; |
| 734 co_list[co_list_num].next = NULL; |
| 735 co_list[co_list_num].prev = NULL; |
| 736 co_list[co_list_num].active = 0; |
| 737 co_list_num++; |
| 738 #ifdef KSSL_DEBUG |
| 739 printf("\t%d: %s %lx %lx %lx\n",i,c->name,c->id,c->algor
ithm_mkey,c->algorithm_auth); |
| 740 #endif /* KSSL_DEBUG */ |
| 741 /* |
| 742 if (!sk_push(ca_list,(char *)c)) goto err; |
| 743 */ |
| 744 } |
| 745 } |
| 746 |
| 747 /* |
| 748 * Prepare linked list from list entries |
| 749 */ |
| 750 if (co_list_num > 0) |
| 751 { |
| 752 co_list[0].prev = NULL; |
| 753 |
| 754 if (co_list_num > 1) |
| 755 { |
| 756 co_list[0].next = &co_list[1]; |
| 757 |
| 758 for (i = 1; i < co_list_num - 1; i++) |
| 759 { |
| 760 co_list[i].prev = &co_list[i - 1]; |
| 761 co_list[i].next = &co_list[i + 1]; |
| 762 } |
| 763 |
| 764 co_list[co_list_num - 1].prev = &co_list[co_list_num - 2
]; |
| 765 } |
| 766 |
| 767 co_list[co_list_num - 1].next = NULL; |
| 768 |
| 769 *head_p = &co_list[0]; |
| 770 *tail_p = &co_list[co_list_num - 1]; |
| 771 } |
| 772 } |
| 773 |
| 774 static void ssl_cipher_collect_aliases(const SSL_CIPHER **ca_list, |
| 775 int num_of_group_aliases, |
| 776 unsigned long disabled_mkey, unsigned long disabled_auth
, |
| 777 unsigned long disabled_enc, unsigned long disabled_mac, |
| 778 unsigned long disabled_ssl, |
| 779 CIPHER_ORDER *head) |
| 780 { |
| 781 CIPHER_ORDER *ciph_curr; |
| 782 const SSL_CIPHER **ca_curr; |
| 783 int i; |
| 784 unsigned long mask_mkey = ~disabled_mkey; |
| 785 unsigned long mask_auth = ~disabled_auth; |
| 786 unsigned long mask_enc = ~disabled_enc; |
| 787 unsigned long mask_mac = ~disabled_mac; |
| 788 unsigned long mask_ssl = ~disabled_ssl; |
| 789 |
| 790 /* |
| 791 * First, add the real ciphers as already collected |
| 792 */ |
| 793 ciph_curr = head; |
| 794 ca_curr = ca_list; |
| 795 while (ciph_curr != NULL) |
| 796 { |
| 797 *ca_curr = ciph_curr->cipher; |
| 798 ca_curr++; |
| 799 ciph_curr = ciph_curr->next; |
| 800 } |
| 801 |
| 802 /* |
| 803 * Now we add the available ones from the cipher_aliases[] table. |
| 804 * They represent either one or more algorithms, some of which |
| 805 * in any affected category must be supported (set in enabled_mask), |
| 806 * or represent a cipher strength value (will be added in any case becau
se algorithms=0). |
| 807 */ |
| 808 for (i = 0; i < num_of_group_aliases; i++) |
| 809 { |
| 810 unsigned long algorithm_mkey = cipher_aliases[i].algorithm_mkey; |
| 811 unsigned long algorithm_auth = cipher_aliases[i].algorithm_auth; |
| 812 unsigned long algorithm_enc = cipher_aliases[i].algorithm_enc; |
| 813 unsigned long algorithm_mac = cipher_aliases[i].algorithm_mac; |
| 814 unsigned long algorithm_ssl = cipher_aliases[i].algorithm_ssl; |
| 815 |
| 816 if (algorithm_mkey) |
| 817 if ((algorithm_mkey & mask_mkey) == 0) |
| 818 continue; |
| 819 |
| 820 if (algorithm_auth) |
| 821 if ((algorithm_auth & mask_auth) == 0) |
| 822 continue; |
| 823 |
| 824 if (algorithm_enc) |
| 825 if ((algorithm_enc & mask_enc) == 0) |
| 826 continue; |
| 827 |
| 828 if (algorithm_mac) |
| 829 if ((algorithm_mac & mask_mac) == 0) |
| 830 continue; |
| 831 |
| 832 if (algorithm_ssl) |
| 833 if ((algorithm_ssl & mask_ssl) == 0) |
| 834 continue; |
| 835 |
| 836 *ca_curr = (SSL_CIPHER *)(cipher_aliases + i); |
| 837 ca_curr++; |
| 838 } |
| 839 |
| 840 *ca_curr = NULL; /* end of list */ |
| 841 } |
| 842 |
| 843 static void ssl_cipher_apply_rule(unsigned long cipher_id, |
| 844 unsigned long alg_mkey, unsigned long alg_auth, |
| 845 unsigned long alg_enc, unsigned long alg_mac, |
| 846 unsigned long alg_ssl, |
| 847 unsigned long algo_strength, |
| 848 int rule, int strength_bits, |
| 849 CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p) |
| 850 { |
| 851 CIPHER_ORDER *head, *tail, *curr, *curr2, *last; |
| 852 const SSL_CIPHER *cp; |
| 853 int reverse = 0; |
| 854 |
| 855 #ifdef CIPHER_DEBUG |
| 856 printf("Applying rule %d with %08lx/%08lx/%08lx/%08lx/%08lx %08lx (%d)\n
", |
| 857 rule, alg_mkey, alg_auth, alg_enc, alg_mac, alg_ssl, algo_streng
th, strength_bits); |
| 858 #endif |
| 859 |
| 860 if (rule == CIPHER_DEL) |
| 861 reverse = 1; /* needed to maintain sorting between currently del
eted ciphers */ |
| 862 |
| 863 head = *head_p; |
| 864 tail = *tail_p; |
| 865 |
| 866 if (reverse) |
| 867 { |
| 868 curr = tail; |
| 869 last = head; |
| 870 } |
| 871 else |
| 872 { |
| 873 curr = head; |
| 874 last = tail; |
| 875 } |
| 876 |
| 877 curr2 = curr; |
| 878 for (;;) |
| 879 { |
| 880 if ((curr == NULL) || (curr == last)) break; |
| 881 curr = curr2; |
| 882 curr2 = reverse ? curr->prev : curr->next; |
| 883 |
| 884 cp = curr->cipher; |
| 885 |
| 886 /* |
| 887 * Selection criteria is either the value of strength_bits |
| 888 * or the algorithms used. |
| 889 */ |
| 890 if (strength_bits >= 0) |
| 891 { |
| 892 if (strength_bits != cp->strength_bits) |
| 893 continue; |
| 894 } |
| 895 else |
| 896 { |
| 897 #ifdef CIPHER_DEBUG |
| 898 printf("\nName: %s:\nAlgo = %08lx/%08lx/%08lx/%08lx/%08l
x Algo_strength = %08lx\n", cp->name, cp->algorithm_mkey, cp->algorithm_auth, cp
->algorithm_enc, cp->algorithm_mac, cp->algorithm_ssl, cp->algo_strength); |
| 899 #endif |
| 900 |
| 901 if (alg_mkey && !(alg_mkey & cp->algorithm_mkey)) |
| 902 continue; |
| 903 if (alg_auth && !(alg_auth & cp->algorithm_auth)) |
| 904 continue; |
| 905 if (alg_enc && !(alg_enc & cp->algorithm_enc)) |
| 906 continue; |
| 907 if (alg_mac && !(alg_mac & cp->algorithm_mac)) |
| 908 continue; |
| 909 if (alg_ssl && !(alg_ssl & cp->algorithm_ssl)) |
| 910 continue; |
| 911 if ((algo_strength & SSL_EXP_MASK) && !(algo_strength &
SSL_EXP_MASK & cp->algo_strength)) |
| 912 continue; |
| 913 if ((algo_strength & SSL_STRONG_MASK) && !(algo_strength
& SSL_STRONG_MASK & cp->algo_strength)) |
| 914 continue; |
| 915 } |
| 916 |
| 917 #ifdef CIPHER_DEBUG |
| 918 printf("Action = %d\n", rule); |
| 919 #endif |
| 920 |
| 921 /* add the cipher if it has not been added yet. */ |
| 922 if (rule == CIPHER_ADD) |
| 923 { |
| 924 /* reverse == 0 */ |
| 925 if (!curr->active) |
| 926 { |
| 927 ll_append_tail(&head, curr, &tail); |
| 928 curr->active = 1; |
| 929 } |
| 930 } |
| 931 /* Move the added cipher to this location */ |
| 932 else if (rule == CIPHER_ORD) |
| 933 { |
| 934 /* reverse == 0 */ |
| 935 if (curr->active) |
| 936 { |
| 937 ll_append_tail(&head, curr, &tail); |
| 938 } |
| 939 } |
| 940 else if (rule == CIPHER_DEL) |
| 941 { |
| 942 /* reverse == 1 */ |
| 943 if (curr->active) |
| 944 { |
| 945 /* most recently deleted ciphersuites get best p
ositions |
| 946 * for any future CIPHER_ADD (note that the CIPH
ER_DEL loop |
| 947 * works in reverse to maintain the order) */ |
| 948 ll_append_head(&head, curr, &tail); |
| 949 curr->active = 0; |
| 950 } |
| 951 } |
| 952 else if (rule == CIPHER_KILL) |
| 953 { |
| 954 /* reverse == 0 */ |
| 955 if (head == curr) |
| 956 head = curr->next; |
| 957 else |
| 958 curr->prev->next = curr->next; |
| 959 if (tail == curr) |
| 960 tail = curr->prev; |
| 961 curr->active = 0; |
| 962 if (curr->next != NULL) |
| 963 curr->next->prev = curr->prev; |
| 964 if (curr->prev != NULL) |
| 965 curr->prev->next = curr->next; |
| 966 curr->next = NULL; |
| 967 curr->prev = NULL; |
| 968 } |
| 969 } |
| 970 |
| 971 *head_p = head; |
| 972 *tail_p = tail; |
| 973 } |
| 974 |
| 975 static int ssl_cipher_strength_sort(CIPHER_ORDER **head_p, |
| 976 CIPHER_ORDER **tail_p) |
| 977 { |
| 978 int max_strength_bits, i, *number_uses; |
| 979 CIPHER_ORDER *curr; |
| 980 |
| 981 /* |
| 982 * This routine sorts the ciphers with descending strength. The sorting |
| 983 * must keep the pre-sorted sequence, so we apply the normal sorting |
| 984 * routine as '+' movement to the end of the list. |
| 985 */ |
| 986 max_strength_bits = 0; |
| 987 curr = *head_p; |
| 988 while (curr != NULL) |
| 989 { |
| 990 if (curr->active && |
| 991 (curr->cipher->strength_bits > max_strength_bits)) |
| 992 max_strength_bits = curr->cipher->strength_bits; |
| 993 curr = curr->next; |
| 994 } |
| 995 |
| 996 number_uses = OPENSSL_malloc((max_strength_bits + 1) * sizeof(int)); |
| 997 if (!number_uses) |
| 998 { |
| 999 SSLerr(SSL_F_SSL_CIPHER_STRENGTH_SORT,ERR_R_MALLOC_FAILURE); |
| 1000 return(0); |
| 1001 } |
| 1002 memset(number_uses, 0, (max_strength_bits + 1) * sizeof(int)); |
| 1003 |
| 1004 /* |
| 1005 * Now find the strength_bits values actually used |
| 1006 */ |
| 1007 curr = *head_p; |
| 1008 while (curr != NULL) |
| 1009 { |
| 1010 if (curr->active) |
| 1011 number_uses[curr->cipher->strength_bits]++; |
| 1012 curr = curr->next; |
| 1013 } |
| 1014 /* |
| 1015 * Go through the list of used strength_bits values in descending |
| 1016 * order. |
| 1017 */ |
| 1018 for (i = max_strength_bits; i >= 0; i--) |
| 1019 if (number_uses[i] > 0) |
| 1020 ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_ORD, i
, head_p, tail_p); |
| 1021 |
| 1022 OPENSSL_free(number_uses); |
| 1023 return(1); |
| 1024 } |
| 1025 |
| 1026 static int ssl_cipher_process_rulestr(const char *rule_str, |
| 1027 CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p, |
| 1028 const SSL_CIPHER **ca_list) |
| 1029 { |
| 1030 unsigned long alg_mkey, alg_auth, alg_enc, alg_mac, alg_ssl, algo_streng
th; |
| 1031 const char *l, *buf; |
| 1032 int j, multi, found, rule, retval, ok, buflen; |
| 1033 unsigned long cipher_id = 0; |
| 1034 char ch; |
| 1035 |
| 1036 retval = 1; |
| 1037 l = rule_str; |
| 1038 for (;;) |
| 1039 { |
| 1040 ch = *l; |
| 1041 |
| 1042 if (ch == '\0') |
| 1043 break; /* done */ |
| 1044 if (ch == '-') |
| 1045 { rule = CIPHER_DEL; l++; } |
| 1046 else if (ch == '+') |
| 1047 { rule = CIPHER_ORD; l++; } |
| 1048 else if (ch == '!') |
| 1049 { rule = CIPHER_KILL; l++; } |
| 1050 else if (ch == '@') |
| 1051 { rule = CIPHER_SPECIAL; l++; } |
| 1052 else |
| 1053 { rule = CIPHER_ADD; } |
| 1054 |
| 1055 if (ITEM_SEP(ch)) |
| 1056 { |
| 1057 l++; |
| 1058 continue; |
| 1059 } |
| 1060 |
| 1061 alg_mkey = 0; |
| 1062 alg_auth = 0; |
| 1063 alg_enc = 0; |
| 1064 alg_mac = 0; |
| 1065 alg_ssl = 0; |
| 1066 algo_strength = 0; |
| 1067 |
| 1068 for (;;) |
| 1069 { |
| 1070 ch = *l; |
| 1071 buf = l; |
| 1072 buflen = 0; |
| 1073 #ifndef CHARSET_EBCDIC |
| 1074 while ( ((ch >= 'A') && (ch <= 'Z')) || |
| 1075 ((ch >= '0') && (ch <= '9')) || |
| 1076 ((ch >= 'a') && (ch <= 'z')) || |
| 1077 (ch == '-')) |
| 1078 #else |
| 1079 while ( isalnum(ch) || (ch == '-')) |
| 1080 #endif |
| 1081 { |
| 1082 ch = *(++l); |
| 1083 buflen++; |
| 1084 } |
| 1085 |
| 1086 if (buflen == 0) |
| 1087 { |
| 1088 /* |
| 1089 * We hit something we cannot deal with, |
| 1090 * it is no command or separator nor |
| 1091 * alphanumeric, so we call this an error. |
| 1092 */ |
| 1093 SSLerr(SSL_F_SSL_CIPHER_PROCESS_RULESTR, |
| 1094 SSL_R_INVALID_COMMAND); |
| 1095 retval = found = 0; |
| 1096 l++; |
| 1097 break; |
| 1098 } |
| 1099 |
| 1100 if (rule == CIPHER_SPECIAL) |
| 1101 { |
| 1102 found = 0; /* unused -- avoid compiler warning *
/ |
| 1103 break; /* special treatment */ |
| 1104 } |
| 1105 |
| 1106 /* check for multi-part specification */ |
| 1107 if (ch == '+') |
| 1108 { |
| 1109 multi=1; |
| 1110 l++; |
| 1111 } |
| 1112 else |
| 1113 multi=0; |
| 1114 |
| 1115 /* |
| 1116 * Now search for the cipher alias in the ca_list. Be ca
reful |
| 1117 * with the strncmp, because the "buflen" limitation |
| 1118 * will make the rule "ADH:SOME" and the cipher |
| 1119 * "ADH-MY-CIPHER" look like a match for buflen=3. |
| 1120 * So additionally check whether the cipher name found |
| 1121 * has the correct length. We can save a strlen() call: |
| 1122 * just checking for the '\0' at the right place is |
| 1123 * sufficient, we have to strncmp() anyway. (We cannot |
| 1124 * use strcmp(), because buf is not '\0' terminated.) |
| 1125 */ |
| 1126 j = found = 0; |
| 1127 cipher_id = 0; |
| 1128 while (ca_list[j]) |
| 1129 { |
| 1130 if (!strncmp(buf, ca_list[j]->name, buflen) && |
| 1131 (ca_list[j]->name[buflen] == '\0')) |
| 1132 { |
| 1133 found = 1; |
| 1134 break; |
| 1135 } |
| 1136 else |
| 1137 j++; |
| 1138 } |
| 1139 |
| 1140 if (!found) |
| 1141 break; /* ignore this entry */ |
| 1142 |
| 1143 if (ca_list[j]->algorithm_mkey) |
| 1144 { |
| 1145 if (alg_mkey) |
| 1146 { |
| 1147 alg_mkey &= ca_list[j]->algorithm_mkey; |
| 1148 if (!alg_mkey) { found = 0; break; } |
| 1149 } |
| 1150 else |
| 1151 alg_mkey = ca_list[j]->algorithm_mkey; |
| 1152 } |
| 1153 |
| 1154 if (ca_list[j]->algorithm_auth) |
| 1155 { |
| 1156 if (alg_auth) |
| 1157 { |
| 1158 alg_auth &= ca_list[j]->algorithm_auth; |
| 1159 if (!alg_auth) { found = 0; break; } |
| 1160 } |
| 1161 else |
| 1162 alg_auth = ca_list[j]->algorithm_auth; |
| 1163 } |
| 1164 |
| 1165 if (ca_list[j]->algorithm_enc) |
| 1166 { |
| 1167 if (alg_enc) |
| 1168 { |
| 1169 alg_enc &= ca_list[j]->algorithm_enc; |
| 1170 if (!alg_enc) { found = 0; break; } |
| 1171 } |
| 1172 else |
| 1173 alg_enc = ca_list[j]->algorithm_enc; |
| 1174 } |
| 1175 |
| 1176 if (ca_list[j]->algorithm_mac) |
| 1177 { |
| 1178 if (alg_mac) |
| 1179 { |
| 1180 alg_mac &= ca_list[j]->algorithm_mac; |
| 1181 if (!alg_mac) { found = 0; break; } |
| 1182 } |
| 1183 else |
| 1184 alg_mac = ca_list[j]->algorithm_mac; |
| 1185 } |
| 1186 |
| 1187 if (ca_list[j]->algo_strength & SSL_EXP_MASK) |
| 1188 { |
| 1189 if (algo_strength & SSL_EXP_MASK) |
| 1190 { |
| 1191 algo_strength &= (ca_list[j]->algo_stren
gth & SSL_EXP_MASK) | ~SSL_EXP_MASK; |
| 1192 if (!(algo_strength & SSL_EXP_MASK)) { f
ound = 0; break; } |
| 1193 } |
| 1194 else |
| 1195 algo_strength |= ca_list[j]->algo_streng
th & SSL_EXP_MASK; |
| 1196 } |
| 1197 |
| 1198 if (ca_list[j]->algo_strength & SSL_STRONG_MASK) |
| 1199 { |
| 1200 if (algo_strength & SSL_STRONG_MASK) |
| 1201 { |
| 1202 algo_strength &= (ca_list[j]->algo_stren
gth & SSL_STRONG_MASK) | ~SSL_STRONG_MASK; |
| 1203 if (!(algo_strength & SSL_STRONG_MASK))
{ found = 0; break; } |
| 1204 } |
| 1205 else |
| 1206 algo_strength |= ca_list[j]->algo_streng
th & SSL_STRONG_MASK; |
| 1207 } |
| 1208 |
| 1209 if (ca_list[j]->valid) |
| 1210 { |
| 1211 /* explicit ciphersuite found; its protocol vers
ion |
| 1212 * does not become part of the search pattern!*/ |
| 1213 |
| 1214 cipher_id = ca_list[j]->id; |
| 1215 } |
| 1216 else |
| 1217 { |
| 1218 /* not an explicit ciphersuite; only in this cas
e, the |
| 1219 * protocol version is considered part of the se
arch pattern */ |
| 1220 |
| 1221 if (ca_list[j]->algorithm_ssl) |
| 1222 { |
| 1223 if (alg_ssl) |
| 1224 { |
| 1225 alg_ssl &= ca_list[j]->algorithm
_ssl; |
| 1226 if (!alg_ssl) { found = 0; break
; } |
| 1227 } |
| 1228 else |
| 1229 alg_ssl = ca_list[j]->algorithm_
ssl; |
| 1230 } |
| 1231 } |
| 1232 |
| 1233 if (!multi) break; |
| 1234 } |
| 1235 |
| 1236 /* |
| 1237 * Ok, we have the rule, now apply it |
| 1238 */ |
| 1239 if (rule == CIPHER_SPECIAL) |
| 1240 { /* special command */ |
| 1241 ok = 0; |
| 1242 if ((buflen == 8) && |
| 1243 !strncmp(buf, "STRENGTH", 8)) |
| 1244 ok = ssl_cipher_strength_sort(head_p, tail_p); |
| 1245 else |
| 1246 SSLerr(SSL_F_SSL_CIPHER_PROCESS_RULESTR, |
| 1247 SSL_R_INVALID_COMMAND); |
| 1248 if (ok == 0) |
| 1249 retval = 0; |
| 1250 /* |
| 1251 * We do not support any "multi" options |
| 1252 * together with "@", so throw away the |
| 1253 * rest of the command, if any left, until |
| 1254 * end or ':' is found. |
| 1255 */ |
| 1256 while ((*l != '\0') && !ITEM_SEP(*l)) |
| 1257 l++; |
| 1258 } |
| 1259 else if (found) |
| 1260 { |
| 1261 ssl_cipher_apply_rule(cipher_id, |
| 1262 alg_mkey, alg_auth, alg_enc, alg_mac, alg_ssl, a
lgo_strength, |
| 1263 rule, -1, head_p, tail_p); |
| 1264 } |
| 1265 else |
| 1266 { |
| 1267 while ((*l != '\0') && !ITEM_SEP(*l)) |
| 1268 l++; |
| 1269 } |
| 1270 if (*l == '\0') break; /* done */ |
| 1271 } |
| 1272 |
| 1273 return(retval); |
| 1274 } |
| 1275 |
| 1276 STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(const SSL_METHOD *ssl_method, |
| 1277 STACK_OF(SSL_CIPHER) **cipher_list, |
| 1278 STACK_OF(SSL_CIPHER) **cipher_list_by_id, |
| 1279 const char *rule_str) |
| 1280 { |
| 1281 int ok, num_of_ciphers, num_of_alias_max, num_of_group_aliases; |
| 1282 unsigned long disabled_mkey, disabled_auth, disabled_enc, disabled_mac,
disabled_ssl; |
| 1283 STACK_OF(SSL_CIPHER) *cipherstack, *tmp_cipher_list; |
| 1284 const char *rule_p; |
| 1285 CIPHER_ORDER *co_list = NULL, *head = NULL, *tail = NULL, *curr; |
| 1286 const SSL_CIPHER **ca_list = NULL; |
| 1287 |
| 1288 /* |
| 1289 * Return with error if nothing to do. |
| 1290 */ |
| 1291 if (rule_str == NULL || cipher_list == NULL || cipher_list_by_id == NULL
) |
| 1292 return NULL; |
| 1293 |
| 1294 /* |
| 1295 * To reduce the work to do we only want to process the compiled |
| 1296 * in algorithms, so we first get the mask of disabled ciphers. |
| 1297 */ |
| 1298 ssl_cipher_get_disabled(&disabled_mkey, &disabled_auth, &disabled_enc, &
disabled_mac, &disabled_ssl); |
| 1299 |
| 1300 /* |
| 1301 * Now we have to collect the available ciphers from the compiled |
| 1302 * in ciphers. We cannot get more than the number compiled in, so |
| 1303 * it is used for allocation. |
| 1304 */ |
| 1305 num_of_ciphers = ssl_method->num_ciphers(); |
| 1306 #ifdef KSSL_DEBUG |
| 1307 printf("ssl_create_cipher_list() for %d ciphers\n", num_of_ciphers); |
| 1308 #endif /* KSSL_DEBUG */ |
| 1309 co_list = (CIPHER_ORDER *)OPENSSL_malloc(sizeof(CIPHER_ORDER) * num_of_c
iphers); |
| 1310 if (co_list == NULL) |
| 1311 { |
| 1312 SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST,ERR_R_MALLOC_FAILURE); |
| 1313 return(NULL); /* Failure */ |
| 1314 } |
| 1315 |
| 1316 ssl_cipher_collect_ciphers(ssl_method, num_of_ciphers, |
| 1317 disabled_mkey, disabled_auth, disabled_enc, d
isabled_mac, disabled_ssl, |
| 1318 co_list, &head, &tail); |
| 1319 |
| 1320 |
| 1321 /* Now arrange all ciphers by preference: */ |
| 1322 |
| 1323 /* Everything else being equal, prefer ephemeral ECDH over other key exc
hange mechanisms */ |
| 1324 ssl_cipher_apply_rule(0, SSL_kEECDH, 0, 0, 0, 0, 0, CIPHER_ADD, -1, &hea
d, &tail); |
| 1325 ssl_cipher_apply_rule(0, SSL_kEECDH, 0, 0, 0, 0, 0, CIPHER_DEL, -1, &hea
d, &tail); |
| 1326 |
| 1327 /* AES is our preferred symmetric cipher */ |
| 1328 ssl_cipher_apply_rule(0, 0, 0, SSL_AES, 0, 0, 0, CIPHER_ADD, -1, &head,
&tail); |
| 1329 |
| 1330 /* Temporarily enable everything else for sorting */ |
| 1331 ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_ADD, -1, &head, &tail)
; |
| 1332 |
| 1333 /* Low priority for MD5 */ |
| 1334 ssl_cipher_apply_rule(0, 0, 0, 0, SSL_MD5, 0, 0, CIPHER_ORD, -1, &head,
&tail); |
| 1335 |
| 1336 /* Move anonymous ciphers to the end. Usually, these will remain disabl
ed. |
| 1337 * (For applications that allow them, they aren't too bad, but we prefer |
| 1338 * authenticated ciphers.) */ |
| 1339 ssl_cipher_apply_rule(0, 0, SSL_aNULL, 0, 0, 0, 0, CIPHER_ORD, -1, &head
, &tail); |
| 1340 |
| 1341 /* Move ciphers without forward secrecy to the end */ |
| 1342 ssl_cipher_apply_rule(0, 0, SSL_aECDH, 0, 0, 0, 0, CIPHER_ORD, -1, &head
, &tail); |
| 1343 /* ssl_cipher_apply_rule(0, 0, SSL_aDH, 0, 0, 0, 0, CIPHER_ORD, -1, &hea
d, &tail); */ |
| 1344 ssl_cipher_apply_rule(0, SSL_kRSA, 0, 0, 0, 0, 0, CIPHER_ORD, -1, &head,
&tail); |
| 1345 ssl_cipher_apply_rule(0, SSL_kPSK, 0,0, 0, 0, 0, CIPHER_ORD, -1, &head,
&tail); |
| 1346 ssl_cipher_apply_rule(0, SSL_kKRB5, 0,0, 0, 0, 0, CIPHER_ORD, -1, &head,
&tail); |
| 1347 |
| 1348 /* RC4 is sort-of broken -- move the the end */ |
| 1349 ssl_cipher_apply_rule(0, 0, 0, SSL_RC4, 0, 0, 0, CIPHER_ORD, -1, &head,
&tail); |
| 1350 |
| 1351 /* Now sort by symmetric encryption strength. The above ordering remain
s |
| 1352 * in force within each class */ |
| 1353 if (!ssl_cipher_strength_sort(&head, &tail)) |
| 1354 { |
| 1355 OPENSSL_free(co_list); |
| 1356 return NULL; |
| 1357 } |
| 1358 |
| 1359 /* Now disable everything (maintaining the ordering!) */ |
| 1360 ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_DEL, -1, &head, &tail)
; |
| 1361 |
| 1362 |
| 1363 /* |
| 1364 * We also need cipher aliases for selecting based on the rule_str. |
| 1365 * There might be two types of entries in the rule_str: 1) names |
| 1366 * of ciphers themselves 2) aliases for groups of ciphers. |
| 1367 * For 1) we need the available ciphers and for 2) the cipher |
| 1368 * groups of cipher_aliases added together in one list (otherwise |
| 1369 * we would be happy with just the cipher_aliases table). |
| 1370 */ |
| 1371 num_of_group_aliases = sizeof(cipher_aliases) / sizeof(SSL_CIPHER); |
| 1372 num_of_alias_max = num_of_ciphers + num_of_group_aliases + 1; |
| 1373 ca_list = OPENSSL_malloc(sizeof(SSL_CIPHER *) * num_of_alias_max); |
| 1374 if (ca_list == NULL) |
| 1375 { |
| 1376 OPENSSL_free(co_list); |
| 1377 SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST,ERR_R_MALLOC_FAILURE); |
| 1378 return(NULL); /* Failure */ |
| 1379 } |
| 1380 ssl_cipher_collect_aliases(ca_list, num_of_group_aliases, |
| 1381 disabled_mkey, disabled_auth, disabled_enc, |
| 1382 disabled_mac, disabled_ssl, head); |
| 1383 |
| 1384 /* |
| 1385 * If the rule_string begins with DEFAULT, apply the default rule |
| 1386 * before using the (possibly available) additional rules. |
| 1387 */ |
| 1388 ok = 1; |
| 1389 rule_p = rule_str; |
| 1390 if (strncmp(rule_str,"DEFAULT",7) == 0) |
| 1391 { |
| 1392 ok = ssl_cipher_process_rulestr(SSL_DEFAULT_CIPHER_LIST, |
| 1393 &head, &tail, ca_list); |
| 1394 rule_p += 7; |
| 1395 if (*rule_p == ':') |
| 1396 rule_p++; |
| 1397 } |
| 1398 |
| 1399 if (ok && (strlen(rule_p) > 0)) |
| 1400 ok = ssl_cipher_process_rulestr(rule_p, &head, &tail, ca_list); |
| 1401 |
| 1402 OPENSSL_free((void *)ca_list); /* Not needed anymore */ |
| 1403 |
| 1404 if (!ok) |
| 1405 { /* Rule processing failure */ |
| 1406 OPENSSL_free(co_list); |
| 1407 return(NULL); |
| 1408 } |
| 1409 |
| 1410 /* |
| 1411 * Allocate new "cipherstack" for the result, return with error |
| 1412 * if we cannot get one. |
| 1413 */ |
| 1414 if ((cipherstack = sk_SSL_CIPHER_new_null()) == NULL) |
| 1415 { |
| 1416 OPENSSL_free(co_list); |
| 1417 return(NULL); |
| 1418 } |
| 1419 |
| 1420 /* |
| 1421 * The cipher selection for the list is done. The ciphers are added |
| 1422 * to the resulting precedence to the STACK_OF(SSL_CIPHER). |
| 1423 */ |
| 1424 for (curr = head; curr != NULL; curr = curr->next) |
| 1425 { |
| 1426 if (curr->active) |
| 1427 { |
| 1428 sk_SSL_CIPHER_push(cipherstack, curr->cipher); |
| 1429 #ifdef CIPHER_DEBUG |
| 1430 printf("<%s>\n",curr->cipher->name); |
| 1431 #endif |
| 1432 } |
| 1433 } |
| 1434 OPENSSL_free(co_list); /* Not needed any longer */ |
| 1435 |
| 1436 tmp_cipher_list = sk_SSL_CIPHER_dup(cipherstack); |
| 1437 if (tmp_cipher_list == NULL) |
| 1438 { |
| 1439 sk_SSL_CIPHER_free(cipherstack); |
| 1440 return NULL; |
| 1441 } |
| 1442 if (*cipher_list != NULL) |
| 1443 sk_SSL_CIPHER_free(*cipher_list); |
| 1444 *cipher_list = cipherstack; |
| 1445 if (*cipher_list_by_id != NULL) |
| 1446 sk_SSL_CIPHER_free(*cipher_list_by_id); |
| 1447 *cipher_list_by_id = tmp_cipher_list; |
| 1448 (void)sk_SSL_CIPHER_set_cmp_func(*cipher_list_by_id,ssl_cipher_ptr_id_cm
p); |
| 1449 |
| 1450 sk_SSL_CIPHER_sort(*cipher_list_by_id); |
| 1451 return(cipherstack); |
| 1452 } |
| 1453 |
| 1454 char *SSL_CIPHER_description(const SSL_CIPHER *cipher, char *buf, int len) |
| 1455 { |
| 1456 int is_export,pkl,kl; |
| 1457 const char *ver,*exp_str; |
| 1458 const char *kx,*au,*enc,*mac; |
| 1459 unsigned long alg_mkey,alg_auth,alg_enc,alg_mac,alg_ssl,alg2; |
| 1460 #ifdef KSSL_DEBUG |
| 1461 static const char *format="%-23s %s Kx=%-8s Au=%-4s Enc=%-9s Mac=%-4s%s
AL=%lx/%lx/%lx/%lx/%lx\n"; |
| 1462 #else |
| 1463 static const char *format="%-23s %s Kx=%-8s Au=%-4s Enc=%-9s Mac=%-4s%s\
n"; |
| 1464 #endif /* KSSL_DEBUG */ |
| 1465 |
| 1466 alg_mkey = cipher->algorithm_mkey; |
| 1467 alg_auth = cipher->algorithm_auth; |
| 1468 alg_enc = cipher->algorithm_enc; |
| 1469 alg_mac = cipher->algorithm_mac; |
| 1470 alg_ssl = cipher->algorithm_ssl; |
| 1471 |
| 1472 alg2=cipher->algorithm2; |
| 1473 |
| 1474 is_export=SSL_C_IS_EXPORT(cipher); |
| 1475 pkl=SSL_C_EXPORT_PKEYLENGTH(cipher); |
| 1476 kl=SSL_C_EXPORT_KEYLENGTH(cipher); |
| 1477 exp_str=is_export?" export":""; |
| 1478 |
| 1479 if (alg_ssl & SSL_SSLV2) |
| 1480 ver="SSLv2"; |
| 1481 else if (alg_ssl & SSL_SSLV3) |
| 1482 ver="SSLv3"; |
| 1483 else |
| 1484 ver="unknown"; |
| 1485 |
| 1486 switch (alg_mkey) |
| 1487 { |
| 1488 case SSL_kRSA: |
| 1489 kx=is_export?(pkl == 512 ? "RSA(512)" : "RSA(1024)"):"RSA"; |
| 1490 break; |
| 1491 case SSL_kDHr: |
| 1492 kx="DH/RSA"; |
| 1493 break; |
| 1494 case SSL_kDHd: |
| 1495 kx="DH/DSS"; |
| 1496 break; |
| 1497 case SSL_kKRB5: |
| 1498 kx="KRB5"; |
| 1499 break; |
| 1500 case SSL_kEDH: |
| 1501 kx=is_export?(pkl == 512 ? "DH(512)" : "DH(1024)"):"DH"; |
| 1502 break; |
| 1503 case SSL_kECDHr: |
| 1504 kx="ECDH/RSA"; |
| 1505 break; |
| 1506 case SSL_kECDHe: |
| 1507 kx="ECDH/ECDSA"; |
| 1508 break; |
| 1509 case SSL_kEECDH: |
| 1510 kx="ECDH"; |
| 1511 break; |
| 1512 case SSL_kPSK: |
| 1513 kx="PSK"; |
| 1514 break; |
| 1515 default: |
| 1516 kx="unknown"; |
| 1517 } |
| 1518 |
| 1519 switch (alg_auth) |
| 1520 { |
| 1521 case SSL_aRSA: |
| 1522 au="RSA"; |
| 1523 break; |
| 1524 case SSL_aDSS: |
| 1525 au="DSS"; |
| 1526 break; |
| 1527 case SSL_aDH: |
| 1528 au="DH"; |
| 1529 break; |
| 1530 case SSL_aKRB5: |
| 1531 au="KRB5"; |
| 1532 break; |
| 1533 case SSL_aECDH: |
| 1534 au="ECDH"; |
| 1535 break; |
| 1536 case SSL_aNULL: |
| 1537 au="None"; |
| 1538 break; |
| 1539 case SSL_aECDSA: |
| 1540 au="ECDSA"; |
| 1541 break; |
| 1542 case SSL_aPSK: |
| 1543 au="PSK"; |
| 1544 break; |
| 1545 default: |
| 1546 au="unknown"; |
| 1547 break; |
| 1548 } |
| 1549 |
| 1550 switch (alg_enc) |
| 1551 { |
| 1552 case SSL_DES: |
| 1553 enc=(is_export && kl == 5)?"DES(40)":"DES(56)"; |
| 1554 break; |
| 1555 case SSL_3DES: |
| 1556 enc="3DES(168)"; |
| 1557 break; |
| 1558 case SSL_RC4: |
| 1559 enc=is_export?(kl == 5 ? "RC4(40)" : "RC4(56)") |
| 1560 :((alg2&SSL2_CF_8_BYTE_ENC)?"RC4(64)":"RC4(128)"); |
| 1561 break; |
| 1562 case SSL_RC2: |
| 1563 enc=is_export?(kl == 5 ? "RC2(40)" : "RC2(56)"):"RC2(128)"; |
| 1564 break; |
| 1565 case SSL_IDEA: |
| 1566 enc="IDEA(128)"; |
| 1567 break; |
| 1568 case SSL_eNULL: |
| 1569 enc="None"; |
| 1570 break; |
| 1571 case SSL_AES128: |
| 1572 enc="AES(128)"; |
| 1573 break; |
| 1574 case SSL_AES256: |
| 1575 enc="AES(256)"; |
| 1576 break; |
| 1577 case SSL_CAMELLIA128: |
| 1578 enc="Camellia(128)"; |
| 1579 break; |
| 1580 case SSL_CAMELLIA256: |
| 1581 enc="Camellia(256)"; |
| 1582 break; |
| 1583 case SSL_SEED: |
| 1584 enc="SEED(128)"; |
| 1585 break; |
| 1586 default: |
| 1587 enc="unknown"; |
| 1588 break; |
| 1589 } |
| 1590 |
| 1591 switch (alg_mac) |
| 1592 { |
| 1593 case SSL_MD5: |
| 1594 mac="MD5"; |
| 1595 break; |
| 1596 case SSL_SHA1: |
| 1597 mac="SHA1"; |
| 1598 break; |
| 1599 default: |
| 1600 mac="unknown"; |
| 1601 break; |
| 1602 } |
| 1603 |
| 1604 if (buf == NULL) |
| 1605 { |
| 1606 len=128; |
| 1607 buf=OPENSSL_malloc(len); |
| 1608 if (buf == NULL) return("OPENSSL_malloc Error"); |
| 1609 } |
| 1610 else if (len < 128) |
| 1611 return("Buffer too small"); |
| 1612 |
| 1613 #ifdef KSSL_DEBUG |
| 1614 BIO_snprintf(buf,len,format,cipher->name,ver,kx,au,enc,mac,exp_str,alg_m
key,alg_auth,alg_enc,alg_mac,alg_ssl); |
| 1615 #else |
| 1616 BIO_snprintf(buf,len,format,cipher->name,ver,kx,au,enc,mac,exp_str); |
| 1617 #endif /* KSSL_DEBUG */ |
| 1618 return(buf); |
| 1619 } |
| 1620 |
| 1621 char *SSL_CIPHER_get_version(const SSL_CIPHER *c) |
| 1622 { |
| 1623 int i; |
| 1624 |
| 1625 if (c == NULL) return("(NONE)"); |
| 1626 i=(int)(c->id>>24L); |
| 1627 if (i == 3) |
| 1628 return("TLSv1/SSLv3"); |
| 1629 else if (i == 2) |
| 1630 return("SSLv2"); |
| 1631 else |
| 1632 return("unknown"); |
| 1633 } |
| 1634 |
| 1635 /* return the actual cipher being used */ |
| 1636 const char *SSL_CIPHER_get_name(const SSL_CIPHER *c) |
| 1637 { |
| 1638 if (c != NULL) |
| 1639 return(c->name); |
| 1640 return("(NONE)"); |
| 1641 } |
| 1642 |
| 1643 /* number of bits for symmetric cipher */ |
| 1644 int SSL_CIPHER_get_bits(const SSL_CIPHER *c, int *alg_bits) |
| 1645 { |
| 1646 int ret=0; |
| 1647 |
| 1648 if (c != NULL) |
| 1649 { |
| 1650 if (alg_bits != NULL) *alg_bits = c->alg_bits; |
| 1651 ret = c->strength_bits; |
| 1652 } |
| 1653 return(ret); |
| 1654 } |
| 1655 |
| 1656 SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n) |
| 1657 { |
| 1658 SSL_COMP *ctmp; |
| 1659 int i,nn; |
| 1660 |
| 1661 if ((n == 0) || (sk == NULL)) return(NULL); |
| 1662 nn=sk_SSL_COMP_num(sk); |
| 1663 for (i=0; i<nn; i++) |
| 1664 { |
| 1665 ctmp=sk_SSL_COMP_value(sk,i); |
| 1666 if (ctmp->id == n) |
| 1667 return(ctmp); |
| 1668 } |
| 1669 return(NULL); |
| 1670 } |
| 1671 |
| 1672 #ifdef OPENSSL_NO_COMP |
| 1673 void *SSL_COMP_get_compression_methods(void) |
| 1674 { |
| 1675 return NULL; |
| 1676 } |
| 1677 int SSL_COMP_add_compression_method(int id, void *cm) |
| 1678 { |
| 1679 return 1; |
| 1680 } |
| 1681 |
| 1682 const char *SSL_COMP_get_name(const void *comp) |
| 1683 { |
| 1684 return NULL; |
| 1685 } |
| 1686 #else |
| 1687 STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void) |
| 1688 { |
| 1689 load_builtin_compressions(); |
| 1690 return(ssl_comp_methods); |
| 1691 } |
| 1692 |
| 1693 int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm) |
| 1694 { |
| 1695 SSL_COMP *comp; |
| 1696 |
| 1697 if (cm == NULL || cm->type == NID_undef) |
| 1698 return 1; |
| 1699 |
| 1700 /* According to draft-ietf-tls-compression-04.txt, the |
| 1701 compression number ranges should be the following: |
| 1702 |
| 1703 0 to 63: methods defined by the IETF |
| 1704 64 to 192: external party methods assigned by IANA |
| 1705 193 to 255: reserved for private use */ |
| 1706 if (id < 193 || id > 255) |
| 1707 { |
| 1708 SSLerr(SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD,SSL_R_COMPRESSION_I
D_NOT_WITHIN_PRIVATE_RANGE); |
| 1709 return 0; |
| 1710 } |
| 1711 |
| 1712 MemCheck_off(); |
| 1713 comp=(SSL_COMP *)OPENSSL_malloc(sizeof(SSL_COMP)); |
| 1714 comp->id=id; |
| 1715 comp->method=cm; |
| 1716 load_builtin_compressions(); |
| 1717 if (ssl_comp_methods |
| 1718 && sk_SSL_COMP_find(ssl_comp_methods,comp) >= 0) |
| 1719 { |
| 1720 OPENSSL_free(comp); |
| 1721 MemCheck_on(); |
| 1722 SSLerr(SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD,SSL_R_DUPLICATE_COM
PRESSION_ID); |
| 1723 return(1); |
| 1724 } |
| 1725 else if ((ssl_comp_methods == NULL) |
| 1726 || !sk_SSL_COMP_push(ssl_comp_methods,comp)) |
| 1727 { |
| 1728 OPENSSL_free(comp); |
| 1729 MemCheck_on(); |
| 1730 SSLerr(SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD,ERR_R_MALLOC_FAILUR
E); |
| 1731 return(1); |
| 1732 } |
| 1733 else |
| 1734 { |
| 1735 MemCheck_on(); |
| 1736 return(0); |
| 1737 } |
| 1738 } |
| 1739 |
| 1740 const char *SSL_COMP_get_name(const COMP_METHOD *comp) |
| 1741 { |
| 1742 if (comp) |
| 1743 return comp->name; |
| 1744 return NULL; |
| 1745 } |
| 1746 |
| 1747 #endif |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 9254031:
Upgrade chrome's OpenSSL to same version Android ships with. (Closed)
Base URL: http://src.chromium.org/svn/trunk/deps/third_party/openssl/