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