crypto/openssl/ssl/s2_clnt.c

   1 /* ssl/s2_clnt.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-2001 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 #include "ssl_locl.h"
 113 #ifndef OPENSSL_NO_SSL2
 114 # include <stdio.h>
 115 # include <openssl/rand.h>
 116 # include <openssl/buffer.h>
 117 # include <openssl/objects.h>
 118 # include <openssl/evp.h>
 119
 120 static SSL_METHOD *ssl2_get_client_method(int ver);
 121 static int get_server_finished(SSL *s);
 122 static int get_server_verify(SSL *s);
 123 static int get_server_hello(SSL *s);
 124 static int client_hello(SSL *s);
 125 static int client_master_key(SSL *s);
 126 static int client_finished(SSL *s);
 127 static int client_certificate(SSL *s);
 128 static int ssl_rsa_public_encrypt(SESS_CERT *sc, int len, unsigned char *from,
 129                                   unsigned char *to, int padding);
 130 # define BREAK   break
 131
 132 static SSL_METHOD *ssl2_get_client_method(int ver)
 133 {
 134     if (ver == SSL2_VERSION)
 135         return (SSLv2_client_method());
 136     else
 137         return (NULL);
 138 }
 139
 140 IMPLEMENT_ssl2_meth_func(SSLv2_client_method,
 141                          ssl_undefined_function,
 142                          ssl2_connect, ssl2_get_client_method)
 143
 144 int ssl2_connect(SSL *s)
 145 {
 146     unsigned long l = (unsigned long)time(NULL);
 147     BUF_MEM *buf = NULL;
 148     int ret = -1;
 149     void (*cb) (const SSL *ssl, int type, int val) = NULL;
 150     int new_state, state;
 151
 152     RAND_add(&l, sizeof(l), 0);
 153     ERR_clear_error();
 154     clear_sys_error();
 155
 156     if (s->info_callback != NULL)
 157         cb = s->info_callback;
 158     else if (s->ctx->info_callback != NULL)
 159         cb = s->ctx->info_callback;
 160
 161     /* init things to blank */
 162     s->in_handshake++;
 163     if (!SSL_in_init(s) || SSL_in_before(s))
 164         SSL_clear(s);
 165
 166     for (;;) {
 167         state = s->state;
 168
 169         switch (s->state) {
 170         case SSL_ST_BEFORE:
 171         case SSL_ST_CONNECT:
 172         case SSL_ST_BEFORE | SSL_ST_CONNECT:
 173         case SSL_ST_OK | SSL_ST_CONNECT:
 174
 175             s->server = 0;
 176             if (cb != NULL)
 177                 cb(s, SSL_CB_HANDSHAKE_START, 1);
 178
 179             s->version = SSL2_VERSION;
 180             s->type = SSL_ST_CONNECT;
 181
 182             buf = s->init_buf;
 183             if ((buf == NULL) && ((buf = BUF_MEM_new()) == NULL)) {
 184                 ret = -1;
 185                 goto end;
 186             }
 187             if (!BUF_MEM_grow(buf, SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)) {
 188                 if (buf == s->init_buf)
 189                     buf = NULL;
 190                 ret = -1;
 191                 goto end;
 192             }
 193             s->init_buf = buf;
 194             buf = NULL;
 195             s->init_num = 0;
 196             s->state = SSL2_ST_SEND_CLIENT_HELLO_A;
 197             s->ctx->stats.sess_connect++;
 198             s->handshake_func = ssl2_connect;
 199             BREAK;
 200
 201         case SSL2_ST_SEND_CLIENT_HELLO_A:
 202         case SSL2_ST_SEND_CLIENT_HELLO_B:
 203             s->shutdown = 0;
 204             ret = client_hello(s);
 205             if (ret <= 0)
 206                 goto end;
 207             s->init_num = 0;
 208             s->state = SSL2_ST_GET_SERVER_HELLO_A;
 209             BREAK;
 210
 211         case SSL2_ST_GET_SERVER_HELLO_A:
 212         case SSL2_ST_GET_SERVER_HELLO_B:
 213             ret = get_server_hello(s);
 214             if (ret <= 0)
 215                 goto end;
 216             s->init_num = 0;
 217             if (!s->hit) {      /* new session */
 218                 s->state = SSL2_ST_SEND_CLIENT_MASTER_KEY_A;
 219                 BREAK;
 220             } else {
 221                 s->state = SSL2_ST_CLIENT_START_ENCRYPTION;
 222                 break;
 223             }
 224
 225         case SSL2_ST_SEND_CLIENT_MASTER_KEY_A:
 226         case SSL2_ST_SEND_CLIENT_MASTER_KEY_B:
 227             ret = client_master_key(s);
 228             if (ret <= 0)
 229                 goto end;
 230             s->init_num = 0;
 231             s->state = SSL2_ST_CLIENT_START_ENCRYPTION;
 232             break;
 233
 234         case SSL2_ST_CLIENT_START_ENCRYPTION:
 235             /*
 236              * Ok, we now have all the stuff needed to start encrypting, so
 237              * lets fire it up :-)
 238              */
 239             if (!ssl2_enc_init(s, 1)) {
 240                 ret = -1;
 241                 goto end;
 242             }
 243             s->s2->clear_text = 0;
 244             s->state = SSL2_ST_SEND_CLIENT_FINISHED_A;
 245             break;
 246
 247         case SSL2_ST_SEND_CLIENT_FINISHED_A:
 248         case SSL2_ST_SEND_CLIENT_FINISHED_B:
 249             ret = client_finished(s);
 250             if (ret <= 0)
 251                 goto end;
 252             s->init_num = 0;
 253             s->state = SSL2_ST_GET_SERVER_VERIFY_A;
 254             break;
 255
 256         case SSL2_ST_GET_SERVER_VERIFY_A:
 257         case SSL2_ST_GET_SERVER_VERIFY_B:
 258             ret = get_server_verify(s);
 259             if (ret <= 0)
 260                 goto end;
 261             s->init_num = 0;
 262             s->state = SSL2_ST_GET_SERVER_FINISHED_A;
 263             break;
 264
 265         case SSL2_ST_GET_SERVER_FINISHED_A:
 266         case SSL2_ST_GET_SERVER_FINISHED_B:
 267             ret = get_server_finished(s);
 268             if (ret <= 0)
 269                 goto end;
 270             break;
 271
 272         case SSL2_ST_SEND_CLIENT_CERTIFICATE_A:
 273         case SSL2_ST_SEND_CLIENT_CERTIFICATE_B:
 274         case SSL2_ST_SEND_CLIENT_CERTIFICATE_C:
 275         case SSL2_ST_SEND_CLIENT_CERTIFICATE_D:
 276         case SSL2_ST_X509_GET_CLIENT_CERTIFICATE:
 277             ret = client_certificate(s);
 278             if (ret <= 0)
 279                 goto end;
 280             s->init_num = 0;
 281             s->state = SSL2_ST_GET_SERVER_FINISHED_A;
 282             break;
 283
 284         case SSL_ST_OK:
 285             if (s->init_buf != NULL) {
 286                 BUF_MEM_free(s->init_buf);
 287                 s->init_buf = NULL;
 288             }
 289             s->init_num = 0;
 290             /*      ERR_clear_error(); */
 291
 292             /*
 293              * If we want to cache session-ids in the client and we
 294              * successfully add the session-id to the cache, and there is a
 295              * callback, then pass it out. 26/11/96 - eay - only add if not a
 296              * re-used session.
 297              */
 298
 299             ssl_update_cache(s, SSL_SESS_CACHE_CLIENT);
 300             if (s->hit)
 301                 s->ctx->stats.sess_hit++;
 302
 303             ret = 1;
 304             /* s->server=0; */
 305             s->ctx->stats.sess_connect_good++;
 306
 307             if (cb != NULL)
 308                 cb(s, SSL_CB_HANDSHAKE_DONE, 1);
 309
 310             goto end;
 311             /* break; */
 312         default:
 313             SSLerr(SSL_F_SSL2_CONNECT, SSL_R_UNKNOWN_STATE);
 314             return (-1);
 315             /* break; */
 316         }
 317
 318         if ((cb != NULL) && (s->state != state)) {
 319             new_state = s->state;
 320             s->state = state;
 321             cb(s, SSL_CB_CONNECT_LOOP, 1);
 322             s->state = new_state;
 323         }
 324     }
 325  end:
 326     s->in_handshake--;
 327     if (buf != NULL)
 328         BUF_MEM_free(buf);
 329     if (cb != NULL)
 330         cb(s, SSL_CB_CONNECT_EXIT, ret);
 331     return (ret);
 332 }
 333
 334 static int get_server_hello(SSL *s)
 335 {
 336     unsigned char *buf;
 337     unsigned char *p;
 338     int i, j;
 339     unsigned long len;
 340     STACK_OF(SSL_CIPHER) *sk = NULL, *cl, *prio, *allow;
 341
 342     buf = (unsigned char *)s->init_buf->data;
 343     p = buf;
 344     if (s->state == SSL2_ST_GET_SERVER_HELLO_A) {
 345         i = ssl2_read(s, (char *)&(buf[s->init_num]), 11 - s->init_num);
 346         if (i < (11 - s->init_num))
 347             return (ssl2_part_read(s, SSL_F_GET_SERVER_HELLO, i));
 348         s->init_num = 11;
 349
 350         if (*(p++) != SSL2_MT_SERVER_HELLO) {
 351             if (p[-1] != SSL2_MT_ERROR) {
 352                 ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 353                 SSLerr(SSL_F_GET_SERVER_HELLO, SSL_R_READ_WRONG_PACKET_TYPE);
 354             } else
 355                 SSLerr(SSL_F_GET_SERVER_HELLO, SSL_R_PEER_ERROR);
 356             return (-1);
 357         }
 358 # ifdef __APPLE_CC__
 359         /*
 360          * The Rhapsody 5.5 (a.k.a. MacOS X) compiler bug workaround.
 361          * <appro@fy.chalmers.se>
 362          */
 363         s->hit = (i = *(p++)) ? 1 : 0;
 364 # else
 365         s->hit = (*(p++)) ? 1 : 0;
 366 # endif
 367         s->s2->tmp.cert_type = *(p++);
 368         n2s(p, i);
 369         if (i < s->version)
 370             s->version = i;
 371         n2s(p, i);
 372         s->s2->tmp.cert_length = i;
 373         n2s(p, i);
 374         s->s2->tmp.csl = i;
 375         n2s(p, i);
 376         s->s2->tmp.conn_id_length = i;
 377         s->state = SSL2_ST_GET_SERVER_HELLO_B;
 378     }
 379
 380     /* SSL2_ST_GET_SERVER_HELLO_B */
 381     len =
 382         11 + (unsigned long)s->s2->tmp.cert_length +
 383         (unsigned long)s->s2->tmp.csl +
 384         (unsigned long)s->s2->tmp.conn_id_length;
 385     if (len > SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER) {
 386         SSLerr(SSL_F_GET_SERVER_HELLO, SSL_R_MESSAGE_TOO_LONG);
 387         return -1;
 388     }
 389     j = (int)len - s->init_num;
 390     i = ssl2_read(s, (char *)&(buf[s->init_num]), j);
 391     if (i != j)
 392         return (ssl2_part_read(s, SSL_F_GET_SERVER_HELLO, i));
 393     if (s->msg_callback) {
 394         /* SERVER-HELLO */
 395         s->msg_callback(0, s->version, 0, buf, (size_t)len, s,
 396                         s->msg_callback_arg);
 397     }
 398
 399     /* things are looking good */
 400
 401     p = buf + 11;
 402     if (s->hit) {
 403         if (s->s2->tmp.cert_length != 0) {
 404             SSLerr(SSL_F_GET_SERVER_HELLO, SSL_R_REUSE_CERT_LENGTH_NOT_ZERO);
 405             return (-1);
 406         }
 407         if (s->s2->tmp.cert_type != 0) {
 408             if (!(s->options & SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG)) {
 409                 SSLerr(SSL_F_GET_SERVER_HELLO,
 410                        SSL_R_REUSE_CERT_TYPE_NOT_ZERO);
 411                 return (-1);
 412             }
 413         }
 414         if (s->s2->tmp.csl != 0) {
 415             SSLerr(SSL_F_GET_SERVER_HELLO, SSL_R_REUSE_CIPHER_LIST_NOT_ZERO);
 416             return (-1);
 417         }
 418     } else {
 419 # ifdef undef
 420         /* very bad */
 421         memset(s->session->session_id, 0,
 422                SSL_MAX_SSL_SESSION_ID_LENGTH_IN_BYTES);
 423         s->session->session_id_length = 0;
 424         */
 425 # endif
 426             /*
 427              * we need to do this in case we were trying to reuse a client
 428              * session but others are already reusing it. If this was a new
 429              * 'blank' session ID, the session-id length will still be 0
 430              */
 431             if (s->session->session_id_length > 0) {
 432             if (!ssl_get_new_session(s, 0)) {
 433                 ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 434                 return (-1);
 435             }
 436         }
 437
 438         if (ssl2_set_certificate(s, s->s2->tmp.cert_type,
 439                                  s->s2->tmp.cert_length, p) <= 0) {
 440             ssl2_return_error(s, SSL2_PE_BAD_CERTIFICATE);
 441             return (-1);
 442         }
 443         p += s->s2->tmp.cert_length;
 444
 445         if (s->s2->tmp.csl == 0) {
 446             ssl2_return_error(s, SSL2_PE_NO_CIPHER);
 447             SSLerr(SSL_F_GET_SERVER_HELLO, SSL_R_NO_CIPHER_LIST);
 448             return (-1);
 449         }
 450
 451         /*
 452          * We have just received a list of ciphers back from the server.  We
 453          * need to get the ones that match, then select the one we want the
 454          * most :-).
 455          */
 456
 457         /* load the ciphers */
 458         sk = ssl_bytes_to_cipher_list(s, p, s->s2->tmp.csl,
 459                                       &s->session->ciphers);
 460         p += s->s2->tmp.csl;
 461         if (sk == NULL) {
 462             ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 463             SSLerr(SSL_F_GET_SERVER_HELLO, ERR_R_MALLOC_FAILURE);
 464             return (-1);
 465         }
 466
 467         (void)sk_SSL_CIPHER_set_cmp_func(sk, ssl_cipher_ptr_id_cmp);
 468
 469         /* get the array of ciphers we will accept */
 470         cl = SSL_get_ciphers(s);
 471         (void)sk_SSL_CIPHER_set_cmp_func(cl, ssl_cipher_ptr_id_cmp);
 472
 473         /*
 474          * If server preference flag set, choose the first
 475          * (highest priority) cipher the server sends, otherwise
 476          * client preference has priority.
 477          */
 478         if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) {
 479             prio = sk;
 480             allow = cl;
 481         } else {
 482             prio = cl;
 483             allow = sk;
 484         }
 485         /*
 486          * In theory we could have ciphers sent back that we don't want to
 487          * use but that does not matter since we will check against the list
 488          * we originally sent and for performance reasons we should not
 489          * bother to match the two lists up just to check.
 490          */
 491         for (i = 0; i < sk_SSL_CIPHER_num(prio); i++) {
 492             if (sk_SSL_CIPHER_find(allow, sk_SSL_CIPHER_value(prio, i)) >= 0)
 493                 break;
 494         }
 495
 496         if (i >= sk_SSL_CIPHER_num(prio)) {
 497             ssl2_return_error(s, SSL2_PE_NO_CIPHER);
 498             SSLerr(SSL_F_GET_SERVER_HELLO, SSL_R_NO_CIPHER_MATCH);
 499             return (-1);
 500         }
 501         s->session->cipher = sk_SSL_CIPHER_value(prio, i);
 502
 503         if (s->session->peer != NULL) { /* can't happen */
 504             ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 505             SSLerr(SSL_F_GET_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
 506             return (-1);
 507         }
 508
 509         s->session->peer = s->session->sess_cert->peer_key->x509;
 510         /* peer_key->x509 has been set by ssl2_set_certificate. */
 511         CRYPTO_add(&s->session->peer->references, 1, CRYPTO_LOCK_X509);
 512     }
 513
 514     if (s->session->sess_cert == NULL
 515         || s->session->peer != s->session->sess_cert->peer_key->x509)
 516         /* can't happen */
 517     {
 518         ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 519         SSLerr(SSL_F_GET_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
 520         return (-1);
 521     }
 522
 523     s->s2->conn_id_length = s->s2->tmp.conn_id_length;
 524     if (s->s2->conn_id_length > sizeof s->s2->conn_id) {
 525         ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 526         SSLerr(SSL_F_GET_SERVER_HELLO, SSL_R_SSL2_CONNECTION_ID_TOO_LONG);
 527         return -1;
 528     }
 529     memcpy(s->s2->conn_id, p, s->s2->tmp.conn_id_length);
 530     return (1);
 531 }
 532
 533 static int client_hello(SSL *s)
 534 {
 535     unsigned char *buf;
 536     unsigned char *p, *d;
 537 /*      CIPHER **cipher;*/
 538     int i, n, j;
 539
 540     buf = (unsigned char *)s->init_buf->data;
 541     if (s->state == SSL2_ST_SEND_CLIENT_HELLO_A) {
 542         if ((s->session == NULL) || (s->session->ssl_version != s->version)) {
 543             if (!ssl_get_new_session(s, 0)) {
 544                 ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 545                 return (-1);
 546             }
 547         }
 548         /* else use the pre-loaded session */
 549
 550         p = buf;                /* header */
 551         d = p + 9;              /* data section */
 552         *(p++) = SSL2_MT_CLIENT_HELLO; /* type */
 553         s2n(SSL2_VERSION, p);   /* version */
 554         n = j = 0;
 555
 556         n = ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), d, 0);
 557         d += n;
 558
 559         if (n == 0) {
 560             SSLerr(SSL_F_CLIENT_HELLO, SSL_R_NO_CIPHERS_AVAILABLE);
 561             return (-1);
 562         }
 563
 564         s2n(n, p);              /* cipher spec num bytes */
 565
 566         if ((s->session->session_id_length > 0) &&
 567             (s->session->session_id_length <=
 568              SSL2_MAX_SSL_SESSION_ID_LENGTH)) {
 569             i = s->session->session_id_length;
 570             s2n(i, p);          /* session id length */
 571             memcpy(d, s->session->session_id, (unsigned int)i);
 572             d += i;
 573         } else {
 574             s2n(0, p);
 575         }
 576
 577         s->s2->challenge_length = SSL2_CHALLENGE_LENGTH;
 578         s2n(SSL2_CHALLENGE_LENGTH, p); /* challenge length */
 579         /*
 580          * challenge id data
 581          */
 582         if (RAND_pseudo_bytes(s->s2->challenge, SSL2_CHALLENGE_LENGTH) <= 0)
 583             return -1;
 584         memcpy(d, s->s2->challenge, SSL2_CHALLENGE_LENGTH);
 585         d += SSL2_CHALLENGE_LENGTH;
 586
 587         s->state = SSL2_ST_SEND_CLIENT_HELLO_B;
 588         s->init_num = d - buf;
 589         s->init_off = 0;
 590     }
 591     /* SSL2_ST_SEND_CLIENT_HELLO_B */
 592     return (ssl2_do_write(s));
 593 }
 594
 595 static int client_master_key(SSL *s)
 596 {
 597     unsigned char *buf;
 598     unsigned char *p, *d;
 599     int clear, enc, karg, i;
 600     SSL_SESSION *sess;
 601     const EVP_CIPHER *c;
 602     const EVP_MD *md;
 603
 604     buf = (unsigned char *)s->init_buf->data;
 605     if (s->state == SSL2_ST_SEND_CLIENT_MASTER_KEY_A) {
 606
 607         if (!ssl_cipher_get_evp(s->session, &c, &md, NULL)) {
 608             ssl2_return_error(s, SSL2_PE_NO_CIPHER);
 609             SSLerr(SSL_F_CLIENT_MASTER_KEY,
 610                    SSL_R_PROBLEMS_MAPPING_CIPHER_FUNCTIONS);
 611             return (-1);
 612         }
 613         sess = s->session;
 614         p = buf;
 615         d = p + 10;
 616         *(p++) = SSL2_MT_CLIENT_MASTER_KEY; /* type */
 617
 618         i = ssl_put_cipher_by_char(s, sess->cipher, p);
 619         p += i;
 620
 621         /* make key_arg data */
 622         i = EVP_CIPHER_iv_length(c);
 623         sess->key_arg_length = i;
 624         if (i > SSL_MAX_KEY_ARG_LENGTH) {
 625             ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 626             SSLerr(SSL_F_CLIENT_MASTER_KEY, ERR_R_INTERNAL_ERROR);
 627             return -1;
 628         }
 629         if (i > 0)
 630             if (RAND_pseudo_bytes(sess->key_arg, i) <= 0)
 631                 return -1;
 632
 633         /* make a master key */
 634         i = EVP_CIPHER_key_length(c);
 635         sess->master_key_length = i;
 636         if (i > 0) {
 637             if (i > (int)sizeof(sess->master_key)) {
 638                 ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 639                 SSLerr(SSL_F_CLIENT_MASTER_KEY, ERR_R_INTERNAL_ERROR);
 640                 return -1;
 641             }
 642             if (RAND_bytes(sess->master_key, i) <= 0) {
 643                 ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 644                 return (-1);
 645             }
 646         }
 647
 648         if (sess->cipher->algorithm2 & SSL2_CF_8_BYTE_ENC)
 649             enc = 8;
 650         else if (SSL_C_IS_EXPORT(sess->cipher))
 651             enc = 5;
 652         else
 653             enc = i;
 654
 655         if ((int)i < enc) {
 656             ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 657             SSLerr(SSL_F_CLIENT_MASTER_KEY, SSL_R_CIPHER_TABLE_SRC_ERROR);
 658             return (-1);
 659         }
 660         clear = i - enc;
 661         s2n(clear, p);
 662         memcpy(d, sess->master_key, (unsigned int)clear);
 663         d += clear;
 664
 665         enc = ssl_rsa_public_encrypt(sess->sess_cert, enc,
 666                                      &(sess->master_key[clear]), d,
 667                                      (s->
 668                                       s2->ssl2_rollback) ? RSA_SSLV23_PADDING
 669                                      : RSA_PKCS1_PADDING);
 670         if (enc <= 0) {
 671             ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 672             SSLerr(SSL_F_CLIENT_MASTER_KEY, SSL_R_PUBLIC_KEY_ENCRYPT_ERROR);
 673             return (-1);
 674         }
 675 # ifdef PKCS1_CHECK
 676         if (s->options & SSL_OP_PKCS1_CHECK_1)
 677             d[1]++;
 678         if (s->options & SSL_OP_PKCS1_CHECK_2)
 679             sess->master_key[clear]++;
 680 # endif
 681         s2n(enc, p);
 682         d += enc;
 683         karg = sess->key_arg_length;
 684         s2n(karg, p);           /* key arg size */
 685         if (karg > (int)sizeof(sess->key_arg)) {
 686             ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 687             SSLerr(SSL_F_CLIENT_MASTER_KEY, ERR_R_INTERNAL_ERROR);
 688             return -1;
 689         }
 690         memcpy(d, sess->key_arg, (unsigned int)karg);
 691         d += karg;
 692
 693         s->state = SSL2_ST_SEND_CLIENT_MASTER_KEY_B;
 694         s->init_num = d - buf;
 695         s->init_off = 0;
 696     }
 697
 698     /* SSL2_ST_SEND_CLIENT_MASTER_KEY_B */
 699     return (ssl2_do_write(s));
 700 }
 701
 702 static int client_finished(SSL *s)
 703 {
 704     unsigned char *p;
 705
 706     if (s->state == SSL2_ST_SEND_CLIENT_FINISHED_A) {
 707         p = (unsigned char *)s->init_buf->data;
 708         *(p++) = SSL2_MT_CLIENT_FINISHED;
 709         if (s->s2->conn_id_length > sizeof s->s2->conn_id) {
 710             SSLerr(SSL_F_CLIENT_FINISHED, ERR_R_INTERNAL_ERROR);
 711             return -1;
 712         }
 713         memcpy(p, s->s2->conn_id, (unsigned int)s->s2->conn_id_length);
 714
 715         s->state = SSL2_ST_SEND_CLIENT_FINISHED_B;
 716         s->init_num = s->s2->conn_id_length + 1;
 717         s->init_off = 0;
 718     }
 719     return (ssl2_do_write(s));
 720 }
 721
 722 /* read the data and then respond */
 723 static int client_certificate(SSL *s)
 724 {
 725     unsigned char *buf;
 726     unsigned char *p, *d;
 727     int i;
 728     unsigned int n;
 729     int cert_ch_len;
 730     unsigned char *cert_ch;
 731
 732     buf = (unsigned char *)s->init_buf->data;
 733
 734     /*
 735      * We have a cert associated with the SSL, so attach it to the session if
 736      * it does not have one
 737      */
 738
 739     if (s->state == SSL2_ST_SEND_CLIENT_CERTIFICATE_A) {
 740         i = ssl2_read(s, (char *)&(buf[s->init_num]),
 741                       SSL2_MAX_CERT_CHALLENGE_LENGTH + 2 - s->init_num);
 742         if (i < (SSL2_MIN_CERT_CHALLENGE_LENGTH + 2 - s->init_num))
 743             return (ssl2_part_read(s, SSL_F_CLIENT_CERTIFICATE, i));
 744         s->init_num += i;
 745         if (s->msg_callback) {
 746             /* REQUEST-CERTIFICATE */
 747             s->msg_callback(0, s->version, 0, buf, (size_t)s->init_num, s,
 748                             s->msg_callback_arg);
 749         }
 750
 751         /* type=buf[0]; */
 752         /* type eq x509 */
 753         if (buf[1] != SSL2_AT_MD5_WITH_RSA_ENCRYPTION) {
 754             ssl2_return_error(s, SSL2_PE_UNSUPPORTED_CERTIFICATE_TYPE);
 755             SSLerr(SSL_F_CLIENT_CERTIFICATE, SSL_R_BAD_AUTHENTICATION_TYPE);
 756             return (-1);
 757         }
 758
 759         if ((s->cert == NULL) ||
 760             (s->cert->key->x509 == NULL) ||
 761             (s->cert->key->privatekey == NULL)) {
 762             s->state = SSL2_ST_X509_GET_CLIENT_CERTIFICATE;
 763         } else
 764             s->state = SSL2_ST_SEND_CLIENT_CERTIFICATE_C;
 765     }
 766
 767     cert_ch = buf + 2;
 768     cert_ch_len = s->init_num - 2;
 769
 770     if (s->state == SSL2_ST_X509_GET_CLIENT_CERTIFICATE) {
 771         X509 *x509 = NULL;
 772         EVP_PKEY *pkey = NULL;
 773
 774         /*
 775          * If we get an error we need to ssl->rwstate=SSL_X509_LOOKUP;
 776          * return(error); We should then be retried when things are ok and we
 777          * can get a cert or not
 778          */
 779
 780         i = 0;
 781         if (s->ctx->client_cert_cb != NULL) {
 782             i = s->ctx->client_cert_cb(s, &(x509), &(pkey));
 783         }
 784
 785         if (i < 0) {
 786             s->rwstate = SSL_X509_LOOKUP;
 787             return (-1);
 788         }
 789         s->rwstate = SSL_NOTHING;
 790
 791         if ((i == 1) && (pkey != NULL) && (x509 != NULL)) {
 792             s->state = SSL2_ST_SEND_CLIENT_CERTIFICATE_C;
 793             if (!SSL_use_certificate(s, x509) || !SSL_use_PrivateKey(s, pkey)) {
 794                 i = 0;
 795             }
 796             X509_free(x509);
 797             EVP_PKEY_free(pkey);
 798         } else if (i == 1) {
 799             if (x509 != NULL)
 800                 X509_free(x509);
 801             if (pkey != NULL)
 802                 EVP_PKEY_free(pkey);
 803             SSLerr(SSL_F_CLIENT_CERTIFICATE,
 804                    SSL_R_BAD_DATA_RETURNED_BY_CALLBACK);
 805             i = 0;
 806         }
 807
 808         if (i == 0) {
 809             /*
 810              * We have no client certificate to respond with so send the
 811              * correct error message back
 812              */
 813             s->state = SSL2_ST_SEND_CLIENT_CERTIFICATE_B;
 814             p = buf;
 815             *(p++) = SSL2_MT_ERROR;
 816             s2n(SSL2_PE_NO_CERTIFICATE, p);
 817             s->init_off = 0;
 818             s->init_num = 3;
 819             /* Write is done at the end */
 820         }
 821     }
 822
 823     if (s->state == SSL2_ST_SEND_CLIENT_CERTIFICATE_B) {
 824         return (ssl2_do_write(s));
 825     }
 826
 827     if (s->state == SSL2_ST_SEND_CLIENT_CERTIFICATE_C) {
 828         EVP_MD_CTX ctx;
 829
 830         /*
 831          * ok, now we calculate the checksum do it first so we can reuse buf
 832          * :-)
 833          */
 834         p = buf;
 835         EVP_MD_CTX_init(&ctx);
 836         EVP_SignInit_ex(&ctx, s->ctx->rsa_md5, NULL);
 837         EVP_SignUpdate(&ctx, s->s2->key_material, s->s2->key_material_length);
 838         EVP_SignUpdate(&ctx, cert_ch, (unsigned int)cert_ch_len);
 839         n = i2d_X509(s->session->sess_cert->peer_key->x509, &p);
 840         EVP_SignUpdate(&ctx, buf, (unsigned int)n);
 841
 842         p = buf;
 843         d = p + 6;
 844         *(p++) = SSL2_MT_CLIENT_CERTIFICATE;
 845         *(p++) = SSL2_CT_X509_CERTIFICATE;
 846         n = i2d_X509(s->cert->key->x509, &d);
 847         s2n(n, p);
 848
 849         if (!EVP_SignFinal(&ctx, d, &n, s->cert->key->privatekey)) {
 850             /*
 851              * this is not good.  If things have failed it means there so
 852              * something wrong with the key. We will continue with a 0 length
 853              * signature
 854              */
 855         }
 856         EVP_MD_CTX_cleanup(&ctx);
 857         s2n(n, p);
 858         d += n;
 859
 860         s->state = SSL2_ST_SEND_CLIENT_CERTIFICATE_D;
 861         s->init_num = d - buf;
 862         s->init_off = 0;
 863     }
 864     /* if (s->state == SSL2_ST_SEND_CLIENT_CERTIFICATE_D) */
 865     return (ssl2_do_write(s));
 866 }
 867
 868 static int get_server_verify(SSL *s)
 869 {
 870     unsigned char *p;
 871     int i, n, len;
 872
 873     p = (unsigned char *)s->init_buf->data;
 874     if (s->state == SSL2_ST_GET_SERVER_VERIFY_A) {
 875         i = ssl2_read(s, (char *)&(p[s->init_num]), 1 - s->init_num);
 876         if (i < (1 - s->init_num))
 877             return (ssl2_part_read(s, SSL_F_GET_SERVER_VERIFY, i));
 878         s->init_num += i;
 879
 880         s->state = SSL2_ST_GET_SERVER_VERIFY_B;
 881         if (*p != SSL2_MT_SERVER_VERIFY) {
 882             if (p[0] != SSL2_MT_ERROR) {
 883                 ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 884                 SSLerr(SSL_F_GET_SERVER_VERIFY, SSL_R_READ_WRONG_PACKET_TYPE);
 885             } else {
 886                 SSLerr(SSL_F_GET_SERVER_VERIFY, SSL_R_PEER_ERROR);
 887                 /* try to read the error message */
 888                 i = ssl2_read(s, (char *)&(p[s->init_num]), 3 - s->init_num);
 889                 return ssl2_part_read(s, SSL_F_GET_SERVER_VERIFY, i);
 890             }
 891             return (-1);
 892         }
 893     }
 894
 895     p = (unsigned char *)s->init_buf->data;
 896     len = 1 + s->s2->challenge_length;
 897     n = len - s->init_num;
 898     i = ssl2_read(s, (char *)&(p[s->init_num]), n);
 899     if (i < n)
 900         return (ssl2_part_read(s, SSL_F_GET_SERVER_VERIFY, i));
 901     if (s->msg_callback) {
 902         /* SERVER-VERIFY */
 903         s->msg_callback(0, s->version, 0, p, len, s, s->msg_callback_arg);
 904     }
 905     p += 1;
 906
 907     if (CRYPTO_memcmp(p, s->s2->challenge, s->s2->challenge_length) != 0) {
 908         ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 909         SSLerr(SSL_F_GET_SERVER_VERIFY, SSL_R_CHALLENGE_IS_DIFFERENT);
 910         return (-1);
 911     }
 912     return (1);
 913 }
 914
 915 static int get_server_finished(SSL *s)
 916 {
 917     unsigned char *buf;
 918     unsigned char *p;
 919     int i, n, len;
 920
 921     buf = (unsigned char *)s->init_buf->data;
 922     p = buf;
 923     if (s->state == SSL2_ST_GET_SERVER_FINISHED_A) {
 924         i = ssl2_read(s, (char *)&(buf[s->init_num]), 1 - s->init_num);
 925         if (i < (1 - s->init_num))
 926             return (ssl2_part_read(s, SSL_F_GET_SERVER_FINISHED, i));
 927         s->init_num += i;
 928
 929         if (*p == SSL2_MT_REQUEST_CERTIFICATE) {
 930             s->state = SSL2_ST_SEND_CLIENT_CERTIFICATE_A;
 931             return (1);
 932         } else if (*p != SSL2_MT_SERVER_FINISHED) {
 933             if (p[0] != SSL2_MT_ERROR) {
 934                 ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 935                 SSLerr(SSL_F_GET_SERVER_FINISHED,
 936                        SSL_R_READ_WRONG_PACKET_TYPE);
 937             } else {
 938                 SSLerr(SSL_F_GET_SERVER_FINISHED, SSL_R_PEER_ERROR);
 939                 /* try to read the error message */
 940                 i = ssl2_read(s, (char *)&(p[s->init_num]), 3 - s->init_num);
 941                 return ssl2_part_read(s, SSL_F_GET_SERVER_VERIFY, i);
 942             }
 943             return (-1);
 944         }
 945         s->state = SSL2_ST_GET_SERVER_FINISHED_B;
 946     }
 947
 948     len = 1 + SSL2_SSL_SESSION_ID_LENGTH;
 949     n = len - s->init_num;
 950     i = ssl2_read(s, (char *)&(buf[s->init_num]), n);
 951     if (i < n) {
 952         /*
 953          * XXX could be shorter than SSL2_SSL_SESSION_ID_LENGTH,
 954          * that's the maximum
 955          */
 956         return (ssl2_part_read(s, SSL_F_GET_SERVER_FINISHED, i));
 957     }
 958     s->init_num += i;
 959     if (s->msg_callback) {
 960         /* SERVER-FINISHED */
 961         s->msg_callback(0, s->version, 0, buf, (size_t)s->init_num, s,
 962                         s->msg_callback_arg);
 963     }
 964
 965     if (!s->hit) {              /* new session */
 966         /* new session-id */
 967         /*
 968          * Make sure we were not trying to re-use an old SSL_SESSION or bad
 969          * things can happen
 970          */
 971         /* ZZZZZZZZZZZZZ */
 972         s->session->session_id_length = SSL2_SSL_SESSION_ID_LENGTH;
 973         memcpy(s->session->session_id, p + 1, SSL2_SSL_SESSION_ID_LENGTH);
 974     } else {
 975         if (!(s->options & SSL_OP_MICROSOFT_SESS_ID_BUG)) {
 976             if ((s->session->session_id_length >
 977                  sizeof s->session->session_id)
 978                 || (0 !=
 979                     memcmp(buf + 1, s->session->session_id,
 980                            (unsigned int)s->session->session_id_length))) {
 981                 ssl2_return_error(s, SSL2_PE_UNDEFINED_ERROR);
 982                 SSLerr(SSL_F_GET_SERVER_FINISHED,
 983                        SSL_R_SSL_SESSION_ID_IS_DIFFERENT);
 984                 return (-1);
 985             }
 986         }
 987     }
 988     s->state = SSL_ST_OK;
 989     return (1);
 990 }
 991
 992 /* loads in the certificate from the server */
 993 int ssl2_set_certificate(SSL *s, int type, int len, const unsigned char *data)
 994 {
 995     STACK_OF(X509) *sk = NULL;
 996     EVP_PKEY *pkey = NULL;
 997     SESS_CERT *sc = NULL;
 998     int i;
 999     X509 *x509 = NULL;
1000     int ret = 0;
1001
1002     x509 = d2i_X509(NULL, &data, (long)len);
1003     if (x509 == NULL) {
1004         SSLerr(SSL_F_SSL2_SET_CERTIFICATE, ERR_R_X509_LIB);
1005         goto err;
1006     }
1007
1008     if ((sk = sk_X509_new_null()) == NULL || !sk_X509_push(sk, x509)) {
1009         SSLerr(SSL_F_SSL2_SET_CERTIFICATE, ERR_R_MALLOC_FAILURE);
1010         goto err;
1011     }
1012
1013     i = ssl_verify_cert_chain(s, sk);
1014
1015     if ((s->verify_mode != SSL_VERIFY_NONE) && (i <= 0)) {
1016         SSLerr(SSL_F_SSL2_SET_CERTIFICATE, SSL_R_CERTIFICATE_VERIFY_FAILED);
1017         goto err;
1018     }
1019     ERR_clear_error();          /* but we keep s->verify_result */
1020     s->session->verify_result = s->verify_result;
1021
1022     /* server's cert for this session */
1023     sc = ssl_sess_cert_new();
1024     if (sc == NULL) {
1025         ret = -1;
1026         goto err;
1027     }
1028     if (s->session->sess_cert)
1029         ssl_sess_cert_free(s->session->sess_cert);
1030     s->session->sess_cert = sc;
1031
1032     sc->peer_pkeys[SSL_PKEY_RSA_ENC].x509 = x509;
1033     sc->peer_key = &(sc->peer_pkeys[SSL_PKEY_RSA_ENC]);
1034
1035     pkey = X509_get_pubkey(x509);
1036     x509 = NULL;
1037     if (pkey == NULL) {
1038         SSLerr(SSL_F_SSL2_SET_CERTIFICATE,
1039                SSL_R_UNABLE_TO_EXTRACT_PUBLIC_KEY);
1040         goto err;
1041     }
1042     if (pkey->type != EVP_PKEY_RSA) {
1043         SSLerr(SSL_F_SSL2_SET_CERTIFICATE, SSL_R_PUBLIC_KEY_NOT_RSA);
1044         goto err;
1045     }
1046
1047     if (!ssl_set_peer_cert_type(sc, SSL2_CT_X509_CERTIFICATE))
1048         goto err;
1049     ret = 1;
1050  err:
1051     sk_X509_free(sk);
1052     X509_free(x509);
1053     EVP_PKEY_free(pkey);
1054     return (ret);
1055 }
1056
1057 static int ssl_rsa_public_encrypt(SESS_CERT *sc, int len, unsigned char *from,
1058                                   unsigned char *to, int padding)
1059 {
1060     EVP_PKEY *pkey = NULL;
1061     int i = -1;
1062
1063     if ((sc == NULL) || (sc->peer_key->x509 == NULL) ||
1064         ((pkey = X509_get_pubkey(sc->peer_key->x509)) == NULL)) {
1065         SSLerr(SSL_F_SSL_RSA_PUBLIC_ENCRYPT, SSL_R_NO_PUBLICKEY);
1066         return (-1);
1067     }
1068     if (pkey->type != EVP_PKEY_RSA) {
1069         SSLerr(SSL_F_SSL_RSA_PUBLIC_ENCRYPT, SSL_R_PUBLIC_KEY_IS_NOT_RSA);
1070         goto end;
1071     }
1072
1073     /* we have the public key */
1074     i = RSA_public_encrypt(len, from, to, pkey->pkey.rsa, padding);
1075     if (i < 0)
1076         SSLerr(SSL_F_SSL_RSA_PUBLIC_ENCRYPT, ERR_R_RSA_LIB);
1077  end:
1078     EVP_PKEY_free(pkey);
1079     return (i);
1080 }
1081 #else                           /* !OPENSSL_NO_SSL2 */
1082
1083 # if PEDANTIC
1084 static void *dummy = &dummy;
1085 # endif
1086
1087 #endif