ssl/s3_pkt.c

   1 /* ssl/s3_pkt.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 #include <stdio.h>
 113 #include <limits.h>
 114 #include <errno.h>
 115 #define USE_SOCKETS
 116 #include "ssl_locl.h"
 117 #include <openssl/evp.h>
 118 #include <openssl/buffer.h>
 119 #include <openssl/rand.h>
 120
 121 static int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
 122                          unsigned int len, int create_empty_fragment);
 123 static int ssl3_get_record(SSL *s);
 124
 125 int ssl3_read_n(SSL *s, int n, int max, int extend)
 126 {
 127     /*
 128      * If extend == 0, obtain new n-byte packet; if extend == 1, increase
 129      * packet by another n bytes. The packet will be in the sub-array of
 130      * s->s3->rbuf.buf specified by s->packet and s->packet_length. (If
 131      * s->read_ahead is set, 'max' bytes may be stored in rbuf [plus
 132      * s->packet_length bytes if extend == 1].)
 133      */
 134     int i, len, left;
 135     long align = 0;
 136     unsigned char *pkt;
 137     SSL3_BUFFER *rb;
 138
 139     if (n <= 0)
 140         return n;
 141
 142     rb = &(s->s3->rbuf);
 143     if (rb->buf == NULL)
 144         if (!ssl3_setup_read_buffer(s))
 145             return -1;
 146
 147     left = rb->left;
 148 #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0
 149     align = (long)rb->buf + SSL3_RT_HEADER_LENGTH;
 150     align = (-align) & (SSL3_ALIGN_PAYLOAD - 1);
 151 #endif
 152
 153     if (!extend) {
 154         /* start with empty packet ... */
 155         if (left == 0)
 156             rb->offset = align;
 157         else if (align != 0 && left >= SSL3_RT_HEADER_LENGTH) {
 158             /*
 159              * check if next packet length is large enough to justify payload
 160              * alignment...
 161              */
 162             pkt = rb->buf + rb->offset;
 163             if (pkt[0] == SSL3_RT_APPLICATION_DATA
 164                 && (pkt[3] << 8 | pkt[4]) >= 128) {
 165                 /*
 166                  * Note that even if packet is corrupted and its length field
 167                  * is insane, we can only be led to wrong decision about
 168                  * whether memmove will occur or not. Header values has no
 169                  * effect on memmove arguments and therefore no buffer
 170                  * overrun can be triggered.
 171                  */
 172                 memmove(rb->buf + align, pkt, left);
 173                 rb->offset = align;
 174             }
 175         }
 176         s->packet = rb->buf + rb->offset;
 177         s->packet_length = 0;
 178         /* ... now we can act as if 'extend' was set */
 179     }
 180
 181     /*
 182      * For DTLS/UDP reads should not span multiple packets because the read
 183      * operation returns the whole packet at once (as long as it fits into
 184      * the buffer).
 185      */
 186     if (SSL_version(s) == DTLS1_VERSION || SSL_version(s) == DTLS1_BAD_VER) {
 187         if (left == 0 && extend)
 188             return 0;
 189         if (left > 0 && n > left)
 190             n = left;
 191     }
 192
 193     /* if there is enough in the buffer from a previous read, take some */
 194     if (left >= n) {
 195         s->packet_length += n;
 196         rb->left = left - n;
 197         rb->offset += n;
 198         return (n);
 199     }
 200
 201     /* else we need to read more data */
 202
 203     len = s->packet_length;
 204     pkt = rb->buf + align;
 205     /*
 206      * Move any available bytes to front of buffer: 'len' bytes already
 207      * pointed to by 'packet', 'left' extra ones at the end
 208      */
 209     if (s->packet != pkt) {     /* len > 0 */
 210         memmove(pkt, s->packet, len + left);
 211         s->packet = pkt;
 212         rb->offset = len + align;
 213     }
 214
 215     if (n > (int)(rb->len - rb->offset)) { /* does not happen */
 216         SSLerr(SSL_F_SSL3_READ_N, ERR_R_INTERNAL_ERROR);
 217         return -1;
 218     }
 219
 220     /* We always act like read_ahead is set for DTLS */
 221     if (!s->read_ahead && !SSL_IS_DTLS(s))
 222         /* ignore max parameter */
 223         max = n;
 224     else {
 225         if (max < n)
 226             max = n;
 227         if (max > (int)(rb->len - rb->offset))
 228             max = rb->len - rb->offset;
 229     }
 230
 231     while (left < n) {
 232         /*
 233          * Now we have len+left bytes at the front of s->s3->rbuf.buf and
 234          * need to read in more until we have len+n (up to len+max if
 235          * possible)
 236          */
 237
 238         clear_sys_error();
 239         if (s->rbio != NULL) {
 240             s->rwstate = SSL_READING;
 241             i = BIO_read(s->rbio, pkt + len + left, max - left);
 242         } else {
 243             SSLerr(SSL_F_SSL3_READ_N, SSL_R_READ_BIO_NOT_SET);
 244             i = -1;
 245         }
 246
 247         if (i <= 0) {
 248             rb->left = left;
 249             if (s->mode & SSL_MODE_RELEASE_BUFFERS &&
 250                 SSL_version(s) != DTLS1_VERSION
 251                 && SSL_version(s) != DTLS1_BAD_VER)
 252                 if (len + left == 0)
 253                     ssl3_release_read_buffer(s);
 254             return (i);
 255         }
 256         left += i;
 257         /*
 258          * reads should *never* span multiple packets for DTLS because the
 259          * underlying transport protocol is message oriented as opposed to
 260          * byte oriented as in the TLS case.
 261          */
 262         if (SSL_version(s) == DTLS1_VERSION
 263             || SSL_version(s) == DTLS1_BAD_VER) {
 264             if (n > left)
 265                 n = left;       /* makes the while condition false */
 266         }
 267     }
 268
 269     /* done reading, now the book-keeping */
 270     rb->offset += n;
 271     rb->left = left - n;
 272     s->packet_length += n;
 273     s->rwstate = SSL_NOTHING;
 274     return (n);
 275 }
 276
 277 /*
 278  * MAX_EMPTY_RECORDS defines the number of consecutive, empty records that
 279  * will be processed per call to ssl3_get_record. Without this limit an
 280  * attacker could send empty records at a faster rate than we can process and
 281  * cause ssl3_get_record to loop forever.
 282  */
 283 #define MAX_EMPTY_RECORDS 32
 284
 285 /*-
 286  * Call this to get a new input record.
 287  * It will return <= 0 if more data is needed, normally due to an error
 288  * or non-blocking IO.
 289  * When it finishes, one packet has been decoded and can be found in
 290  * ssl->s3->rrec.type    - is the type of record
 291  * ssl->s3->rrec.data,   - data
 292  * ssl->s3->rrec.length, - number of bytes
 293  */
 294 /* used only by ssl3_read_bytes */
 295 static int ssl3_get_record(SSL *s)
 296 {
 297     int ssl_major, ssl_minor, al;
 298     int enc_err, n, i, ret = -1;
 299     SSL3_RECORD *rr;
 300     SSL_SESSION *sess;
 301     unsigned char *p;
 302     unsigned char md[EVP_MAX_MD_SIZE];
 303     short version;
 304     unsigned mac_size, orig_len;
 305     size_t extra;
 306     unsigned empty_record_count = 0;
 307
 308     rr = &(s->s3->rrec);
 309     sess = s->session;
 310
 311     if (s->options & SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER)
 312         extra = SSL3_RT_MAX_EXTRA;
 313     else
 314         extra = 0;
 315     if (extra && !s->s3->init_extra) {
 316         /*
 317          * An application error: SLS_OP_MICROSOFT_BIG_SSLV3_BUFFER set after
 318          * ssl3_setup_buffers() was done
 319          */
 320         SSLerr(SSL_F_SSL3_GET_RECORD, ERR_R_INTERNAL_ERROR);
 321         return -1;
 322     }
 323
 324  again:
 325     /* check if we have the header */
 326     if ((s->rstate != SSL_ST_READ_BODY) ||
 327         (s->packet_length < SSL3_RT_HEADER_LENGTH)) {
 328         n = ssl3_read_n(s, SSL3_RT_HEADER_LENGTH, s->s3->rbuf.len, 0);
 329         if (n <= 0)
 330             return (n);         /* error or non-blocking */
 331         s->rstate = SSL_ST_READ_BODY;
 332
 333         p = s->packet;
 334
 335         /* Pull apart the header into the SSL3_RECORD */
 336         rr->type = *(p++);
 337         ssl_major = *(p++);
 338         ssl_minor = *(p++);
 339         version = (ssl_major << 8) | ssl_minor;
 340         n2s(p, rr->length);
 341 #if 0
 342         fprintf(stderr, "Record type=%d, Length=%d\n", rr->type, rr->length);
 343 #endif
 344
 345         /* Lets check version */
 346         if (!s->first_packet) {
 347             if (version != s->version) {
 348                 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_WRONG_VERSION_NUMBER);
 349                 if ((s->version & 0xFF00) == (version & 0xFF00)
 350                     && !s->enc_write_ctx && !s->write_hash) {
 351                     if (rr->type == SSL3_RT_ALERT) {
 352                         /*
 353                          * The record is using an incorrect version number, but
 354                          * what we've got appears to be an alert. We haven't
 355                          * read the body yet to check whether its a fatal or
 356                          * not - but chances are it is. We probably shouldn't
 357                          * send a fatal alert back. We'll just end.
 358                          */
 359                          goto err;
 360                     }
 361                     /*
 362                      * Send back error using their minor version number :-)
 363                      */
 364                     s->version = (unsigned short)version;
 365                 }
 366                 al = SSL_AD_PROTOCOL_VERSION;
 367                 goto f_err;
 368             }
 369         }
 370
 371         if ((version >> 8) != SSL3_VERSION_MAJOR) {
 372             SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_WRONG_VERSION_NUMBER);
 373             goto err;
 374         }
 375
 376         if (rr->length > s->s3->rbuf.len - SSL3_RT_HEADER_LENGTH) {
 377             al = SSL_AD_RECORD_OVERFLOW;
 378             SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_PACKET_LENGTH_TOO_LONG);
 379             goto f_err;
 380         }
 381
 382         /* now s->rstate == SSL_ST_READ_BODY */
 383     }
 384
 385     /* s->rstate == SSL_ST_READ_BODY, get and decode the data */
 386
 387     if (rr->length > s->packet_length - SSL3_RT_HEADER_LENGTH) {
 388         /* now s->packet_length == SSL3_RT_HEADER_LENGTH */
 389         i = rr->length;
 390         n = ssl3_read_n(s, i, i, 1);
 391         if (n <= 0)
 392             return (n);         /* error or non-blocking io */
 393         /*
 394          * now n == rr->length, and s->packet_length == SSL3_RT_HEADER_LENGTH
 395          * + rr->length
 396          */
 397     }
 398
 399     s->rstate = SSL_ST_READ_HEADER; /* set state for later operations */
 400
 401     /*
 402      * At this point, s->packet_length == SSL3_RT_HEADER_LNGTH + rr->length,
 403      * and we have that many bytes in s->packet
 404      */
 405     rr->input = &(s->packet[SSL3_RT_HEADER_LENGTH]);
 406
 407     /*
 408      * ok, we can now read from 's->packet' data into 'rr' rr->input points
 409      * at rr->length bytes, which need to be copied into rr->data by either
 410      * the decryption or by the decompression When the data is 'copied' into
 411      * the rr->data buffer, rr->input will be pointed at the new buffer
 412      */
 413
 414     /*
 415      * We now have - encrypted [ MAC [ compressed [ plain ] ] ] rr->length
 416      * bytes of encrypted compressed stuff.
 417      */
 418
 419     /* check is not needed I believe */
 420     if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH + extra) {
 421         al = SSL_AD_RECORD_OVERFLOW;
 422         SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
 423         goto f_err;
 424     }
 425
 426     /* decrypt in place in 'rr->input' */
 427     rr->data = rr->input;
 428
 429     enc_err = s->method->ssl3_enc->enc(s, 0);
 430     /*-
 431      * enc_err is:
 432      *    0: (in non-constant time) if the record is publically invalid.
 433      *    1: if the padding is valid
 434      *    -1: if the padding is invalid
 435      */
 436     if (enc_err == 0) {
 437         al = SSL_AD_DECRYPTION_FAILED;
 438         SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BLOCK_CIPHER_PAD_IS_WRONG);
 439         goto f_err;
 440     }
 441 #ifdef TLS_DEBUG
 442     printf("dec %d\n", rr->length);
 443     {
 444         unsigned int z;
 445         for (z = 0; z < rr->length; z++)
 446             printf("%02X%c", rr->data[z], ((z + 1) % 16) ? ' ' : '\n');
 447     }
 448     printf("\n");
 449 #endif
 450
 451     /* r->length is now the compressed data plus mac */
 452     if ((sess != NULL) &&
 453         (s->enc_read_ctx != NULL) && (EVP_MD_CTX_md(s->read_hash) != NULL)) {
 454         /* s->read_hash != NULL => mac_size != -1 */
 455         unsigned char *mac = NULL;
 456         unsigned char mac_tmp[EVP_MAX_MD_SIZE];
 457         mac_size = EVP_MD_CTX_size(s->read_hash);
 458         OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);
 459
 460         /*
 461          * kludge: *_cbc_remove_padding passes padding length in rr->type
 462          */
 463         orig_len = rr->length + ((unsigned int)rr->type >> 8);
 464
 465         /*
 466          * orig_len is the length of the record before any padding was
 467          * removed. This is public information, as is the MAC in use,
 468          * therefore we can safely process the record in a different amount
 469          * of time if it's too short to possibly contain a MAC.
 470          */
 471         if (orig_len < mac_size ||
 472             /* CBC records must have a padding length byte too. */
 473             (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
 474              orig_len < mac_size + 1)) {
 475             al = SSL_AD_DECODE_ERROR;
 476             SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_LENGTH_TOO_SHORT);
 477             goto f_err;
 478         }
 479
 480         if (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE) {
 481             /*
 482              * We update the length so that the TLS header bytes can be
 483              * constructed correctly but we need to extract the MAC in
 484              * constant time from within the record, without leaking the
 485              * contents of the padding bytes.
 486              */
 487             mac = mac_tmp;
 488             ssl3_cbc_copy_mac(mac_tmp, rr, mac_size, orig_len);
 489             rr->length -= mac_size;
 490         } else {
 491             /*
 492              * In this case there's no padding, so |orig_len| equals
 493              * |rec->length| and we checked that there's enough bytes for
 494              * |mac_size| above.
 495              */
 496             rr->length -= mac_size;
 497             mac = &rr->data[rr->length];
 498         }
 499
 500         i = s->method->ssl3_enc->mac(s, md, 0 /* not send */ );
 501         if (i < 0 || mac == NULL
 502             || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0)
 503             enc_err = -1;
 504         if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + extra + mac_size)
 505             enc_err = -1;
 506     }
 507
 508     if (enc_err < 0) {
 509         /*
 510          * A separate 'decryption_failed' alert was introduced with TLS 1.0,
 511          * SSL 3.0 only has 'bad_record_mac'.  But unless a decryption
 512          * failure is directly visible from the ciphertext anyway, we should
 513          * not reveal which kind of error occured -- this might become
 514          * visible to an attacker (e.g. via a logfile)
 515          */
 516         al = SSL_AD_BAD_RECORD_MAC;
 517         SSLerr(SSL_F_SSL3_GET_RECORD,
 518                SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
 519         goto f_err;
 520     }
 521
 522     /* r->length is now just compressed */
 523     if (s->expand != NULL) {
 524         if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + extra) {
 525             al = SSL_AD_RECORD_OVERFLOW;
 526             SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_COMPRESSED_LENGTH_TOO_LONG);
 527             goto f_err;
 528         }
 529         if (!ssl3_do_uncompress(s)) {
 530             al = SSL_AD_DECOMPRESSION_FAILURE;
 531             SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BAD_DECOMPRESSION);
 532             goto f_err;
 533         }
 534     }
 535
 536     if (rr->length > SSL3_RT_MAX_PLAIN_LENGTH + extra) {
 537         al = SSL_AD_RECORD_OVERFLOW;
 538         SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_DATA_LENGTH_TOO_LONG);
 539         goto f_err;
 540     }
 541
 542     rr->off = 0;
 543     /*-
 544      * So at this point the following is true
 545      * ssl->s3->rrec.type   is the type of record
 546      * ssl->s3->rrec.length == number of bytes in record
 547      * ssl->s3->rrec.off    == offset to first valid byte
 548      * ssl->s3->rrec.data   == where to take bytes from, increment
 549      *                         after use :-).
 550      */
 551
 552     /* we have pulled in a full packet so zero things */
 553     s->packet_length = 0;
 554
 555     /* just read a 0 length packet */
 556     if (rr->length == 0) {
 557         empty_record_count++;
 558         if (empty_record_count > MAX_EMPTY_RECORDS) {
 559             al = SSL_AD_UNEXPECTED_MESSAGE;
 560             SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_RECORD_TOO_SMALL);
 561             goto f_err;
 562         }
 563         goto again;
 564     }
 565 #if 0
 566     fprintf(stderr, "Ultimate Record type=%d, Length=%d\n", rr->type,
 567             rr->length);
 568 #endif
 569
 570     return (1);
 571
 572  f_err:
 573     ssl3_send_alert(s, SSL3_AL_FATAL, al);
 574  err:
 575     return (ret);
 576 }
 577
 578 int ssl3_do_uncompress(SSL *ssl)
 579 {
 580 #ifndef OPENSSL_NO_COMP
 581     int i;
 582     SSL3_RECORD *rr;
 583
 584     rr = &(ssl->s3->rrec);
 585     i = COMP_expand_block(ssl->expand, rr->comp,
 586                           SSL3_RT_MAX_PLAIN_LENGTH, rr->data,
 587                           (int)rr->length);
 588     if (i < 0)
 589         return (0);
 590     else
 591         rr->length = i;
 592     rr->data = rr->comp;
 593 #endif
 594     return (1);
 595 }
 596
 597 int ssl3_do_compress(SSL *ssl)
 598 {
 599 #ifndef OPENSSL_NO_COMP
 600     int i;
 601     SSL3_RECORD *wr;
 602
 603     wr = &(ssl->s3->wrec);
 604     i = COMP_compress_block(ssl->compress, wr->data,
 605                             SSL3_RT_MAX_COMPRESSED_LENGTH,
 606                             wr->input, (int)wr->length);
 607     if (i < 0)
 608         return (0);
 609     else
 610         wr->length = i;
 611
 612     wr->input = wr->data;
 613 #endif
 614     return (1);
 615 }
 616
 617 /*
 618  * Call this to write data in records of type 'type' It will return <= 0 if
 619  * not all data has been sent or non-blocking IO.
 620  */
 621 int ssl3_write_bytes(SSL *s, int type, const void *buf_, int len)
 622 {
 623     const unsigned char *buf = buf_;
 624     unsigned int n, nw;
 625     int i, tot;
 626
 627     s->rwstate = SSL_NOTHING;
 628     OPENSSL_assert(s->s3->wnum <= INT_MAX);
 629     tot = s->s3->wnum;
 630     s->s3->wnum = 0;
 631
 632     if (SSL_in_init(s) && !s->in_handshake) {
 633         i = s->handshake_func(s);
 634         if (i < 0)
 635             return (i);
 636         if (i == 0) {
 637             SSLerr(SSL_F_SSL3_WRITE_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);
 638             return -1;
 639         }
 640     }
 641
 642     /*
 643      * ensure that if we end up with a smaller value of data to write out
 644      * than the the original len from a write which didn't complete for
 645      * non-blocking I/O and also somehow ended up avoiding the check for
 646      * this in ssl3_write_pending/SSL_R_BAD_WRITE_RETRY as it must never be
 647      * possible to end up with (len-tot) as a large number that will then
 648      * promptly send beyond the end of the users buffer ... so we trap and
 649      * report the error in a way the user will notice
 650      */
 651     if (len < tot) {
 652         SSLerr(SSL_F_SSL3_WRITE_BYTES, SSL_R_BAD_LENGTH);
 653         return (-1);
 654     }
 655
 656     n = (len - tot);
 657     for (;;) {
 658         if (n > s->max_send_fragment)
 659             nw = s->max_send_fragment;
 660         else
 661             nw = n;
 662
 663         i = do_ssl3_write(s, type, &(buf[tot]), nw, 0);
 664         if (i <= 0) {
 665             s->s3->wnum = tot;
 666             return i;
 667         }
 668
 669         if ((i == (int)n) ||
 670             (type == SSL3_RT_APPLICATION_DATA &&
 671              (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE))) {
 672             /*
 673              * next chunk of data should get another prepended empty fragment
 674              * in ciphersuites with known-IV weakness:
 675              */
 676             s->s3->empty_fragment_done = 0;
 677
 678             return tot + i;
 679         }
 680
 681         n -= i;
 682         tot += i;
 683     }
 684 }
 685
 686 static int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
 687                          unsigned int len, int create_empty_fragment)
 688 {
 689     unsigned char *p, *plen;
 690     int i, mac_size, clear = 0;
 691     int prefix_len = 0;
 692     int eivlen;
 693     long align = 0;
 694     SSL3_RECORD *wr;
 695     SSL3_BUFFER *wb = &(s->s3->wbuf);
 696     SSL_SESSION *sess;
 697
 698     /*
 699      * first check if there is a SSL3_BUFFER still being written out.  This
 700      * will happen with non blocking IO
 701      */
 702     if (wb->left != 0)
 703         return (ssl3_write_pending(s, type, buf, len));
 704
 705     /* If we have an alert to send, lets send it */
 706     if (s->s3->alert_dispatch) {
 707         i = s->method->ssl_dispatch_alert(s);
 708         if (i <= 0)
 709             return (i);
 710         /* if it went, fall through and send more stuff */
 711     }
 712
 713     if (wb->buf == NULL)
 714         if (!ssl3_setup_write_buffer(s))
 715             return -1;
 716
 717     if (len == 0 && !create_empty_fragment)
 718         return 0;
 719
 720     wr = &(s->s3->wrec);
 721     sess = s->session;
 722
 723     if ((sess == NULL) ||
 724         (s->enc_write_ctx == NULL) ||
 725         (EVP_MD_CTX_md(s->write_hash) == NULL)) {
 726 #if 1
 727         clear = s->enc_write_ctx ? 0 : 1; /* must be AEAD cipher */
 728 #else
 729         clear = 1;
 730 #endif
 731         mac_size = 0;
 732     } else {
 733         mac_size = EVP_MD_CTX_size(s->write_hash);
 734         if (mac_size < 0)
 735             goto err;
 736     }
 737
 738     /*
 739      * 'create_empty_fragment' is true only when this function calls itself
 740      */
 741     if (!clear && !create_empty_fragment && !s->s3->empty_fragment_done) {
 742         /*
 743          * countermeasure against known-IV weakness in CBC ciphersuites (see
 744          * http://www.openssl.org/~bodo/tls-cbc.txt)
 745          */
 746
 747         if (s->s3->need_empty_fragments && type == SSL3_RT_APPLICATION_DATA) {
 748             /*
 749              * recursive function call with 'create_empty_fragment' set; this
 750              * prepares and buffers the data for an empty fragment (these
 751              * 'prefix_len' bytes are sent out later together with the actual
 752              * payload)
 753              */
 754             prefix_len = do_ssl3_write(s, type, buf, 0, 1);
 755             if (prefix_len <= 0)
 756                 goto err;
 757
 758             if (prefix_len >
 759                 (SSL3_RT_HEADER_LENGTH + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD))
 760             {
 761                 /* insufficient space */
 762                 SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);
 763                 goto err;
 764             }
 765         }
 766
 767         s->s3->empty_fragment_done = 1;
 768     }
 769
 770     if (create_empty_fragment) {
 771 #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0
 772         /*
 773          * extra fragment would be couple of cipher blocks, which would be
 774          * multiple of SSL3_ALIGN_PAYLOAD, so if we want to align the real
 775          * payload, then we can just pretent we simply have two headers.
 776          */
 777         align = (long)wb->buf + 2 * SSL3_RT_HEADER_LENGTH;
 778         align = (-align) & (SSL3_ALIGN_PAYLOAD - 1);
 779 #endif
 780         p = wb->buf + align;
 781         wb->offset = align;
 782     } else if (prefix_len) {
 783         p = wb->buf + wb->offset + prefix_len;
 784     } else {
 785 #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0
 786         align = (long)wb->buf + SSL3_RT_HEADER_LENGTH;
 787         align = (-align) & (SSL3_ALIGN_PAYLOAD - 1);
 788 #endif
 789         p = wb->buf + align;
 790         wb->offset = align;
 791     }
 792
 793     /* write the header */
 794
 795     *(p++) = type & 0xff;
 796     wr->type = type;
 797
 798     *(p++) = (s->version >> 8);
 799     /*
 800      * Some servers hang if iniatial client hello is larger than 256 bytes
 801      * and record version number > TLS 1.0
 802      */
 803     if (s->state == SSL3_ST_CW_CLNT_HELLO_B
 804         && !s->renegotiate && TLS1_get_version(s) > TLS1_VERSION)
 805         *(p++) = 0x1;
 806     else
 807         *(p++) = s->version & 0xff;
 808
 809     /* field where we are to write out packet length */
 810     plen = p;
 811     p += 2;
 812     /* Explicit IV length, block ciphers and TLS version 1.1 or later */
 813     if (s->enc_write_ctx && s->version >= TLS1_1_VERSION) {
 814         int mode = EVP_CIPHER_CTX_mode(s->enc_write_ctx);
 815         if (mode == EVP_CIPH_CBC_MODE) {
 816             eivlen = EVP_CIPHER_CTX_iv_length(s->enc_write_ctx);
 817             if (eivlen <= 1)
 818                 eivlen = 0;
 819         }
 820         /* Need explicit part of IV for GCM mode */
 821         else if (mode == EVP_CIPH_GCM_MODE)
 822             eivlen = EVP_GCM_TLS_EXPLICIT_IV_LEN;
 823         else
 824             eivlen = 0;
 825     } else
 826         eivlen = 0;
 827
 828     /* lets setup the record stuff. */
 829     wr->data = p + eivlen;
 830     wr->length = (int)len;
 831     wr->input = (unsigned char *)buf;
 832
 833     /*
 834      * we now 'read' from wr->input, wr->length bytes into wr->data
 835      */
 836
 837     /* first we compress */
 838     if (s->compress != NULL) {
 839         if (!ssl3_do_compress(s)) {
 840             SSLerr(SSL_F_DO_SSL3_WRITE, SSL_R_COMPRESSION_FAILURE);
 841             goto err;
 842         }
 843     } else {
 844         memcpy(wr->data, wr->input, wr->length);
 845         wr->input = wr->data;
 846     }
 847
 848     /*
 849      * we should still have the output to wr->data and the input from
 850      * wr->input.  Length should be wr->length. wr->data still points in the
 851      * wb->buf
 852      */
 853
 854     if (mac_size != 0) {
 855         if (s->method->ssl3_enc->mac(s, &(p[wr->length + eivlen]), 1) < 0)
 856             goto err;
 857         wr->length += mac_size;
 858     }
 859
 860     wr->input = p;
 861     wr->data = p;
 862
 863     if (eivlen) {
 864         /*
 865          * if (RAND_pseudo_bytes(p, eivlen) <= 0) goto err;
 866          */
 867         wr->length += eivlen;
 868     }
 869
 870     if (s->method->ssl3_enc->enc(s, 1) < 1)
 871         goto err;
 872
 873     /* record length after mac and block padding */
 874     s2n(wr->length, plen);
 875
 876     /*
 877      * we should now have wr->data pointing to the encrypted data, which is
 878      * wr->length long
 879      */
 880     wr->type = type;            /* not needed but helps for debugging */
 881     wr->length += SSL3_RT_HEADER_LENGTH;
 882
 883     if (create_empty_fragment) {
 884         /*
 885          * we are in a recursive call; just return the length, don't write
 886          * out anything here
 887          */
 888         return wr->length;
 889     }
 890
 891     /* now let's set up wb */
 892     wb->left = prefix_len + wr->length;
 893
 894     /*
 895      * memorize arguments so that ssl3_write_pending can detect bad write
 896      * retries later
 897      */
 898     s->s3->wpend_tot = len;
 899     s->s3->wpend_buf = buf;
 900     s->s3->wpend_type = type;
 901     s->s3->wpend_ret = len;
 902
 903     /* we now just need to write the buffer */
 904     return ssl3_write_pending(s, type, buf, len);
 905  err:
 906     return -1;
 907 }
 908
 909 /* if s->s3->wbuf.left != 0, we need to call this */
 910 int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
 911                        unsigned int len)
 912 {
 913     int i;
 914     SSL3_BUFFER *wb = &(s->s3->wbuf);
 915
 916 /* XXXX */
 917     if ((s->s3->wpend_tot > (int)len)
 918         || ((s->s3->wpend_buf != buf) &&
 919             !(s->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER))
 920         || (s->s3->wpend_type != type)) {
 921         SSLerr(SSL_F_SSL3_WRITE_PENDING, SSL_R_BAD_WRITE_RETRY);
 922         return (-1);
 923     }
 924
 925     for (;;) {
 926         clear_sys_error();
 927         if (s->wbio != NULL) {
 928             s->rwstate = SSL_WRITING;
 929             i = BIO_write(s->wbio,
 930                           (char *)&(wb->buf[wb->offset]),
 931                           (unsigned int)wb->left);
 932         } else {
 933             SSLerr(SSL_F_SSL3_WRITE_PENDING, SSL_R_BIO_NOT_SET);
 934             i = -1;
 935         }
 936         if (i == wb->left) {
 937             wb->left = 0;
 938             wb->offset += i;
 939             if (s->mode & SSL_MODE_RELEASE_BUFFERS &&
 940                 SSL_version(s) != DTLS1_VERSION
 941                 && SSL_version(s) != DTLS1_BAD_VER)
 942                 ssl3_release_write_buffer(s);
 943             s->rwstate = SSL_NOTHING;
 944             return (s->s3->wpend_ret);
 945         } else if (i <= 0) {
 946             if (s->version == DTLS1_VERSION || s->version == DTLS1_BAD_VER) {
 947                 /*
 948                  * For DTLS, just drop it. That's kind of the whole point in
 949                  * using a datagram service
 950                  */
 951                 wb->left = 0;
 952             }
 953             return (i);
 954         }
 955         wb->offset += i;
 956         wb->left -= i;
 957     }
 958 }
 959
 960 /*-
 961  * Return up to 'len' payload bytes received in 'type' records.
 962  * 'type' is one of the following:
 963  *
 964  *   -  SSL3_RT_HANDSHAKE (when ssl3_get_message calls us)
 965  *   -  SSL3_RT_APPLICATION_DATA (when ssl3_read calls us)
 966  *   -  0 (during a shutdown, no data has to be returned)
 967  *
 968  * If we don't have stored data to work from, read a SSL/TLS record first
 969  * (possibly multiple records if we still don't have anything to return).
 970  *
 971  * This function must handle any surprises the peer may have for us, such as
 972  * Alert records (e.g. close_notify), ChangeCipherSpec records (not really
 973  * a surprise, but handled as if it were), or renegotiation requests.
 974  * Also if record payloads contain fragments too small to process, we store
 975  * them until there is enough for the respective protocol (the record protocol
 976  * may use arbitrary fragmentation and even interleaving):
 977  *     Change cipher spec protocol
 978  *             just 1 byte needed, no need for keeping anything stored
 979  *     Alert protocol
 980  *             2 bytes needed (AlertLevel, AlertDescription)
 981  *     Handshake protocol
 982  *             4 bytes needed (HandshakeType, uint24 length) -- we just have
 983  *             to detect unexpected Client Hello and Hello Request messages
 984  *             here, anything else is handled by higher layers
 985  *     Application data protocol
 986  *             none of our business
 987  */
 988 int ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
 989 {
 990     int al, i, j, ret;
 991     unsigned int n;
 992     SSL3_RECORD *rr;
 993     void (*cb) (const SSL *ssl, int type2, int val) = NULL;
 994
 995     if (s->s3->rbuf.buf == NULL) /* Not initialized yet */
 996         if (!ssl3_setup_read_buffer(s))
 997             return (-1);
 998
 999     if ((type && (type != SSL3_RT_APPLICATION_DATA)
1000          && (type != SSL3_RT_HANDSHAKE)) || (peek
1001                                              && (type !=
1002                                                  SSL3_RT_APPLICATION_DATA))) {
1003         SSLerr(SSL_F_SSL3_READ_BYTES, ERR_R_INTERNAL_ERROR);
1004         return -1;
1005     }
1006
1007     if ((type == SSL3_RT_HANDSHAKE) && (s->s3->handshake_fragment_len > 0))
1008         /* (partially) satisfy request from storage */
1009     {
1010         unsigned char *src = s->s3->handshake_fragment;
1011         unsigned char *dst = buf;
1012         unsigned int k;
1013
1014         /* peek == 0 */
1015         n = 0;
1016         while ((len > 0) && (s->s3->handshake_fragment_len > 0)) {
1017             *dst++ = *src++;
1018             len--;
1019             s->s3->handshake_fragment_len--;
1020             n++;
1021         }
1022         /* move any remaining fragment bytes: */
1023         for (k = 0; k < s->s3->handshake_fragment_len; k++)
1024             s->s3->handshake_fragment[k] = *src++;
1025         return n;
1026     }
1027
1028     /*
1029      * Now s->s3->handshake_fragment_len == 0 if type == SSL3_RT_HANDSHAKE.
1030      */
1031
1032     if (!s->in_handshake && SSL_in_init(s)) {
1033         /* type == SSL3_RT_APPLICATION_DATA */
1034         i = s->handshake_func(s);
1035         if (i < 0)
1036             return (i);
1037         if (i == 0) {
1038             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);
1039             return (-1);
1040         }
1041     }
1042  start:
1043     s->rwstate = SSL_NOTHING;
1044
1045     /*-
1046      * s->s3->rrec.type         - is the type of record
1047      * s->s3->rrec.data,    - data
1048      * s->s3->rrec.off,     - offset into 'data' for next read
1049      * s->s3->rrec.length,  - number of bytes.
1050      */
1051     rr = &(s->s3->rrec);
1052
1053     /* get new packet if necessary */
1054     if ((rr->length == 0) || (s->rstate == SSL_ST_READ_BODY)) {
1055         ret = ssl3_get_record(s);
1056         if (ret <= 0)
1057             return (ret);
1058     }
1059
1060     /* we now have a packet which can be read and processed */
1061
1062     if (s->s3->change_cipher_spec /* set when we receive ChangeCipherSpec,
1063                                    * reset by ssl3_get_finished */
1064         && (rr->type != SSL3_RT_HANDSHAKE)) {
1065         al = SSL_AD_UNEXPECTED_MESSAGE;
1066         SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_DATA_BETWEEN_CCS_AND_FINISHED);
1067         goto f_err;
1068     }
1069
1070     /*
1071      * If the other end has shut down, throw anything we read away (even in
1072      * 'peek' mode)
1073      */
1074     if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
1075         rr->length = 0;
1076         s->rwstate = SSL_NOTHING;
1077         return (0);
1078     }
1079
1080     if (type == rr->type) {     /* SSL3_RT_APPLICATION_DATA or
1081                                  * SSL3_RT_HANDSHAKE */
1082         /*
1083          * make sure that we are not getting application data when we are
1084          * doing a handshake for the first time
1085          */
1086         if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) &&
1087             (s->enc_read_ctx == NULL)) {
1088             al = SSL_AD_UNEXPECTED_MESSAGE;
1089             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_APP_DATA_IN_HANDSHAKE);
1090             goto f_err;
1091         }
1092
1093         if (len <= 0)
1094             return (len);
1095
1096         if ((unsigned int)len > rr->length)
1097             n = rr->length;
1098         else
1099             n = (unsigned int)len;
1100
1101         memcpy(buf, &(rr->data[rr->off]), n);
1102         if (!peek) {
1103             rr->length -= n;
1104             rr->off += n;
1105             if (rr->length == 0) {
1106                 s->rstate = SSL_ST_READ_HEADER;
1107                 rr->off = 0;
1108                 if (s->mode & SSL_MODE_RELEASE_BUFFERS
1109                     && s->s3->rbuf.left == 0)
1110                     ssl3_release_read_buffer(s);
1111             }
1112         }
1113         return (n);
1114     }
1115
1116     /*
1117      * If we get here, then type != rr->type; if we have a handshake message,
1118      * then it was unexpected (Hello Request or Client Hello).
1119      */
1120
1121     /*
1122      * In case of record types for which we have 'fragment' storage, fill
1123      * that so that we can process the data at a fixed place.
1124      */
1125     {
1126         unsigned int dest_maxlen = 0;
1127         unsigned char *dest = NULL;
1128         unsigned int *dest_len = NULL;
1129
1130         if (rr->type == SSL3_RT_HANDSHAKE) {
1131             dest_maxlen = sizeof s->s3->handshake_fragment;
1132             dest = s->s3->handshake_fragment;
1133             dest_len = &s->s3->handshake_fragment_len;
1134         } else if (rr->type == SSL3_RT_ALERT) {
1135             dest_maxlen = sizeof s->s3->alert_fragment;
1136             dest = s->s3->alert_fragment;
1137             dest_len = &s->s3->alert_fragment_len;
1138         }
1139 #ifndef OPENSSL_NO_HEARTBEATS
1140         else if (rr->type == TLS1_RT_HEARTBEAT) {
1141             tls1_process_heartbeat(s);
1142
1143             /* Exit and notify application to read again */
1144             rr->length = 0;
1145             s->rwstate = SSL_READING;
1146             BIO_clear_retry_flags(SSL_get_rbio(s));
1147             BIO_set_retry_read(SSL_get_rbio(s));
1148             return (-1);
1149         }
1150 #endif
1151
1152         if (dest_maxlen > 0) {
1153             n = dest_maxlen - *dest_len; /* available space in 'dest' */
1154             if (rr->length < n)
1155                 n = rr->length; /* available bytes */
1156
1157             /* now move 'n' bytes: */
1158             while (n-- > 0) {
1159                 dest[(*dest_len)++] = rr->data[rr->off++];
1160                 rr->length--;
1161             }
1162
1163             if (*dest_len < dest_maxlen)
1164                 goto start;     /* fragment was too small */
1165         }
1166     }
1167
1168     /*-
1169      * s->s3->handshake_fragment_len == 4  iff  rr->type == SSL3_RT_HANDSHAKE;
1170      * s->s3->alert_fragment_len == 2      iff  rr->type == SSL3_RT_ALERT.
1171      * (Possibly rr is 'empty' now, i.e. rr->length may be 0.)
1172      */
1173
1174     /* If we are a client, check for an incoming 'Hello Request': */
1175     if ((!s->server) &&
1176         (s->s3->handshake_fragment_len >= 4) &&
1177         (s->s3->handshake_fragment[0] == SSL3_MT_HELLO_REQUEST) &&
1178         (s->session != NULL) && (s->session->cipher != NULL)) {
1179         s->s3->handshake_fragment_len = 0;
1180
1181         if ((s->s3->handshake_fragment[1] != 0) ||
1182             (s->s3->handshake_fragment[2] != 0) ||
1183             (s->s3->handshake_fragment[3] != 0)) {
1184             al = SSL_AD_DECODE_ERROR;
1185             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_BAD_HELLO_REQUEST);
1186             goto f_err;
1187         }
1188
1189         if (s->msg_callback)
1190             s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE,
1191                             s->s3->handshake_fragment, 4, s,
1192                             s->msg_callback_arg);
1193
1194         if (SSL_is_init_finished(s) &&
1195             !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS) &&
1196             !s->s3->renegotiate) {
1197             ssl3_renegotiate(s);
1198             if (ssl3_renegotiate_check(s)) {
1199                 i = s->handshake_func(s);
1200                 if (i < 0)
1201                     return (i);
1202                 if (i == 0) {
1203                     SSLerr(SSL_F_SSL3_READ_BYTES,
1204                            SSL_R_SSL_HANDSHAKE_FAILURE);
1205                     return (-1);
1206                 }
1207
1208                 if (!(s->mode & SSL_MODE_AUTO_RETRY)) {
1209                     if (s->s3->rbuf.left == 0) { /* no read-ahead left? */
1210                         BIO *bio;
1211                         /*
1212                          * In the case where we try to read application data,
1213                          * but we trigger an SSL handshake, we return -1 with
1214                          * the retry option set.  Otherwise renegotiation may
1215                          * cause nasty problems in the blocking world
1216                          */
1217                         s->rwstate = SSL_READING;
1218                         bio = SSL_get_rbio(s);
1219                         BIO_clear_retry_flags(bio);
1220                         BIO_set_retry_read(bio);
1221                         return (-1);
1222                     }
1223                 }
1224             }
1225         }
1226         /*
1227          * we either finished a handshake or ignored the request, now try
1228          * again to obtain the (application) data we were asked for
1229          */
1230         goto start;
1231     }
1232     /*
1233      * If we are a server and get a client hello when renegotiation isn't
1234      * allowed send back a no renegotiation alert and carry on. WARNING:
1235      * experimental code, needs reviewing (steve)
1236      */
1237     if (s->server &&
1238         SSL_is_init_finished(s) &&
1239         !s->s3->send_connection_binding &&
1240         (s->version > SSL3_VERSION) &&
1241         (s->s3->handshake_fragment_len >= 4) &&
1242         (s->s3->handshake_fragment[0] == SSL3_MT_CLIENT_HELLO) &&
1243         (s->session != NULL) && (s->session->cipher != NULL) &&
1244         !(s->ctx->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
1245         /*
1246          * s->s3->handshake_fragment_len = 0;
1247          */
1248         rr->length = 0;
1249         ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_RENEGOTIATION);
1250         goto start;
1251     }
1252     if (s->s3->alert_fragment_len >= 2) {
1253         int alert_level = s->s3->alert_fragment[0];
1254         int alert_descr = s->s3->alert_fragment[1];
1255
1256         s->s3->alert_fragment_len = 0;
1257
1258         if (s->msg_callback)
1259             s->msg_callback(0, s->version, SSL3_RT_ALERT,
1260                             s->s3->alert_fragment, 2, s, s->msg_callback_arg);
1261
1262         if (s->info_callback != NULL)
1263             cb = s->info_callback;
1264         else if (s->ctx->info_callback != NULL)
1265             cb = s->ctx->info_callback;
1266
1267         if (cb != NULL) {
1268             j = (alert_level << 8) | alert_descr;
1269             cb(s, SSL_CB_READ_ALERT, j);
1270         }
1271
1272         if (alert_level == SSL3_AL_WARNING) {
1273             s->s3->warn_alert = alert_descr;
1274             if (alert_descr == SSL_AD_CLOSE_NOTIFY) {
1275                 s->shutdown |= SSL_RECEIVED_SHUTDOWN;
1276                 return (0);
1277             }
1278             /*
1279              * This is a warning but we receive it if we requested
1280              * renegotiation and the peer denied it. Terminate with a fatal
1281              * alert because if application tried to renegotiatie it
1282              * presumably had a good reason and expects it to succeed. In
1283              * future we might have a renegotiation where we don't care if
1284              * the peer refused it where we carry on.
1285              */
1286             else if (alert_descr == SSL_AD_NO_RENEGOTIATION) {
1287                 al = SSL_AD_HANDSHAKE_FAILURE;
1288                 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_NO_RENEGOTIATION);
1289                 goto f_err;
1290             }
1291 #ifdef SSL_AD_MISSING_SRP_USERNAME
1292             else if (alert_descr == SSL_AD_MISSING_SRP_USERNAME)
1293                 return (0);
1294 #endif
1295         } else if (alert_level == SSL3_AL_FATAL) {
1296             char tmp[16];
1297
1298             s->rwstate = SSL_NOTHING;
1299             s->s3->fatal_alert = alert_descr;
1300             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_AD_REASON_OFFSET + alert_descr);
1301             BIO_snprintf(tmp, sizeof tmp, "%d", alert_descr);
1302             ERR_add_error_data(2, "SSL alert number ", tmp);
1303             s->shutdown |= SSL_RECEIVED_SHUTDOWN;
1304             SSL_CTX_remove_session(s->ctx, s->session);
1305             return (0);
1306         } else {
1307             al = SSL_AD_ILLEGAL_PARAMETER;
1308             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_UNKNOWN_ALERT_TYPE);
1309             goto f_err;
1310         }
1311
1312         goto start;
1313     }
1314
1315     if (s->shutdown & SSL_SENT_SHUTDOWN) { /* but we have not received a
1316                                             * shutdown */
1317         s->rwstate = SSL_NOTHING;
1318         rr->length = 0;
1319         return (0);
1320     }
1321
1322     if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) {
1323         /*
1324          * 'Change Cipher Spec' is just a single byte, so we know exactly
1325          * what the record payload has to look like
1326          */
1327         if ((rr->length != 1) || (rr->off != 0) ||
1328             (rr->data[0] != SSL3_MT_CCS)) {
1329             al = SSL_AD_ILLEGAL_PARAMETER;
1330             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_BAD_CHANGE_CIPHER_SPEC);
1331             goto f_err;
1332         }
1333
1334         /* Check we have a cipher to change to */
1335         if (s->s3->tmp.new_cipher == NULL) {
1336             al = SSL_AD_UNEXPECTED_MESSAGE;
1337             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_CCS_RECEIVED_EARLY);
1338             goto f_err;
1339         }
1340
1341         if (!(s->s3->flags & SSL3_FLAGS_CCS_OK)) {
1342             al = SSL_AD_UNEXPECTED_MESSAGE;
1343             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_CCS_RECEIVED_EARLY);
1344             goto f_err;
1345         }
1346
1347         s->s3->flags &= ~SSL3_FLAGS_CCS_OK;
1348
1349         rr->length = 0;
1350
1351         if (s->msg_callback)
1352             s->msg_callback(0, s->version, SSL3_RT_CHANGE_CIPHER_SPEC,
1353                             rr->data, 1, s, s->msg_callback_arg);
1354
1355         s->s3->change_cipher_spec = 1;
1356         if (!ssl3_do_change_cipher_spec(s))
1357             goto err;
1358         else
1359             goto start;
1360     }
1361
1362     /*
1363      * Unexpected handshake message (Client Hello, or protocol violation)
1364      */
1365     if ((s->s3->handshake_fragment_len >= 4) && !s->in_handshake) {
1366         if (((s->state & SSL_ST_MASK) == SSL_ST_OK) &&
1367             !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS)) {
1368 #if 0                           /* worked only because C operator preferences
1369                                  * are not as expected (and because this is
1370                                  * not really needed for clients except for
1371                                  * detecting protocol violations): */
1372             s->state = SSL_ST_BEFORE | (s->server)
1373                 ? SSL_ST_ACCEPT : SSL_ST_CONNECT;
1374 #else
1375             s->state = s->server ? SSL_ST_ACCEPT : SSL_ST_CONNECT;
1376 #endif
1377             s->renegotiate = 1;
1378             s->new_session = 1;
1379         }
1380         i = s->handshake_func(s);
1381         if (i < 0)
1382             return (i);
1383         if (i == 0) {
1384             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);
1385             return (-1);
1386         }
1387
1388         if (!(s->mode & SSL_MODE_AUTO_RETRY)) {
1389             if (s->s3->rbuf.left == 0) { /* no read-ahead left? */
1390                 BIO *bio;
1391                 /*
1392                  * In the case where we try to read application data, but we
1393                  * trigger an SSL handshake, we return -1 with the retry
1394                  * option set.  Otherwise renegotiation may cause nasty
1395                  * problems in the blocking world
1396                  */
1397                 s->rwstate = SSL_READING;
1398                 bio = SSL_get_rbio(s);
1399                 BIO_clear_retry_flags(bio);
1400                 BIO_set_retry_read(bio);
1401                 return (-1);
1402             }
1403         }
1404         goto start;
1405     }
1406
1407     switch (rr->type) {
1408     default:
1409 #ifndef OPENSSL_NO_TLS
1410         /*
1411          * TLS up to v1.1 just ignores unknown message types: TLS v1.2 give
1412          * an unexpected message alert.
1413          */
1414         if (s->version >= TLS1_VERSION && s->version <= TLS1_1_VERSION) {
1415             rr->length = 0;
1416             goto start;
1417         }
1418 #endif
1419         al = SSL_AD_UNEXPECTED_MESSAGE;
1420         SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_UNEXPECTED_RECORD);
1421         goto f_err;
1422     case SSL3_RT_CHANGE_CIPHER_SPEC:
1423     case SSL3_RT_ALERT:
1424     case SSL3_RT_HANDSHAKE:
1425         /*
1426          * we already handled all of these, with the possible exception of
1427          * SSL3_RT_HANDSHAKE when s->in_handshake is set, but that should not
1428          * happen when type != rr->type
1429          */
1430         al = SSL_AD_UNEXPECTED_MESSAGE;
1431         SSLerr(SSL_F_SSL3_READ_BYTES, ERR_R_INTERNAL_ERROR);
1432         goto f_err;
1433     case SSL3_RT_APPLICATION_DATA:
1434         /*
1435          * At this point, we were expecting handshake data, but have
1436          * application data.  If the library was running inside ssl3_read()
1437          * (i.e. in_read_app_data is set) and it makes sense to read
1438          * application data at this point (session renegotiation not yet
1439          * started), we will indulge it.
1440          */
1441         if (s->s3->in_read_app_data &&
1442             (s->s3->total_renegotiations != 0) &&
1443             (((s->state & SSL_ST_CONNECT) &&
1444               (s->state >= SSL3_ST_CW_CLNT_HELLO_A) &&
1445               (s->state <= SSL3_ST_CR_SRVR_HELLO_A)
1446              ) || ((s->state & SSL_ST_ACCEPT) &&
1447                    (s->state <= SSL3_ST_SW_HELLO_REQ_A) &&
1448                    (s->state >= SSL3_ST_SR_CLNT_HELLO_A)
1449              )
1450             )) {
1451             s->s3->in_read_app_data = 2;
1452             return (-1);
1453         } else {
1454             al = SSL_AD_UNEXPECTED_MESSAGE;
1455             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_UNEXPECTED_RECORD);
1456             goto f_err;
1457         }
1458     }
1459     /* not reached */
1460
1461  f_err:
1462     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1463  err:
1464     return (-1);
1465 }
1466
1467 int ssl3_do_change_cipher_spec(SSL *s)
1468 {
1469     int i;
1470     const char *sender;
1471     int slen;
1472
1473     if (s->state & SSL_ST_ACCEPT)
1474         i = SSL3_CHANGE_CIPHER_SERVER_READ;
1475     else
1476         i = SSL3_CHANGE_CIPHER_CLIENT_READ;
1477
1478     if (s->s3->tmp.key_block == NULL) {
1479         if (s->session == NULL || s->session->master_key_length == 0) {
1480             /* might happen if dtls1_read_bytes() calls this */
1481             SSLerr(SSL_F_SSL3_DO_CHANGE_CIPHER_SPEC,
1482                    SSL_R_CCS_RECEIVED_EARLY);
1483             return (0);
1484         }
1485
1486         s->session->cipher = s->s3->tmp.new_cipher;
1487         if (!s->method->ssl3_enc->setup_key_block(s))
1488             return (0);
1489     }
1490
1491     if (!s->method->ssl3_enc->change_cipher_state(s, i))
1492         return (0);
1493
1494     /*
1495      * we have to record the message digest at this point so we can get it
1496      * before we read the finished message
1497      */
1498     if (s->state & SSL_ST_CONNECT) {
1499         sender = s->method->ssl3_enc->server_finished_label;
1500         slen = s->method->ssl3_enc->server_finished_label_len;
1501     } else {
1502         sender = s->method->ssl3_enc->client_finished_label;
1503         slen = s->method->ssl3_enc->client_finished_label_len;
1504     }
1505
1506     i = s->method->ssl3_enc->final_finish_mac(s,
1507                                               sender, slen,
1508                                               s->s3->tmp.peer_finish_md);
1509     if (i == 0) {
1510         SSLerr(SSL_F_SSL3_DO_CHANGE_CIPHER_SPEC, ERR_R_INTERNAL_ERROR);
1511         return 0;
1512     }
1513     s->s3->tmp.peer_finish_md_len = i;
1514
1515     return (1);
1516 }
1517
1518 int ssl3_send_alert(SSL *s, int level, int desc)
1519 {
1520     /* Map tls/ssl alert value to correct one */
1521     desc = s->method->ssl3_enc->alert_value(desc);
1522     if (s->version == SSL3_VERSION && desc == SSL_AD_PROTOCOL_VERSION)
1523         desc = SSL_AD_HANDSHAKE_FAILURE; /* SSL 3.0 does not have
1524                                           * protocol_version alerts */
1525     if (desc < 0)
1526         return -1;
1527     /* If a fatal one, remove from cache */
1528     if ((level == 2) && (s->session != NULL))
1529         SSL_CTX_remove_session(s->ctx, s->session);
1530
1531     s->s3->alert_dispatch = 1;
1532     s->s3->send_alert[0] = level;
1533     s->s3->send_alert[1] = desc;
1534     if (s->s3->wbuf.left == 0)  /* data still being written out? */
1535         return s->method->ssl_dispatch_alert(s);
1536     /*
1537      * else data is still being written out, we will get written some time in
1538      * the future
1539      */
1540     return -1;
1541 }
1542
1543 int ssl3_dispatch_alert(SSL *s)
1544 {
1545     int i, j;
1546     void (*cb) (const SSL *ssl, int type, int val) = NULL;
1547
1548     s->s3->alert_dispatch = 0;
1549     i = do_ssl3_write(s, SSL3_RT_ALERT, &s->s3->send_alert[0], 2, 0);
1550     if (i <= 0) {
1551         s->s3->alert_dispatch = 1;
1552     } else {
1553         /*
1554          * Alert sent to BIO.  If it is important, flush it now. If the
1555          * message does not get sent due to non-blocking IO, we will not
1556          * worry too much.
1557          */
1558         if (s->s3->send_alert[0] == SSL3_AL_FATAL)
1559             (void)BIO_flush(s->wbio);
1560
1561         if (s->msg_callback)
1562             s->msg_callback(1, s->version, SSL3_RT_ALERT, s->s3->send_alert,
1563                             2, s, s->msg_callback_arg);
1564
1565         if (s->info_callback != NULL)
1566             cb = s->info_callback;
1567         else if (s->ctx->info_callback != NULL)
1568             cb = s->ctx->info_callback;
1569
1570         if (cb != NULL) {
1571             j = (s->s3->send_alert[0] << 8) | s->s3->send_alert[1];
1572             cb(s, SSL_CB_WRITE_ALERT, j);
1573         }
1574     }
1575     return (i);
1576 }