crypto/openssl/ssl/ssl_ciph.c

   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-2006 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 #include <stdio.h>
 117 #include <openssl/objects.h>
 118 #ifndef OPENSSL_NO_COMP
 119 # include <openssl/comp.h>
 120 #endif
 121
 122 #include "ssl_locl.h"
 123
 124 #define SSL_ENC_DES_IDX         0
 125 #define SSL_ENC_3DES_IDX        1
 126 #define SSL_ENC_RC4_IDX         2
 127 #define SSL_ENC_RC2_IDX         3
 128 #define SSL_ENC_IDEA_IDX        4
 129 #define SSL_ENC_eFZA_IDX        5
 130 #define SSL_ENC_NULL_IDX        6
 131 #define SSL_ENC_AES128_IDX      7
 132 #define SSL_ENC_AES256_IDX      8
 133 #define SSL_ENC_CAMELLIA128_IDX 9
 134 #define SSL_ENC_CAMELLIA256_IDX 10
 135 #define SSL_ENC_SEED_IDX        11
 136 #define SSL_ENC_NUM_IDX         12
 137
 138 static const EVP_CIPHER *ssl_cipher_methods[SSL_ENC_NUM_IDX] = {
 139     NULL, NULL, NULL, NULL, NULL, NULL,
 140 };
 141
 142 #define SSL_COMP_NULL_IDX       0
 143 #define SSL_COMP_ZLIB_IDX       1
 144 #define SSL_COMP_NUM_IDX        2
 145
 146 static STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
 147
 148 #define SSL_MD_MD5_IDX  0
 149 #define SSL_MD_SHA1_IDX 1
 150 #define SSL_MD_NUM_IDX  2
 151 static const EVP_MD *ssl_digest_methods[SSL_MD_NUM_IDX] = {
 152     NULL, NULL,
 153 };
 154
 155 #define CIPHER_ADD      1
 156 #define CIPHER_KILL     2
 157 #define CIPHER_DEL      3
 158 #define CIPHER_ORD      4
 159 #define CIPHER_SPECIAL  5
 160
 161 typedef struct cipher_order_st {
 162     SSL_CIPHER *cipher;
 163     int active;
 164     int dead;
 165     struct cipher_order_st *next, *prev;
 166 } CIPHER_ORDER;
 167
 168 static const SSL_CIPHER cipher_aliases[] = {
 169     /* Don't include eNULL unless specifically enabled. */
 170     /*
 171      * Don't include ECC in ALL because these ciphers are not yet official.
 172      */
 173     /* must be first */
 174     {0, SSL_TXT_ALL, 0, SSL_ALL & ~SSL_eNULL & ~SSL_kECDH & ~SSL_kECDHE,
 175      SSL_ALL, 0, 0, 0, SSL_ALL, SSL_ALL},
 176     /*
 177      * TODO: COMPLEMENT OF ALL do not have ECC cipher suites handled properly.
 178      */
 179     /* COMPLEMENT OF ALL */
 180     {0, SSL_TXT_CMPALL, 0, SSL_eNULL, 0, 0, 0, 0, SSL_ENC_MASK, 0},
 181     {0, SSL_TXT_CMPDEF, 0, SSL_ADH, SSL_EXP_MASK, 0, 0, 0, SSL_AUTH_MASK, 0},
 182     /* VRS Kerberos5 */
 183     {0, SSL_TXT_kKRB5, 0, SSL_kKRB5, 0, 0, 0, 0, SSL_MKEY_MASK, 0},
 184     {0, SSL_TXT_kRSA, 0, SSL_kRSA, 0, 0, 0, 0, SSL_MKEY_MASK, 0},
 185     {0, SSL_TXT_kDHr, 0, SSL_kDHr, 0, 0, 0, 0, SSL_MKEY_MASK, 0},
 186     {0, SSL_TXT_kDHd, 0, SSL_kDHd, 0, 0, 0, 0, SSL_MKEY_MASK, 0},
 187     {0, SSL_TXT_kEDH, 0, SSL_kEDH, 0, 0, 0, 0, SSL_MKEY_MASK, 0},
 188     {0, SSL_TXT_kFZA, 0, SSL_kFZA, 0, 0, 0, 0, SSL_MKEY_MASK, 0},
 189     {0, SSL_TXT_DH, 0, SSL_DH, 0, 0, 0, 0, SSL_MKEY_MASK, 0},
 190     {0, SSL_TXT_ECC, 0, (SSL_kECDH | SSL_kECDHE), 0, 0, 0, 0, SSL_MKEY_MASK,
 191      0},
 192     {0, SSL_TXT_EDH, 0, SSL_EDH, 0, 0, 0, 0, SSL_MKEY_MASK | SSL_AUTH_MASK,
 193      0},
 194     /* VRS Kerberos5 */
 195     {0, SSL_TXT_aKRB5, 0, SSL_aKRB5, 0, 0, 0, 0, SSL_AUTH_MASK, 0},
 196     {0, SSL_TXT_aRSA, 0, SSL_aRSA, 0, 0, 0, 0, SSL_AUTH_MASK, 0},
 197     {0, SSL_TXT_aDSS, 0, SSL_aDSS, 0, 0, 0, 0, SSL_AUTH_MASK, 0},
 198     {0, SSL_TXT_aFZA, 0, SSL_aFZA, 0, 0, 0, 0, SSL_AUTH_MASK, 0},
 199     {0, SSL_TXT_aNULL, 0, SSL_aNULL, 0, 0, 0, 0, SSL_AUTH_MASK, 0},
 200     {0, SSL_TXT_aDH, 0, SSL_aDH, 0, 0, 0, 0, SSL_AUTH_MASK, 0},
 201     {0, SSL_TXT_DSS, 0, SSL_DSS, 0, 0, 0, 0, SSL_AUTH_MASK, 0},
 202
 203     {0, SSL_TXT_DES, 0, SSL_DES, 0, 0, 0, 0, SSL_ENC_MASK, 0},
 204     {0, SSL_TXT_3DES, 0, SSL_3DES, 0, 0, 0, 0, SSL_ENC_MASK, 0},
 205     {0, SSL_TXT_RC4, 0, SSL_RC4, 0, 0, 0, 0, SSL_ENC_MASK, 0},
 206     {0, SSL_TXT_RC2, 0, SSL_RC2, 0, 0, 0, 0, SSL_ENC_MASK, 0},
 207 #ifndef OPENSSL_NO_IDEA
 208     {0, SSL_TXT_IDEA, 0, SSL_IDEA, 0, 0, 0, 0, SSL_ENC_MASK, 0},
 209 #endif
 210     {0, SSL_TXT_SEED, 0, SSL_SEED, 0, 0, 0, 0, SSL_ENC_MASK, 0},
 211     {0, SSL_TXT_eNULL, 0, SSL_eNULL, 0, 0, 0, 0, SSL_ENC_MASK, 0},
 212     {0, SSL_TXT_eFZA, 0, SSL_eFZA, 0, 0, 0, 0, SSL_ENC_MASK, 0},
 213     {0, SSL_TXT_AES, 0, SSL_AES, 0, 0, 0, 0, SSL_ENC_MASK, 0},
 214     {0, SSL_TXT_CAMELLIA, 0, SSL_CAMELLIA, 0, 0, 0, 0, SSL_ENC_MASK, 0},
 215
 216     {0, SSL_TXT_MD5, 0, SSL_MD5, 0, 0, 0, 0, SSL_MAC_MASK, 0},
 217     {0, SSL_TXT_SHA1, 0, SSL_SHA1, 0, 0, 0, 0, SSL_MAC_MASK, 0},
 218     {0, SSL_TXT_SHA, 0, SSL_SHA, 0, 0, 0, 0, SSL_MAC_MASK, 0},
 219
 220     {0, SSL_TXT_NULL, 0, SSL_NULL, 0, 0, 0, 0, SSL_ENC_MASK, 0},
 221     {0, SSL_TXT_KRB5, 0, SSL_KRB5, 0, 0, 0, 0, SSL_AUTH_MASK | SSL_MKEY_MASK,
 222      0},
 223     {0, SSL_TXT_RSA, 0, SSL_RSA, 0, 0, 0, 0, SSL_AUTH_MASK | SSL_MKEY_MASK,
 224      0},
 225     {0, SSL_TXT_ADH, 0, SSL_ADH, 0, 0, 0, 0, SSL_AUTH_MASK | SSL_MKEY_MASK,
 226      0},
 227     {0, SSL_TXT_FZA, 0, SSL_FZA, 0, 0, 0, 0,
 228      SSL_AUTH_MASK | SSL_MKEY_MASK | SSL_ENC_MASK, 0},
 229
 230     {0, SSL_TXT_SSLV2, 0, SSL_SSLV2, 0, 0, 0, 0, SSL_SSL_MASK, 0},
 231     {0, SSL_TXT_SSLV3, 0, SSL_SSLV3, 0, 0, 0, 0, SSL_SSL_MASK, 0},
 232     {0, SSL_TXT_TLSV1, 0, SSL_TLSV1, 0, 0, 0, 0, SSL_SSL_MASK, 0},
 233
 234     {0, SSL_TXT_EXP, 0, 0, SSL_EXPORT, 0, 0, 0, 0, SSL_EXP_MASK},
 235     {0, SSL_TXT_EXPORT, 0, 0, SSL_EXPORT, 0, 0, 0, 0, SSL_EXP_MASK},
 236     {0, SSL_TXT_EXP40, 0, 0, SSL_EXP40, 0, 0, 0, 0, SSL_STRONG_MASK},
 237     {0, SSL_TXT_EXP56, 0, 0, SSL_EXP56, 0, 0, 0, 0, SSL_STRONG_MASK},
 238     {0, SSL_TXT_LOW, 0, 0, SSL_LOW, 0, 0, 0, 0, SSL_STRONG_MASK},
 239     {0, SSL_TXT_MEDIUM, 0, 0, SSL_MEDIUM, 0, 0, 0, 0, SSL_STRONG_MASK},
 240     {0, SSL_TXT_HIGH, 0, 0, SSL_HIGH, 0, 0, 0, 0, SSL_STRONG_MASK},
 241     {0, SSL_TXT_FIPS, 0, 0, SSL_FIPS, 0, 0, 0, 0, SSL_FIPS | SSL_STRONG_NONE},
 242 };
 243
 244 void ssl_load_ciphers(void)
 245 {
 246     ssl_cipher_methods[SSL_ENC_DES_IDX] = EVP_get_cipherbyname(SN_des_cbc);
 247     ssl_cipher_methods[SSL_ENC_3DES_IDX] =
 248         EVP_get_cipherbyname(SN_des_ede3_cbc);
 249     ssl_cipher_methods[SSL_ENC_RC4_IDX] = EVP_get_cipherbyname(SN_rc4);
 250     ssl_cipher_methods[SSL_ENC_RC2_IDX] = EVP_get_cipherbyname(SN_rc2_cbc);
 251 #ifndef OPENSSL_NO_IDEA
 252     ssl_cipher_methods[SSL_ENC_IDEA_IDX] = EVP_get_cipherbyname(SN_idea_cbc);
 253 #else
 254     ssl_cipher_methods[SSL_ENC_IDEA_IDX] = NULL;
 255 #endif
 256     ssl_cipher_methods[SSL_ENC_AES128_IDX] =
 257         EVP_get_cipherbyname(SN_aes_128_cbc);
 258     ssl_cipher_methods[SSL_ENC_AES256_IDX] =
 259         EVP_get_cipherbyname(SN_aes_256_cbc);
 260     ssl_cipher_methods[SSL_ENC_CAMELLIA128_IDX] =
 261         EVP_get_cipherbyname(SN_camellia_128_cbc);
 262     ssl_cipher_methods[SSL_ENC_CAMELLIA256_IDX] =
 263         EVP_get_cipherbyname(SN_camellia_256_cbc);
 264     ssl_cipher_methods[SSL_ENC_SEED_IDX] = EVP_get_cipherbyname(SN_seed_cbc);
 265
 266     ssl_digest_methods[SSL_MD_MD5_IDX] = EVP_get_digestbyname(SN_md5);
 267     ssl_digest_methods[SSL_MD_SHA1_IDX] = EVP_get_digestbyname(SN_sha1);
 268 }
 269
 270 #ifndef OPENSSL_NO_COMP
 271
 272 static int sk_comp_cmp(const SSL_COMP *const *a, const SSL_COMP *const *b)
 273 {
 274     return ((*a)->id - (*b)->id);
 275 }
 276
 277 static void load_builtin_compressions(void)
 278 {
 279     int got_write_lock = 0;
 280
 281     CRYPTO_r_lock(CRYPTO_LOCK_SSL);
 282     if (ssl_comp_methods == NULL) {
 283         CRYPTO_r_unlock(CRYPTO_LOCK_SSL);
 284         CRYPTO_w_lock(CRYPTO_LOCK_SSL);
 285         got_write_lock = 1;
 286
 287         if (ssl_comp_methods == NULL) {
 288             SSL_COMP *comp = NULL;
 289
 290             MemCheck_off();
 291             ssl_comp_methods = sk_SSL_COMP_new(sk_comp_cmp);
 292             if (ssl_comp_methods != NULL) {
 293                 comp = (SSL_COMP *)OPENSSL_malloc(sizeof(SSL_COMP));
 294                 if (comp != NULL) {
 295                     comp->method = COMP_zlib();
 296                     if (comp->method && comp->method->type == NID_undef)
 297                         OPENSSL_free(comp);
 298                     else {
 299                         comp->id = SSL_COMP_ZLIB_IDX;
 300                         comp->name = comp->method->name;
 301                         sk_SSL_COMP_push(ssl_comp_methods, comp);
 302                     }
 303                 }
 304                 sk_SSL_COMP_sort(ssl_comp_methods);
 305             }
 306             MemCheck_on();
 307         }
 308     }
 309
 310     if (got_write_lock)
 311         CRYPTO_w_unlock(CRYPTO_LOCK_SSL);
 312     else
 313         CRYPTO_r_unlock(CRYPTO_LOCK_SSL);
 314 }
 315 #endif
 316
 317 int ssl_cipher_get_evp(const SSL_SESSION *s, const EVP_CIPHER **enc,
 318                        const EVP_MD **md, SSL_COMP **comp)
 319 {
 320     int i;
 321     SSL_CIPHER *c;
 322
 323     c = s->cipher;
 324     if (c == NULL)
 325         return (0);
 326     if (comp != NULL) {
 327         SSL_COMP ctmp;
 328 #ifndef OPENSSL_NO_COMP
 329         load_builtin_compressions();
 330 #endif
 331
 332         *comp = NULL;
 333         ctmp.id = s->compress_meth;
 334         if (ssl_comp_methods != NULL) {
 335             i = sk_SSL_COMP_find(ssl_comp_methods, &ctmp);
 336             if (i >= 0)
 337                 *comp = sk_SSL_COMP_value(ssl_comp_methods, i);
 338             else
 339                 *comp = NULL;
 340         }
 341     }
 342
 343     if ((enc == NULL) || (md == NULL))
 344         return (0);
 345
 346     switch (c->algorithms & SSL_ENC_MASK) {
 347     case SSL_DES:
 348         i = SSL_ENC_DES_IDX;
 349         break;
 350     case SSL_3DES:
 351         i = SSL_ENC_3DES_IDX;
 352         break;
 353     case SSL_RC4:
 354         i = SSL_ENC_RC4_IDX;
 355         break;
 356     case SSL_RC2:
 357         i = SSL_ENC_RC2_IDX;
 358         break;
 359     case SSL_IDEA:
 360         i = SSL_ENC_IDEA_IDX;
 361         break;
 362     case SSL_eNULL:
 363         i = SSL_ENC_NULL_IDX;
 364         break;
 365     case SSL_AES:
 366         switch (c->alg_bits) {
 367         case 128:
 368             i = SSL_ENC_AES128_IDX;
 369             break;
 370         case 256:
 371             i = SSL_ENC_AES256_IDX;
 372             break;
 373         default:
 374             i = -1;
 375             break;
 376         }
 377         break;
 378     case SSL_CAMELLIA:
 379         switch (c->alg_bits) {
 380         case 128:
 381             i = SSL_ENC_CAMELLIA128_IDX;
 382             break;
 383         case 256:
 384             i = SSL_ENC_CAMELLIA256_IDX;
 385             break;
 386         default:
 387             i = -1;
 388             break;
 389         }
 390         break;
 391     case SSL_SEED:
 392         i = SSL_ENC_SEED_IDX;
 393         break;
 394
 395     default:
 396         i = -1;
 397         break;
 398     }
 399
 400     if ((i < 0) || (i >= SSL_ENC_NUM_IDX))
 401         *enc = NULL;
 402     else {
 403         if (i == SSL_ENC_NULL_IDX)
 404             *enc = EVP_enc_null();
 405         else
 406             *enc = ssl_cipher_methods[i];
 407     }
 408
 409     switch (c->algorithms & SSL_MAC_MASK) {
 410     case SSL_MD5:
 411         i = SSL_MD_MD5_IDX;
 412         break;
 413     case SSL_SHA1:
 414         i = SSL_MD_SHA1_IDX;
 415         break;
 416     default:
 417         i = -1;
 418         break;
 419     }
 420     if ((i < 0) || (i >= SSL_MD_NUM_IDX))
 421         *md = NULL;
 422     else
 423         *md = ssl_digest_methods[i];
 424
 425     if ((*enc != NULL) && (*md != NULL))
 426         return (1);
 427     else
 428         return (0);
 429 }
 430
 431 #define ITEM_SEP(a) \
 432         (((a) == ':') || ((a) == ' ') || ((a) == ';') || ((a) == ','))
 433
 434 static void ll_append_tail(CIPHER_ORDER **head, CIPHER_ORDER *curr,
 435                            CIPHER_ORDER **tail)
 436 {
 437     if (curr == *tail)
 438         return;
 439     if (curr == *head)
 440         *head = curr->next;
 441     if (curr->prev != NULL)
 442         curr->prev->next = curr->next;
 443     if (curr->next != NULL)     /* should always be true */
 444         curr->next->prev = curr->prev;
 445     (*tail)->next = curr;
 446     curr->prev = *tail;
 447     curr->next = NULL;
 448     *tail = curr;
 449 }
 450
 451 struct disabled_masks {         /* This is a kludge no longer needed with
 452                                  * OpenSSL 0.9.9, where 128-bit and 256-bit
 453                                  * algorithms simply will get separate bits. */
 454     unsigned long mask;         /* everything except m256 */
 455     unsigned long m256;         /* applies to 256-bit algorithms only */
 456 };
 457
 458 static struct disabled_masks ssl_cipher_get_disabled(void)
 459 {
 460     unsigned long mask;
 461     unsigned long m256;
 462     struct disabled_masks ret;
 463
 464     mask = SSL_kFZA;
 465 #ifdef OPENSSL_NO_RSA
 466     mask |= SSL_aRSA | SSL_kRSA;
 467 #endif
 468 #ifdef OPENSSL_NO_DSA
 469     mask |= SSL_aDSS;
 470 #endif
 471 #ifdef OPENSSL_NO_DH
 472     mask |= SSL_kDHr | SSL_kDHd | SSL_kEDH | SSL_aDH;
 473 #endif
 474 #ifdef OPENSSL_NO_KRB5
 475     mask |= SSL_kKRB5 | SSL_aKRB5;
 476 #endif
 477 #ifdef OPENSSL_NO_ECDH
 478     mask |= SSL_kECDH | SSL_kECDHE;
 479 #endif
 480 #ifdef SSL_FORBID_ENULL
 481     mask |= SSL_eNULL;
 482 #endif
 483
 484     mask |= (ssl_cipher_methods[SSL_ENC_DES_IDX] == NULL) ? SSL_DES : 0;
 485     mask |= (ssl_cipher_methods[SSL_ENC_3DES_IDX] == NULL) ? SSL_3DES : 0;
 486     mask |= (ssl_cipher_methods[SSL_ENC_RC4_IDX] == NULL) ? SSL_RC4 : 0;
 487     mask |= (ssl_cipher_methods[SSL_ENC_RC2_IDX] == NULL) ? SSL_RC2 : 0;
 488     mask |= (ssl_cipher_methods[SSL_ENC_IDEA_IDX] == NULL) ? SSL_IDEA : 0;
 489     mask |= (ssl_cipher_methods[SSL_ENC_eFZA_IDX] == NULL) ? SSL_eFZA : 0;
 490     mask |= (ssl_cipher_methods[SSL_ENC_SEED_IDX] == NULL) ? SSL_SEED : 0;
 491
 492     mask |= (ssl_digest_methods[SSL_MD_MD5_IDX] == NULL) ? SSL_MD5 : 0;
 493     mask |= (ssl_digest_methods[SSL_MD_SHA1_IDX] == NULL) ? SSL_SHA1 : 0;
 494
 495     /* finally consider algorithms where mask and m256 differ */
 496     m256 = mask;
 497     mask |= (ssl_cipher_methods[SSL_ENC_AES128_IDX] == NULL) ? SSL_AES : 0;
 498     mask |=
 499         (ssl_cipher_methods[SSL_ENC_CAMELLIA128_IDX] ==
 500          NULL) ? SSL_CAMELLIA : 0;
 501     m256 |= (ssl_cipher_methods[SSL_ENC_AES256_IDX] == NULL) ? SSL_AES : 0;
 502     m256 |=
 503         (ssl_cipher_methods[SSL_ENC_CAMELLIA256_IDX] ==
 504          NULL) ? SSL_CAMELLIA : 0;
 505
 506     ret.mask = mask;
 507     ret.m256 = m256;
 508     return ret;
 509 }
 510
 511 static void ssl_cipher_collect_ciphers(const SSL_METHOD *ssl_method,
 512                                        int num_of_ciphers, unsigned long mask,
 513                                        unsigned long m256,
 514                                        CIPHER_ORDER *co_list,
 515                                        CIPHER_ORDER **head_p,
 516                                        CIPHER_ORDER **tail_p)
 517 {
 518     int i, co_list_num;
 519     SSL_CIPHER *c;
 520
 521     /*
 522      * We have num_of_ciphers descriptions compiled in, depending on the
 523      * method selected (SSLv2 and/or SSLv3, TLSv1 etc).
 524      * These will later be sorted in a linked list with at most num
 525      * entries.
 526      */
 527
 528     /* Get the initial list of ciphers */
 529     co_list_num = 0;            /* actual count of ciphers */
 530     for (i = 0; i < num_of_ciphers; i++) {
 531         c = ssl_method->get_cipher(i);
 532 #define IS_MASKED(c) ((c)->algorithms & (((c)->alg_bits == 256) ? m256 : mask))
 533         /* drop those that use any of that is not available */
 534 #ifdef OPENSSL_FIPS
 535         if ((c != NULL) && c->valid && !IS_MASKED(c)
 536             && (!FIPS_mode() || (c->algo_strength & SSL_FIPS)))
 537 #else
 538         if ((c != NULL) && c->valid && !IS_MASKED(c))
 539 #endif
 540         {
 541             co_list[co_list_num].cipher = c;
 542             co_list[co_list_num].next = NULL;
 543             co_list[co_list_num].prev = NULL;
 544             co_list[co_list_num].active = 0;
 545             co_list_num++;
 546 #ifdef KSSL_DEBUG
 547             printf("\t%d: %s %lx %lx\n", i, c->name, c->id, c->algorithms);
 548 #endif                          /* KSSL_DEBUG */
 549             /*
 550              * if (!sk_push(ca_list,(char *)c)) goto err;
 551              */
 552         }
 553     }
 554
 555     /*
 556      * Prepare linked list from list entries
 557      */
 558     for (i = 1; i < co_list_num - 1; i++) {
 559         co_list[i].prev = &(co_list[i - 1]);
 560         co_list[i].next = &(co_list[i + 1]);
 561     }
 562     if (co_list_num > 0) {
 563         (*head_p) = &(co_list[0]);
 564         (*head_p)->prev = NULL;
 565         (*head_p)->next = &(co_list[1]);
 566         (*tail_p) = &(co_list[co_list_num - 1]);
 567         (*tail_p)->prev = &(co_list[co_list_num - 2]);
 568         (*tail_p)->next = NULL;
 569     }
 570 }
 571
 572 static void ssl_cipher_collect_aliases(SSL_CIPHER **ca_list,
 573                                        int num_of_group_aliases,
 574                                        unsigned long mask, CIPHER_ORDER *head)
 575 {
 576     CIPHER_ORDER *ciph_curr;
 577     SSL_CIPHER **ca_curr;
 578     int i;
 579
 580     /*
 581      * First, add the real ciphers as already collected
 582      */
 583     ciph_curr = head;
 584     ca_curr = ca_list;
 585     while (ciph_curr != NULL) {
 586         *ca_curr = ciph_curr->cipher;
 587         ca_curr++;
 588         ciph_curr = ciph_curr->next;
 589     }
 590
 591     /*
 592      * Now we add the available ones from the cipher_aliases[] table.
 593      * They represent either an algorithm, that must be fully
 594      * supported (not match any bit in mask) or represent a cipher
 595      * strength value (will be added in any case because algorithms=0).
 596      */
 597     for (i = 0; i < num_of_group_aliases; i++) {
 598         if ((i == 0) ||         /* always fetch "ALL" */
 599             !(cipher_aliases[i].algorithms & mask)) {
 600             *ca_curr = (SSL_CIPHER *)(cipher_aliases + i);
 601             ca_curr++;
 602         }
 603     }
 604
 605     *ca_curr = NULL;            /* end of list */
 606 }
 607
 608 static void ssl_cipher_apply_rule(unsigned long cipher_id,
 609                                   unsigned long ssl_version,
 610                                   unsigned long algorithms,
 611                                   unsigned long mask,
 612                                   unsigned long algo_strength,
 613                                   unsigned long mask_strength, int rule,
 614                                   int strength_bits, CIPHER_ORDER *co_list,
 615                                   CIPHER_ORDER **head_p,
 616                                   CIPHER_ORDER **tail_p)
 617 {
 618     CIPHER_ORDER *head, *tail, *curr, *curr2, *tail2;
 619     SSL_CIPHER *cp;
 620     unsigned long ma, ma_s;
 621
 622 #ifdef CIPHER_DEBUG
 623     printf("Applying rule %d with %08lx %08lx %08lx %08lx (%d)\n",
 624            rule, algorithms, mask, algo_strength, mask_strength,
 625            strength_bits);
 626 #endif
 627
 628     curr = head = *head_p;
 629     curr2 = head;
 630     tail2 = tail = *tail_p;
 631     for (;;) {
 632         if ((curr == NULL) || (curr == tail2))
 633             break;
 634         curr = curr2;
 635         curr2 = curr->next;
 636
 637         cp = curr->cipher;
 638         /* Special case: only satisfied by COMPLEMENTOFDEFAULT */
 639         if (algo_strength == SSL_EXP_MASK) {
 640             if ((SSL_C_IS_EXPORT(cp) || cp->algorithms & SSL_SSLV2
 641                 || cp->algorithms & SSL_aNULL)
 642                 && !(cp->algorithms & (SSL_kECDHE|SSL_kECDH)))
 643                 goto ok;
 644             else
 645                 continue;
 646         }
 647
 648         /*
 649          * If explicit cipher suite, match only that one for its own protocol
 650          * version. Usual selection criteria will be used for similar
 651          * ciphersuites from other version!
 652          */
 653
 654         if (cipher_id && (cp->algorithms & SSL_SSL_MASK) == ssl_version) {
 655             if (cp->id != cipher_id)
 656                 continue;
 657         }
 658
 659         /*
 660          * Selection criteria is either the number of strength_bits
 661          * or the algorithm used.
 662          */
 663         else if (strength_bits == -1) {
 664             ma = mask & cp->algorithms;
 665             ma_s = mask_strength & cp->algo_strength;
 666
 667 #ifdef CIPHER_DEBUG
 668             printf
 669                 ("\nName: %s:\nAlgo = %08lx Algo_strength = %08lx\nMask = %08lx Mask_strength %08lx\n",
 670                  cp->name, cp->algorithms, cp->algo_strength, mask,
 671                  mask_strength);
 672             printf("ma = %08lx ma_s %08lx, ma&algo=%08lx, ma_s&algos=%08lx\n",
 673                    ma, ma_s, ma & algorithms, ma_s & algo_strength);
 674 #endif
 675             /*
 676              * Select: if none of the mask bit was met from the
 677              * cipher or not all of the bits were met, the
 678              * selection does not apply.
 679              */
 680             if (((ma == 0) && (ma_s == 0)) ||
 681                 ((ma & algorithms) != ma) || ((ma_s & algo_strength) != ma_s))
 682                 continue;       /* does not apply */
 683         } else if (strength_bits != cp->strength_bits)
 684             continue;           /* does not apply */
 685
 686         ok:
 687
 688 #ifdef CIPHER_DEBUG
 689         printf("Action = %d\n", rule);
 690 #endif
 691
 692         /* add the cipher if it has not been added yet. */
 693         if (rule == CIPHER_ADD) {
 694             if (!curr->active) {
 695                 int add_this_cipher = 1;
 696
 697                 if (((cp->algorithms & (SSL_kECDHE | SSL_kECDH | SSL_aECDSA))
 698                      != 0)) {
 699                     /*
 700                      * Make sure "ECCdraft" ciphersuites are activated only
 701                      * if *explicitly* requested, but not implicitly (such as
 702                      * as part of the "AES" alias).
 703                      */
 704
 705                     add_this_cipher =
 706                         (mask & (SSL_kECDHE | SSL_kECDH | SSL_aECDSA)) != 0
 707                         || cipher_id != 0;
 708                 }
 709
 710                 if (add_this_cipher) {
 711                     ll_append_tail(&head, curr, &tail);
 712                     curr->active = 1;
 713                 }
 714             }
 715         }
 716         /* Move the added cipher to this location */
 717         else if (rule == CIPHER_ORD) {
 718             if (curr->active) {
 719                 ll_append_tail(&head, curr, &tail);
 720             }
 721         } else if (rule == CIPHER_DEL)
 722             curr->active = 0;
 723         else if (rule == CIPHER_KILL) {
 724             if (head == curr)
 725                 head = curr->next;
 726             else
 727                 curr->prev->next = curr->next;
 728             if (tail == curr)
 729                 tail = curr->prev;
 730             curr->active = 0;
 731             if (curr->next != NULL)
 732                 curr->next->prev = curr->prev;
 733             if (curr->prev != NULL)
 734                 curr->prev->next = curr->next;
 735             curr->next = NULL;
 736             curr->prev = NULL;
 737         }
 738     }
 739
 740     *head_p = head;
 741     *tail_p = tail;
 742 }
 743
 744 static int ssl_cipher_strength_sort(CIPHER_ORDER *co_list,
 745                                     CIPHER_ORDER **head_p,
 746                                     CIPHER_ORDER **tail_p)
 747 {
 748     int max_strength_bits, i, *number_uses;
 749     CIPHER_ORDER *curr;
 750
 751     /*
 752      * This routine sorts the ciphers with descending strength. The sorting
 753      * must keep the pre-sorted sequence, so we apply the normal sorting
 754      * routine as '+' movement to the end of the list.
 755      */
 756     max_strength_bits = 0;
 757     curr = *head_p;
 758     while (curr != NULL) {
 759         if (curr->active && (curr->cipher->strength_bits > max_strength_bits))
 760             max_strength_bits = curr->cipher->strength_bits;
 761         curr = curr->next;
 762     }
 763
 764     number_uses = OPENSSL_malloc((max_strength_bits + 1) * sizeof(int));
 765     if (!number_uses) {
 766         SSLerr(SSL_F_SSL_CIPHER_STRENGTH_SORT, ERR_R_MALLOC_FAILURE);
 767         return (0);
 768     }
 769     memset(number_uses, 0, (max_strength_bits + 1) * sizeof(int));
 770
 771     /*
 772      * Now find the strength_bits values actually used
 773      */
 774     curr = *head_p;
 775     while (curr != NULL) {
 776         if (curr->active)
 777             number_uses[curr->cipher->strength_bits]++;
 778         curr = curr->next;
 779     }
 780     /*
 781      * Go through the list of used strength_bits values in descending
 782      * order.
 783      */
 784     for (i = max_strength_bits; i >= 0; i--)
 785         if (number_uses[i] > 0)
 786             ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, CIPHER_ORD, i,
 787                                   co_list, head_p, tail_p);
 788
 789     OPENSSL_free(number_uses);
 790     return (1);
 791 }
 792
 793 static int ssl_cipher_process_rulestr(const char *rule_str,
 794                                       CIPHER_ORDER *co_list,
 795                                       CIPHER_ORDER **head_p,
 796                                       CIPHER_ORDER **tail_p,
 797                                       SSL_CIPHER **ca_list)
 798 {
 799     unsigned long algorithms, mask, algo_strength, mask_strength;
 800     const char *l, *buf;
 801     int j, multi, found, rule, retval, ok, buflen;
 802     unsigned long cipher_id = 0, ssl_version = 0;
 803     char ch;
 804
 805     retval = 1;
 806     l = rule_str;
 807     for (;;) {
 808         ch = *l;
 809
 810         if (ch == '\0')
 811             break;              /* done */
 812         if (ch == '-') {
 813             rule = CIPHER_DEL;
 814             l++;
 815         } else if (ch == '+') {
 816             rule = CIPHER_ORD;
 817             l++;
 818         } else if (ch == '!') {
 819             rule = CIPHER_KILL;
 820             l++;
 821         } else if (ch == '@') {
 822             rule = CIPHER_SPECIAL;
 823             l++;
 824         } else {
 825             rule = CIPHER_ADD;
 826         }
 827
 828         if (ITEM_SEP(ch)) {
 829             l++;
 830             continue;
 831         }
 832
 833         algorithms = mask = algo_strength = mask_strength = 0;
 834
 835         for (;;) {
 836             ch = *l;
 837             buf = l;
 838             buflen = 0;
 839 #ifndef CHARSET_EBCDIC
 840             while (((ch >= 'A') && (ch <= 'Z')) ||
 841                    ((ch >= '0') && (ch <= '9')) ||
 842                    ((ch >= 'a') && (ch <= 'z')) || (ch == '-'))
 843 #else
 844             while (isalnum(ch) || (ch == '-'))
 845 #endif
 846             {
 847                 ch = *(++l);
 848                 buflen++;
 849             }
 850
 851             if (buflen == 0) {
 852                 /*
 853                  * We hit something we cannot deal with,
 854                  * it is no command or separator nor
 855                  * alphanumeric, so we call this an error.
 856                  */
 857                 SSLerr(SSL_F_SSL_CIPHER_PROCESS_RULESTR,
 858                        SSL_R_INVALID_COMMAND);
 859                 retval = found = 0;
 860                 l++;
 861                 break;
 862             }
 863
 864             if (rule == CIPHER_SPECIAL) {
 865                 found = 0;      /* unused -- avoid compiler warning */
 866                 break;          /* special treatment */
 867             }
 868
 869             /* check for multi-part specification */
 870             if (ch == '+') {
 871                 multi = 1;
 872                 l++;
 873             } else
 874                 multi = 0;
 875
 876             /*
 877              * Now search for the cipher alias in the ca_list. Be careful
 878              * with the strncmp, because the "buflen" limitation
 879              * will make the rule "ADH:SOME" and the cipher
 880              * "ADH-MY-CIPHER" look like a match for buflen=3.
 881              * So additionally check whether the cipher name found
 882              * has the correct length. We can save a strlen() call:
 883              * just checking for the '\0' at the right place is
 884              * sufficient, we have to strncmp() anyway. (We cannot
 885              * use strcmp(), because buf is not '\0' terminated.)
 886              */
 887             j = found = 0;
 888             cipher_id = 0;
 889             ssl_version = 0;
 890             while (ca_list[j]) {
 891                 if (!strncmp(buf, ca_list[j]->name, buflen) &&
 892                     (ca_list[j]->name[buflen] == '\0')) {
 893                     found = 1;
 894                     break;
 895                 } else
 896                     j++;
 897             }
 898             if (!found)
 899                 break;          /* ignore this entry */
 900
 901             /*-
 902              * New algorithms:
 903              *  1 - any old restrictions apply outside new mask
 904              *  2 - any new restrictions apply outside old mask
 905              *  3 - enforce old & new where masks intersect
 906              */
 907             algorithms = (algorithms & ~ca_list[j]->mask) | /* 1 */
 908                 (ca_list[j]->algorithms & ~mask) | /* 2 */
 909                 (algorithms & ca_list[j]->algorithms); /* 3 */
 910             mask |= ca_list[j]->mask;
 911             algo_strength = (algo_strength & ~ca_list[j]->mask_strength) |
 912                 (ca_list[j]->algo_strength & ~mask_strength) |
 913                 (algo_strength & ca_list[j]->algo_strength);
 914             mask_strength |= ca_list[j]->mask_strength;
 915
 916             /* explicit ciphersuite found */
 917             if (ca_list[j]->valid) {
 918                 cipher_id = ca_list[j]->id;
 919                 ssl_version = ca_list[j]->algorithms & SSL_SSL_MASK;
 920                 break;
 921             }
 922
 923             if (!multi)
 924                 break;
 925         }
 926
 927         /*
 928          * Ok, we have the rule, now apply it
 929          */
 930         if (rule == CIPHER_SPECIAL) { /* special command */
 931             ok = 0;
 932             if ((buflen == 8) && !strncmp(buf, "STRENGTH", 8))
 933                 ok = ssl_cipher_strength_sort(co_list, head_p, tail_p);
 934             else
 935                 SSLerr(SSL_F_SSL_CIPHER_PROCESS_RULESTR,
 936                        SSL_R_INVALID_COMMAND);
 937             if (ok == 0)
 938                 retval = 0;
 939             /*
 940              * We do not support any "multi" options
 941              * together with "@", so throw away the
 942              * rest of the command, if any left, until
 943              * end or ':' is found.
 944              */
 945             while ((*l != '\0') && !ITEM_SEP(*l))
 946                 l++;
 947         } else if (found) {
 948             ssl_cipher_apply_rule(cipher_id, ssl_version, algorithms, mask,
 949                                   algo_strength, mask_strength, rule, -1,
 950                                   co_list, head_p, tail_p);
 951         } else {
 952             while ((*l != '\0') && !ITEM_SEP(*l))
 953                 l++;
 954         }
 955         if (*l == '\0')
 956             break;              /* done */
 957     }
 958
 959     return (retval);
 960 }
 961
 962 STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(const SSL_METHOD *ssl_method, STACK_OF(SSL_CIPHER)
 963                                              **cipher_list, STACK_OF(SSL_CIPHER)
 964                                              **cipher_list_by_id,
 965                                              const char *rule_str)
 966 {
 967     int ok, num_of_ciphers, num_of_alias_max, num_of_group_aliases;
 968     unsigned long disabled_mask;
 969     unsigned long disabled_m256;
 970     STACK_OF(SSL_CIPHER) *cipherstack, *tmp_cipher_list;
 971     const char *rule_p;
 972     CIPHER_ORDER *co_list = NULL, *head = NULL, *tail = NULL, *curr;
 973     SSL_CIPHER **ca_list = NULL;
 974
 975     /*
 976      * Return with error if nothing to do.
 977      */
 978     if (rule_str == NULL || cipher_list == NULL || cipher_list_by_id == NULL)
 979         return NULL;
 980
 981     /*
 982      * To reduce the work to do we only want to process the compiled
 983      * in algorithms, so we first get the mask of disabled ciphers.
 984      */
 985     {
 986         struct disabled_masks d;
 987         d = ssl_cipher_get_disabled();
 988         disabled_mask = d.mask;
 989         disabled_m256 = d.m256;
 990     }
 991
 992     /*
 993      * Now we have to collect the available ciphers from the compiled
 994      * in ciphers. We cannot get more than the number compiled in, so
 995      * it is used for allocation.
 996      */
 997     num_of_ciphers = ssl_method->num_ciphers();
 998 #ifdef KSSL_DEBUG
 999     printf("ssl_create_cipher_list() for %d ciphers\n", num_of_ciphers);
1000 #endif                          /* KSSL_DEBUG */
1001     co_list =
1002         (CIPHER_ORDER *)OPENSSL_malloc(sizeof(CIPHER_ORDER) * num_of_ciphers);
1003     if (co_list == NULL) {
1004         SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST, ERR_R_MALLOC_FAILURE);
1005         return (NULL);          /* Failure */
1006     }
1007
1008     ssl_cipher_collect_ciphers(ssl_method, num_of_ciphers, disabled_mask,
1009                                disabled_m256, co_list, &head, &tail);
1010
1011     /*
1012      * We also need cipher aliases for selecting based on the rule_str.
1013      * There might be two types of entries in the rule_str: 1) names
1014      * of ciphers themselves 2) aliases for groups of ciphers.
1015      * For 1) we need the available ciphers and for 2) the cipher
1016      * groups of cipher_aliases added together in one list (otherwise
1017      * we would be happy with just the cipher_aliases table).
1018      */
1019     num_of_group_aliases = sizeof(cipher_aliases) / sizeof(SSL_CIPHER);
1020     num_of_alias_max = num_of_ciphers + num_of_group_aliases + 1;
1021     ca_list =
1022         (SSL_CIPHER **)OPENSSL_malloc(sizeof(SSL_CIPHER *) *
1023                                       num_of_alias_max);
1024     if (ca_list == NULL) {
1025         OPENSSL_free(co_list);
1026         SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST, ERR_R_MALLOC_FAILURE);
1027         return (NULL);          /* Failure */
1028     }
1029     ssl_cipher_collect_aliases(ca_list, num_of_group_aliases,
1030                                (disabled_mask & disabled_m256), head);
1031
1032     /*
1033      * If the rule_string begins with DEFAULT, apply the default rule
1034      * before using the (possibly available) additional rules.
1035      */
1036     ok = 1;
1037     rule_p = rule_str;
1038     if (strncmp(rule_str, "DEFAULT", 7) == 0) {
1039         ok = ssl_cipher_process_rulestr(SSL_DEFAULT_CIPHER_LIST,
1040                                         co_list, &head, &tail, ca_list);
1041         rule_p += 7;
1042         if (*rule_p == ':')
1043             rule_p++;
1044     }
1045
1046     if (ok && (strlen(rule_p) > 0))
1047         ok = ssl_cipher_process_rulestr(rule_p, co_list, &head, &tail,
1048                                         ca_list);
1049
1050     OPENSSL_free(ca_list);      /* Not needed anymore */
1051
1052     if (!ok) {                  /* Rule processing failure */
1053         OPENSSL_free(co_list);
1054         return (NULL);
1055     }
1056     /*
1057      * Allocate new "cipherstack" for the result, return with error
1058      * if we cannot get one.
1059      */
1060     if ((cipherstack = sk_SSL_CIPHER_new_null()) == NULL) {
1061         OPENSSL_free(co_list);
1062         return (NULL);
1063     }
1064
1065     /*
1066      * The cipher selection for the list is done. The ciphers are added
1067      * to the resulting precedence to the STACK_OF(SSL_CIPHER).
1068      */
1069     for (curr = head; curr != NULL; curr = curr->next) {
1070 #ifdef OPENSSL_FIPS
1071         if (curr->active
1072             && (!FIPS_mode() || curr->cipher->algo_strength & SSL_FIPS))
1073 #else
1074         if (curr->active)
1075 #endif
1076         {
1077             sk_SSL_CIPHER_push(cipherstack, curr->cipher);
1078 #ifdef CIPHER_DEBUG
1079             printf("<%s>\n", curr->cipher->name);
1080 #endif
1081         }
1082     }
1083     OPENSSL_free(co_list);      /* Not needed any longer */
1084
1085     tmp_cipher_list = sk_SSL_CIPHER_dup(cipherstack);
1086     if (tmp_cipher_list == NULL) {
1087         sk_SSL_CIPHER_free(cipherstack);
1088         return NULL;
1089     }
1090     if (*cipher_list != NULL)
1091         sk_SSL_CIPHER_free(*cipher_list);
1092     *cipher_list = cipherstack;
1093     if (*cipher_list_by_id != NULL)
1094         sk_SSL_CIPHER_free(*cipher_list_by_id);
1095     *cipher_list_by_id = tmp_cipher_list;
1096     (void)sk_SSL_CIPHER_set_cmp_func(*cipher_list_by_id,
1097                                      ssl_cipher_ptr_id_cmp);
1098
1099     sk_SSL_CIPHER_sort(*cipher_list_by_id);
1100     return (cipherstack);
1101 }
1102
1103 char *SSL_CIPHER_description(const SSL_CIPHER *cipher, char *buf, int len)
1104 {
1105     int is_export, pkl, kl;
1106     const char *ver, *exp_str;
1107     const char *kx, *au, *enc, *mac;
1108     unsigned long alg, alg2;
1109 #ifdef KSSL_DEBUG
1110     static const char *format =
1111         "%-23s %s Kx=%-8s Au=%-4s Enc=%-9s Mac=%-4s%s AL=%lx\n";
1112 #else
1113     static const char *format =
1114         "%-23s %s Kx=%-8s Au=%-4s Enc=%-9s Mac=%-4s%s\n";
1115 #endif                          /* KSSL_DEBUG */
1116
1117     alg = cipher->algorithms;
1118     alg2 = cipher->algorithm2;
1119
1120     is_export = SSL_C_IS_EXPORT(cipher);
1121     pkl = SSL_C_EXPORT_PKEYLENGTH(cipher);
1122     kl = SSL_C_EXPORT_KEYLENGTH(cipher);
1123     exp_str = is_export ? " export" : "";
1124
1125     if (alg & SSL_SSLV2)
1126         ver = "SSLv2";
1127     else if (alg & SSL_SSLV3)
1128         ver = "SSLv3";
1129     else
1130         ver = "unknown";
1131
1132     switch (alg & SSL_MKEY_MASK) {
1133     case SSL_kRSA:
1134         kx = is_export ? (pkl == 512 ? "RSA(512)" : "RSA(1024)") : "RSA";
1135         break;
1136     case SSL_kDHr:
1137         kx = "DH/RSA";
1138         break;
1139     case SSL_kDHd:
1140         kx = "DH/DSS";
1141         break;
1142     case SSL_kKRB5:            /* VRS */
1143     case SSL_KRB5:             /* VRS */
1144         kx = "KRB5";
1145         break;
1146     case SSL_kFZA:
1147         kx = "Fortezza";
1148         break;
1149     case SSL_kEDH:
1150         kx = is_export ? (pkl == 512 ? "DH(512)" : "DH(1024)") : "DH";
1151         break;
1152     case SSL_kECDH:
1153     case SSL_kECDHE:
1154         kx = is_export ? "ECDH(<=163)" : "ECDH";
1155         break;
1156     default:
1157         kx = "unknown";
1158     }
1159
1160     switch (alg & SSL_AUTH_MASK) {
1161     case SSL_aRSA:
1162         au = "RSA";
1163         break;
1164     case SSL_aDSS:
1165         au = "DSS";
1166         break;
1167     case SSL_aDH:
1168         au = "DH";
1169         break;
1170     case SSL_aKRB5:            /* VRS */
1171     case SSL_KRB5:             /* VRS */
1172         au = "KRB5";
1173         break;
1174     case SSL_aFZA:
1175     case SSL_aNULL:
1176         au = "None";
1177         break;
1178     case SSL_aECDSA:
1179         au = "ECDSA";
1180         break;
1181     default:
1182         au = "unknown";
1183         break;
1184     }
1185
1186     switch (alg & SSL_ENC_MASK) {
1187     case SSL_DES:
1188         enc = (is_export && kl == 5) ? "DES(40)" : "DES(56)";
1189         break;
1190     case SSL_3DES:
1191         enc = "3DES(168)";
1192         break;
1193     case SSL_RC4:
1194         enc = is_export ? (kl == 5 ? "RC4(40)" : "RC4(56)")
1195             : ((alg2 & SSL2_CF_8_BYTE_ENC) ? "RC4(64)" : "RC4(128)");
1196         break;
1197     case SSL_RC2:
1198         enc = is_export ? (kl == 5 ? "RC2(40)" : "RC2(56)") : "RC2(128)";
1199         break;
1200     case SSL_IDEA:
1201         enc = "IDEA(128)";
1202         break;
1203     case SSL_eFZA:
1204         enc = "Fortezza";
1205         break;
1206     case SSL_eNULL:
1207         enc = "None";
1208         break;
1209     case SSL_AES:
1210         switch (cipher->strength_bits) {
1211         case 128:
1212             enc = "AES(128)";
1213             break;
1214         case 192:
1215             enc = "AES(192)";
1216             break;
1217         case 256:
1218             enc = "AES(256)";
1219             break;
1220         default:
1221             enc = "AES(?" "?" "?)";
1222             break;
1223         }
1224         break;
1225     case SSL_CAMELLIA:
1226         switch (cipher->strength_bits) {
1227         case 128:
1228             enc = "Camellia(128)";
1229             break;
1230         case 256:
1231             enc = "Camellia(256)";
1232             break;
1233         default:
1234             enc = "Camellia(?" "?" "?)";
1235             break;
1236         }
1237         break;
1238     case SSL_SEED:
1239         enc = "SEED(128)";
1240         break;
1241
1242     default:
1243         enc = "unknown";
1244         break;
1245     }
1246
1247     switch (alg & SSL_MAC_MASK) {
1248     case SSL_MD5:
1249         mac = "MD5";
1250         break;
1251     case SSL_SHA1:
1252         mac = "SHA1";
1253         break;
1254     default:
1255         mac = "unknown";
1256         break;
1257     }
1258
1259     if (buf == NULL) {
1260         len = 128;
1261         buf = OPENSSL_malloc(len);
1262         if (buf == NULL)
1263             return ("OPENSSL_malloc Error");
1264     } else if (len < 128)
1265         return ("Buffer too small");
1266
1267 #ifdef KSSL_DEBUG
1268     BIO_snprintf(buf, len, format, cipher->name, ver, kx, au, enc, mac,
1269                  exp_str, alg);
1270 #else
1271     BIO_snprintf(buf, len, format, cipher->name, ver, kx, au, enc, mac,
1272                  exp_str);
1273 #endif                          /* KSSL_DEBUG */
1274     return (buf);
1275 }
1276
1277 char *SSL_CIPHER_get_version(const SSL_CIPHER *c)
1278 {
1279     int i;
1280
1281     if (c == NULL)
1282         return ("(NONE)");
1283     i = (int)(c->id >> 24L);
1284     if (i == 3)
1285         return ("TLSv1/SSLv3");
1286     else if (i == 2)
1287         return ("SSLv2");
1288     else
1289         return ("unknown");
1290 }
1291
1292 /* return the actual cipher being used */
1293 const char *SSL_CIPHER_get_name(const SSL_CIPHER *c)
1294 {
1295     if (c != NULL)
1296         return (c->name);
1297     return ("(NONE)");
1298 }
1299
1300 /* number of bits for symmetric cipher */
1301 int SSL_CIPHER_get_bits(const SSL_CIPHER *c, int *alg_bits)
1302 {
1303     int ret = 0;
1304
1305     if (c != NULL) {
1306         if (alg_bits != NULL)
1307             *alg_bits = c->alg_bits;
1308         ret = c->strength_bits;
1309     }
1310     return (ret);
1311 }
1312
1313 SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n)
1314 {
1315     SSL_COMP *ctmp;
1316     int i, nn;
1317
1318     if ((n == 0) || (sk == NULL))
1319         return (NULL);
1320     nn = sk_SSL_COMP_num(sk);
1321     for (i = 0; i < nn; i++) {
1322         ctmp = sk_SSL_COMP_value(sk, i);
1323         if (ctmp->id == n)
1324             return (ctmp);
1325     }
1326     return (NULL);
1327 }
1328
1329 #ifdef OPENSSL_NO_COMP
1330 void *SSL_COMP_get_compression_methods(void)
1331 {
1332     return NULL;
1333 }
1334
1335 int SSL_COMP_add_compression_method(int id, void *cm)
1336 {
1337     return 1;
1338 }
1339
1340 const char *SSL_COMP_get_name(const void *comp)
1341 {
1342     return NULL;
1343 }
1344 #else
1345 STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void)
1346 {
1347     load_builtin_compressions();
1348     return (ssl_comp_methods);
1349 }
1350
1351 int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm)
1352 {
1353     SSL_COMP *comp;
1354
1355     if (cm == NULL || cm->type == NID_undef)
1356         return 1;
1357
1358     /*-
1359      * According to draft-ietf-tls-compression-04.txt, the
1360      * compression number ranges should be the following:
1361      *
1362      *   0 to  63:  methods defined by the IETF
1363      *  64 to 192:  external party methods assigned by IANA
1364      * 193 to 255:  reserved for private use
1365      */
1366     if (id < 193 || id > 255) {
1367         SSLerr(SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD,
1368                SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE);
1369         return 0;
1370     }
1371
1372     MemCheck_off();
1373     comp = (SSL_COMP *)OPENSSL_malloc(sizeof(SSL_COMP));
1374     comp->id = id;
1375     comp->method = cm;
1376     load_builtin_compressions();
1377     if (ssl_comp_methods && sk_SSL_COMP_find(ssl_comp_methods, comp) >= 0) {
1378         OPENSSL_free(comp);
1379         MemCheck_on();
1380         SSLerr(SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD,
1381                SSL_R_DUPLICATE_COMPRESSION_ID);
1382         return (1);
1383     } else if ((ssl_comp_methods == NULL)
1384                || !sk_SSL_COMP_push(ssl_comp_methods, comp)) {
1385         OPENSSL_free(comp);
1386         MemCheck_on();
1387         SSLerr(SSL_F_SSL_COMP_ADD_COMPRESSION_METHOD, ERR_R_MALLOC_FAILURE);
1388         return (1);
1389     } else {
1390         MemCheck_on();
1391         return (0);
1392     }
1393 }
1394
1395 const char *SSL_COMP_get_name(const COMP_METHOD *comp)
1396 {
1397     if (comp)
1398         return comp->name;
1399     return NULL;
1400 }
1401
1402 #endif