ssl/s3_lib.c

   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 #include <stdio.h>
  60 #include <openssl/md5.h>
  61 #include <openssl/sha.h>
  62 #include <openssl/objects.h>
  63 #include "ssl_locl.h"
  64
  65 const char *ssl3_version_str="SSLv3" OPENSSL_VERSION_PTEXT;
  66
  67 #define SSL3_NUM_CIPHERS        (sizeof(ssl3_ciphers)/sizeof(SSL_CIPHER))
  68
  69 static long ssl3_default_timeout(void );
  70
  71 OPENSSL_GLOBAL SSL_CIPHER ssl3_ciphers[]={
  72 /* The RSA ciphers */
  73 /* Cipher 01 */
  74         {
  75         1,
  76         SSL3_TXT_RSA_NULL_MD5,
  77         SSL3_CK_RSA_NULL_MD5,
  78         SSL_kRSA|SSL_aRSA|SSL_eNULL |SSL_MD5|SSL_NOT_EXP|SSL_SSLV3,
  79         0,
  80         SSL_ALL_CIPHERS,
  81         },
  82 /* Cipher 02 */
  83         {
  84         1,
  85         SSL3_TXT_RSA_NULL_SHA,
  86         SSL3_CK_RSA_NULL_SHA,
  87         SSL_kRSA|SSL_aRSA|SSL_eNULL |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3,
  88         0,
  89         SSL_ALL_CIPHERS,
  90         },
  91
  92 /* anon DH */
  93 /* Cipher 17 */
  94         {
  95         1,
  96         SSL3_TXT_ADH_RC4_40_MD5,
  97         SSL3_CK_ADH_RC4_40_MD5,
  98         SSL_kEDH |SSL_aNULL|SSL_RC4  |SSL_MD5 |SSL_EXP40|SSL_SSLV3,
  99         0,
 100         SSL_ALL_CIPHERS,
 101         },
 102 /* Cipher 18 */
 103         {
 104         1,
 105         SSL3_TXT_ADH_RC4_128_MD5,
 106         SSL3_CK_ADH_RC4_128_MD5,
 107         SSL_kEDH |SSL_aNULL|SSL_RC4  |SSL_MD5|SSL_NOT_EXP|SSL_SSLV3,
 108         0,
 109         SSL_ALL_CIPHERS,
 110         },
 111 /* Cipher 19 */
 112         {
 113         1,
 114         SSL3_TXT_ADH_DES_40_CBC_SHA,
 115         SSL3_CK_ADH_DES_40_CBC_SHA,
 116         SSL_kEDH |SSL_aNULL|SSL_DES|SSL_SHA1|SSL_EXP40|SSL_SSLV3,
 117         0,
 118         SSL_ALL_CIPHERS,
 119         },
 120 /* Cipher 1A */
 121         {
 122         1,
 123         SSL3_TXT_ADH_DES_64_CBC_SHA,
 124         SSL3_CK_ADH_DES_64_CBC_SHA,
 125         SSL_kEDH |SSL_aNULL|SSL_DES  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3,
 126         0,
 127         SSL_ALL_CIPHERS,
 128         },
 129 /* Cipher 1B */
 130         {
 131         1,
 132         SSL3_TXT_ADH_DES_192_CBC_SHA,
 133         SSL3_CK_ADH_DES_192_CBC_SHA,
 134         SSL_kEDH |SSL_aNULL|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3,
 135         0,
 136         SSL_ALL_CIPHERS,
 137         },
 138
 139 /* RSA again */
 140 /* Cipher 03 */
 141         {
 142         1,
 143         SSL3_TXT_RSA_RC4_40_MD5,
 144         SSL3_CK_RSA_RC4_40_MD5,
 145         SSL_kRSA|SSL_aRSA|SSL_RC4  |SSL_MD5 |SSL_EXP40|SSL_SSLV3,
 146         0,
 147         SSL_ALL_CIPHERS,
 148         },
 149 /* Cipher 04 */
 150         {
 151         1,
 152         SSL3_TXT_RSA_RC4_128_MD5,
 153         SSL3_CK_RSA_RC4_128_MD5,
 154         SSL_kRSA|SSL_aRSA|SSL_RC4  |SSL_MD5|SSL_NOT_EXP|SSL_SSLV3|SSL_MEDIUM,
 155         0,
 156         SSL_ALL_CIPHERS,
 157         },
 158 /* Cipher 05 */
 159         {
 160         1,
 161         SSL3_TXT_RSA_RC4_128_SHA,
 162         SSL3_CK_RSA_RC4_128_SHA,
 163         SSL_kRSA|SSL_aRSA|SSL_RC4  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_MEDIUM,
 164         0,
 165         SSL_ALL_CIPHERS,
 166         },
 167 /* Cipher 06 */
 168         {
 169         1,
 170         SSL3_TXT_RSA_RC2_40_MD5,
 171         SSL3_CK_RSA_RC2_40_MD5,
 172         SSL_kRSA|SSL_aRSA|SSL_RC2  |SSL_MD5 |SSL_EXP40|SSL_SSLV3,
 173         0,
 174         SSL_ALL_CIPHERS,
 175         },
 176 /* Cipher 07 */
 177         {
 178         1,
 179         SSL3_TXT_RSA_IDEA_128_SHA,
 180         SSL3_CK_RSA_IDEA_128_SHA,
 181         SSL_kRSA|SSL_aRSA|SSL_IDEA |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_MEDIUM,
 182         0,
 183         SSL_ALL_CIPHERS,
 184         },
 185 /* Cipher 08 */
 186         {
 187         1,
 188         SSL3_TXT_RSA_DES_40_CBC_SHA,
 189         SSL3_CK_RSA_DES_40_CBC_SHA,
 190         SSL_kRSA|SSL_aRSA|SSL_DES|SSL_SHA1|SSL_EXP40|SSL_SSLV3,
 191         0,
 192         SSL_ALL_CIPHERS,
 193         },
 194 /* Cipher 09 */
 195         {
 196         1,
 197         SSL3_TXT_RSA_DES_64_CBC_SHA,
 198         SSL3_CK_RSA_DES_64_CBC_SHA,
 199         SSL_kRSA|SSL_aRSA|SSL_DES  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW,
 200         0,
 201         SSL_ALL_CIPHERS,
 202         },
 203 /* Cipher 0A */
 204         {
 205         1,
 206         SSL3_TXT_RSA_DES_192_CBC3_SHA,
 207         SSL3_CK_RSA_DES_192_CBC3_SHA,
 208         SSL_kRSA|SSL_aRSA|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH,
 209         0,
 210         SSL_ALL_CIPHERS,
 211         },
 212
 213 /*  The DH ciphers */
 214 /* Cipher 0B */
 215         {
 216         0,
 217         SSL3_TXT_DH_DSS_DES_40_CBC_SHA,
 218         SSL3_CK_DH_DSS_DES_40_CBC_SHA,
 219         SSL_kDHd |SSL_aDH|SSL_DES|SSL_SHA1|SSL_EXP40|SSL_SSLV3,
 220         0,
 221         SSL_ALL_CIPHERS,
 222         },
 223 /* Cipher 0C */
 224         {
 225         0,
 226         SSL3_TXT_DH_DSS_DES_64_CBC_SHA,
 227         SSL3_CK_DH_DSS_DES_64_CBC_SHA,
 228         SSL_kDHd |SSL_aDH|SSL_DES  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW,
 229         0,
 230         SSL_ALL_CIPHERS,
 231         },
 232 /* Cipher 0D */
 233         {
 234         0,
 235         SSL3_TXT_DH_DSS_DES_192_CBC3_SHA,
 236         SSL3_CK_DH_DSS_DES_192_CBC3_SHA,
 237         SSL_kDHd |SSL_aDH|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH,
 238         0,
 239         SSL_ALL_CIPHERS,
 240         },
 241 /* Cipher 0E */
 242         {
 243         0,
 244         SSL3_TXT_DH_RSA_DES_40_CBC_SHA,
 245         SSL3_CK_DH_RSA_DES_40_CBC_SHA,
 246         SSL_kDHr |SSL_aDH|SSL_DES|SSL_SHA1|SSL_EXP40|SSL_SSLV3,
 247         0,
 248         SSL_ALL_CIPHERS,
 249         },
 250 /* Cipher 0F */
 251         {
 252         0,
 253         SSL3_TXT_DH_RSA_DES_64_CBC_SHA,
 254         SSL3_CK_DH_RSA_DES_64_CBC_SHA,
 255         SSL_kDHr |SSL_aDH|SSL_DES  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW,
 256         0,
 257         SSL_ALL_CIPHERS,
 258         },
 259 /* Cipher 10 */
 260         {
 261         0,
 262         SSL3_TXT_DH_RSA_DES_192_CBC3_SHA,
 263         SSL3_CK_DH_RSA_DES_192_CBC3_SHA,
 264         SSL_kDHr |SSL_aDH|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH,
 265         0,
 266         SSL_ALL_CIPHERS,
 267         },
 268
 269 /* The Ephemeral DH ciphers */
 270 /* Cipher 11 */
 271         {
 272         1,
 273         SSL3_TXT_EDH_DSS_DES_40_CBC_SHA,
 274         SSL3_CK_EDH_DSS_DES_40_CBC_SHA,
 275         SSL_kEDH|SSL_aDSS|SSL_DES|SSL_SHA1|SSL_EXP40|SSL_SSLV3,
 276         0,
 277         SSL_ALL_CIPHERS,
 278         },
 279 /* Cipher 12 */
 280         {
 281         1,
 282         SSL3_TXT_EDH_DSS_DES_64_CBC_SHA,
 283         SSL3_CK_EDH_DSS_DES_64_CBC_SHA,
 284         SSL_kEDH|SSL_aDSS|SSL_DES  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW,
 285         0,
 286         SSL_ALL_CIPHERS,
 287         },
 288 /* Cipher 13 */
 289         {
 290         1,
 291         SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA,
 292         SSL3_CK_EDH_DSS_DES_192_CBC3_SHA,
 293         SSL_kEDH|SSL_aDSS|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH,
 294         0,
 295         SSL_ALL_CIPHERS,
 296         },
 297 /* Cipher 14 */
 298         {
 299         1,
 300         SSL3_TXT_EDH_RSA_DES_40_CBC_SHA,
 301         SSL3_CK_EDH_RSA_DES_40_CBC_SHA,
 302         SSL_kEDH|SSL_aRSA|SSL_DES|SSL_SHA1|SSL_EXP40|SSL_SSLV3,
 303         0,
 304         SSL_ALL_CIPHERS,
 305         },
 306 /* Cipher 15 */
 307         {
 308         1,
 309         SSL3_TXT_EDH_RSA_DES_64_CBC_SHA,
 310         SSL3_CK_EDH_RSA_DES_64_CBC_SHA,
 311         SSL_kEDH|SSL_aRSA|SSL_DES  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_LOW,
 312         0,
 313         SSL_ALL_CIPHERS,
 314         },
 315 /* Cipher 16 */
 316         {
 317         1,
 318         SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA,
 319         SSL3_CK_EDH_RSA_DES_192_CBC3_SHA,
 320         SSL_kEDH|SSL_aRSA|SSL_3DES |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3|SSL_HIGH,
 321         0,
 322         SSL_ALL_CIPHERS,
 323         },
 324
 325 /* Fortezza */
 326 /* Cipher 1C */
 327         {
 328         0,
 329         SSL3_TXT_FZA_DMS_NULL_SHA,
 330         SSL3_CK_FZA_DMS_NULL_SHA,
 331         SSL_kFZA|SSL_aFZA |SSL_eNULL |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3,
 332         0,
 333         SSL_ALL_CIPHERS,
 334         },
 335
 336 /* Cipher 1D */
 337         {
 338         0,
 339         SSL3_TXT_FZA_DMS_FZA_SHA,
 340         SSL3_CK_FZA_DMS_FZA_SHA,
 341         SSL_kFZA|SSL_aFZA |SSL_eFZA |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3,
 342         0,
 343         SSL_ALL_CIPHERS,
 344         },
 345
 346 /* Cipher 1E */
 347         {
 348         0,
 349         SSL3_TXT_FZA_DMS_RC4_SHA,
 350         SSL3_CK_FZA_DMS_RC4_SHA,
 351         SSL_kFZA|SSL_aFZA |SSL_RC4  |SSL_SHA1|SSL_NOT_EXP|SSL_SSLV3,
 352         0,
 353         SSL_ALL_CIPHERS,
 354         },
 355
 356 #if TLS1_ALLOW_EXPERIMENTAL_CIPHERSUITES
 357         /* New TLS Export CipherSuites */
 358         /* Cipher 60 */
 359             {
 360             1,
 361             TLS1_TXT_RSA_EXPORT1024_WITH_RC4_56_MD5,
 362             TLS1_CK_RSA_EXPORT1024_WITH_RC4_56_MD5,
 363             SSL_kRSA|SSL_aRSA|SSL_RC4|SSL_MD5|SSL_EXP56|SSL_TLSV1,
 364             0,
 365             SSL_ALL_CIPHERS
 366             },
 367         /* Cipher 61 */
 368             {
 369             1,
 370             TLS1_TXT_RSA_EXPORT1024_WITH_RC2_CBC_56_MD5,
 371             TLS1_CK_RSA_EXPORT1024_WITH_RC2_CBC_56_MD5,
 372             SSL_kRSA|SSL_aRSA|SSL_RC2|SSL_MD5|SSL_EXP56|SSL_TLSV1,
 373             0,
 374             SSL_ALL_CIPHERS
 375             },
 376         /* Cipher 62 */
 377             {
 378             1,
 379             TLS1_TXT_RSA_EXPORT1024_WITH_DES_CBC_SHA,
 380             TLS1_CK_RSA_EXPORT1024_WITH_DES_CBC_SHA,
 381             SSL_kRSA|SSL_aRSA|SSL_DES|SSL_SHA|SSL_EXP56|SSL_TLSV1,
 382             0,
 383             SSL_ALL_CIPHERS
 384             },
 385         /* Cipher 63 */
 386             {
 387             1,
 388             TLS1_TXT_DHE_DSS_EXPORT1024_WITH_DES_CBC_SHA,
 389             TLS1_CK_DHE_DSS_EXPORT1024_WITH_DES_CBC_SHA,
 390             SSL_kEDH|SSL_aDSS|SSL_DES|SSL_SHA|SSL_EXP56|SSL_TLSV1,
 391             0,
 392             SSL_ALL_CIPHERS
 393             },
 394         /* Cipher 64 */
 395             {
 396             1,
 397             TLS1_TXT_RSA_EXPORT1024_WITH_RC4_56_SHA,
 398             TLS1_CK_RSA_EXPORT1024_WITH_RC4_56_SHA,
 399             SSL_kRSA|SSL_aRSA|SSL_RC4|SSL_SHA|SSL_EXP56|SSL_TLSV1,
 400             0,
 401             SSL_ALL_CIPHERS
 402             },
 403         /* Cipher 65 */
 404             {
 405             1,
 406             TLS1_TXT_DHE_DSS_EXPORT1024_WITH_RC4_56_SHA,
 407             TLS1_CK_DHE_DSS_EXPORT1024_WITH_RC4_56_SHA,
 408             SSL_kEDH|SSL_aDSS|SSL_RC4|SSL_SHA|SSL_EXP56|SSL_TLSV1,
 409             0,
 410             SSL_ALL_CIPHERS
 411             },
 412         /* Cipher 66 */
 413             {
 414             1,
 415             TLS1_TXT_DHE_DSS_WITH_RC4_128_SHA,
 416             TLS1_CK_DHE_DSS_WITH_RC4_128_SHA,
 417             SSL_kEDH|SSL_aDSS|SSL_RC4|SSL_SHA|SSL_TLSV1,
 418             0,
 419             SSL_ALL_CIPHERS
 420             },
 421 #endif
 422
 423 /* end of list */
 424         };
 425
 426 static SSL3_ENC_METHOD SSLv3_enc_data={
 427         ssl3_enc,
 428         ssl3_mac,
 429         ssl3_setup_key_block,
 430         ssl3_generate_master_secret,
 431         ssl3_change_cipher_state,
 432         ssl3_final_finish_mac,
 433         MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH,
 434         ssl3_cert_verify_mac,
 435         SSL3_MD_CLIENT_FINISHED_CONST,4,
 436         SSL3_MD_SERVER_FINISHED_CONST,4,
 437         ssl3_alert_code,
 438         };
 439
 440 static SSL_METHOD SSLv3_data= {
 441         SSL3_VERSION,
 442         ssl3_new,
 443         ssl3_clear,
 444         ssl3_free,
 445         ssl_undefined_function,
 446         ssl_undefined_function,
 447         ssl3_read,
 448         ssl3_peek,
 449         ssl3_write,
 450         ssl3_shutdown,
 451         ssl3_renegotiate,
 452         ssl3_renegotiate_check,
 453         ssl3_ctrl,
 454         ssl3_ctx_ctrl,
 455         ssl3_get_cipher_by_char,
 456         ssl3_put_cipher_by_char,
 457         ssl3_pending,
 458         ssl3_num_ciphers,
 459         ssl3_get_cipher,
 460         ssl_bad_method,
 461         ssl3_default_timeout,
 462         &SSLv3_enc_data,
 463         };
 464
 465 static long ssl3_default_timeout(void)
 466         {
 467         /* 2 hours, the 24 hours mentioned in the SSLv3 spec
 468          * is way too long for http, the cache would over fill */
 469         return(60*60*2);
 470         }
 471
 472 SSL_METHOD *sslv3_base_method(void)
 473         {
 474         return(&SSLv3_data);
 475         }
 476
 477 int ssl3_num_ciphers(void)
 478         {
 479         return(SSL3_NUM_CIPHERS);
 480         }
 481
 482 SSL_CIPHER *ssl3_get_cipher(unsigned int u)
 483         {
 484         if (u < SSL3_NUM_CIPHERS)
 485                 return(&(ssl3_ciphers[SSL3_NUM_CIPHERS-1-u]));
 486         else
 487                 return(NULL);
 488         }
 489
 490 /* The problem is that it may not be the correct record type */
 491 int ssl3_pending(SSL *s)
 492         {
 493         return(s->s3->rrec.length);
 494         }
 495
 496 int ssl3_new(SSL *s)
 497         {
 498         SSL3_CTX *s3;
 499
 500         if ((s3=(SSL3_CTX *)Malloc(sizeof(SSL3_CTX))) == NULL) goto err;
 501         memset(s3,0,sizeof(SSL3_CTX));
 502
 503         s->s3=s3;
 504         /*
 505         s->s3->tmp.ca_names=NULL;
 506         s->s3->tmp.key_block=NULL;
 507         s->s3->tmp.key_block_length=0;
 508         s->s3->rbuf.buf=NULL;
 509         s->s3->wbuf.buf=NULL;
 510         */
 511
 512         s->method->ssl_clear(s);
 513         return(1);
 514 err:
 515         return(0);
 516         }
 517
 518 void ssl3_free(SSL *s)
 519         {
 520         if(s == NULL)
 521             return;
 522
 523         ssl3_cleanup_key_block(s);
 524         if (s->s3->rbuf.buf != NULL)
 525                 Free(s->s3->rbuf.buf);
 526         if (s->s3->wbuf.buf != NULL)
 527                 Free(s->s3->wbuf.buf);
 528         if (s->s3->rrec.comp != NULL)
 529                 Free(s->s3->rrec.comp);
 530 #ifndef NO_DH
 531         if (s->s3->tmp.dh != NULL)
 532                 DH_free(s->s3->tmp.dh);
 533 #endif
 534         if (s->s3->tmp.ca_names != NULL)
 535                 sk_X509_NAME_pop_free(s->s3->tmp.ca_names,X509_NAME_free);
 536         memset(s->s3,0,sizeof(SSL3_CTX));
 537         Free(s->s3);
 538         s->s3=NULL;
 539         }
 540
 541 void ssl3_clear(SSL *s)
 542         {
 543         unsigned char *rp,*wp;
 544
 545         ssl3_cleanup_key_block(s);
 546         if (s->s3->tmp.ca_names != NULL)
 547                 sk_X509_NAME_pop_free(s->s3->tmp.ca_names,X509_NAME_free);
 548
 549         if (s->s3->rrec.comp != NULL)
 550                 {
 551                 Free(s->s3->rrec.comp);
 552                 s->s3->rrec.comp=NULL;
 553                 }
 554
 555         rp=s->s3->rbuf.buf;
 556         wp=s->s3->wbuf.buf;
 557
 558         memset(s->s3,0,sizeof(SSL3_CTX));
 559         if (rp != NULL) s->s3->rbuf.buf=rp;
 560         if (wp != NULL) s->s3->wbuf.buf=wp;
 561
 562         ssl_free_wbio_buffer(s);
 563
 564         s->packet_length=0;
 565         s->s3->renegotiate=0;
 566         s->s3->total_renegotiations=0;
 567         s->s3->num_renegotiations=0;
 568         s->s3->in_read_app_data=0;
 569         s->version=SSL3_VERSION;
 570         }
 571
 572 long ssl3_ctrl(SSL *s, int cmd, long larg, char *parg)
 573         {
 574         int ret=0;
 575
 576 #if !defined(NO_DSA) || !defined(NO_RSA)
 577         if (
 578 #ifndef NO_RSA
 579             cmd == SSL_CTRL_SET_TMP_RSA ||
 580             cmd == SSL_CTRL_SET_TMP_RSA_CB ||
 581 #endif
 582 #ifndef NO_DSA
 583             cmd == SSL_CTRL_SET_TMP_DH ||
 584             cmd == SSL_CTRL_SET_TMP_DH_CB ||
 585 #endif
 586                 0)
 587                 {
 588                 if (!ssl_cert_inst(&s->cert))
 589                         {
 590                         SSLerr(SSL_F_SSL3_CTRL, ERR_R_MALLOC_FAILURE);
 591                         return(0);
 592                         }
 593                 }
 594 #endif
 595
 596         switch (cmd)
 597                 {
 598         case SSL_CTRL_GET_SESSION_REUSED:
 599                 ret=s->hit;
 600                 break;
 601         case SSL_CTRL_GET_CLIENT_CERT_REQUEST:
 602                 break;
 603         case SSL_CTRL_GET_NUM_RENEGOTIATIONS:
 604                 ret=s->s3->num_renegotiations;
 605                 break;
 606         case SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS:
 607                 ret=s->s3->num_renegotiations;
 608                 s->s3->num_renegotiations=0;
 609                 break;
 610         case SSL_CTRL_GET_TOTAL_RENEGOTIATIONS:
 611                 ret=s->s3->total_renegotiations;
 612                 break;
 613         case SSL_CTRL_GET_FLAGS:
 614                 ret=(int)(s->s3->flags);
 615                 break;
 616 #ifndef NO_RSA
 617         case SSL_CTRL_NEED_TMP_RSA:
 618                 if ((s->cert != NULL) && (s->cert->rsa_tmp == NULL) &&
 619                     ((s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey == NULL) ||
 620                      (EVP_PKEY_size(s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey) > (512/8))))
 621                         ret = 1;
 622                 break;
 623         case SSL_CTRL_SET_TMP_RSA:
 624                 {
 625                         RSA *rsa = (RSA *)parg;
 626                         if (rsa == NULL) {
 627                                 SSLerr(SSL_F_SSL3_CTRL, ERR_R_PASSED_NULL_PARAMETER);
 628                                 return(ret);
 629                         }
 630                         if ((rsa = RSAPrivateKey_dup(rsa)) == NULL) {
 631                                 SSLerr(SSL_F_SSL3_CTRL, ERR_R_RSA_LIB);
 632                                 return(ret);
 633                         }
 634                         if (s->cert->rsa_tmp != NULL)
 635                                 RSA_free(s->cert->rsa_tmp);
 636                         s->cert->rsa_tmp = rsa;
 637                         ret = 1;
 638                 }
 639                 break;
 640         case SSL_CTRL_SET_TMP_RSA_CB:
 641                 s->cert->rsa_tmp_cb = (RSA *(*)(SSL *, int, int))parg;
 642                 break;
 643 #endif
 644 #ifndef NO_DH
 645         case SSL_CTRL_SET_TMP_DH:
 646                 {
 647                         DH *dh = (DH *)parg;
 648                         if (dh == NULL) {
 649                                 SSLerr(SSL_F_SSL3_CTRL, ERR_R_PASSED_NULL_PARAMETER);
 650                                 return(ret);
 651                         }
 652                         if ((dh = DHparams_dup(dh)) == NULL) {
 653                                 SSLerr(SSL_F_SSL3_CTRL, ERR_R_DH_LIB);
 654                                 return(ret);
 655                         }
 656                         if (!DH_generate_key(dh)) {
 657                                 DH_free(dh);
 658                                 SSLerr(SSL_F_SSL3_CTRL, ERR_R_DH_LIB);
 659                                 return(ret);
 660                         }
 661                         if (s->cert->dh_tmp != NULL)
 662                                 DH_free(s->cert->dh_tmp);
 663                         s->cert->dh_tmp = dh;
 664                         ret = 1;
 665                 }
 666                 break;
 667         case SSL_CTRL_SET_TMP_DH_CB:
 668                 s->cert->dh_tmp_cb = (DH *(*)(SSL *, int, int))parg;
 669                 break;
 670 #endif
 671         default:
 672                 break;
 673                 }
 674         return(ret);
 675         }
 676
 677 long ssl3_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, char *parg)
 678         {
 679         CERT *cert;
 680
 681         cert=ctx->cert;
 682
 683         switch (cmd)
 684                 {
 685 #ifndef NO_RSA
 686         case SSL_CTRL_NEED_TMP_RSA:
 687                 if (    (cert->rsa_tmp == NULL) &&
 688                         ((cert->pkeys[SSL_PKEY_RSA_ENC].privatekey == NULL) ||
 689                          (EVP_PKEY_size(cert->pkeys[SSL_PKEY_RSA_ENC].privatekey) > (512/8)))
 690                         )
 691                         return(1);
 692                 else
 693                         return(0);
 694                 /* break; */
 695         case SSL_CTRL_SET_TMP_RSA:
 696                 {
 697                 RSA *rsa;
 698                 int i;
 699
 700                 rsa=(RSA *)parg;
 701                 i=1;
 702                 if (rsa == NULL)
 703                         i=0;
 704                 else
 705                         {
 706                         if ((rsa=RSAPrivateKey_dup(rsa)) == NULL)
 707                                 i=0;
 708                         }
 709                 if (!i)
 710                         {
 711                         SSLerr(SSL_F_SSL3_CTX_CTRL,ERR_R_RSA_LIB);
 712                         return(0);
 713                         }
 714                 else
 715                         {
 716                         if (cert->rsa_tmp != NULL)
 717                                 RSA_free(cert->rsa_tmp);
 718                         cert->rsa_tmp=rsa;
 719                         return(1);
 720                         }
 721                 }
 722                 /* break; */
 723         case SSL_CTRL_SET_TMP_RSA_CB:
 724                 cert->rsa_tmp_cb=(RSA *(*)(SSL *, int, int))parg;
 725                 break;
 726 #endif
 727 #ifndef NO_DH
 728         case SSL_CTRL_SET_TMP_DH:
 729                 {
 730                 DH *new=NULL,*dh;
 731                 int rret=0;
 732
 733                 dh=(DH *)parg;
 734                 if (    ((new=DHparams_dup(dh)) == NULL) ||
 735                         (!DH_generate_key(new)))
 736                         {
 737                         SSLerr(SSL_F_SSL3_CTX_CTRL,ERR_R_DH_LIB);
 738                         if (new != NULL) DH_free(new);
 739                         }
 740                 else
 741                         {
 742                         if (cert->dh_tmp != NULL)
 743                                 DH_free(cert->dh_tmp);
 744                         cert->dh_tmp=new;
 745                         rret=1;
 746                         }
 747                 return(rret);
 748                 }
 749                 /*break; */
 750         case SSL_CTRL_SET_TMP_DH_CB:
 751                 cert->dh_tmp_cb=(DH *(*)(SSL *, int, int))parg;
 752                 break;
 753 #endif
 754         /* A Thawte special :-) */
 755         case SSL_CTRL_EXTRA_CHAIN_CERT:
 756                 if (ctx->extra_certs == NULL)
 757                         {
 758                         if ((ctx->extra_certs=sk_X509_new_null()) == NULL)
 759                                 return(0);
 760                         }
 761                 sk_X509_push(ctx->extra_certs,(X509 *)parg);
 762                 break;
 763
 764         default:
 765                 return(0);
 766                 }
 767         return(1);
 768         }
 769
 770 /* This function needs to check if the ciphers required are actually
 771  * available */
 772 SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p)
 773         {
 774         static int init=1;
 775         static SSL_CIPHER *sorted[SSL3_NUM_CIPHERS];
 776         SSL_CIPHER c,*cp= &c,**cpp;
 777         unsigned long id;
 778         int i;
 779
 780         if (init)
 781                 {
 782                 CRYPTO_w_lock(CRYPTO_LOCK_SSL);
 783
 784                 for (i=0; i<SSL3_NUM_CIPHERS; i++)
 785                         sorted[i]= &(ssl3_ciphers[i]);
 786
 787                 qsort(  (char *)sorted,
 788                         SSL3_NUM_CIPHERS,sizeof(SSL_CIPHER *),
 789                         FP_ICC ssl_cipher_ptr_id_cmp);
 790
 791                 CRYPTO_w_unlock(CRYPTO_LOCK_SSL);
 792
 793                 init=0;
 794                 }
 795
 796         id=0x03000000L|((unsigned long)p[0]<<8L)|(unsigned long)p[1];
 797         c.id=id;
 798         cpp=(SSL_CIPHER **)OBJ_bsearch((char *)&cp,
 799                 (char *)sorted,
 800                 SSL3_NUM_CIPHERS,sizeof(SSL_CIPHER *),
 801                 (int (*)())ssl_cipher_ptr_id_cmp);
 802         if ((cpp == NULL) || !(*cpp)->valid)
 803                 return(NULL);
 804         else
 805                 return(*cpp);
 806         }
 807
 808 int ssl3_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p)
 809         {
 810         long l;
 811
 812         if (p != NULL)
 813                 {
 814                 l=c->id;
 815                 if ((l & 0xff000000) != 0x03000000) return(0);
 816                 p[0]=((unsigned char)(l>> 8L))&0xFF;
 817                 p[1]=((unsigned char)(l     ))&0xFF;
 818                 }
 819         return(2);
 820         }
 821
 822 int ssl3_part_read(SSL *s, int i)
 823         {
 824         s->rwstate=SSL_READING;
 825
 826         if (i < 0)
 827                 {
 828                 return(i);
 829                 }
 830         else
 831                 {
 832                 s->init_num+=i;
 833                 return(0);
 834                 }
 835         }
 836
 837 SSL_CIPHER *ssl3_choose_cipher(SSL *s, STACK_OF(SSL_CIPHER) *have,
 838              STACK_OF(SSL_CIPHER) *pref)
 839         {
 840         SSL_CIPHER *c,*ret=NULL;
 841         int i,j,ok;
 842         CERT *cert;
 843         unsigned long alg,mask,emask;
 844
 845         /* Let's see which ciphers we can support */
 846         cert=s->cert;
 847
 848         sk_SSL_CIPHER_set_cmp_func(pref,ssl_cipher_ptr_id_cmp);
 849
 850 #ifdef CIPHER_DEBUG
 851         printf("Have:\n");
 852         for(i=0 ; i < sk_num(pref) ; ++i)
 853             {
 854             c=(SSL_CIPHER *)sk_value(pref,i);
 855             printf("%p:%s\n",c,c->name);
 856             }
 857 #endif
 858
 859         for (i=0; i<sk_SSL_CIPHER_num(have); i++)
 860                 {
 861                 c=sk_SSL_CIPHER_value(have,i);
 862
 863                 ssl_set_cert_masks(cert,c);
 864                 mask=cert->mask;
 865                 emask=cert->export_mask;
 866
 867                 alg=c->algorithms&(SSL_MKEY_MASK|SSL_AUTH_MASK);
 868                 if (SSL_IS_EXPORT(c->algorithms))
 869                         {
 870                         ok=((alg & emask) == alg)?1:0;
 871 #ifdef CIPHER_DEBUG
 872                         printf("%d:[%08lX:%08lX]%p:%s (export)\n",ok,alg,emask,
 873                                c,c->name);
 874 #endif
 875                         }
 876                 else
 877                         {
 878                         ok=((alg & mask) == alg)?1:0;
 879 #ifdef CIPHER_DEBUG
 880                         printf("%d:[%08lX:%08lX]%p:%s\n",ok,alg,mask,c,
 881                                c->name);
 882 #endif
 883                         }
 884
 885                 if (!ok) continue;
 886
 887                 j=sk_SSL_CIPHER_find(pref,c);
 888                 if (j >= 0)
 889                         {
 890                         ret=sk_SSL_CIPHER_value(pref,j);
 891                         break;
 892                         }
 893                 }
 894         return(ret);
 895         }
 896
 897 int ssl3_get_req_cert_type(SSL *s, unsigned char *p)
 898         {
 899         int ret=0;
 900         unsigned long alg;
 901
 902         alg=s->s3->tmp.new_cipher->algorithms;
 903
 904 #ifndef NO_DH
 905         if (alg & (SSL_kDHr|SSL_kEDH))
 906                 {
 907 #  ifndef NO_RSA
 908                 p[ret++]=SSL3_CT_RSA_FIXED_DH;
 909 #  endif
 910 #  ifndef NO_DSA
 911                 p[ret++]=SSL3_CT_DSS_FIXED_DH;
 912 #  endif
 913                 }
 914         if ((s->version == SSL3_VERSION) &&
 915                 (alg & (SSL_kEDH|SSL_kDHd|SSL_kDHr)))
 916                 {
 917 #  ifndef NO_RSA
 918                 p[ret++]=SSL3_CT_RSA_EPHEMERAL_DH;
 919 #  endif
 920 #  ifndef NO_DSA
 921                 p[ret++]=SSL3_CT_DSS_EPHEMERAL_DH;
 922 #  endif
 923                 }
 924 #endif /* !NO_DH */
 925 #ifndef NO_RSA
 926         p[ret++]=SSL3_CT_RSA_SIGN;
 927 #endif
 928 #ifndef NO_DSA
 929         p[ret++]=SSL3_CT_DSS_SIGN;
 930 #endif
 931         return(ret);
 932         }
 933
 934 int ssl3_shutdown(SSL *s)
 935         {
 936
 937         /* Don't do anything much if we have not done the handshake or
 938          * we don't want to send messages :-) */
 939         if ((s->quiet_shutdown) || (s->state == SSL_ST_BEFORE))
 940                 {
 941                 s->shutdown=(SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN);
 942                 return(1);
 943                 }
 944
 945         if (!(s->shutdown & SSL_SENT_SHUTDOWN))
 946                 {
 947                 s->shutdown|=SSL_SENT_SHUTDOWN;
 948 #if 1
 949                 ssl3_send_alert(s,SSL3_AL_WARNING,SSL_AD_CLOSE_NOTIFY);
 950 #endif
 951                 /* our shutdown alert has been sent now, and if it still needs
 952                  * to be written, s->s3->alert_dispatch will be true */
 953                 }
 954         else if (s->s3->alert_dispatch)
 955                 {
 956                 /* resend it if not sent */
 957 #if 1
 958                 ssl3_dispatch_alert(s);
 959 #endif
 960                 }
 961         else if (!(s->shutdown & SSL_RECEIVED_SHUTDOWN))
 962                 {
 963                 /* If we are waiting for a close from our peer, we are closed */
 964                 ssl3_read_bytes(s,0,NULL,0);
 965                 }
 966
 967         if ((s->shutdown == (SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN)) &&
 968                 !s->s3->alert_dispatch)
 969                 return(1);
 970         else
 971                 return(0);
 972         }
 973
 974 int ssl3_write(SSL *s, const void *buf, int len)
 975         {
 976         int ret,n;
 977
 978 #if 0
 979         if (s->shutdown & SSL_SEND_SHUTDOWN)
 980                 {
 981                 s->rwstate=SSL_NOTHING;
 982                 return(0);
 983                 }
 984 #endif
 985         clear_sys_error();
 986         if (s->s3->renegotiate) ssl3_renegotiate_check(s);
 987
 988         /* This is an experimental flag that sends the
 989          * last handshake message in the same packet as the first
 990          * use data - used to see if it helps the TCP protocol during
 991          * session-id reuse */
 992         /* The second test is because the buffer may have been removed */
 993         if ((s->s3->flags & SSL3_FLAGS_POP_BUFFER) && (s->wbio == s->bbio))
 994                 {
 995                 /* First time through, we write into the buffer */
 996                 if (s->s3->delay_buf_pop_ret == 0)
 997                         {
 998                         ret=ssl3_write_bytes(s,SSL3_RT_APPLICATION_DATA,
 999                                              buf,len);
1000                         if (ret <= 0) return(ret);
1001
1002                         s->s3->delay_buf_pop_ret=ret;
1003                         }
1004
1005                 s->rwstate=SSL_WRITING;
1006                 n=BIO_flush(s->wbio);
1007                 if (n <= 0) return(n);
1008                 s->rwstate=SSL_NOTHING;
1009
1010                 /* We have flushed the buffer, so remove it */
1011                 ssl_free_wbio_buffer(s);
1012                 s->s3->flags&= ~SSL3_FLAGS_POP_BUFFER;
1013
1014                 ret=s->s3->delay_buf_pop_ret;
1015                 s->s3->delay_buf_pop_ret=0;
1016                 }
1017         else
1018                 {
1019                 ret=ssl3_write_bytes(s,SSL3_RT_APPLICATION_DATA,
1020                                      buf,len);
1021                 if (ret <= 0) return(ret);
1022                 }
1023
1024         return(ret);
1025         }
1026
1027 int ssl3_read(SSL *s, void *buf, int len)
1028         {
1029         int ret;
1030
1031         clear_sys_error();
1032         if (s->s3->renegotiate) ssl3_renegotiate_check(s);
1033         s->s3->in_read_app_data=1;
1034         ret=ssl3_read_bytes(s,SSL3_RT_APPLICATION_DATA,buf,len);
1035         if ((ret == -1) && (s->s3->in_read_app_data == 0))
1036                 {
1037                 ERR_get_error(); /* clear the error */
1038                 s->s3->in_read_app_data=0;
1039                 s->in_handshake++;
1040                 ret=ssl3_read_bytes(s,SSL3_RT_APPLICATION_DATA,buf,len);
1041                 s->in_handshake--;
1042                 }
1043         else
1044                 s->s3->in_read_app_data=0;
1045
1046         return(ret);
1047         }
1048
1049 int ssl3_peek(SSL *s, char *buf, int len)
1050         {
1051         SSL3_RECORD *rr;
1052         int n;
1053
1054         rr= &(s->s3->rrec);
1055         if ((rr->length == 0) || (rr->type != SSL3_RT_APPLICATION_DATA))
1056                 {
1057                 n=ssl3_read(s,buf,1);
1058                 if (n <= 0) return(n);
1059                 rr->length++;
1060                 rr->off--;
1061                 }
1062
1063         if ((unsigned int)len > rr->length)
1064                 n=rr->length;
1065         else
1066                 n=len;
1067         memcpy(buf,&(rr->data[rr->off]),(unsigned int)n);
1068         return(n);
1069         }
1070
1071 int ssl3_renegotiate(SSL *s)
1072         {
1073         if (s->handshake_func == NULL)
1074                 return(1);
1075
1076         if (s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS)
1077                 return(0);
1078
1079         s->s3->renegotiate=1;
1080         return(1);
1081         }
1082
1083 int ssl3_renegotiate_check(SSL *s)
1084         {
1085         int ret=0;
1086
1087         if (s->s3->renegotiate)
1088                 {
1089                 if (    (s->s3->rbuf.left == 0) &&
1090                         (s->s3->wbuf.left == 0) &&
1091                         !SSL_in_init(s))
1092                         {
1093 /*
1094 if we are the server, and we have sent a 'RENEGOTIATE' message, we
1095 need to go to SSL_ST_ACCEPT.\1e
1096 */
1097                         /* SSL_ST_ACCEPT */
1098                         s->state=SSL_ST_RENEGOTIATE;
1099                         s->s3->renegotiate=0;
1100                         s->s3->num_renegotiations++;
1101                         s->s3->total_renegotiations++;
1102                         ret=1;
1103                         }
1104                 }
1105         return(ret);
1106         }
1107