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   * Copyright (c) 1998-2006 The OpenSSL Project.  All rights reserved.

    58  *

    59  * Redistribution and use in source and binary forms, with or without

    60  * modification, are permitted provided that the following conditions

    61  * are met:

    62  *

    63  * 1. Redistributions of source code must retain the above copyright

    64  *    notice, this list of conditions and the following disclaimer. 

    65  *

    66  * 2. Redistributions in binary form must reproduce the above copyright

    67  *    notice, this list of conditions and the following disclaimer in

    68  *    the documentation and/or other materials provided with the

    69  *    distribution.

    70  *

    71  * 3. All advertising materials mentioning features or use of this

    72  *    software must display the following acknowledgment:

    73  *    "This product includes software developed by the OpenSSL Project

    74  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"

    75  *

    76  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to

    77  *    endorse or promote products derived from this software without

    78  *    prior written permission. For written permission, please contact

    79  *    openssl-core@openssl.org.

    80  *

    81  * 5. Products derived from this software may not be called "OpenSSL"

    82  *    nor may "OpenSSL" appear in their names without prior written

    83  *    permission of the OpenSSL Project.

    84  *

    85  * 6. Redistributions of any form whatsoever must retain the following

    86  *    acknowledgment:

    87  *    "This product includes software developed by the OpenSSL Project

    88  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"

    89  *

    90  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY

    91  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    92  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    93  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR

    94  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

    95  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

    96  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    97  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

    98  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

    99  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

   100  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED

   101  * OF THE POSSIBILITY OF SUCH DAMAGE.

   102  * ====================================================================

   103  *

   104  * This product includes cryptographic software written by Eric Young

   105  * (eay@cryptsoft.com).  This product includes software written by Tim

   106  * Hudson (tjh@cryptsoft.com).

   107  *

   108  */

   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  © Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

   118  */

   119  

   120 #include <stdio.h>

   121 #include <openssl/objects.h>

   122 #include <openssl/comp.h>

   123 #include "ssl_locl.h"

   124 

   125 #define SSL_ENC_DES_IDX		0

   126 #define SSL_ENC_3DES_IDX	1

   127 #define SSL_ENC_RC4_IDX		2

   128 #define SSL_ENC_RC2_IDX		3

   129 #define SSL_ENC_IDEA_IDX	4

   130 #define SSL_ENC_eFZA_IDX	5

   131 #define SSL_ENC_NULL_IDX	6

   132 #define SSL_ENC_AES128_IDX	7

   133 #define SSL_ENC_AES256_IDX	8

   134 #define SSL_ENC_NUM_IDX		9

   135 

   136 #ifndef EMULATOR

   137 static const EVP_CIPHER *ssl_cipher_methods[SSL_ENC_NUM_IDX]={

   138 	NULL,NULL,NULL,NULL,NULL,NULL,

   139 	};

   140 #else

   141 	GET_STATIC_ARRAY_FROM_TLS(ssl_cipher_methods,ssl_ciph,const EVP_CIPHER *)

   142 	

   143 	#define ssl_cipher_methods (GET_WSD_VAR_NAME(ssl_cipher_methods,ssl_ciph,s)())

   144 #endif

   145 

   146 #define SSL_COMP_NULL_IDX	0

   147 #define SSL_COMP_ZLIB_IDX	1

   148 #define SSL_COMP_NUM_IDX	2

   149 

   150 #ifndef EMULATOR

   151 static STACK_OF(SSL_COMP) *ssl_comp_methods=NULL;

   152 #else

   153 	GET_STATIC_VAR_FROM_TLS(ssl_comp_methods,ssl_ciph,STACK_OF(SSL_COMP) *)

   154 	

   155 	#define ssl_comp_methods (*GET_WSD_VAR_NAME(ssl_comp_methods,ssl_ciph,s)())

   156 #endif

   157 

   158 #define SSL_MD_MD5_IDX	0

   159 #define SSL_MD_SHA1_IDX	1

   160 #define SSL_MD_NUM_IDX	2

   161 #ifndef EMULATOR

   162 static const EVP_MD *ssl_digest_methods[SSL_MD_NUM_IDX]={

   163 	NULL,NULL,

   164 	};

   165 #else /* EMULATOR */

   166 	GET_STATIC_ARRAY_FROM_TLS(ssl_digest_methods,ssl_ciph,const EVP_MD *)

   167 	

   168 	#define ssl_digest_methods (GET_WSD_VAR_NAME(ssl_digest_methods,ssl_ciph,s)())

   169 #endif

   170 #define CIPHER_ADD	1

   171 #define CIPHER_KILL	2

   172 #define CIPHER_DEL	3

   173 #define CIPHER_ORD	4

   174 #define CIPHER_SPECIAL	5

   175 

   176 typedef struct cipher_order_st

   177 	{

   178 	SSL_CIPHER *cipher;

   179 	int active;

   180 	int dead;

   181 	struct cipher_order_st *next,*prev;

   182 	} CIPHER_ORDER;

   183 

   184 static const SSL_CIPHER cipher_aliases[]={

   185 	/* Don't include eNULL unless specifically enabled. */

   186 	/* Don't include ECC in ALL because these ciphers are not yet official. */

   187 	{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 */

   188 	/* TODO: COMPLEMENT OF ALL and COMPLEMENT OF DEFAULT do not have ECC cipher suites handled properly. */

   189 	{0,SSL_TXT_CMPALL,0,SSL_eNULL,0,0,0,0,SSL_ENC_MASK,0},  /* COMPLEMENT OF ALL */

   190 	{0,SSL_TXT_CMPDEF,0,SSL_ADH, 0,0,0,0,SSL_AUTH_MASK,0},

   191 	{0,SSL_TXT_kKRB5,0,SSL_kKRB5,0,0,0,0,SSL_MKEY_MASK,0},  /* VRS Kerberos5 */

   192 	{0,SSL_TXT_kRSA,0,SSL_kRSA,  0,0,0,0,SSL_MKEY_MASK,0},

   193 	{0,SSL_TXT_kDHr,0,SSL_kDHr,  0,0,0,0,SSL_MKEY_MASK,0},

   194 	{0,SSL_TXT_kDHd,0,SSL_kDHd,  0,0,0,0,SSL_MKEY_MASK,0},

   195 	{0,SSL_TXT_kEDH,0,SSL_kEDH,  0,0,0,0,SSL_MKEY_MASK,0},

   196 	{0,SSL_TXT_kFZA,0,SSL_kFZA,  0,0,0,0,SSL_MKEY_MASK,0},

   197 	{0,SSL_TXT_DH,	0,SSL_DH,    0,0,0,0,SSL_MKEY_MASK,0},

   198 	{0,SSL_TXT_ECC,	0,(SSL_kECDH|SSL_kECDHE), 0,0,0,0,SSL_MKEY_MASK,0},

   199 	{0,SSL_TXT_EDH,	0,SSL_EDH,   0,0,0,0,SSL_MKEY_MASK|SSL_AUTH_MASK,0},

   200 	{0,SSL_TXT_aKRB5,0,SSL_aKRB5,0,0,0,0,SSL_AUTH_MASK,0},  /* VRS Kerberos5 */

   201 	{0,SSL_TXT_aRSA,0,SSL_aRSA,  0,0,0,0,SSL_AUTH_MASK,0},

   202 	{0,SSL_TXT_aDSS,0,SSL_aDSS,  0,0,0,0,SSL_AUTH_MASK,0},

   203 	{0,SSL_TXT_aFZA,0,SSL_aFZA,  0,0,0,0,SSL_AUTH_MASK,0},

   204 	{0,SSL_TXT_aNULL,0,SSL_aNULL,0,0,0,0,SSL_AUTH_MASK,0},

   205 	{0,SSL_TXT_aDH, 0,SSL_aDH,   0,0,0,0,SSL_AUTH_MASK,0},

   206 	{0,SSL_TXT_DSS,	0,SSL_DSS,   0,0,0,0,SSL_AUTH_MASK,0},

   207 

   208 	{0,SSL_TXT_DES,	0,SSL_DES,   0,0,0,0,SSL_ENC_MASK,0},

   209 	{0,SSL_TXT_3DES,0,SSL_3DES,  0,0,0,0,SSL_ENC_MASK,0},

   210 	{0,SSL_TXT_RC4,	0,SSL_RC4,   0,0,0,0,SSL_ENC_MASK,0},

   211 	{0,SSL_TXT_RC2,	0,SSL_RC2,   0,0,0,0,SSL_ENC_MASK,0},

   212 #ifndef OPENSSL_NO_IDEA

   213 	{0,SSL_TXT_IDEA,0,SSL_IDEA,  0,0,0,0,SSL_ENC_MASK,0},

   214 #endif

   215 	{0,SSL_TXT_eNULL,0,SSL_eNULL,0,0,0,0,SSL_ENC_MASK,0},

   216 	{0,SSL_TXT_eFZA,0,SSL_eFZA,  0,0,0,0,SSL_ENC_MASK,0},

   217 	{0,SSL_TXT_AES,	0,SSL_AES,   0,0,0,0,SSL_ENC_MASK,0},

   218 

   219 	{0,SSL_TXT_MD5,	0,SSL_MD5,   0,0,0,0,SSL_MAC_MASK,0},

   220 	{0,SSL_TXT_SHA1,0,SSL_SHA1,  0,0,0,0,SSL_MAC_MASK,0},

   221 	{0,SSL_TXT_SHA,	0,SSL_SHA,   0,0,0,0,SSL_MAC_MASK,0},

   222 

   223 	{0,SSL_TXT_NULL,0,SSL_NULL,  0,0,0,0,SSL_ENC_MASK,0},

   224 	{0,SSL_TXT_KRB5,0,SSL_KRB5,  0,0,0,0,SSL_AUTH_MASK|SSL_MKEY_MASK,0},

   225 	{0,SSL_TXT_RSA,	0,SSL_RSA,   0,0,0,0,SSL_AUTH_MASK|SSL_MKEY_MASK,0},

   226 	{0,SSL_TXT_ADH,	0,SSL_ADH,   0,0,0,0,SSL_AUTH_MASK|SSL_MKEY_MASK,0},

   227 	{0,SSL_TXT_FZA,	0,SSL_FZA,   0,0,0,0,SSL_AUTH_MASK|SSL_MKEY_MASK|SSL_ENC_MASK,0},

   228 

   229 	{0,SSL_TXT_SSLV2, 0,SSL_SSLV2, 0,0,0,0,SSL_SSL_MASK,0},

   230 	{0,SSL_TXT_SSLV3, 0,SSL_SSLV3, 0,0,0,0,SSL_SSL_MASK,0},

   231 	{0,SSL_TXT_TLSV1, 0,SSL_TLSV1, 0,0,0,0,SSL_SSL_MASK,0},

   232 

   233 	{0,SSL_TXT_EXP   ,0, 0,SSL_EXPORT, 0,0,0,0,SSL_EXP_MASK},

   234 	{0,SSL_TXT_EXPORT,0, 0,SSL_EXPORT, 0,0,0,0,SSL_EXP_MASK},

   235 	{0,SSL_TXT_EXP40, 0, 0, SSL_EXP40, 0,0,0,0,SSL_STRONG_MASK},

   236 	{0,SSL_TXT_EXP56, 0, 0, SSL_EXP56, 0,0,0,0,SSL_STRONG_MASK},

   237 	{0,SSL_TXT_LOW,   0, 0,   SSL_LOW, 0,0,0,0,SSL_STRONG_MASK},

   238 	{0,SSL_TXT_MEDIUM,0, 0,SSL_MEDIUM, 0,0,0,0,SSL_STRONG_MASK},

   239 	{0,SSL_TXT_HIGH,  0, 0,  SSL_HIGH, 0,0,0,0,SSL_STRONG_MASK},

   240 	};

   241 

   242 void ssl_load_ciphers(void)

   243 	{

   244 	ssl_cipher_methods[SSL_ENC_DES_IDX]= 

   245 		EVP_get_cipherbyname(SN_des_cbc);

   246 	ssl_cipher_methods[SSL_ENC_3DES_IDX]=

   247 		EVP_get_cipherbyname(SN_des_ede3_cbc);

   248 	ssl_cipher_methods[SSL_ENC_RC4_IDX]=

   249 		EVP_get_cipherbyname(SN_rc4);

   250 	ssl_cipher_methods[SSL_ENC_RC2_IDX]= 

   251 		EVP_get_cipherbyname(SN_rc2_cbc);

   252 #ifndef OPENSSL_NO_IDEA

   253 	ssl_cipher_methods[SSL_ENC_IDEA_IDX]= 

   254 		EVP_get_cipherbyname(SN_idea_cbc);

   255 #else

   256 	ssl_cipher_methods[SSL_ENC_IDEA_IDX]= NULL;

   257 #endif

   258 	ssl_cipher_methods[SSL_ENC_AES128_IDX]=

   259 	  EVP_get_cipherbyname(SN_aes_128_cbc);

   260 	ssl_cipher_methods[SSL_ENC_AES256_IDX]=

   261 	  EVP_get_cipherbyname(SN_aes_256_cbc);

   262 

   263 	ssl_digest_methods[SSL_MD_MD5_IDX]=

   264 		EVP_get_digestbyname(SN_md5);

   265 	ssl_digest_methods[SSL_MD_SHA1_IDX]=

   266 		EVP_get_digestbyname(SN_sha1);

   267 	}

   268 

   269 

   270 #ifndef OPENSSL_NO_COMP

   271 

   272 static int sk_comp_cmp(const SSL_COMP * const *a,

   273 			const SSL_COMP * const *b)

   274 	{

   275 	return((*a)->id-(*b)->id);

   276 	}

   277 

   278 static void load_builtin_compressions(void)

   279 	{

   280 		int got_write_lock = 0;

   281 

   282 	CRYPTO_r_lock(CRYPTO_LOCK_SSL);

   283 	if (ssl_comp_methods == NULL)

   284 		{

   285 		CRYPTO_r_unlock(CRYPTO_LOCK_SSL);

   286 		CRYPTO_w_lock(CRYPTO_LOCK_SSL);

   287 		got_write_lock = 1;

   288 		

   289 		if (ssl_comp_methods == NULL)

   290 			{

   291 			SSL_COMP *comp = NULL;

   292 

   293 			MemCheck_off();

   294 			ssl_comp_methods=sk_SSL_COMP_new(sk_comp_cmp);

   295 			if (ssl_comp_methods != NULL)

   296 				{

   297 				comp=(SSL_COMP *)OPENSSL_malloc(sizeof(SSL_COMP));

   298 				if (comp != NULL)

   299 					{

   300 					comp->method=COMP_zlib();

   301 					if (comp->method

   302 						&& comp->method->type == NID_undef)

   303 						OPENSSL_free(comp);

   304 					else

   305 						{

   306 						comp->id=SSL_COMP_ZLIB_IDX;

   307 						comp->name=comp->method->name;

   308 						sk_SSL_COMP_push(ssl_comp_methods,comp);

   309 						}

   310 					}

   311 				}

   312 			MemCheck_on();

   313 			}

   314 		}

   315 	

   316 	if (got_write_lock)

   317 		CRYPTO_w_unlock(CRYPTO_LOCK_SSL);

   318 	else

   319 		CRYPTO_r_unlock(CRYPTO_LOCK_SSL);

   320 }

   321 #endif

   322 

   323 int ssl_cipher_get_evp(const SSL_SESSION *s, const EVP_CIPHER **enc,

   324 	     const EVP_MD **md, SSL_COMP **comp)

   325 	{

   326 	int i;

   327 	SSL_CIPHER *c;

   328 

   329 	c=s->cipher;

   330 	if (c == NULL) return(0);

   331 	if (comp != NULL)

   332 		{

   333 		SSL_COMP ctmp;

   334 #ifndef OPENSSL_NO_COMP

   335 		load_builtin_compressions();

   336 #endif

   337 

   338 		*comp=NULL;

   339 		ctmp.id=s->compress_meth;

   340 		if (ssl_comp_methods != NULL)

   341 			{

   342 			i=sk_SSL_COMP_find(ssl_comp_methods,&ctmp);

   343 			if (i >= 0)

   344 				*comp=sk_SSL_COMP_value(ssl_comp_methods,i);

   345 			else

   346 				*comp=NULL;

   347 			}

   348 		}

   349 

   350 	if ((enc == NULL) || (md == NULL)) return(0);

   351 

   352 	switch (c->algorithms & SSL_ENC_MASK)

   353 		{

   354 	case SSL_DES:

   355 		i=SSL_ENC_DES_IDX;

   356 		break;

   357 	case SSL_3DES:

   358 		i=SSL_ENC_3DES_IDX;

   359 		break;

   360 	case SSL_RC4:

   361 		i=SSL_ENC_RC4_IDX;

   362 		break;

   363 	case SSL_RC2:

   364 		i=SSL_ENC_RC2_IDX;

   365 		break;

   366 	case SSL_IDEA:

   367 		i=SSL_ENC_IDEA_IDX;

   368 		break;

   369 	case SSL_eNULL:

   370 		i=SSL_ENC_NULL_IDX;

   371 		break;

   372 	case SSL_AES:

   373 		switch(c->alg_bits)

   374 			{

   375 		case 128: i=SSL_ENC_AES128_IDX; break;

   376 		case 256: i=SSL_ENC_AES256_IDX; break;

   377 		default: i=-1; break;

   378 			}

   379 		break;

   380 	default:

   381 		i= -1;

   382 		break;

   383 		}

   384 

   385 	if ((i < 0) || (i > SSL_ENC_NUM_IDX))

   386 		*enc=NULL;

   387 	else

   388 		{

   389 		if (i == SSL_ENC_NULL_IDX)

   390 			*enc=EVP_enc_null();

   391 		else

   392 			*enc=ssl_cipher_methods[i];

   393 		}

   394 

   395 	switch (c->algorithms & SSL_MAC_MASK)

   396 		{

   397 	case SSL_MD5:

   398 		i=SSL_MD_MD5_IDX;

   399 		break;

   400 	case SSL_SHA1:

   401 		i=SSL_MD_SHA1_IDX;

   402 		break;

   403 	default:

   404 		i= -1;

   405 		break;

   406 		}

   407 	if ((i < 0) || (i > SSL_MD_NUM_IDX))

   408 		*md=NULL;

   409 	else

   410 		*md=ssl_digest_methods[i];

   411 

   412 	if ((*enc != NULL) && (*md != NULL))

   413 		return(1);

   414 	else

   415 		return(0);

   416 	}

   417 

   418 #define ITEM_SEP(a) \

   419 	(((a) == ':') || ((a) == ' ') || ((a) == ';') || ((a) == ','))

   420 

   421 static void ll_append_tail(CIPHER_ORDER **head, CIPHER_ORDER *curr,

   422 	     CIPHER_ORDER **tail)

   423 	{

   424 	if (curr == *tail) return;

   425 	if (curr == *head)

   426 		*head=curr->next;

   427 	if (curr->prev != NULL)

   428 		curr->prev->next=curr->next;

   429 	if (curr->next != NULL) /* should always be true */

   430 		curr->next->prev=curr->prev;

   431 	(*tail)->next=curr;

   432 	curr->prev= *tail;

   433 	curr->next=NULL;

   434 	*tail=curr;

   435 	}

   436 

   437 static unsigned long ssl_cipher_get_disabled(void)

   438 	{

   439 	unsigned long mask;

   440 

   441 	mask = SSL_kFZA;

   442 #ifdef OPENSSL_NO_RSA

   443 	mask |= SSL_aRSA|SSL_kRSA;

   444 #endif

   445 #ifdef OPENSSL_NO_DSA

   446 	mask |= SSL_aDSS;

   447 #endif

   448 #ifdef OPENSSL_NO_DH

   449 	mask |= SSL_kDHr|SSL_kDHd|SSL_kEDH|SSL_aDH;

   450 #endif

   451 #ifdef OPENSSL_NO_KRB5

   452 	mask |= SSL_kKRB5|SSL_aKRB5;

   453 #endif

   454 #ifdef OPENSSL_NO_ECDH

   455 	mask |= SSL_kECDH|SSL_kECDHE;

   456 #endif

   457 #ifdef SSL_FORBID_ENULL

   458 	mask |= SSL_eNULL;

   459 #endif

   460 

   461 	mask |= (ssl_cipher_methods[SSL_ENC_DES_IDX ] == NULL) ? SSL_DES :0;

   462 	mask |= (ssl_cipher_methods[SSL_ENC_3DES_IDX] == NULL) ? SSL_3DES:0;

   463 	mask |= (ssl_cipher_methods[SSL_ENC_RC4_IDX ] == NULL) ? SSL_RC4 :0;

   464 	mask |= (ssl_cipher_methods[SSL_ENC_RC2_IDX ] == NULL) ? SSL_RC2 :0;

   465 	mask |= (ssl_cipher_methods[SSL_ENC_IDEA_IDX] == NULL) ? SSL_IDEA:0;

   466 	mask |= (ssl_cipher_methods[SSL_ENC_eFZA_IDX] == NULL) ? SSL_eFZA:0;

   467 	mask |= (ssl_cipher_methods[SSL_ENC_AES128_IDX] == NULL) ? SSL_AES:0;

   468 

   469 	mask |= (ssl_digest_methods[SSL_MD_MD5_IDX ] == NULL) ? SSL_MD5 :0;

   470 	mask |= (ssl_digest_methods[SSL_MD_SHA1_IDX] == NULL) ? SSL_SHA1:0;

   471 

   472 	return(mask);

   473 	}

   474 

   475 static void ssl_cipher_collect_ciphers(const SSL_METHOD *ssl_method,

   476 		int num_of_ciphers, unsigned long mask, CIPHER_ORDER *co_list,

   477 		CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p)

   478 	{

   479 	int i, co_list_num;

   480 	SSL_CIPHER *c;

   481 

   482 	/*

   483 	 * We have num_of_ciphers descriptions compiled in, depending on the

   484 	 * method selected (SSLv2 and/or SSLv3, TLSv1 etc).

   485 	 * These will later be sorted in a linked list with at most num

   486 	 * entries.

   487 	 */

   488 

   489 	/* Get the initial list of ciphers */

   490 	co_list_num = 0;	/* actual count of ciphers */

   491 	for (i = 0; i < num_of_ciphers; i++)

   492 		{

   493 		c = ssl_method->get_cipher(i);

   494 		/* drop those that use any of that is not available */

   495 		if ((c != NULL) && c->valid && !(c->algorithms & mask))

   496 			{

   497 			co_list[co_list_num].cipher = c;

   498 			co_list[co_list_num].next = NULL;

   499 			co_list[co_list_num].prev = NULL;

   500 			co_list[co_list_num].active = 0;

   501 			co_list_num++;

   502 #ifdef KSSL_DEBUG

   503 			printf("\t%d: %s %lx %lx\n",i,c->name,c->id,c->algorithms);

   504 #endif	/* KSSL_DEBUG */

   505 			/*

   506 			if (!sk_push(ca_list,(char *)c)) goto err;

   507 			*/

   508 			}

   509 		}

   510 

   511 	/*

   512 	 * Prepare linked list from list entries

   513 	 */	

   514 	for (i = 1; i < co_list_num - 1; i++)

   515 		{

   516 		co_list[i].prev = &(co_list[i-1]);

   517 		co_list[i].next = &(co_list[i+1]);

   518 		}

   519 	if (co_list_num > 0)

   520 		{

   521 		(*head_p) = &(co_list[0]);

   522 		(*head_p)->prev = NULL;

   523 		(*head_p)->next = &(co_list[1]);

   524 		(*tail_p) = &(co_list[co_list_num - 1]);

   525 		(*tail_p)->prev = &(co_list[co_list_num - 2]);

   526 		(*tail_p)->next = NULL;

   527 		}

   528 	}

   529 

   530 static void ssl_cipher_collect_aliases(SSL_CIPHER **ca_list,

   531 			int num_of_group_aliases, unsigned long mask,

   532 			CIPHER_ORDER *head)

   533 	{

   534 	CIPHER_ORDER *ciph_curr;

   535 	SSL_CIPHER **ca_curr;

   536 	int i;

   537 

   538 	/*

   539 	 * First, add the real ciphers as already collected

   540 	 */

   541 	ciph_curr = head;

   542 	ca_curr = ca_list;

   543 	while (ciph_curr != NULL)

   544 		{

   545 		*ca_curr = ciph_curr->cipher;

   546 		ca_curr++;

   547 		ciph_curr = ciph_curr->next;

   548 		}

   549 

   550 	/*

   551 	 * Now we add the available ones from the cipher_aliases[] table.

   552 	 * They represent either an algorithm, that must be fully

   553 	 * supported (not match any bit in mask) or represent a cipher

   554 	 * strength value (will be added in any case because algorithms=0).

   555 	 */

   556 	for (i = 0; i < num_of_group_aliases; i++)

   557 		{

   558 		if ((i == 0) ||		/* always fetch "ALL" */

   559 		    !(cipher_aliases[i].algorithms & mask))

   560 			{

   561 			*ca_curr = (SSL_CIPHER *)(cipher_aliases + i);

   562 			ca_curr++;

   563 			}

   564 		}

   565 

   566 	*ca_curr = NULL;	/* end of list */

   567 	}

   568 

   569 static void ssl_cipher_apply_rule(unsigned long cipher_id, unsigned long ssl_version,

   570 		unsigned long algorithms, unsigned long mask,

   571 		unsigned long algo_strength, unsigned long mask_strength,

   572 		int rule, int strength_bits, CIPHER_ORDER *co_list,

   573 		CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p)

   574 	{

   575 	CIPHER_ORDER *head, *tail, *curr, *curr2, *tail2;

   576 	SSL_CIPHER *cp;

   577 	unsigned long ma, ma_s;

   578 

   579 #ifdef CIPHER_DEBUG

   580 	printf("Applying rule %d with %08lx %08lx %08lx %08lx (%d)\n",

   581 		rule, algorithms, mask, algo_strength, mask_strength,

   582 		strength_bits);

   583 #endif

   584 

   585 	curr = head = *head_p;

   586 	curr2 = head;

   587 	tail2 = tail = *tail_p;

   588 	for (;;)

   589 		{

   590 		if ((curr == NULL) || (curr == tail2)) break;

   591 		curr = curr2;

   592 		curr2 = curr->next;

   593 

   594 		cp = curr->cipher;

   595 

   596 		/* If explicit cipher suite, match only that one for its own protocol version.

   597 		 * Usual selection criteria will be used for similar ciphersuites from other version! */

   598 

   599 		if (cipher_id && (cp->algorithms & SSL_SSL_MASK) == ssl_version)

   600 			{

   601 			if (cp->id != cipher_id)

   602 				continue;

   603 			}

   604 

   605 		/*

   606 		 * Selection criteria is either the number of strength_bits

   607 		 * or the algorithm used.

   608 		 */

   609 		else if (strength_bits == -1)

   610 			{

   611 			ma = mask & cp->algorithms;

   612 			ma_s = mask_strength & cp->algo_strength;

   613 

   614 #ifdef CIPHER_DEBUG

   615 			printf("\nName: %s:\nAlgo = %08lx Algo_strength = %08lx\nMask = %08lx Mask_strength %08lx\n", cp->name, cp->algorithms, cp->algo_strength, mask, mask_strength);

   616 			printf("ma = %08lx ma_s %08lx, ma&algo=%08lx, ma_s&algos=%08lx\n", ma, ma_s, ma&algorithms, ma_s&algo_strength);

   617 #endif

   618 			/*

   619 			 * Select: if none of the mask bit was met from the

   620 			 * cipher or not all of the bits were met, the

   621 			 * selection does not apply.

   622 			 */

   623 			if (((ma == 0) && (ma_s == 0)) ||

   624 			    ((ma & algorithms) != ma) ||

   625 			    ((ma_s & algo_strength) != ma_s))

   626 				continue; /* does not apply */

   627 			}

   628 		else if (strength_bits != cp->strength_bits)

   629 			continue;	/* does not apply */

   630 

   631 #ifdef CIPHER_DEBUG

   632 		printf("Action = %d\n", rule);

   633 #endif

   634 

   635 		/* add the cipher if it has not been added yet. */

   636 		if (rule == CIPHER_ADD)

   637 			{

   638 			if (!curr->active)

   639 				{

   640 				int add_this_cipher = 1;

   641 

   642 				if (((cp->algorithms & (SSL_kECDHE|SSL_kECDH|SSL_aECDSA)) != 0))

   643 					{

   644 					/* Make sure "ECCdraft" ciphersuites are activated only if

   645 					 * *explicitly* requested, but not implicitly (such as

   646 					 * as part of the "AES" alias). */

   647 

   648 					add_this_cipher = (mask & (SSL_kECDHE|SSL_kECDH|SSL_aECDSA)) != 0 || cipher_id != 0;

   649 					}

   650 				

   651 				if (add_this_cipher)

   652 					{

   653 					ll_append_tail(&head, curr, &tail);

   654 					curr->active = 1;

   655 					}

   656 				}

   657 			}

   658 		/* Move the added cipher to this location */

   659 		else if (rule == CIPHER_ORD)

   660 			{

   661 			if (curr->active)

   662 				{

   663 				ll_append_tail(&head, curr, &tail);

   664 				}

   665 			}

   666 		else if	(rule == CIPHER_DEL)

   667 			curr->active = 0;

   668 		else if (rule == CIPHER_KILL)

   669 			{

   670 			if (head == curr)

   671 				head = curr->next;

   672 			else

   673 				curr->prev->next = curr->next;

   674 			if (tail == curr)

   675 				tail = curr->prev;

   676 			curr->active = 0;

   677 			if (curr->next != NULL)

   678 				curr->next->prev = curr->prev;

   679 			if (curr->prev != NULL)

   680 				curr->prev->next = curr->next;

   681 			curr->next = NULL;

   682 			curr->prev = NULL;

   683 			}

   684 		}

   685 

   686 	*head_p = head;

   687 	*tail_p = tail;

   688 	}

   689 

   690 static int ssl_cipher_strength_sort(CIPHER_ORDER *co_list,

   691 				    CIPHER_ORDER **head_p,

   692 				    CIPHER_ORDER **tail_p)

   693 	{

   694 	int max_strength_bits, i, *number_uses;

   695 	CIPHER_ORDER *curr;

   696 

   697 	/*

   698 	 * This routine sorts the ciphers with descending strength. The sorting

   699 	 * must keep the pre-sorted sequence, so we apply the normal sorting

   700 	 * routine as '+' movement to the end of the list.

   701 	 */

   702 	max_strength_bits = 0;

   703 	curr = *head_p;

   704 	while (curr != NULL)

   705 		{

   706 		if (curr->active &&

   707 		    (curr->cipher->strength_bits > max_strength_bits))

   708 		    max_strength_bits = curr->cipher->strength_bits;

   709 		curr = curr->next;

   710 		}

   711 

   712 	number_uses = OPENSSL_malloc((max_strength_bits + 1) * sizeof(int));

   713 	if (!number_uses)

   714 	{

   715 		SSLerr(SSL_F_SSL_CIPHER_STRENGTH_SORT,ERR_R_MALLOC_FAILURE);

   716 		return(0);

   717 	}

   718 	memset(number_uses, 0, (max_strength_bits + 1) * sizeof(int));

   719 

   720 	/*

   721 	 * Now find the strength_bits values actually used

   722 	 */

   723 	curr = *head_p;

   724 	while (curr != NULL)

   725 		{

   726 		if (curr->active)

   727 			number_uses[curr->cipher->strength_bits]++;

   728 		curr = curr->next;

   729 		}

   730 	/*

   731 	 * Go through the list of used strength_bits values in descending

   732 	 * order.

   733 	 */

   734 	for (i = max_strength_bits; i >= 0; i--)

   735 		if (number_uses[i] > 0)

   736 			ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, CIPHER_ORD, i,

   737 					co_list, head_p, tail_p);

   738 

   739 	OPENSSL_free(number_uses);

   740 	return(1);

   741 	}

   742 

   743 static int ssl_cipher_process_rulestr(const char *rule_str,

   744 		CIPHER_ORDER *co_list, CIPHER_ORDER **head_p,

   745 		CIPHER_ORDER **tail_p, SSL_CIPHER **ca_list)

   746 	{

   747 	unsigned long algorithms, mask, algo_strength, mask_strength;

   748 	const char *l, *start, *buf;

   749 	int j, multi, found, rule, retval, ok, buflen;

   750 	unsigned long cipher_id = 0, ssl_version = 0;

   751 	char ch;

   752 

   753 	retval = 1;

   754 	l = rule_str;

   755 	for (;;)

   756 		{

   757 		ch = *l;

   758 

   759 		if (ch == '\0')

   760 			break;		/* done */

   761 		if (ch == '-')

   762 			{ rule = CIPHER_DEL; l++; }

   763 		else if (ch == '+')

   764 			{ rule = CIPHER_ORD; l++; }

   765 		else if (ch == '!')

   766 			{ rule = CIPHER_KILL; l++; }

   767 		else if (ch == '@')

   768 			{ rule = CIPHER_SPECIAL; l++; }

   769 		else

   770 			{ rule = CIPHER_ADD; }

   771 

   772 		if (ITEM_SEP(ch))

   773 			{

   774 			l++;

   775 			continue;

   776 			}

   777 

   778 		algorithms = mask = algo_strength = mask_strength = 0;

   779 

   780 		start=l;

   781 		for (;;)

   782 			{

   783 			ch = *l;

   784 			buf = l;

   785 			buflen = 0;

   786 #ifndef CHARSET_EBCDIC

   787 			while (	((ch >= 'A') && (ch <= 'Z')) ||

   788 				((ch >= '0') && (ch <= '9')) ||

   789 				((ch >= 'a') && (ch <= 'z')) ||

   790 				 (ch == '-'))

   791 #else

   792 			while (	isalnum(ch) || (ch == '-'))

   793 #endif

   794 				 {

   795 				 ch = *(++l);

   796 				 buflen++;

   797 				 }

   798 

   799 			if (buflen == 0)

   800 				{

   801 				/*

   802 				 * We hit something we cannot deal with,

   803 				 * it is no command or separator nor

   804 				 * alphanumeric, so we call this an error.

   805 				 */

   806 				SSLerr(SSL_F_SSL_CIPHER_PROCESS_RULESTR,

   807 				       SSL_R_INVALID_COMMAND);

   808 				retval = found = 0;

   809 				l++;

   810 				break;

   811 				}

   812 

   813 			if (rule == CIPHER_SPECIAL)

   814 				{

   815 				found = 0; /* unused -- avoid compiler warning */

   816 				break;	/* special treatment */

   817 				}

   818 

   819 			/* check for multi-part specification */

   820 			if (ch == '+')

   821 				{

   822 				multi=1;

   823 				l++;

   824 				}

   825 			else

   826 				multi=0;

   827 

   828 			/*

   829 			 * Now search for the cipher alias in the ca_list. Be careful

   830 			 * with the strncmp, because the "buflen" limitation

   831 			 * will make the rule "ADH:SOME" and the cipher

   832 			 * "ADH-MY-CIPHER" look like a match for buflen=3.

   833 			 * So additionally check whether the cipher name found

   834 			 * has the correct length. We can save a strlen() call:

   835 			 * just checking for the '\0' at the right place is

   836 			 * sufficient, we have to strncmp() anyway. (We cannot

   837 			 * use strcmp(), because buf is not '\0' terminated.)

   838 			 */

   839 			 j = found = 0;

   840  			 cipher_id = 0;

   841 			 ssl_version = 0;

   842 

   843 			 while (ca_list[j])

   844 				{

   845 				if (!strncmp(buf, ca_list[j]->name, buflen) &&

   846 				    (ca_list[j]->name[buflen] == '\0'))

   847 					{

   848 					found = 1;

   849 					break;

   850 					}

   851 				else

   852 					j++;

   853 				}

   854 			if (!found)

   855 				break;	/* ignore this entry */

   856 

   857 			/* New algorithms:

   858 			 *  1 - any old restrictions apply outside new mask

   859 			 *  2 - any new restrictions apply outside old mask

   860 			 *  3 - enforce old & new where masks intersect

   861 			 */

   862 			algorithms = (algorithms & ~ca_list[j]->mask) |		/* 1 */

   863 			             (ca_list[j]->algorithms & ~mask) |		/* 2 */

   864 			             (algorithms & ca_list[j]->algorithms);	/* 3 */

   865 			mask |= ca_list[j]->mask;

   866 			algo_strength = (algo_strength & ~ca_list[j]->mask_strength) |

   867 			                (ca_list[j]->algo_strength & ~mask_strength) |

   868 			                (algo_strength & ca_list[j]->algo_strength);

   869 			mask_strength |= ca_list[j]->mask_strength;

   870 

   871 			/* explicit ciphersuite found */

   872 			if (ca_list[j]->valid)

   873 				{

   874 				cipher_id = ca_list[j]->id;

   875 				ssl_version = ca_list[j]->algorithms & SSL_SSL_MASK;

   876 				break;

   877 				}

   878 

   879 			if (!multi) break;

   880 			}

   881 

   882 		/*

   883 		 * Ok, we have the rule, now apply it

   884 		 */

   885 		if (rule == CIPHER_SPECIAL)

   886 			{	/* special command */

   887 			ok = 0;

   888 			if ((buflen == 8) &&

   889 				!strncmp(buf, "STRENGTH", 8))

   890 				ok = ssl_cipher_strength_sort(co_list,

   891 					head_p, tail_p);

   892 			else

   893 				SSLerr(SSL_F_SSL_CIPHER_PROCESS_RULESTR,

   894 					SSL_R_INVALID_COMMAND);

   895 			if (ok == 0)

   896 				retval = 0;

   897 			/*

   898 			 * We do not support any "multi" options

   899 			 * together with "@", so throw away the

   900 			 * rest of the command, if any left, until

   901 			 * end or ':' is found.

   902 			 */

   903 			while ((*l != '\0') && !ITEM_SEP(*l))

   904 				l++;

   905 			}

   906 		else if (found)

   907 			{

   908 			ssl_cipher_apply_rule(cipher_id, ssl_version, algorithms, mask,

   909 				algo_strength, mask_strength, rule, -1,

   910 				co_list, head_p, tail_p);

   911 			}

   912 		else

   913 			{

   914 			while ((*l != '\0') && !ITEM_SEP(*l))

   915 				l++;

   916 			}

   917 		if (*l == '\0') break; /* done */

   918 		}

   919 

   920 	return(retval);

   921 	}

   922 

   923 STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(const SSL_METHOD *ssl_method,

   924 		STACK_OF(SSL_CIPHER) **cipher_list,

   925 		STACK_OF(SSL_CIPHER) **cipher_list_by_id,

   926 		const char *rule_str)

   927 	{

   928 	int ok, num_of_ciphers, num_of_alias_max, num_of_group_aliases;

   929 	unsigned long disabled_mask;

   930 	STACK_OF(SSL_CIPHER) *cipherstack, *tmp_cipher_list;

   931 	const char *rule_p;

   932 	CIPHER_ORDER *co_list = NULL, *head = NULL, *tail = NULL, *curr;

   933 	SSL_CIPHER **ca_list = NULL;

   934 

   935 	/*

   936 	 * Return with error if nothing to do.

   937 	 */

   938 	if (rule_str == NULL || cipher_list == NULL || cipher_list_by_id == NULL)

   939 		return NULL;

   940 

   941 	/*

   942 	 * To reduce the work to do we only want to process the compiled

   943 	 * in algorithms, so we first get the mask of disabled ciphers.

   944 	 */

   945 	disabled_mask = ssl_cipher_get_disabled();

   946 

   947 	/*

   948 	 * Now we have to collect the available ciphers from the compiled

   949 	 * in ciphers. We cannot get more than the number compiled in, so

   950 	 * it is used for allocation.

   951 	 */

   952 	num_of_ciphers = ssl_method->num_ciphers();

   953 #ifdef KSSL_DEBUG

   954 	printf("ssl_create_cipher_list() for %d ciphers\n", num_of_ciphers);

   955 #endif    /* KSSL_DEBUG */

   956 	co_list = (CIPHER_ORDER *)OPENSSL_malloc(sizeof(CIPHER_ORDER) * num_of_ciphers);

   957 	if (co_list == NULL)

   958 		{

   959 		SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST,ERR_R_MALLOC_FAILURE);

   960 		return(NULL);	/* Failure */

   961 		}

   962 

   963 	ssl_cipher_collect_ciphers(ssl_method, num_of_ciphers, disabled_mask,

   964 				   co_list, &head, &tail);

   965 

   966 	/*

   967 	 * We also need cipher aliases for selecting based on the rule_str.

   968 	 * There might be two types of entries in the rule_str: 1) names

   969 	 * of ciphers themselves 2) aliases for groups of ciphers.

   970 	 * For 1) we need the available ciphers and for 2) the cipher

   971 	 * groups of cipher_aliases added together in one list (otherwise

   972 	 * we would be happy with just the cipher_aliases table).

   973 	 */

   974 	num_of_group_aliases = sizeof(cipher_aliases) / sizeof(SSL_CIPHER);

   975 	num_of_alias_max = num_of_ciphers + num_of_group_aliases + 1;

   976 	ca_list =

   977 		(SSL_CIPHER **)OPENSSL_malloc(sizeof(SSL_CIPHER *) * num_of_alias_max);

   978 	if (ca_list == NULL)

   979 		{

   980 		OPENSSL_free(co_list);

   981 		SSLerr(SSL_F_SSL_CREATE_CIPHER_LIST,ERR_R_MALLOC_FAILURE);

   982 		return(NULL);	/* Failure */

   983 		}

   984 	ssl_cipher_collect_aliases(ca_list, num_of_group_aliases, disabled_mask,

   985 				   head);

   986 

   987 	/*

   988 	 * If the rule_string begins with DEFAULT, apply the default rule

   989 	 * before using the (possibly available) additional rules.

   990 	 */

   991 	ok = 1;

   992 	rule_p = rule_str;

   993 	if (strncmp(rule_str,"DEFAULT",7) == 0)

   994 		{

   995 		ok = ssl_cipher_process_rulestr(SSL_DEFAULT_CIPHER_LIST,

   996 			co_list, &head, &tail, ca_list);

   997 		rule_p += 7;

   998 		if (*rule_p == ':')

   999 			rule_p++;

  1000 		}

  1001 

  1002 	if (ok && (strlen(rule_p) > 0))

  1003 		ok = ssl_cipher_process_rulestr(rule_p, co_list, &head, &tail,

  1004 						ca_list);

  1005 

  1006 	OPENSSL_free(ca_list);	/* Not needed anymore */

  1007 

  1008 	if (!ok)

  1009 		{	/* Rule processing failure */

  1010 		OPENSSL_free(co_list);

  1011 		return(NULL);

  1012 		}

  1013 	/*

  1014 	 * Allocate new "cipherstack" for the result, return with error

  1015 	 * if we cannot get one.

  1016 	 */

  1017 	if ((cipherstack = sk_SSL_CIPHER_new_null()) == NULL)

  1018 		{

  1019 		OPENSSL_free(co_list);

  1020 		return(NULL);

  1021 		}

  1022 

  1023 	/*

  1024 	 * The cipher selection for the list is done. The ciphers are added

  1025 	 * to the resulting precedence to the STACK_OF(SSL_CIPHER).

  1026 	 */

  1027 	for (curr = head; curr != NULL; curr = curr->next)

  1028 		{

  1029 		if (curr->active)

  1030 			{

  1031 			sk_SSL_CIPHER_push(cipherstack, curr->cipher);

  1032 #ifdef CIPHER_DEBUG

  1033 			printf("<%s>\n",curr->cipher->name);

  1034 #endif

  1035 			}

  1036 		}

  1037 	OPENSSL_free(co_list);	/* Not needed any longer */

  1038 

  1039 	tmp_cipher_list = sk_SSL_CIPHER_dup(cipherstack);

  1040 	if (tmp_cipher_list == NULL)

  1041 		{

  1042 		sk_SSL_CIPHER_free(cipherstack);

  1043 		return NULL;

  1044 		}

  1045 	if (*cipher_list != NULL)

  1046 		sk_SSL_CIPHER_free(*cipher_list);

  1047 	*cipher_list = cipherstack;

  1048 	if (*cipher_list_by_id != NULL)

  1049 		sk_SSL_CIPHER_free(*cipher_list_by_id);

  1050 	*cipher_list_by_id = tmp_cipher_list;

  1051 	(void)sk_SSL_CIPHER_set_cmp_func(*cipher_list_by_id,ssl_cipher_ptr_id_cmp);

  1052 

  1053 	return(cipherstack);

  1054 	}

  1055 

  1056 EXPORT_C char *SSL_CIPHER_description(SSL_CIPHER *cipher, char *buf, int len)

  1057 	{

  1058 	int is_export,pkl,kl;

  1059 	const char *ver,*exp_str;

  1060 	const char *kx,*au,*enc,*mac;

  1061 	unsigned long alg,alg2,alg_s;

  1062 #ifndef EMULATOR

  1063 #ifdef KSSL_DEBUG

  1064 	static const char *format="%-23s %s Kx=%-8s Au=%-4s Enc=%-9s Mac=%-4s%s AL=%lx\n";

  1065 #else

  1066 	static const char *format="%-23s %s Kx=%-8s Au=%-4s Enc=%-9s Mac=%-4s%s\n";

  1067 #endif /* KSSL_DEBUG */

  1068 #else /* EMULATOR */

  1069 #ifdef KSSL_DEBUG

  1070 	static const char *const format="%-23s %s Kx=%-8s Au=%-4s Enc=%-9s Mac=%-4s%s AL=%lx\n";

  1071 #else

  1072 	static const char *const format="%-23s %s Kx=%-8s Au=%-4s Enc=%-9s Mac=%-4s%s\n";

  1073 #endif /* KSSL_DEBUG */

  1074 

  1075 #endif /* EMULATOR */

  1076 	alg=cipher->algorithms;

  1077 	alg_s=cipher->algo_strength;

  1078 	alg2=cipher->algorithm2;

  1079 

  1080 	is_export=SSL_C_IS_EXPORT(cipher);

  1081 	pkl=SSL_C_EXPORT_PKEYLENGTH(cipher);

  1082 	kl=SSL_C_EXPORT_KEYLENGTH(cipher);

  1083 	exp_str=is_export?" export":"";

  1084 	

  1085 	if (alg & SSL_SSLV2)

  1086 		ver="SSLv2";

  1087 	else if (alg & SSL_SSLV3)

  1088 		ver="SSLv3";

  1089 	else

  1090 		ver="unknown";

  1091 

  1092 	switch (alg&SSL_MKEY_MASK)

  1093 		{

  1094 	case SSL_kRSA:

  1095 		kx=is_export?(pkl == 512 ? "RSA(512)" : "RSA(1024)"):"RSA";

  1096 		break;

  1097 	case SSL_kDHr:

  1098 		kx="DH/RSA";

  1099 		break;

  1100 	case SSL_kDHd:

  1101 		kx="DH/DSS";

  1102 		break;

  1103         case SSL_kKRB5:         /* VRS */

  1104         case SSL_KRB5:          /* VRS */

  1105             kx="KRB5";

  1106             break;

  1107 	case SSL_kFZA:

  1108 		kx="Fortezza";

  1109 		break;

  1110 	case SSL_kEDH:

  1111 		kx=is_export?(pkl == 512 ? "DH(512)" : "DH(1024)"):"DH";

  1112 		break;

  1113 	case SSL_kECDH:

  1114 	case SSL_kECDHE:

  1115 		kx=is_export?"ECDH(<=163)":"ECDH";

  1116 		break;

  1117 	default:

  1118 		kx="unknown";

  1119 		}

  1120 

  1121 	switch (alg&SSL_AUTH_MASK)

  1122 		{

  1123 	case SSL_aRSA:

  1124 		au="RSA";

  1125 		break;

  1126 	case SSL_aDSS:

  1127 		au="DSS";

  1128 		break;

  1129 	case SSL_aDH:

  1130 		au="DH";

  1131 		break;

  1132         case SSL_aKRB5:         /* VRS */

  1133         case SSL_KRB5:          /* VRS */

  1134             au="KRB5";

  1135             break;