Symaptic: os/ossrv/ssl/libssl/src/s3

     1 /* ssl/s3_lib.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-2002 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  *

   114  * Portions of the attached software ("Contribution") are developed by

   115  * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.

   116  *

   117  * The Contribution is licensed pursuant to the OpenSSL open source

   118  * license provided above.

   119  *

   120  * ECC cipher suite support in OpenSSL originally written by

   121  * Vipul Gupta and Sumit Gupta of Sun Microsystems Laboratories.

   122  *

   123  */

   124 /*

   125  © Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

   126  */

   128 #include <stdio.h>

   129 #include <openssl/objects.h>

   130 #include "ssl_locl.h"

   131 #include "kssl_lcl.h"

   132 #include <openssl/md5.h>

   133 #ifndef OPENSSL_NO_DH

   134 #include <openssl/dh.h>

   135 #endif

   136 #include <openssl/pq_compat.h>

   138 #if (defined(SYMBIAN) && (defined(__WINSCW__) || defined(__WINS__)))

   139 #include "libssl_wsd.h"

   140 #endif

   143 #ifdef EMULATOR

   145 	GET_STATIC_VAR_FROM_TLS(sslv3_base_method_data,s3_lib,SSL_METHOD)

   147 	#define sslv3_base_method_data (*GET_WSD_VAR_NAME(sslv3_base_method_data,s3_lib,s)())

   149 #endif

   151 const char ssl3_version_str[]="SSLv3" OPENSSL_VERSION_PTEXT;

   153 #ifndef EMULATOR

   154 #define SSL3_NUM_CIPHERS	(sizeof(ssl3_ciphers)/sizeof(SSL_CIPHER))

   155 /* #else */

   156 /* #define SSL3_NUM_CIPHERS	87      /* Defined in libssl_wsd.h */

   157 #endif

   160 /* list of available SSLv3 ciphers (sorted by id) */

   162 #ifdef EMULATOR

   164 	GET_GLOBAL_ARRAY_FROM_TLS(ssl3_ciphers,s3_lib,SSL_CIPHER)

   166 	#define ssl3_ciphers (GET_WSD_VAR_NAME(ssl3_ciphers,s3_lib,g)())

   168 #endif

   171 #ifndef EMULATOR

   172 OPENSSL_GLOBAL SSL_CIPHER ssl3_ciphers[]={

   173 #else

   174 OPENSSL_GLOBAL const SSL_CIPHER temp_ssl3_ciphers[]={

   175 #endif

   176 /* The RSA ciphers */

   177 /* Cipher 01 */

   178 	{

   179 	1,

   180 	SSL3_TXT_RSA_NULL_MD5,

   181 	SSL3_CK_RSA_NULL_MD5,

   182 	SSL_kRSA|SSL_aRSA|SSL_eNULL |SSL_MD5|SSL_SSLV3,

   183 	SSL_NOT_EXP|SSL_STRONG_NONE,

   184 	0,

   185 	0,

   186 	0,

   187 	SSL_ALL_CIPHERS,

   188 	SSL_ALL_STRENGTHS,

   189 	},

   190 /* Cipher 02 */

   191 	{

   192 	1,

   193 	SSL3_TXT_RSA_NULL_SHA,

   194 	SSL3_CK_RSA_NULL_SHA,

   195 	SSL_kRSA|SSL_aRSA|SSL_eNULL |SSL_SHA1|SSL_SSLV3,

   196 	SSL_NOT_EXP|SSL_STRONG_NONE,

   197 	0,

   198 	0,

   199 	0,

   200 	SSL_ALL_CIPHERS,

   201 	SSL_ALL_STRENGTHS,

   202 	},

   203 /* Cipher 03 */

   204 	{

   205 	1,

   206 	SSL3_TXT_RSA_RC4_40_MD5,

   207 	SSL3_CK_RSA_RC4_40_MD5,

   208 	SSL_kRSA|SSL_aRSA|SSL_RC4  |SSL_MD5 |SSL_SSLV3,

   209 	SSL_EXPORT|SSL_EXP40,

   210 	0,

   211 	40,

   212 	128,

   213 	SSL_ALL_CIPHERS,

   214 	SSL_ALL_STRENGTHS,

   215 	},

   216 /* Cipher 04 */

   217 	{

   218 	1,

   219 	SSL3_TXT_RSA_RC4_128_MD5,

   220 	SSL3_CK_RSA_RC4_128_MD5,

   221 	SSL_kRSA|SSL_aRSA|SSL_RC4  |SSL_MD5|SSL_SSLV3,

   222 	SSL_NOT_EXP|SSL_MEDIUM,

   223 	0,

   224 	128,

   225 	128,

   226 	SSL_ALL_CIPHERS,

   227 	SSL_ALL_STRENGTHS,

   228 	},

   229 /* Cipher 05 */

   230 	{

   231 	1,

   232 	SSL3_TXT_RSA_RC4_128_SHA,

   233 	SSL3_CK_RSA_RC4_128_SHA,

   234 	SSL_kRSA|SSL_aRSA|SSL_RC4  |SSL_SHA1|SSL_SSLV3,

   235 	SSL_NOT_EXP|SSL_MEDIUM,

   236 	0,

   237 	128,

   238 	128,

   239 	SSL_ALL_CIPHERS,

   240 	SSL_ALL_STRENGTHS,

   241 	},

   242 /* Cipher 06 */

   243 	{

   244 	1,

   245 	SSL3_TXT_RSA_RC2_40_MD5,

   246 	SSL3_CK_RSA_RC2_40_MD5,

   247 	SSL_kRSA|SSL_aRSA|SSL_RC2  |SSL_MD5 |SSL_SSLV3,

   248 	SSL_EXPORT|SSL_EXP40,

   249 	0,

   250 	40,

   251 	128,

   252 	SSL_ALL_CIPHERS,

   253 	SSL_ALL_STRENGTHS,

   254 	},

   255 /* Cipher 07 */

   256 #ifndef OPENSSL_NO_IDEA

   257 	{

   258 	1,

   259 	SSL3_TXT_RSA_IDEA_128_SHA,

   260 	SSL3_CK_RSA_IDEA_128_SHA,

   261 	SSL_kRSA|SSL_aRSA|SSL_IDEA |SSL_SHA1|SSL_SSLV3,

   262 	SSL_NOT_EXP|SSL_MEDIUM,

   263 	0,

   264 	128,

   265 	128,

   266 	SSL_ALL_CIPHERS,

   267 	SSL_ALL_STRENGTHS,

   268 	},

   269 #endif

   270 /* Cipher 08 */

   271 	{

   272 	1,

   273 	SSL3_TXT_RSA_DES_40_CBC_SHA,

   274 	SSL3_CK_RSA_DES_40_CBC_SHA,

   275 	SSL_kRSA|SSL_aRSA|SSL_DES|SSL_SHA1|SSL_SSLV3,

   276 	SSL_EXPORT|SSL_EXP40,

   277 	0,

   278 	40,

   279 	56,

   280 	SSL_ALL_CIPHERS,

   281 	SSL_ALL_STRENGTHS,

   282 	},

   283 /* Cipher 09 */

   284 	{

   285 	1,

   286 	SSL3_TXT_RSA_DES_64_CBC_SHA,

   287 	SSL3_CK_RSA_DES_64_CBC_SHA,

   288 	SSL_kRSA|SSL_aRSA|SSL_DES  |SSL_SHA1|SSL_SSLV3,

   289 	SSL_NOT_EXP|SSL_LOW,

   290 	0,

   291 	56,

   292 	56,

   293 	SSL_ALL_CIPHERS,

   294 	SSL_ALL_STRENGTHS,

   295 	},

   296 /* Cipher 0A */

   297 	{

   298 	1,

   299 	SSL3_TXT_RSA_DES_192_CBC3_SHA,

   300 	SSL3_CK_RSA_DES_192_CBC3_SHA,

   301 	SSL_kRSA|SSL_aRSA|SSL_3DES |SSL_SHA1|SSL_SSLV3,

   302 	SSL_NOT_EXP|SSL_HIGH,

   303 	0,

   304 	168,

   305 	168,

   306 	SSL_ALL_CIPHERS,

   307 	SSL_ALL_STRENGTHS,

   308 	},

   309 /* The DH ciphers */

   310 /* Cipher 0B */

   311 	{

   312 	0,

   313 	SSL3_TXT_DH_DSS_DES_40_CBC_SHA,

   314 	SSL3_CK_DH_DSS_DES_40_CBC_SHA,

   315 	SSL_kDHd |SSL_aDH|SSL_DES|SSL_SHA1|SSL_SSLV3,

   316 	SSL_EXPORT|SSL_EXP40,

   317 	0,

   318 	40,

   319 	56,

   320 	SSL_ALL_CIPHERS,

   321 	SSL_ALL_STRENGTHS,

   322 	},

   323 /* Cipher 0C */

   324 	{

   325 	0,

   326 	SSL3_TXT_DH_DSS_DES_64_CBC_SHA,

   327 	SSL3_CK_DH_DSS_DES_64_CBC_SHA,

   328 	SSL_kDHd |SSL_aDH|SSL_DES  |SSL_SHA1|SSL_SSLV3,

   329 	SSL_NOT_EXP|SSL_LOW,

   330 	0,

   331 	56,

   332 	56,

   333 	SSL_ALL_CIPHERS,

   334 	SSL_ALL_STRENGTHS,

   335 	},

   336 /* Cipher 0D */

   337 	{

   338 	0,

   339 	SSL3_TXT_DH_DSS_DES_192_CBC3_SHA,

   340 	SSL3_CK_DH_DSS_DES_192_CBC3_SHA,

   341 	SSL_kDHd |SSL_aDH|SSL_3DES |SSL_SHA1|SSL_SSLV3,

   342 	SSL_NOT_EXP|SSL_HIGH,

   343 	0,

   344 	168,

   345 	168,

   346 	SSL_ALL_CIPHERS,

   347 	SSL_ALL_STRENGTHS,

   348 	},

   349 /* Cipher 0E */

   350 	{

   351 	0,

   352 	SSL3_TXT_DH_RSA_DES_40_CBC_SHA,

   353 	SSL3_CK_DH_RSA_DES_40_CBC_SHA,

   354 	SSL_kDHr |SSL_aDH|SSL_DES|SSL_SHA1|SSL_SSLV3,

   355 	SSL_EXPORT|SSL_EXP40,

   356 	0,

   357 	40,

   358 	56,

   359 	SSL_ALL_CIPHERS,

   360 	SSL_ALL_STRENGTHS,

   361 	},

   362 /* Cipher 0F */

   363 	{

   364 	0,

   365 	SSL3_TXT_DH_RSA_DES_64_CBC_SHA,

   366 	SSL3_CK_DH_RSA_DES_64_CBC_SHA,

   367 	SSL_kDHr |SSL_aDH|SSL_DES  |SSL_SHA1|SSL_SSLV3,

   368 	SSL_NOT_EXP|SSL_LOW,

   369 	0,

   370 	56,

   371 	56,

   372 	SSL_ALL_CIPHERS,

   373 	SSL_ALL_STRENGTHS,

   374 	},

   375 /* Cipher 10 */

   376 	{

   377 	0,

   378 	SSL3_TXT_DH_RSA_DES_192_CBC3_SHA,

   379 	SSL3_CK_DH_RSA_DES_192_CBC3_SHA,

   380 	SSL_kDHr |SSL_aDH|SSL_3DES |SSL_SHA1|SSL_SSLV3,

   381 	SSL_NOT_EXP|SSL_HIGH,

   382 	0,

   383 	168,

   384 	168,

   385 	SSL_ALL_CIPHERS,

   386 	SSL_ALL_STRENGTHS,

   387 	},

   389 /* The Ephemeral DH ciphers */

   390 /* Cipher 11 */

   391 	{

   392 	1,

   393 	SSL3_TXT_EDH_DSS_DES_40_CBC_SHA,

   394 	SSL3_CK_EDH_DSS_DES_40_CBC_SHA,

   395 	SSL_kEDH|SSL_aDSS|SSL_DES|SSL_SHA1|SSL_SSLV3,

   396 	SSL_EXPORT|SSL_EXP40,

   397 	0,

   398 	40,

   399 	56,

   400 	SSL_ALL_CIPHERS,

   401 	SSL_ALL_STRENGTHS,

   402 	},

   403 /* Cipher 12 */

   404 	{

   405 	1,

   406 	SSL3_TXT_EDH_DSS_DES_64_CBC_SHA,

   407 	SSL3_CK_EDH_DSS_DES_64_CBC_SHA,

   408 	SSL_kEDH|SSL_aDSS|SSL_DES  |SSL_SHA1|SSL_SSLV3,

   409 	SSL_NOT_EXP|SSL_LOW,

   410 	0,

   411 	56,

   412 	56,

   413 	SSL_ALL_CIPHERS,

   414 	SSL_ALL_STRENGTHS,

   415 	},

   416 /* Cipher 13 */

   417 	{

   418 	1,

   419 	SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA,

   420 	SSL3_CK_EDH_DSS_DES_192_CBC3_SHA,

   421 	SSL_kEDH|SSL_aDSS|SSL_3DES |SSL_SHA1|SSL_SSLV3,

   422 	SSL_NOT_EXP|SSL_HIGH,

   423 	0,

   424 	168,

   425 	168,

   426 	SSL_ALL_CIPHERS,

   427 	SSL_ALL_STRENGTHS,

   428 	},

   429 /* Cipher 14 */

   430 	{

   431 	1,

   432 	SSL3_TXT_EDH_RSA_DES_40_CBC_SHA,

   433 	SSL3_CK_EDH_RSA_DES_40_CBC_SHA,

   434 	SSL_kEDH|SSL_aRSA|SSL_DES|SSL_SHA1|SSL_SSLV3,

   435 	SSL_EXPORT|SSL_EXP40,

   436 	0,

   437 	40,

   438 	56,

   439 	SSL_ALL_CIPHERS,

   440 	SSL_ALL_STRENGTHS,

   441 	},

   442 /* Cipher 15 */

   443 	{

   444 	1,

   445 	SSL3_TXT_EDH_RSA_DES_64_CBC_SHA,

   446 	SSL3_CK_EDH_RSA_DES_64_CBC_SHA,

   447 	SSL_kEDH|SSL_aRSA|SSL_DES  |SSL_SHA1|SSL_SSLV3,

   448 	SSL_NOT_EXP|SSL_LOW,

   449 	0,

   450 	56,

   451 	56,

   452 	SSL_ALL_CIPHERS,

   453 	SSL_ALL_STRENGTHS,

   454 	},

   455 /* Cipher 16 */

   456 	{

   457 	1,

   458 	SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA,

   459 	SSL3_CK_EDH_RSA_DES_192_CBC3_SHA,

   460 	SSL_kEDH|SSL_aRSA|SSL_3DES |SSL_SHA1|SSL_SSLV3,

   461 	SSL_NOT_EXP|SSL_HIGH,

   462 	0,

   463 	168,

   464 	168,

   465 	SSL_ALL_CIPHERS,

   466 	SSL_ALL_STRENGTHS,

   467 	},

   468 /* Cipher 17 */

   469 	{

   470 	1,

   471 	SSL3_TXT_ADH_RC4_40_MD5,

   472 	SSL3_CK_ADH_RC4_40_MD5,

   473 	SSL_kEDH |SSL_aNULL|SSL_RC4  |SSL_MD5 |SSL_SSLV3,

   474 	SSL_EXPORT|SSL_EXP40,

   475 	0,

   476 	40,

   477 	128,

   478 	SSL_ALL_CIPHERS,

   479 	SSL_ALL_STRENGTHS,

   480 	},

   481 /* Cipher 18 */

   482 	{

   483 	1,

   484 	SSL3_TXT_ADH_RC4_128_MD5,

   485 	SSL3_CK_ADH_RC4_128_MD5,

   486 	SSL_kEDH |SSL_aNULL|SSL_RC4  |SSL_MD5 |SSL_SSLV3,

   487 	SSL_NOT_EXP|SSL_MEDIUM,

   488 	0,

   489 	128,

   490 	128,

   491 	SSL_ALL_CIPHERS,

   492 	SSL_ALL_STRENGTHS,

   493 	},

   494 /* Cipher 19 */

   495 	{

   496 	1,

   497 	SSL3_TXT_ADH_DES_40_CBC_SHA,

   498 	SSL3_CK_ADH_DES_40_CBC_SHA,

   499 	SSL_kEDH |SSL_aNULL|SSL_DES|SSL_SHA1|SSL_SSLV3,

   500 	SSL_EXPORT|SSL_EXP40,

   501 	0,

   502 	40,

   503 	128,

   504 	SSL_ALL_CIPHERS,

   505 	SSL_ALL_STRENGTHS,

   506 	},

   507 /* Cipher 1A */

   508 	{

   509 	1,

   510 	SSL3_TXT_ADH_DES_64_CBC_SHA,

   511 	SSL3_CK_ADH_DES_64_CBC_SHA,

   512 	SSL_kEDH |SSL_aNULL|SSL_DES  |SSL_SHA1|SSL_SSLV3,

   513 	SSL_NOT_EXP|SSL_LOW,

   514 	0,

   515 	56,

   516 	56,

   517 	SSL_ALL_CIPHERS,

   518 	SSL_ALL_STRENGTHS,

   519 	},

   520 /* Cipher 1B */

   521 	{

   522 	1,

   523 	SSL3_TXT_ADH_DES_192_CBC_SHA,

   524 	SSL3_CK_ADH_DES_192_CBC_SHA,

   525 	SSL_kEDH |SSL_aNULL|SSL_3DES |SSL_SHA1|SSL_SSLV3,

   526 	SSL_NOT_EXP|SSL_HIGH,

   527 	0,

   528 	168,

   529 	168,

   530 	SSL_ALL_CIPHERS,

   531 	SSL_ALL_STRENGTHS,

   532 	},

   534 /* Fortezza */

   535 /* Cipher 1C */

   536 	{

   537 	0,

   538 	SSL3_TXT_FZA_DMS_NULL_SHA,

   539 	SSL3_CK_FZA_DMS_NULL_SHA,

   540 	SSL_kFZA|SSL_aFZA |SSL_eNULL |SSL_SHA1|SSL_SSLV3,

   541 	SSL_NOT_EXP|SSL_STRONG_NONE,

   542 	0,

   543 	0,

   544 	0,

   545 	SSL_ALL_CIPHERS,

   546 	SSL_ALL_STRENGTHS,

   547 	},

   549 /* Cipher 1D */

   550 	{

   551 	0,

   552 	SSL3_TXT_FZA_DMS_FZA_SHA,

   553 	SSL3_CK_FZA_DMS_FZA_SHA,

   554 	SSL_kFZA|SSL_aFZA |SSL_eFZA |SSL_SHA1|SSL_SSLV3,

   555 	SSL_NOT_EXP|SSL_STRONG_NONE,

   556 	0,

   557 	0,

   558 	0,

   559 	SSL_ALL_CIPHERS,

   560 	SSL_ALL_STRENGTHS,

   561 	},

   563 #if 0

   564 /* Cipher 1E */

   565 	{

   566 	0,

   567 	SSL3_TXT_FZA_DMS_RC4_SHA,

   568 	SSL3_CK_FZA_DMS_RC4_SHA,

   569 	SSL_kFZA|SSL_aFZA |SSL_RC4  |SSL_SHA1|SSL_SSLV3,

   570 	SSL_NOT_EXP|SSL_MEDIUM,

   571 	0,

   572 	128,

   573 	128,

   574 	SSL_ALL_CIPHERS,

   575 	SSL_ALL_STRENGTHS,

   576 	},

   577 #endif

   579 #ifndef OPENSSL_NO_KRB5

   580 /* The Kerberos ciphers */

   581 /* Cipher 1E */

   582 	{

   583 	1,

   584 	SSL3_TXT_KRB5_DES_64_CBC_SHA,

   585 	SSL3_CK_KRB5_DES_64_CBC_SHA,

   586 	SSL_kKRB5|SSL_aKRB5|  SSL_DES|SSL_SHA1   |SSL_SSLV3,

   587 	SSL_NOT_EXP|SSL_LOW,

   588 	0,

   589 	56,

   590 	56,

   591 	SSL_ALL_CIPHERS,

   592 	SSL_ALL_STRENGTHS,

   593 	},

   595 /* Cipher 1F */

   596 	{

   597 	1,

   598 	SSL3_TXT_KRB5_DES_192_CBC3_SHA,

   599 	SSL3_CK_KRB5_DES_192_CBC3_SHA,

   600 	SSL_kKRB5|SSL_aKRB5|  SSL_3DES|SSL_SHA1  |SSL_SSLV3,

   601 	SSL_NOT_EXP|SSL_HIGH,

   602 	0,

   603 	168,

   604 	168,

   605 	SSL_ALL_CIPHERS,

   606 	SSL_ALL_STRENGTHS,

   607 	},

   609 /* Cipher 20 */

   610 	{

   611 	1,

   612 	SSL3_TXT_KRB5_RC4_128_SHA,

   613 	SSL3_CK_KRB5_RC4_128_SHA,

   614 	SSL_kKRB5|SSL_aKRB5|  SSL_RC4|SSL_SHA1  |SSL_SSLV3,

   615 	SSL_NOT_EXP|SSL_MEDIUM,

   616 	0,

   617 	128,

   618 	128,

   619 	SSL_ALL_CIPHERS,

   620 	SSL_ALL_STRENGTHS,

   621 	},

   623 /* Cipher 21 */

   624 	{

   625 	1,

   626 	SSL3_TXT_KRB5_IDEA_128_CBC_SHA,

   627 	SSL3_CK_KRB5_IDEA_128_CBC_SHA,

   628 	SSL_kKRB5|SSL_aKRB5|  SSL_IDEA|SSL_SHA1  |SSL_SSLV3,

   629 	SSL_NOT_EXP|SSL_MEDIUM,

   630 	0,

   631 	128,

   632 	128,

   633 	SSL_ALL_CIPHERS,

   634 	SSL_ALL_STRENGTHS,

   635 	},

   637 /* Cipher 22 */

   638 	{

   639 	1,

   640 	SSL3_TXT_KRB5_DES_64_CBC_MD5,

   641 	SSL3_CK_KRB5_DES_64_CBC_MD5,

   642 	SSL_kKRB5|SSL_aKRB5|  SSL_DES|SSL_MD5    |SSL_SSLV3,

   643 	SSL_NOT_EXP|SSL_LOW,

   644 	0,

   645 	56,

   646 	56,

   647 	SSL_ALL_CIPHERS,

   648 	SSL_ALL_STRENGTHS,

   649 	},

   651 /* Cipher 23 */

   652 	{

   653 	1,

   654 	SSL3_TXT_KRB5_DES_192_CBC3_MD5,

   655 	SSL3_CK_KRB5_DES_192_CBC3_MD5,

   656 	SSL_kKRB5|SSL_aKRB5|  SSL_3DES|SSL_MD5   |SSL_SSLV3,

   657 	SSL_NOT_EXP|SSL_HIGH,

   658 	0,

   659 	168,

   660 	168,

   661 	SSL_ALL_CIPHERS,

   662 	SSL_ALL_STRENGTHS,

   663 	},

   665 /* Cipher 24 */

   666 	{

   667 	1,

   668 	SSL3_TXT_KRB5_RC4_128_MD5,

   669 	SSL3_CK_KRB5_RC4_128_MD5,

   670 	SSL_kKRB5|SSL_aKRB5|  SSL_RC4|SSL_MD5  |SSL_SSLV3,

   671 	SSL_NOT_EXP|SSL_MEDIUM,

   672 	0,

   673 	128,

   674 	128,

   675 	SSL_ALL_CIPHERS,

   676 	SSL_ALL_STRENGTHS,

   677 	},

   679 /* Cipher 25 */

   680 	{

   681 	1,

   682 	SSL3_TXT_KRB5_IDEA_128_CBC_MD5,

   683 	SSL3_CK_KRB5_IDEA_128_CBC_MD5,

   684 	SSL_kKRB5|SSL_aKRB5|  SSL_IDEA|SSL_MD5  |SSL_SSLV3,

   685 	SSL_NOT_EXP|SSL_MEDIUM,

   686 	0,

   687 	128,

   688 	128,

   689 	SSL_ALL_CIPHERS,

   690 	SSL_ALL_STRENGTHS,

   691 	},

   693 /* Cipher 26 */

   694 	{

   695 	1,

   696 	SSL3_TXT_KRB5_DES_40_CBC_SHA,

   697 	SSL3_CK_KRB5_DES_40_CBC_SHA,

   698 	SSL_kKRB5|SSL_aKRB5|  SSL_DES|SSL_SHA1   |SSL_SSLV3,

   699 	SSL_EXPORT|SSL_EXP40,

   700 	0,

   701 	40,

   702 	56,

   703 	SSL_ALL_CIPHERS,

   704 	SSL_ALL_STRENGTHS,

   705 	},

   707 /* Cipher 27 */

   708 	{

   709 	1,

   710 	SSL3_TXT_KRB5_RC2_40_CBC_SHA,

   711 	SSL3_CK_KRB5_RC2_40_CBC_SHA,

   712 	SSL_kKRB5|SSL_aKRB5|  SSL_RC2|SSL_SHA1   |SSL_SSLV3,

   713 	SSL_EXPORT|SSL_EXP40,

   714 	0,

   715 	40,

   716 	128,

   717 	SSL_ALL_CIPHERS,

   718 	SSL_ALL_STRENGTHS,

   719 	},

   721 /* Cipher 28 */

   722 	{

   723 	1,

   724 	SSL3_TXT_KRB5_RC4_40_SHA,

   725 	SSL3_CK_KRB5_RC4_40_SHA,

   726 	SSL_kKRB5|SSL_aKRB5|  SSL_RC4|SSL_SHA1   |SSL_SSLV3,

   727 	SSL_EXPORT|SSL_EXP40,

   728 	0,

   729 	40,

   730 	128,

   731 	SSL_ALL_CIPHERS,

   732 	SSL_ALL_STRENGTHS,

   733 	},

   735 /* Cipher 29 */

   736 	{

   737 	1,

   738 	SSL3_TXT_KRB5_DES_40_CBC_MD5,

   739 	SSL3_CK_KRB5_DES_40_CBC_MD5,

   740 	SSL_kKRB5|SSL_aKRB5|  SSL_DES|SSL_MD5    |SSL_SSLV3,

   741 	SSL_EXPORT|SSL_EXP40,

   742 	0,

   743 	40,

   744 	56,

   745 	SSL_ALL_CIPHERS,

   746 	SSL_ALL_STRENGTHS,

   747 	},

   749 /* Cipher 2A */

   750 	{

   751 	1,

   752 	SSL3_TXT_KRB5_RC2_40_CBC_MD5,

   753 	SSL3_CK_KRB5_RC2_40_CBC_MD5,

   754 	SSL_kKRB5|SSL_aKRB5|  SSL_RC2|SSL_MD5    |SSL_SSLV3,

   755 	SSL_EXPORT|SSL_EXP40,

   756 	0,

   757 	40,

   758 	128,

   759 	SSL_ALL_CIPHERS,

   760 	SSL_ALL_STRENGTHS,

   761 	},

   763 /* Cipher 2B */

   764 	{

   765 	1,

   766 	SSL3_TXT_KRB5_RC4_40_MD5,

   767 	SSL3_CK_KRB5_RC4_40_MD5,

   768 	SSL_kKRB5|SSL_aKRB5|  SSL_RC4|SSL_MD5    |SSL_SSLV3,

   769 	SSL_EXPORT|SSL_EXP40,

   770 	0,

   771 	40,

   772 	128,

   773 	SSL_ALL_CIPHERS,

   774 	SSL_ALL_STRENGTHS,

   775 	},

   776 #endif	/* OPENSSL_NO_KRB5 */

   778 /* New AES ciphersuites */

   779 /* Cipher 2F */

   780 	{

   781 	1,

   782 	TLS1_TXT_RSA_WITH_AES_128_SHA,

   783 	TLS1_CK_RSA_WITH_AES_128_SHA,

   784 	SSL_kRSA|SSL_aRSA|SSL_AES|SSL_SHA |SSL_TLSV1,

   785 	SSL_NOT_EXP|SSL_HIGH,

   786 	0,

   787 	128,

   788 	128,

   789 	SSL_ALL_CIPHERS,

   790 	SSL_ALL_STRENGTHS,

   791 	},

   792 /* Cipher 30 */

   793 	{

   794 	0,

   795 	TLS1_TXT_DH_DSS_WITH_AES_128_SHA,

   796 	TLS1_CK_DH_DSS_WITH_AES_128_SHA,

   797 	SSL_kDHd|SSL_aDH|SSL_AES|SSL_SHA|SSL_TLSV1,

   798 	SSL_NOT_EXP|SSL_HIGH,

   799 	0,

   800 	128,

   801 	128,

   802 	SSL_ALL_CIPHERS,

   803 	SSL_ALL_STRENGTHS,

   804 	},

   805 /* Cipher 31 */

   806 	{

   807 	0,

   808 	TLS1_TXT_DH_RSA_WITH_AES_128_SHA,

   809 	TLS1_CK_DH_RSA_WITH_AES_128_SHA,

   810 	SSL_kDHr|SSL_aDH|SSL_AES|SSL_SHA|SSL_TLSV1,

   811 	SSL_NOT_EXP|SSL_HIGH,

   812 	0,

   813 	128,

   814 	128,

   815 	SSL_ALL_CIPHERS,

   816 	SSL_ALL_STRENGTHS,

   817 	},

   818 /* Cipher 32 */

   819 	{

   820 	1,

   821 	TLS1_TXT_DHE_DSS_WITH_AES_128_SHA,

   822 	TLS1_CK_DHE_DSS_WITH_AES_128_SHA,

   823 	SSL_kEDH|SSL_aDSS|SSL_AES|SSL_SHA|SSL_TLSV1,

   824 	SSL_NOT_EXP|SSL_HIGH,

   825 	0,

   826 	128,

   827 	128,

   828 	SSL_ALL_CIPHERS,

   829 	SSL_ALL_STRENGTHS,

   830 	},

   831 /* Cipher 33 */

   832 	{

   833 	1,

   834 	TLS1_TXT_DHE_RSA_WITH_AES_128_SHA,

   835 	TLS1_CK_DHE_RSA_WITH_AES_128_SHA,

   836 	SSL_kEDH|SSL_aRSA|SSL_AES|SSL_SHA|SSL_TLSV1,

   837 	SSL_NOT_EXP|SSL_HIGH,

   838 	0,

   839 	128,

   840 	128,

   841 	SSL_ALL_CIPHERS,

   842 	SSL_ALL_STRENGTHS,

   843 	},

   844 /* Cipher 34 */

   845 	{

   846 	1,

   847 	TLS1_TXT_ADH_WITH_AES_128_SHA,

   848 	TLS1_CK_ADH_WITH_AES_128_SHA,

   849 	SSL_kEDH|SSL_aNULL|SSL_AES|SSL_SHA|SSL_TLSV1,

   850 	SSL_NOT_EXP|SSL_HIGH,

   851 	0,

   852 	128,

   853 	128,

   854 	SSL_ALL_CIPHERS,

   855 	SSL_ALL_STRENGTHS,

   856 	},

   858 /* Cipher 35 */

   859 	{

   860 	1,

   861 	TLS1_TXT_RSA_WITH_AES_256_SHA,

   862 	TLS1_CK_RSA_WITH_AES_256_SHA,

   863 	SSL_kRSA|SSL_aRSA|SSL_AES|SSL_SHA |SSL_TLSV1,

   864 	SSL_NOT_EXP|SSL_HIGH,

   865 	0,

   866 	256,

   867 	256,

   868 	SSL_ALL_CIPHERS,

   869 	SSL_ALL_STRENGTHS,

   870 	},

   871 /* Cipher 36 */

   872 	{

   873 	0,

   874 	TLS1_TXT_DH_DSS_WITH_AES_256_SHA,

   875 	TLS1_CK_DH_DSS_WITH_AES_256_SHA,

   876 	SSL_kDHd|SSL_aDH|SSL_AES|SSL_SHA|SSL_TLSV1,

   877 	SSL_NOT_EXP|SSL_HIGH,

   878 	0,

   879 	256,

   880 	256,

   881 	SSL_ALL_CIPHERS,

   882 	SSL_ALL_STRENGTHS,

   883 	},

   884 /* Cipher 37 */

   885 	{

   886 	0,

   887 	TLS1_TXT_DH_RSA_WITH_AES_256_SHA,

   888 	TLS1_CK_DH_RSA_WITH_AES_256_SHA,

   889 	SSL_kDHr|SSL_aDH|SSL_AES|SSL_SHA|SSL_TLSV1,

   890 	SSL_NOT_EXP|SSL_HIGH,

   891 	0,

   892 	256,

   893 	256,

   894 	SSL_ALL_CIPHERS,

   895 	SSL_ALL_STRENGTHS,

   896 	},

   897 /* Cipher 38 */

   898 	{

   899 	1,

   900 	TLS1_TXT_DHE_DSS_WITH_AES_256_SHA,

   901 	TLS1_CK_DHE_DSS_WITH_AES_256_SHA,

   902 	SSL_kEDH|SSL_aDSS|SSL_AES|SSL_SHA|SSL_TLSV1,

   903 	SSL_NOT_EXP|SSL_HIGH,

   904 	0,

   905 	256,

   906 	256,

   907 	SSL_ALL_CIPHERS,

   908 	SSL_ALL_STRENGTHS,

   909 	},

   910 /* Cipher 39 */

   911 	{

   912 	1,

   913 	TLS1_TXT_DHE_RSA_WITH_AES_256_SHA,

   914 	TLS1_CK_DHE_RSA_WITH_AES_256_SHA,

   915 	SSL_kEDH|SSL_aRSA|SSL_AES|SSL_SHA|SSL_TLSV1,

   916 	SSL_NOT_EXP|SSL_HIGH,

   917 	0,

   918 	256,

   919 	256,

   920 	SSL_ALL_CIPHERS,

   921 	SSL_ALL_STRENGTHS,

   922 	},

   923 	/* Cipher 3A */

   924 	{

   925 	1,

   926 	TLS1_TXT_ADH_WITH_AES_256_SHA,

   927 	TLS1_CK_ADH_WITH_AES_256_SHA,

   928 	SSL_kEDH|SSL_aNULL|SSL_AES|SSL_SHA|SSL_TLSV1,

   929 	SSL_NOT_EXP|SSL_HIGH,

   930 	0,

   931 	256,

   932 	256,

   933 	SSL_ALL_CIPHERS,

   934 	SSL_ALL_STRENGTHS,

   935 	},

   936 #ifndef OPENSSL_NO_ECDH

   937 	/* Cipher 47 */

   938 	    {

   939             1,

   940             TLS1_TXT_ECDH_ECDSA_WITH_NULL_SHA,

   941             TLS1_CK_ECDH_ECDSA_WITH_NULL_SHA,

   942             SSL_kECDH|SSL_aECDSA|SSL_eNULL|SSL_SHA|SSL_TLSV1,

   943             SSL_NOT_EXP,

   944             0,

   945             0,

   946             0,

   947             SSL_ALL_CIPHERS,

   948             SSL_ALL_STRENGTHS,

   949             },

   951 	/* Cipher 48 */

   952 	    {

   953             1,

   954             TLS1_TXT_ECDH_ECDSA_WITH_RC4_128_SHA,

   955             TLS1_CK_ECDH_ECDSA_WITH_RC4_128_SHA,

   956             SSL_kECDH|SSL_aECDSA|SSL_RC4|SSL_SHA|SSL_TLSV1,

   957             SSL_NOT_EXP,

   958             0,

   959             128,

   960             128,

   961             SSL_ALL_CIPHERS,

   962             SSL_ALL_STRENGTHS,

   963             },

   965 	/* Cipher 49 */

   966 	    {

   967             1,

   968             TLS1_TXT_ECDH_ECDSA_WITH_DES_CBC_SHA,

   969             TLS1_CK_ECDH_ECDSA_WITH_DES_CBC_SHA,

   970             SSL_kECDH|SSL_aECDSA|SSL_DES|SSL_SHA|SSL_TLSV1,

   971             SSL_NOT_EXP|SSL_LOW,

   972             0,

   973             56,

   974             56,

   975             SSL_ALL_CIPHERS,

   976             SSL_ALL_STRENGTHS,

   977             },

   979 	/* Cipher 4A */

   980 	    {

   981             1,

   982             TLS1_TXT_ECDH_ECDSA_WITH_DES_192_CBC3_SHA,

   983             TLS1_CK_ECDH_ECDSA_WITH_DES_192_CBC3_SHA,

   984             SSL_kECDH|SSL_aECDSA|SSL_3DES|SSL_SHA|SSL_TLSV1,

   985             SSL_NOT_EXP|SSL_HIGH,

   986             0,

   987             168,

   988             168,

   989             SSL_ALL_CIPHERS,

   990             SSL_ALL_STRENGTHS,

   991             },

   993 	/* Cipher 4B */

   994 	    {

   995             1,

   996             TLS1_TXT_ECDH_ECDSA_WITH_AES_128_CBC_SHA,

   997             TLS1_CK_ECDH_ECDSA_WITH_AES_128_CBC_SHA,

   998             SSL_kECDH|SSL_aECDSA|SSL_AES|SSL_SHA|SSL_TLSV1,

   999             SSL_NOT_EXP|SSL_HIGH,

  1000             0,

  1001             128,

  1002             128,

  1003             SSL_ALL_CIPHERS,

  1004             SSL_ALL_STRENGTHS,

  1005             },

  1007 	/* Cipher 4C */

  1008 	    {

  1009             1,

  1010             TLS1_TXT_ECDH_ECDSA_WITH_AES_256_CBC_SHA,

  1011             TLS1_CK_ECDH_ECDSA_WITH_AES_256_CBC_SHA,

  1012             SSL_kECDH|SSL_aECDSA|SSL_AES|SSL_SHA|SSL_TLSV1,

  1013             SSL_NOT_EXP|SSL_HIGH,

  1014             0,

  1015             256,

  1016             256,

  1017             SSL_ALL_CIPHERS,

  1018             SSL_ALL_STRENGTHS,

  1019             },

  1021 	/* Cipher 4D */

  1022 	    {

  1023             1,

  1024             TLS1_TXT_ECDH_RSA_WITH_NULL_SHA,

  1025             TLS1_CK_ECDH_RSA_WITH_NULL_SHA,

  1026             SSL_kECDH|SSL_aRSA|SSL_eNULL|SSL_SHA|SSL_TLSV1,

  1027             SSL_NOT_EXP,

  1028             0,

  1029             0,

  1030             0,

  1031             SSL_ALL_CIPHERS,

  1032             SSL_ALL_STRENGTHS,

  1033             },

  1035 	/* Cipher 4E */

  1036 	    {

  1037             1,

  1038             TLS1_TXT_ECDH_RSA_WITH_RC4_128_SHA,

  1039             TLS1_CK_ECDH_RSA_WITH_RC4_128_SHA,

  1040             SSL_kECDH|SSL_aRSA|SSL_RC4|SSL_SHA|SSL_TLSV1,

  1041             SSL_NOT_EXP,

  1042             0,

  1043             128,

  1044             128,

  1045             SSL_ALL_CIPHERS,

  1046             SSL_ALL_STRENGTHS,

  1047             },

  1049 	/* Cipher 4F */

  1050 	    {

  1051             1,

  1052             TLS1_TXT_ECDH_RSA_WITH_DES_CBC_SHA,

  1053             TLS1_CK_ECDH_RSA_WITH_DES_CBC_SHA,

  1054             SSL_kECDH|SSL_aRSA|SSL_DES|SSL_SHA|SSL_TLSV1,

  1055             SSL_NOT_EXP|SSL_LOW,

  1056             0,

  1057             56,

  1058             56,

  1059             SSL_ALL_CIPHERS,

  1060             SSL_ALL_STRENGTHS,

  1061             },

  1063 	/* Cipher 50 */

  1064 	    {

  1065             1,

  1066             TLS1_TXT_ECDH_RSA_WITH_DES_192_CBC3_SHA,

  1067             TLS1_CK_ECDH_RSA_WITH_DES_192_CBC3_SHA,

  1068             SSL_kECDH|SSL_aRSA|SSL_3DES|SSL_SHA|SSL_TLSV1,

  1069             SSL_NOT_EXP|SSL_HIGH,

  1070             0,

  1071             168,

  1072             168,

  1073             SSL_ALL_CIPHERS,

  1074             SSL_ALL_STRENGTHS,

  1075             },

  1077 	/* Cipher 51 */

  1078 	    {

  1079             1,

  1080             TLS1_TXT_ECDH_RSA_WITH_AES_128_CBC_SHA,

  1081             TLS1_CK_ECDH_RSA_WITH_AES_128_CBC_SHA,

  1082             SSL_kECDH|SSL_aRSA|SSL_AES|SSL_SHA|SSL_TLSV1,

  1083             SSL_NOT_EXP|SSL_HIGH,

  1084             0,

  1085             128,

  1086             128,

  1087             SSL_ALL_CIPHERS,

  1088             SSL_ALL_STRENGTHS,

  1089             },

  1091 	/* Cipher 52 */

  1092 	    {

  1093             1,

  1094             TLS1_TXT_ECDH_RSA_WITH_AES_256_CBC_SHA,

  1095             TLS1_CK_ECDH_RSA_WITH_AES_256_CBC_SHA,

  1096             SSL_kECDH|SSL_aRSA|SSL_AES|SSL_SHA|SSL_TLSV1,

  1097             SSL_NOT_EXP|SSL_HIGH,

  1098             0,

  1099             256,

  1100             256,

  1101             SSL_ALL_CIPHERS,

  1102             SSL_ALL_STRENGTHS,

  1103             },

  1105 	/* Cipher 53 */

  1106 	    {

  1107             1,

  1108             TLS1_TXT_ECDH_RSA_EXPORT_WITH_RC4_40_SHA,

  1109             TLS1_CK_ECDH_RSA_EXPORT_WITH_RC4_40_SHA,

  1110             SSL_kECDH|SSL_aRSA|SSL_RC4|SSL_SHA|SSL_TLSV1,

  1111             SSL_EXPORT|SSL_EXP40,

  1112             0,

  1113             40,

  1114             128,

  1115             SSL_ALL_CIPHERS,

  1116             SSL_ALL_STRENGTHS,

  1117             },

  1119 	/* Cipher 54 */

  1120 	    {

  1121             1,

  1122             TLS1_TXT_ECDH_RSA_EXPORT_WITH_RC4_56_SHA,

  1123             TLS1_CK_ECDH_RSA_EXPORT_WITH_RC4_56_SHA,

  1124             SSL_kECDH|SSL_aRSA|SSL_RC4|SSL_SHA|SSL_TLSV1,

  1125             SSL_EXPORT|SSL_EXP56,

  1126             0,

  1127             56,

  1128             128,

  1129             SSL_ALL_CIPHERS,

  1130             SSL_ALL_STRENGTHS,

  1131             },

  1133 	/* Cipher 55 */

  1134             {

  1135             1,

  1136             TLS1_TXT_ECDH_anon_WITH_NULL_SHA,

  1137             TLS1_CK_ECDH_anon_WITH_NULL_SHA,

  1138             SSL_kECDHE|SSL_aNULL|SSL_eNULL|SSL_SHA|SSL_TLSV1,

  1139             SSL_NOT_EXP,

  1140             0,

  1141             0,

  1142             0,

  1143             SSL_ALL_CIPHERS,

  1144             SSL_ALL_STRENGTHS,

  1145 	    },

  1147 	/* Cipher 56 */

  1148             {

  1149             1,

  1150             TLS1_TXT_ECDH_anon_WITH_RC4_128_SHA,

  1151             TLS1_CK_ECDH_anon_WITH_RC4_128_SHA,

  1152             SSL_kECDHE|SSL_aNULL|SSL_RC4|SSL_SHA|SSL_TLSV1,

  1153             SSL_NOT_EXP,

  1154             0,

  1155             128,

  1156             128,

  1157             SSL_ALL_CIPHERS,

  1158             SSL_ALL_STRENGTHS,

  1159 	    },

  1161 	/* Cipher 57 */

  1162 	    {

  1163             1,

  1164             TLS1_TXT_ECDH_anon_WITH_DES_CBC_SHA,

  1165             TLS1_CK_ECDH_anon_WITH_DES_CBC_SHA,

  1166             SSL_kECDHE|SSL_aNULL|SSL_DES|SSL_SHA|SSL_TLSV1,

  1167             SSL_NOT_EXP|SSL_LOW,

  1168             0,

  1169             56,

  1170             56,

  1171             SSL_ALL_CIPHERS,

  1172             SSL_ALL_STRENGTHS,

  1173             },

  1175 	/* Cipher 58 */

  1176 	    {

  1177             1,

  1178             TLS1_TXT_ECDH_anon_WITH_DES_192_CBC3_SHA,

  1179             TLS1_CK_ECDH_anon_WITH_DES_192_CBC3_SHA,

  1180             SSL_kECDHE|SSL_aNULL|SSL_3DES|SSL_SHA|SSL_TLSV1,

  1181             SSL_NOT_EXP|SSL_HIGH,

  1182             0,

  1183             168,

  1184             168,

  1185             SSL_ALL_CIPHERS,

  1186             SSL_ALL_STRENGTHS,

  1187             },

  1189 	/* Cipher 59 */

  1190 	    {

  1191             1,

  1192             TLS1_TXT_ECDH_anon_EXPORT_WITH_DES_40_CBC_SHA,

  1193             TLS1_CK_ECDH_anon_EXPORT_WITH_DES_40_CBC_SHA,

  1194             SSL_kECDHE|SSL_aNULL|SSL_DES|SSL_SHA|SSL_TLSV1,

  1195             SSL_EXPORT|SSL_EXP40,

  1196             0,

  1197             40,

  1198             56,

  1199             SSL_ALL_CIPHERS,

  1200             SSL_ALL_STRENGTHS,

  1201             },

  1203 	/* Cipher 5A */

  1204 	    {

  1205             1,

  1206             TLS1_TXT_ECDH_anon_EXPORT_WITH_RC4_40_SHA,

  1207             TLS1_CK_ECDH_anon_EXPORT_WITH_RC4_40_SHA,

  1208             SSL_kECDHE|SSL_aNULL|SSL_RC4|SSL_SHA|SSL_TLSV1,

  1209             SSL_EXPORT|SSL_EXP40,

  1210             0,

  1211             40,

  1212             128,

  1213             SSL_ALL_CIPHERS,

  1214             SSL_ALL_STRENGTHS,

  1215             },

  1216 	/* Cipher 5B */

  1217 	/* XXX NOTE: The ECC/TLS draft has a bug and reuses 4B for this */

  1218 	    {

  1219             1,

  1220             TLS1_TXT_ECDH_ECDSA_EXPORT_WITH_RC4_40_SHA,

  1221             TLS1_CK_ECDH_ECDSA_EXPORT_WITH_RC4_40_SHA,

  1222             SSL_kECDH|SSL_aECDSA|SSL_RC4|SSL_SHA|SSL_TLSV1,

  1223             SSL_EXPORT|SSL_EXP40,

  1224             0,

  1225             40,

  1226             128,

  1227             SSL_ALL_CIPHERS,

  1228             SSL_ALL_STRENGTHS,

  1229             },

  1231 	/* Cipher 5C */

  1232 	/* XXX NOTE: The ECC/TLS draft has a bug and reuses 4C for this */

  1233 	    {

  1234             1,

  1235             TLS1_TXT_ECDH_ECDSA_EXPORT_WITH_RC4_56_SHA,

  1236             TLS1_CK_ECDH_ECDSA_EXPORT_WITH_RC4_56_SHA,

  1237             SSL_kECDH|SSL_aECDSA|SSL_RC4|SSL_SHA|SSL_TLSV1,

  1238             SSL_EXPORT|SSL_EXP56,

  1239             0,

  1240             56,

  1241             128,

  1242             SSL_ALL_CIPHERS,

  1243             SSL_ALL_STRENGTHS,

  1244             },

  1246 #endif	/* OPENSSL_NO_ECDH */

  1248 #if TLS1_ALLOW_EXPERIMENTAL_CIPHERSUITES

  1249 	/* New TLS Export CipherSuites from Expired ID */

  1250 #if 0

  1251 	/* Cipher 60 */

  1252 	    {

  1253 	    1,

  1254 	    TLS1_TXT_RSA_EXPORT1024_WITH_RC4_56_MD5,

  1255 	    TLS1_CK_RSA_EXPORT1024_WITH_RC4_56_MD5,

  1256 	    SSL_kRSA|SSL_aRSA|SSL_RC4|SSL_MD5|SSL_TLSV1,

  1257 	    SSL_EXPORT|SSL_EXP56,

  1258 	    0,

  1259 	    56,

  1260 	    128,

  1261 	    SSL_ALL_CIPHERS,

  1262 	    SSL_ALL_STRENGTHS,

  1263 	    },

  1264 	/* Cipher 61 */

  1265 	    {

  1266 	    1,

  1267 	    TLS1_TXT_RSA_EXPORT1024_WITH_RC2_CBC_56_MD5,

  1268 	    TLS1_CK_RSA_EXPORT1024_WITH_RC2_CBC_56_MD5,

  1269 	    SSL_kRSA|SSL_aRSA|SSL_RC2|SSL_MD5|SSL_TLSV1,

  1270 	    SSL_EXPORT|SSL_EXP56,

  1271 	    0,

  1272 	    56,

  1273 	    128,

  1274 	    SSL_ALL_CIPHERS,

  1275 	    SSL_ALL_STRENGTHS,

  1276 	    },

  1277 #endif

  1278 	/* Cipher 62 */

  1279 	    {

  1280 	    1,

  1281 	    TLS1_TXT_RSA_EXPORT1024_WITH_DES_CBC_SHA,

  1282 	    TLS1_CK_RSA_EXPORT1024_WITH_DES_CBC_SHA,

  1283 	    SSL_kRSA|SSL_aRSA|SSL_DES|SSL_SHA|SSL_TLSV1,

  1284 	    SSL_EXPORT|SSL_EXP56,

  1285 	    0,

  1286 	    56,

  1287 	    56,

  1288 	    SSL_ALL_CIPHERS,

  1289 	    SSL_ALL_STRENGTHS,

  1290 	    },

  1291 	/* Cipher 63 */

  1292 	    {

  1293 	    1,

  1294 	    TLS1_TXT_DHE_DSS_EXPORT1024_WITH_DES_CBC_SHA,

  1295 	    TLS1_CK_DHE_DSS_EXPORT1024_WITH_DES_CBC_SHA,

  1296 	    SSL_kEDH|SSL_aDSS|SSL_DES|SSL_SHA|SSL_TLSV1,

  1297 	    SSL_EXPORT|SSL_EXP56,

  1298 	    0,

  1299 	    56,

  1300 	    56,

  1301 	    SSL_ALL_CIPHERS,

  1302 	    SSL_ALL_STRENGTHS,

  1303 	    },

  1304 	/* Cipher 64 */

  1305 	    {

  1306 	    1,

  1307 	    TLS1_TXT_RSA_EXPORT1024_WITH_RC4_56_SHA,

  1308 	    TLS1_CK_RSA_EXPORT1024_WITH_RC4_56_SHA,

  1309 	    SSL_kRSA|SSL_aRSA|SSL_RC4|SSL_SHA|SSL_TLSV1,

  1310 	    SSL_EXPORT|SSL_EXP56,

  1311 	    0,

  1312 	    56,

  1313 	    128,

  1314 	    SSL_ALL_CIPHERS,

  1315 	    SSL_ALL_STRENGTHS,

  1316 	    },

  1317 	/* Cipher 65 */

  1318 	    {

  1319 	    1,

  1320 	    TLS1_TXT_DHE_DSS_EXPORT1024_WITH_RC4_56_SHA,

  1321 	    TLS1_CK_DHE_DSS_EXPORT1024_WITH_RC4_56_SHA,

  1322 	    SSL_kEDH|SSL_aDSS|SSL_RC4|SSL_SHA|SSL_TLSV1,

  1323 	    SSL_EXPORT|SSL_EXP56,

  1324 	    0,

  1325 	    56,

  1326 	    128,

  1327 	    SSL_ALL_CIPHERS,

  1328 	    SSL_ALL_STRENGTHS,

  1329 	    },

  1330 	/* Cipher 66 */

  1331 	    {

  1332 	    1,

  1333 	    TLS1_TXT_DHE_DSS_WITH_RC4_128_SHA,

  1334 	    TLS1_CK_DHE_DSS_WITH_RC4_128_SHA,

  1335 	    SSL_kEDH|SSL_aDSS|SSL_RC4|SSL_SHA|SSL_TLSV1,

  1336 	    SSL_NOT_EXP|SSL_MEDIUM,

  1337 	    0,

  1338 	    128,

  1339 	    128,

  1340 	    SSL_ALL_CIPHERS,

  1341 	    SSL_ALL_STRENGTHS

  1342 	    },

  1343 #endif

  1346 #ifndef OPENSSL_NO_ECDH

  1347 	/* Cipher 77 XXX: ECC ciphersuites offering forward secrecy

  1348 	 * are not yet specified in the ECC/TLS draft but our code

  1349 	 * allows them to be implemented very easily. To add such

  1350 	 * a cipher suite, one needs to add two constant definitions

  1351 	 * to tls1.h and a new structure in this file as shown below. We

  1352 	 * illustrate the process for the made-up cipher

  1353 	 * ECDHE-ECDSA-AES128-SHA.

  1354 	 */

  1355 	    {

  1356             1,

  1357             TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,

  1358             TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,

  1359             SSL_kECDHE|SSL_aECDSA|SSL_AES|SSL_SHA|SSL_TLSV1,

  1360             SSL_NOT_EXP|SSL_HIGH,

  1361             0,

  1362             128,

  1363             128,

  1364             SSL_ALL_CIPHERS,

  1365             SSL_ALL_STRENGTHS,

  1366             },

  1368 	/* Cipher 78 XXX: Another made-up ECC cipher suite that

  1369 	 * offers forward secrecy (ECDHE-RSA-AES128-SHA).

  1370 	 */

  1371 	    {

  1372             1,

  1373             TLS1_TXT_ECDHE_RSA_WITH_AES_128_CBC_SHA,

  1374             TLS1_CK_ECDHE_RSA_WITH_AES_128_CBC_SHA,

  1375             SSL_kECDHE|SSL_aRSA|SSL_AES|SSL_SHA|SSL_TLSV1,

  1376             SSL_NOT_EXP|SSL_HIGH,

  1377             0,

  1378             128,

  1379             128,

  1380             SSL_ALL_CIPHERS,

  1381             SSL_ALL_STRENGTHS,

  1382             },

  1383 #endif /* !OPENSSL_NO_ECDH */

  1385 /* end of list */

  1386 	};

  1387 #ifdef EMULATOR

  1388 GET_GLOBAL_VAR_FROM_TLS(SSLv3_enc_data,s3_lib,SSL3_ENC_METHOD)

  1390 #define SSLv3_enc_data (GET_WSD_VAR_NAME(SSLv3_enc_data,s3_lib,g)())

  1391 #endif

  1392 #ifndef EMULATOR

  1393 SSL3_ENC_METHOD SSLv3_enc_data={

  1394 #else

  1395 const SSL3_ENC_METHOD temp_SSLv3_enc_data={

  1396 #endif

  1397 	ssl3_enc,

  1398 	ssl3_mac,

  1399 	ssl3_setup_key_block,

  1400 	ssl3_generate_master_secret,

  1401 	ssl3_change_cipher_state,

  1402 	ssl3_final_finish_mac,

  1403 	MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH,

  1404 	ssl3_cert_verify_mac,

  1405 	SSL3_MD_CLIENT_FINISHED_CONST,4,

  1406 	SSL3_MD_SERVER_FINISHED_CONST,4,

  1407 	ssl3_alert_code,

  1408 	};

  1410 long ssl3_default_timeout(void)

  1411 	{

  1412 	/* 2 hours, the 24 hours mentioned in the SSLv3 spec

  1413 	 * is way too long for http, the cache would over fill */

  1414 	return(60*60*2);

  1415 	}

  1417 IMPLEMENT_ssl3_meth_func(sslv3_base_method,

  1418 			ssl_undefined_function,

  1419 			ssl_undefined_function,

  1420 			ssl_bad_method)

  1422 int ssl3_num_ciphers(void)

  1423 	{

  1424 	return(SSL3_NUM_CIPHERS);

  1425 	}

  1427 SSL_CIPHER *ssl3_get_cipher(unsigned int u)

  1428 	{

  1429 	if (u < SSL3_NUM_CIPHERS)

  1430 		return(&(ssl3_ciphers[SSL3_NUM_CIPHERS-1-u]));

  1431 	else

  1432 		return(NULL);

  1433 	}

  1435 int ssl3_pending(const SSL *s)

  1436 	{

  1437 	if (s->rstate == SSL_ST_READ_BODY)

  1438 		return 0;

  1440 	return (s->s3->rrec.type == SSL3_RT_APPLICATION_DATA) ? s->s3->rrec.length : 0;

  1441 	}

  1443 int ssl3_new(SSL *s)

  1444 	{

  1445 	SSL3_STATE *s3;

  1447 	if ((s3=OPENSSL_malloc(sizeof *s3)) == NULL) goto err;

  1448 	memset(s3,0,sizeof *s3);

  1449 	EVP_MD_CTX_init(&s3->finish_dgst1);

  1450 	EVP_MD_CTX_init(&s3->finish_dgst2);

  1451 	pq_64bit_init(&(s3->rrec.seq_num));

  1452 	pq_64bit_init(&(s3->wrec.seq_num));

  1454 	s->s3=s3;

  1456 	s->method->ssl_clear(s);

  1457 	return(1);

  1458 err:

  1459 	return(0);

  1460 	}

  1462 void ssl3_free(SSL *s)

  1463 	{

  1464 	if(s == NULL)

  1465 	    return;

  1467 	ssl3_cleanup_key_block(s);

  1468 	if (s->s3->rbuf.buf != NULL)

  1469 		OPENSSL_free(s->s3->rbuf.buf);

  1470 	if (s->s3->wbuf.buf != NULL)

  1471 		OPENSSL_free(s->s3->wbuf.buf);

  1472 	if (s->s3->rrec.comp != NULL)

  1473 		OPENSSL_free(s->s3->rrec.comp);

  1474 #ifndef OPENSSL_NO_DH

  1475 	if (s->s3->tmp.dh != NULL)

  1476 		DH_free(s->s3->tmp.dh);

  1477 #endif

  1478 #ifndef OPENSSL_NO_ECDH

  1479 	if (s->s3->tmp.ecdh != NULL)

  1480 		EC_KEY_free(s->s3->tmp.ecdh);

  1481 #endif

  1483 	if (s->s3->tmp.ca_names != NULL)

  1484 		sk_X509_NAME_pop_free(s->s3->tmp.ca_names,X509_NAME_free);

  1485 	EVP_MD_CTX_cleanup(&s->s3->finish_dgst1);

  1486 	EVP_MD_CTX_cleanup(&s->s3->finish_dgst2);

  1487 	pq_64bit_free(&(s->s3->rrec.seq_num));

  1488 	pq_64bit_free(&(s->s3->wrec.seq_num));

  1490 	OPENSSL_cleanse(s->s3,sizeof *s->s3);

  1491 	OPENSSL_free(s->s3);

  1492 	s->s3=NULL;

  1493 	}

  1495 void ssl3_clear(SSL *s)

  1496 	{

  1497 	unsigned char *rp,*wp;

  1498 	size_t rlen, wlen;

  1500 	ssl3_cleanup_key_block(s);

  1501 	if (s->s3->tmp.ca_names != NULL)

  1502 		sk_X509_NAME_pop_free(s->s3->tmp.ca_names,X509_NAME_free);

  1504 	if (s->s3->rrec.comp != NULL)

  1505 		{

  1506 		OPENSSL_free(s->s3->rrec.comp);

  1507 		s->s3->rrec.comp=NULL;

  1508 		}

  1509 #ifndef OPENSSL_NO_DH

  1510 	if (s->s3->tmp.dh != NULL)

  1511 		DH_free(s->s3->tmp.dh);

  1512 #endif

  1513 #ifndef OPENSSL_NO_ECDH

  1514 	if (s->s3->tmp.ecdh != NULL)

  1515 		EC_KEY_free(s->s3->tmp.ecdh);

  1516 #endif

  1518 	rp = s->s3->rbuf.buf;

  1519 	wp = s->s3->wbuf.buf;

  1520 	rlen = s->s3->rbuf.len;

  1521  	wlen = s->s3->wbuf.len;

  1523 	EVP_MD_CTX_cleanup(&s->s3->finish_dgst1);

  1524 	EVP_MD_CTX_cleanup(&s->s3->finish_dgst2);

  1526 	memset(s->s3,0,sizeof *s->s3);

  1527 	s->s3->rbuf.buf = rp;

  1528 	s->s3->wbuf.buf = wp;

  1529 	s->s3->rbuf.len = rlen;

  1530  	s->s3->wbuf.len = wlen;

  1532 	ssl_free_wbio_buffer(s);

  1534 	s->packet_length=0;

  1535 	s->s3->renegotiate=0;

  1536 	s->s3->total_renegotiations=0;

  1537 	s->s3->num_renegotiations=0;

  1538 	s->s3->in_read_app_data=0;

  1539 	s->version=SSL3_VERSION;

  1540 	}

  1542 long ssl3_ctrl(SSL *s, int cmd, long larg, void *parg)

  1543 	{

  1544 	int ret=0;

  1546 #if !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_RSA)

  1547 	if (

  1548 #ifndef OPENSSL_NO_RSA

  1549 	    cmd == SSL_CTRL_SET_TMP_RSA ||

  1550 	    cmd == SSL_CTRL_SET_TMP_RSA_CB ||

  1551 #endif

  1552 #ifndef OPENSSL_NO_DSA

  1553 	    cmd == SSL_CTRL_SET_TMP_DH ||

  1554 	    cmd == SSL_CTRL_SET_TMP_DH_CB ||

  1555 #endif

  1556 		0)

  1557 		{

  1558 		if (!ssl_cert_inst(&s->cert))

  1559 		    	{

  1560 			SSLerr(SSL_F_SSL3_CTRL, ERR_R_MALLOC_FAILURE);

  1561 			return(0);

  1562 			}

  1563 		}

  1564 #endif

  1566 	switch (cmd)

  1567 		{

  1568 	case SSL_CTRL_GET_SESSION_REUSED:

  1569 		ret=s->hit;

  1570 		break;

  1571 	case SSL_CTRL_GET_CLIENT_CERT_REQUEST:

  1572 		break;

  1573 	case SSL_CTRL_GET_NUM_RENEGOTIATIONS:

  1574 		ret=s->s3->num_renegotiations;

  1575 		break;

  1576 	case SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS:

  1577 		ret=s->s3->num_renegotiations;

  1578 		s->s3->num_renegotiations=0;

  1579 		break;

  1580 	case SSL_CTRL_GET_TOTAL_RENEGOTIATIONS:

  1581 		ret=s->s3->total_renegotiations;

  1582 		break;

  1583 	case SSL_CTRL_GET_FLAGS:

  1584 		ret=(int)(s->s3->flags);

  1585 		break;

  1586 #ifndef OPENSSL_NO_RSA

  1587 	case SSL_CTRL_NEED_TMP_RSA:

  1588 		if ((s->cert != NULL) && (s->cert->rsa_tmp == NULL) &&

  1589 		    ((s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey == NULL) ||

  1590 		     (EVP_PKEY_size(s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey) > (512/8))))

  1591 			ret = 1;

  1592 		break;

  1593 	case SSL_CTRL_SET_TMP_RSA:

  1594 		{

  1595 			RSA *rsa = (RSA *)parg;

  1596 			if (rsa == NULL)

  1597 				{

  1598 				SSLerr(SSL_F_SSL3_CTRL, ERR_R_PASSED_NULL_PARAMETER);

  1599 				return(ret);

  1600 				}

  1601 			if ((rsa = RSAPrivateKey_dup(rsa)) == NULL)

  1602 				{

  1603 				SSLerr(SSL_F_SSL3_CTRL, ERR_R_RSA_LIB);

  1604 				return(ret);

  1605 				}

  1606 			if (s->cert->rsa_tmp != NULL)

  1607 				RSA_free(s->cert->rsa_tmp);

  1608 			s->cert->rsa_tmp = rsa;

  1609 			ret = 1;

  1610 		}

  1611 		break;

  1612 	case SSL_CTRL_SET_TMP_RSA_CB:

  1613 		{

  1614 		SSLerr(SSL_F_SSL3_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);

  1615 		return(ret);

  1616 		}

  1617 		break;

  1618 #endif

  1619 #ifndef OPENSSL_NO_DH

  1620 	case SSL_CTRL_SET_TMP_DH:

  1621 		{

  1622 			DH *dh = (DH *)parg;

  1623 			if (dh == NULL)

  1624 				{

  1625 				SSLerr(SSL_F_SSL3_CTRL, ERR_R_PASSED_NULL_PARAMETER);

  1626 				return(ret);

  1627 				}

  1628 			if ((dh = DHparams_dup(dh)) == NULL)

  1629 				{

  1630 				SSLerr(SSL_F_SSL3_CTRL, ERR_R_DH_LIB);

  1631 				return(ret);

  1632 				}

  1633 			if (!(s->options & SSL_OP_SINGLE_DH_USE))

  1634 				{

  1635 				if (!DH_generate_key(dh))

  1636 					{

  1637 					DH_free(dh);

  1638 					SSLerr(SSL_F_SSL3_CTRL, ERR_R_DH_LIB);

  1639 					return(ret);

  1640 					}

  1641 				}

  1642 			if (s->cert->dh_tmp != NULL)

  1643 				DH_free(s->cert->dh_tmp);

  1644 			s->cert->dh_tmp = dh;

  1645 			ret = 1;

  1646 		}

  1647 		break;

  1648 	case SSL_CTRL_SET_TMP_DH_CB:

  1649 		{

  1650 		SSLerr(SSL_F_SSL3_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);

  1651 		return(ret);

  1652 		}

  1653 		break;

  1654 #endif

  1655 #ifndef OPENSSL_NO_ECDH

  1656 	case SSL_CTRL_SET_TMP_ECDH:

  1657 		{

  1658 		EC_KEY *ecdh = NULL;

  1660 		if (parg == NULL)

  1661 			{

  1662 			SSLerr(SSL_F_SSL3_CTRL, ERR_R_PASSED_NULL_PARAMETER);

  1663 			return(ret);

  1664 			}

  1665 		if (!EC_KEY_up_ref((EC_KEY *)parg))

  1666 			{

  1667 			SSLerr(SSL_F_SSL3_CTRL,ERR_R_ECDH_LIB);

  1668 			return(ret);

  1669 			}

  1670 		ecdh = (EC_KEY *)parg;

  1671 		if (!(s->options & SSL_OP_SINGLE_ECDH_USE))

  1672 			{

  1673 			if (!EC_KEY_generate_key(ecdh))

  1674 				{

  1675 				EC_KEY_free(ecdh);

  1676 				SSLerr(SSL_F_SSL3_CTRL,ERR_R_ECDH_LIB);

  1677 				return(ret);

  1678 				}

  1679 			}

  1680 		if (s->cert->ecdh_tmp != NULL)

  1681 			EC_KEY_free(s->cert->ecdh_tmp);

  1682 		s->cert->ecdh_tmp = ecdh;

  1683 		ret = 1;

  1684 		}

  1685 		break;

  1686 	case SSL_CTRL_SET_TMP_ECDH_CB:

  1687 		{

  1688 		SSLerr(SSL_F_SSL3_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);

  1689 		return(ret);

  1690 		}

  1691 		break;

  1692 #endif /* !OPENSSL_NO_ECDH */

  1693 	default:

  1694 		break;

  1695 		}

  1696 	return(ret);

  1697 	}

  1699 long ssl3_callback_ctrl(SSL *s, int cmd, void (*fp)(void))

  1700 	{

  1701 	int ret=0;

  1703 #if !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_RSA)

  1704 	if (

  1705 #ifndef OPENSSL_NO_RSA

  1706 	    cmd == SSL_CTRL_SET_TMP_RSA_CB ||

  1707 #endif

  1708 #ifndef OPENSSL_NO_DSA

  1709 	    cmd == SSL_CTRL_SET_TMP_DH_CB ||

  1710 #endif

  1711 		0)

  1712 		{

  1713 		if (!ssl_cert_inst(&s->cert))

  1714 			{

  1715 			SSLerr(SSL_F_SSL3_CALLBACK_CTRL, ERR_R_MALLOC_FAILURE);

  1716 			return(0);

  1717 			}

  1718 		}

  1719 #endif

  1721 	switch (cmd)

  1722 		{

  1723 #ifndef OPENSSL_NO_RSA

  1724 	case SSL_CTRL_SET_TMP_RSA_CB:

  1725 		{

  1726 		s->cert->rsa_tmp_cb = (RSA *(*)(SSL *, int, int))fp;

  1727 		}

  1728 		break;

  1729 #endif

  1730 #ifndef OPENSSL_NO_DH

  1731 	case SSL_CTRL_SET_TMP_DH_CB:

  1732 		{

  1733 		s->cert->dh_tmp_cb = (DH *(*)(SSL *, int, int))fp;

  1734 		}

  1735 		break;

  1736 #endif

  1737 #ifndef OPENSSL_NO_ECDH

  1738 	case SSL_CTRL_SET_TMP_ECDH_CB:

  1739 		{

  1740 		s->cert->ecdh_tmp_cb = (EC_KEY *(*)(SSL *, int, int))fp;

  1741 		}

  1742 		break;

  1743 #endif

  1744 	default:

  1745 		break;

  1746 		}

  1747 	return(ret);

  1748 	}

  1750 long ssl3_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)

  1751 	{

  1752 	CERT *cert;

  1754 	cert=ctx->cert;

  1756 	switch (cmd)

  1757 		{

  1758 #ifndef OPENSSL_NO_RSA

  1759 	case SSL_CTRL_NEED_TMP_RSA:

  1760 		if (	(cert->rsa_tmp == NULL) &&

  1761 			((cert->pkeys[SSL_PKEY_RSA_ENC].privatekey == NULL) ||

  1762 			 (EVP_PKEY_size(cert->pkeys[SSL_PKEY_RSA_ENC].privatekey) > (512/8)))

  1763 			)

  1764 			return(1);

  1765 		else

  1766 			return(0);

  1767 		/* break; */

  1768 	case SSL_CTRL_SET_TMP_RSA:

  1769 		{

  1770 		RSA *rsa;

  1771 		int i;

  1773 		rsa=(RSA *)parg;

  1774 		i=1;

  1775 		if (rsa == NULL)

  1776 			i=0;

  1777 		else

  1778 			{

  1779 			if ((rsa=RSAPrivateKey_dup(rsa)) == NULL)

  1780 				i=0;

  1781 			}

  1782 		if (!i)

  1783 			{

  1784 			SSLerr(SSL_F_SSL3_CTX_CTRL,ERR_R_RSA_LIB);

  1785 			return(0);

  1786 			}

  1787 		else

  1788 			{

  1789 			if (cert->rsa_tmp != NULL)

  1790 				RSA_free(cert->rsa_tmp);

  1791 			cert->rsa_tmp=rsa;

  1792 			return(1);

  1793 			}

  1794 		}

  1795 		/* break; */

  1796 	case SSL_CTRL_SET_TMP_RSA_CB:

  1797 		{

  1798 		SSLerr(SSL_F_SSL3_CTX_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);

  1799 		return(0);

  1800 		}

  1801 		break;

  1802 #endif

  1803 #ifndef OPENSSL_NO_DH

  1804 	case SSL_CTRL_SET_TMP_DH:

  1805 		{

  1806 		DH *new=NULL,*dh;

  1808 		dh=(DH *)parg;

  1809 		if ((new=DHparams_dup(dh)) == NULL)

  1810 			{

  1811 			SSLerr(SSL_F_SSL3_CTX_CTRL,ERR_R_DH_LIB);

  1812 			return 0;

  1813 			}

  1814 		if (!(ctx->options & SSL_OP_SINGLE_DH_USE))

  1815 			{

  1816 			if (!DH_generate_key(new))

  1817 				{

  1818 				SSLerr(SSL_F_SSL3_CTX_CTRL,ERR_R_DH_LIB);

  1819 				DH_free(new);

  1820 				return 0;

  1821 				}

  1822 			}

  1823 		if (cert->dh_tmp != NULL)

  1824 			DH_free(cert->dh_tmp);

  1825 		cert->dh_tmp=new;

  1826 		return 1;

  1827 		}

  1828 		/*break; */

  1829 	case SSL_CTRL_SET_TMP_DH_CB:

  1830 		{

  1831 		SSLerr(SSL_F_SSL3_CTX_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);

  1832 		return(0);

  1833 		}

  1834 		break;

  1835 #endif

  1836 #ifndef OPENSSL_NO_ECDH

  1837 	case SSL_CTRL_SET_TMP_ECDH:

  1838 		{

  1839 		EC_KEY *ecdh = NULL;

  1841 		if (parg == NULL)

  1842 			{

  1843 			SSLerr(SSL_F_SSL3_CTX_CTRL,ERR_R_ECDH_LIB);

  1844 			return 0;

  1845 			}

  1846 		ecdh = EC_KEY_dup((EC_KEY *)parg);

  1847 		if (ecdh == NULL)

  1848 			{

  1849 			SSLerr(SSL_F_SSL3_CTX_CTRL,ERR_R_EC_LIB);

  1850 			return 0;

  1851 			}

  1852 		if (!(ctx->options & SSL_OP_SINGLE_ECDH_USE))

  1853 			{

  1854 			if (!EC_KEY_generate_key(ecdh))

  1855 				{

  1856 				EC_KEY_free(ecdh);

  1857 				SSLerr(SSL_F_SSL3_CTX_CTRL,ERR_R_ECDH_LIB);

  1858 				return 0;

  1859 				}

  1860 			}

  1862 		if (cert->ecdh_tmp != NULL)

  1863 			{

  1864 			EC_KEY_free(cert->ecdh_tmp);

  1865 			}

  1866 		cert->ecdh_tmp = ecdh;

  1867 		return 1;

  1868 		}

  1869 		/* break; */

  1870 	case SSL_CTRL_SET_TMP_ECDH_CB:

  1871 		{

  1872 		SSLerr(SSL_F_SSL3_CTX_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);

  1873 		return(0);

  1874 		}

  1875 		break;

  1876 #endif /* !OPENSSL_NO_ECDH */

  1877 	/* A Thawte special :-) */

  1878 	case SSL_CTRL_EXTRA_CHAIN_CERT:

  1879 		if (ctx->extra_certs == NULL)

  1880 			{

  1881 			if ((ctx->extra_certs=sk_X509_new_null()) == NULL)

  1882 				return(0);

  1883 			}

  1884 		sk_X509_push(ctx->extra_certs,(X509 *)parg);

  1885 		break;

  1887 	default:

  1888 		return(0);

  1889 		}

  1890 	return(1);

  1891 	}

  1893 long ssl3_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void))

  1894 	{

  1895 	CERT *cert;

  1897 	cert=ctx->cert;

  1899 	switch (cmd)

  1900 		{

  1901 #ifndef OPENSSL_NO_RSA

  1902 	case SSL_CTRL_SET_TMP_RSA_CB:

  1903 		{

  1904 		cert->rsa_tmp_cb = (RSA *(*)(SSL *, int, int))fp;

  1905 		}

  1906 		break;

  1907 #endif

  1908 #ifndef OPENSSL_NO_DH

  1909 	case SSL_CTRL_SET_TMP_DH_CB:

  1910 		{

  1911 		cert->dh_tmp_cb = (DH *(*)(SSL *, int, int))fp;

  1912 		}

  1913 		break;

  1914 #endif

  1915 #ifndef OPENSSL_NO_ECDH

  1916 	case SSL_CTRL_SET_TMP_ECDH_CB:

  1917 		{

  1918 		cert->ecdh_tmp_cb = (EC_KEY *(*)(SSL *, int, int))fp;

  1919 		}

  1920 		break;

  1921 #endif

  1922 	default:

  1923 		return(0);

  1924 		}

  1925 	return(1);

  1926 	}

  1928 /* This function needs to check if the ciphers required are actually

  1929  * available */

  1930 SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p)

  1931 	{

  1932 	SSL_CIPHER c,*cp;

  1933 	unsigned long id;

  1935 	id=0x03000000L|((unsigned long)p[0]<<8L)|(unsigned long)p[1];

  1936 	c.id=id;

  1937 	cp = (SSL_CIPHER *)OBJ_bsearch((char *)&c,

  1938 		(char *)ssl3_ciphers,

  1939 		SSL3_NUM_CIPHERS,sizeof(SSL_CIPHER),

  1940 		FP_ICC ssl_cipher_id_cmp);

  1941 	if (cp == NULL || cp->valid == 0)

  1942 		return NULL;

  1943 	else

  1944 		return cp;

  1945 	}

  1947 int ssl3_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p)

  1948 	{

  1949 	long l;

  1951 	if (p != NULL)

  1952 		{

  1953 		l=c->id;

  1954 		if ((l & 0xff000000) != 0x03000000) return(0);

  1955 		p[0]=((unsigned char)(l>> 8L))&0xFF;

  1956 		p[1]=((unsigned char)(l     ))&0xFF;

  1957 		}

  1958 	return(2);

  1959 	}

  1961 SSL_CIPHER *ssl3_choose_cipher(SSL *s, STACK_OF(SSL_CIPHER) *clnt,

  1962 	     STACK_OF(SSL_CIPHER) *srvr)

  1963 	{

  1964 	SSL_CIPHER *c,*ret=NULL;

  1965 	STACK_OF(SSL_CIPHER) *prio, *allow;

  1966 	int i,j,ok;

  1968 	CERT *cert;

  1969 	unsigned long alg,mask,emask;

  1971 	/* Let's see which ciphers we can support */

  1972 	cert=s->cert;

  1974 #if 0

  1975 	/* Do not set the compare functions, because this may lead to a

  1976 	 * reordering by "id". We want to keep the original ordering.

  1977 	 * We may pay a price in performance during sk_SSL_CIPHER_find(),

  1978 	 * but would have to pay with the price of sk_SSL_CIPHER_dup().

  1979 	 */

  1980 	sk_SSL_CIPHER_set_cmp_func(srvr, ssl_cipher_ptr_id_cmp);

  1981 	sk_SSL_CIPHER_set_cmp_func(clnt, ssl_cipher_ptr_id_cmp);

  1982 #endif

  1984 #ifdef CIPHER_DEBUG

  1985         printf("Server has %d from %p:\n", sk_SSL_CIPHER_num(srvr), srvr);

  1986         for(i=0 ; i < sk_SSL_CIPHER_num(srvr) ; ++i)

  1987 	    {

  1988 	    c=sk_SSL_CIPHER_value(srvr,i);

  1989 	    printf("%p:%s\n",c,c->name);

  1990 	    }

  1991         printf("Client sent %d from %p:\n", sk_SSL_CIPHER_num(clnt), clnt);

  1992         for(i=0 ; i < sk_SSL_CIPHER_num(clnt) ; ++i)

  1993 	    {

  1994 	    c=sk_SSL_CIPHER_value(clnt,i);

  1995 	    printf("%p:%s\n",c,c->name);

  1996 	    }

  1997 #endif

  1999 	if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE)

  2000 	    {

  2001 	    prio = srvr;

  2002 	    allow = clnt;

  2003 	    }

  2004 	else

  2005 	    {

  2006 	    prio = clnt;

  2007 	    allow = srvr;

  2008 	    }

  2010 	for (i=0; i<sk_SSL_CIPHER_num(prio); i++)

  2011 		{

  2012 		c=sk_SSL_CIPHER_value(prio,i);

  2014 		ssl_set_cert_masks(cert,c);

  2015 		mask=cert->mask;

  2016 		emask=cert->export_mask;

  2018 #ifdef KSSL_DEBUG

  2019 		printf("ssl3_choose_cipher %d alg= %lx\n", i,c->algorithms);

  2020 #endif    /* KSSL_DEBUG */

  2022 		alg=c->algorithms&(SSL_MKEY_MASK|SSL_AUTH_MASK);

  2023 #ifndef OPENSSL_NO_KRB5

  2024                 if (alg & SSL_KRB5)

  2025                         {

  2026                         if ( !kssl_keytab_is_available(s->kssl_ctx) )

  2027                             continue;

  2028                         }

  2029 #endif /* OPENSSL_NO_KRB5 */

  2030 		if (SSL_C_IS_EXPORT(c))

  2031 			{

  2032 			ok=((alg & emask) == alg)?1:0;

  2033 #ifdef CIPHER_DEBUG

  2034 			printf("%d:[%08lX:%08lX]%p:%s (export)\n",ok,alg,emask,

  2035 			       c,c->name);

  2036 #endif

  2037 			}

  2038 		else

  2039 			{

  2040 			ok=((alg & mask) == alg)?1:0;

  2041 #ifdef CIPHER_DEBUG

  2042 			printf("%d:[%08lX:%08lX]%p:%s\n",ok,alg,mask,c,

  2043 			       c->name);

  2044 #endif

  2045 			}

  2047 		if (!ok) continue;

  2048 		j=sk_SSL_CIPHER_find(allow,c);

  2049 		if (j >= 0)

  2050 			{

  2051 			ret=sk_SSL_CIPHER_value(allow,j);

  2052 			break;

  2053 			}

  2054 		}

  2055 	return(ret);

  2056 	}

  2058 int ssl3_get_req_cert_type(SSL *s, unsigned char *p)

  2059 	{

  2060 	int ret=0;

  2061 	unsigned long alg;

  2063 	alg=s->s3->tmp.new_cipher->algorithms;

  2065 #ifndef OPENSSL_NO_DH

  2066 	if (alg & (SSL_kDHr|SSL_kEDH))

  2067 		{

  2068 #  ifndef OPENSSL_NO_RSA

  2069 		p[ret++]=SSL3_CT_RSA_FIXED_DH;

  2070 #  endif

  2071 #  ifndef OPENSSL_NO_DSA

  2072 		p[ret++]=SSL3_CT_DSS_FIXED_DH;

  2073 #  endif

  2074 		}

  2075 	if ((s->version == SSL3_VERSION) &&

  2076 		(alg & (SSL_kEDH|SSL_kDHd|SSL_kDHr)))

  2077 		{

  2078 #  ifndef OPENSSL_NO_RSA

  2079 		p[ret++]=SSL3_CT_RSA_EPHEMERAL_DH;

  2080 #  endif

  2081 #  ifndef OPENSSL_NO_DSA

  2082 		p[ret++]=SSL3_CT_DSS_EPHEMERAL_DH;

  2083 #  endif

  2084 		}

  2085 #endif /* !OPENSSL_NO_DH */

  2086 #ifndef OPENSSL_NO_RSA

  2087 	p[ret++]=SSL3_CT_RSA_SIGN;

  2088 #endif

  2089 #ifndef OPENSSL_NO_DSA

  2090 	p[ret++]=SSL3_CT_DSS_SIGN;

  2091 #endif

  2092 #ifndef OPENSSL_NO_ECDH

  2093 	/* We should ask for fixed ECDH certificates only

  2094 	 * for SSL_kECDH (and not SSL_kECDHE)

  2095 	 */

  2096 	if ((alg & SSL_kECDH) && (s->version >= TLS1_VERSION))

  2097 		{

  2098 		p[ret++]=TLS_CT_RSA_FIXED_ECDH;

  2099 		p[ret++]=TLS_CT_ECDSA_FIXED_ECDH;

  2100 		}

  2101 #endif

  2103 #ifndef OPENSSL_NO_ECDSA

  2104 	/* ECDSA certs can be used with RSA cipher suites as well

  2105 	 * so we don't need to check for SSL_kECDH or SSL_kECDHE

  2106 	 */

  2107 	if (s->version >= TLS1_VERSION)

  2108 		{

  2109 		p[ret++]=TLS_CT_ECDSA_SIGN;

  2110 		}

  2111 #endif

  2112 	return(ret);

  2113 	}

  2115 int ssl3_shutdown(SSL *s)

  2116 	{

  2118 	/* Don't do anything much if we have not done the handshake or

  2119 	 * we don't want to send messages :-) */

  2120 	if ((s->quiet_shutdown) || (s->state == SSL_ST_BEFORE))

  2121 		{

  2122 		s->shutdown=(SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN);

  2123 		return(1);

  2124 		}

  2126 	if (!(s->shutdown & SSL_SENT_SHUTDOWN))

  2127 		{

  2128 		s->shutdown|=SSL_SENT_SHUTDOWN;

  2129 #if 1

  2130 		ssl3_send_alert(s,SSL3_AL_WARNING,SSL_AD_CLOSE_NOTIFY);

  2131 #endif

  2132 		/* our shutdown alert has been sent now, and if it still needs

  2133 	 	 * to be written, s->s3->alert_dispatch will be true */

  2134 		}

  2135 	else if (s->s3->alert_dispatch)

  2136 		{

  2137 		/* resend it if not sent */

  2138 #if 1

  2139 		s->method->ssl_dispatch_alert(s);

  2140 #endif

  2141 		}

  2142 	else if (!(s->shutdown & SSL_RECEIVED_SHUTDOWN))

  2143 		{

  2144 		/* If we are waiting for a close from our peer, we are closed */

  2145 		s->method->ssl_read_bytes(s,0,NULL,0,0);

  2146 		}

  2148 	if ((s->shutdown == (SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN)) &&

  2149 		!s->s3->alert_dispatch)

  2150 		return(1);

  2151 	else

  2152 		return(0);

  2153 	}

  2155 int ssl3_write(SSL *s, const void *buf, int len)

  2156 	{

  2157 	int ret,n;

  2159 #if 0

  2160 	if (s->shutdown & SSL_SEND_SHUTDOWN)

  2161 		{

  2162 		s->rwstate=SSL_NOTHING;

  2163 		return(0);

  2164 		}

  2165 #endif

  2166 	clear_sys_error();

  2167 	if (s->s3->renegotiate) ssl3_renegotiate_check(s);

  2169 	/* This is an experimental flag that sends the

  2170 	 * last handshake message in the same packet as the first

  2171 	 * use data - used to see if it helps the TCP protocol during

  2172 	 * session-id reuse */

  2173 	/* The second test is because the buffer may have been removed */

  2174 	if ((s->s3->flags & SSL3_FLAGS_POP_BUFFER) && (s->wbio == s->bbio))

  2175 		{

  2176 		/* First time through, we write into the buffer */

  2177 		if (s->s3->delay_buf_pop_ret == 0)

  2178 			{

  2179 			ret=ssl3_write_bytes(s,SSL3_RT_APPLICATION_DATA,

  2180 					     buf,len);

  2181 			if (ret <= 0) return(ret);

  2183 			s->s3->delay_buf_pop_ret=ret;

  2184 			}

  2186 		s->rwstate=SSL_WRITING;

  2187 		n=BIO_flush(s->wbio);

  2188 		if (n <= 0) return(n);

  2189 		s->rwstate=SSL_NOTHING;

  2191 		/* We have flushed the buffer, so remove it */

  2192 		ssl_free_wbio_buffer(s);

  2193 		s->s3->flags&= ~SSL3_FLAGS_POP_BUFFER;

  2195 		ret=s->s3->delay_buf_pop_ret;

  2196 		s->s3->delay_buf_pop_ret=0;

  2197 		}

  2198 	else

  2199 		{

  2200 		ret=s->method->ssl_write_bytes(s,SSL3_RT_APPLICATION_DATA,

  2201 			buf,len);

  2202 		if (ret <= 0) return(ret);

  2203 		}

  2205 	return(ret);

  2206 	}

  2208 static int ssl3_read_internal(SSL *s, void *buf, int len, int peek)

  2209 	{

  2210 	int ret;

  2212 	clear_sys_error();

  2213 	if (s->s3->renegotiate) ssl3_renegotiate_check(s);

  2214 	s->s3->in_read_app_data=1;

  2215 	ret=s->method->ssl_read_bytes(s,SSL3_RT_APPLICATION_DATA,buf,len,peek);

  2216 	if ((ret == -1) && (s->s3->in_read_app_data == 2))

  2217 		{

  2218 		/* ssl3_read_bytes decided to call s->handshake_func, which

  2219 		 * called ssl3_read_bytes to read handshake data.

  2220 		 * However, ssl3_read_bytes actually found application data

  2221 		 * and thinks that application data makes sense here; so disable

  2222 		 * handshake processing and try to read application data again. */

  2223 		s->in_handshake++;

  2224 		ret=s->method->ssl_read_bytes(s,SSL3_RT_APPLICATION_DATA,buf,len,peek);

  2225 		s->in_handshake--;

  2226 		}

  2227 	else

  2228 		s->s3->in_read_app_data=0;

  2230 	return(ret);

  2231 	}

  2233 int ssl3_read(SSL *s, void *buf, int len)

  2234 	{

  2235 	return ssl3_read_internal(s, buf, len, 0);

  2236 	}

  2238 int ssl3_peek(SSL *s, void *buf, int len)

  2239 	{

  2240 	return ssl3_read_internal(s, buf, len, 1);

  2241 	}

  2243 int ssl3_renegotiate(SSL *s)

  2244 	{

  2245 	if (s->handshake_func == NULL)

  2246 		return(1);

  2248 	if (s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS)

  2249 		return(0);

  2251 	s->s3->renegotiate=1;

  2252 	return(1);

  2253 	}

  2255 int ssl3_renegotiate_check(SSL *s)

  2256 	{

  2257 	int ret=0;

  2259 	if (s->s3->renegotiate)

  2260 		{

  2261 		if (	(s->s3->rbuf.left == 0) &&

  2262 			(s->s3->wbuf.left == 0) &&

  2263 			!SSL_in_init(s))

  2264 			{

  2265 /*

  2266 if we are the server, and we have sent a 'RENEGOTIATE' message, we

  2267 need to go to SSL_ST_ACCEPT.

  2268 */

  2269 			/* SSL_ST_ACCEPT */

  2270 			s->state=SSL_ST_RENEGOTIATE;

  2271 			s->s3->renegotiate=0;

  2272 			s->s3->num_renegotiations++;

  2273 			s->s3->total_renegotiations++;

  2274 			ret=1;

  2275 			}

  2276 		}

  2277 	return(ret);

  2278 	}

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--