ssl/record/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 #ifndef  EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
 122 # define EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0
 123 #endif
 124
 125 #if     defined(OPENSSL_SMALL_FOOTPRINT) || \
 126         !(      defined(AES_ASM) &&     ( \
 127                 defined(__x86_64)       || defined(__x86_64__)  || \
 128                 defined(_M_AMD64)       || defined(_M_X64)      || \
 129                 defined(__INTEL__)      ) \
 130         )
 131 # undef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
 132 # define EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0
 133 #endif
 134
 135 void RECORD_LAYER_init(RECORD_LAYER *rl, SSL *s)
 136 {
 137     rl->s = s;
 138     SSL3_RECORD_clear(&rl->rrec);
 139     SSL3_RECORD_clear(&rl->wrec);
 140 }
 141
 142 void RECORD_LAYER_clear(RECORD_LAYER *rl)
 143 {
 144     unsigned char *rp, *wp;
 145     size_t rlen, wlen;
 146     int read_ahead;
 147     SSL *s;
 148
 149     s = rl->s;
 150     read_ahead = rl->read_ahead;
 151     rp = SSL3_BUFFER_get_buf(&rl->rbuf);
 152     rlen = SSL3_BUFFER_get_len(&rl->rbuf);
 153     wp = SSL3_BUFFER_get_buf(&rl->wbuf);
 154     wlen = SSL3_BUFFER_get_len(&rl->wbuf);
 155     memset(rl, 0, sizeof (RECORD_LAYER));
 156     SSL3_BUFFER_set_buf(&rl->rbuf, rp);
 157     SSL3_BUFFER_set_len(&rl->rbuf, rlen);
 158     SSL3_BUFFER_set_buf(&rl->wbuf, wp);
 159     SSL3_BUFFER_set_len(&rl->wbuf, wlen);
 160
 161     /* Do I need to do this? As far as I can tell read_ahead did not
 162      * previously get reset by SSL_clear...so I'll keep it that way..but is
 163      * that right?
 164      */
 165     rl->read_ahead = read_ahead;
 166     rl->s = s;
 167 }
 168
 169 void RECORD_LAYER_release(RECORD_LAYER *rl)
 170 {
 171     if (SSL3_BUFFER_is_initialised(&rl->rbuf))
 172         ssl3_release_read_buffer(rl->s);
 173     if (SSL3_BUFFER_is_initialised(&rl->wbuf))
 174         ssl3_release_write_buffer(rl->s);
 175     SSL3_RECORD_release(&rl->rrec);
 176 }
 177
 178 int RECORD_LAYER_read_pending(RECORD_LAYER *rl)
 179 {
 180     return SSL3_BUFFER_get_left(&rl->rbuf) != 0;
 181 }
 182
 183 int RECORD_LAYER_write_pending(RECORD_LAYER *rl)
 184 {
 185     return SSL3_BUFFER_get_left(&rl->wbuf) != 0;
 186 }
 187
 188 int RECORD_LAYER_set_data(RECORD_LAYER *rl, const unsigned char *buf, int len)
 189 {
 190     rl->s->packet_length = len;
 191     if(len != 0) {
 192         rl->s->rstate = SSL_ST_READ_HEADER;
 193         if (!SSL3_BUFFER_is_initialised(&rl->rbuf))
 194             if (!ssl3_setup_read_buffer(rl->s))
 195                 return 0;
 196     }
 197
 198     rl->s->packet = SSL3_BUFFER_get_buf(&rl->rbuf);
 199     SSL3_BUFFER_set_data(&rl->rbuf, buf, len);
 200
 201     return 1;
 202 }
 203
 204 int ssl3_read_n(SSL *s, int n, int max, int extend)
 205 {
 206     /*
 207      * If extend == 0, obtain new n-byte packet; if extend == 1, increase
 208      * packet by another n bytes. The packet will be in the sub-array of
 209      * s->s3->rbuf.buf specified by s->packet and s->packet_length. (If
 210      * s->rlayer.read_ahead is set, 'max' bytes may be stored in rbuf [plus
 211      * s->packet_length bytes if extend == 1].)
 212      */
 213     int i, len, left;
 214     long align = 0;
 215     unsigned char *pkt;
 216     SSL3_BUFFER *rb;
 217
 218     if (n <= 0)
 219         return n;
 220
 221     rb = RECORD_LAYER_get_rbuf(&s->rlayer);
 222     if (rb->buf == NULL)
 223         if (!ssl3_setup_read_buffer(s))
 224             return -1;
 225
 226     left = rb->left;
 227 #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0
 228     align = (long)rb->buf + SSL3_RT_HEADER_LENGTH;
 229     align = (-align) & (SSL3_ALIGN_PAYLOAD - 1);
 230 #endif
 231
 232     if (!extend) {
 233         /* start with empty packet ... */
 234         if (left == 0)
 235             rb->offset = align;
 236         else if (align != 0 && left >= SSL3_RT_HEADER_LENGTH) {
 237             /*
 238              * check if next packet length is large enough to justify payload
 239              * alignment...
 240              */
 241             pkt = rb->buf + rb->offset;
 242             if (pkt[0] == SSL3_RT_APPLICATION_DATA
 243                 && (pkt[3] << 8 | pkt[4]) >= 128) {
 244                 /*
 245                  * Note that even if packet is corrupted and its length field
 246                  * is insane, we can only be led to wrong decision about
 247                  * whether memmove will occur or not. Header values has no
 248                  * effect on memmove arguments and therefore no buffer
 249                  * overrun can be triggered.
 250                  */
 251                 memmove(rb->buf + align, pkt, left);
 252                 rb->offset = align;
 253             }
 254         }
 255         s->packet = rb->buf + rb->offset;
 256         s->packet_length = 0;
 257         /* ... now we can act as if 'extend' was set */
 258     }
 259
 260     /*
 261      * For DTLS/UDP reads should not span multiple packets because the read
 262      * operation returns the whole packet at once (as long as it fits into
 263      * the buffer).
 264      */
 265     if (SSL_IS_DTLS(s)) {
 266         if (left == 0 && extend)
 267             return 0;
 268         if (left > 0 && n > left)
 269             n = left;
 270     }
 271
 272     /* if there is enough in the buffer from a previous read, take some */
 273     if (left >= n) {
 274         s->packet_length += n;
 275         rb->left = left - n;
 276         rb->offset += n;
 277         return (n);
 278     }
 279
 280     /* else we need to read more data */
 281
 282     len = s->packet_length;
 283     pkt = rb->buf + align;
 284     /*
 285      * Move any available bytes to front of buffer: 'len' bytes already
 286      * pointed to by 'packet', 'left' extra ones at the end
 287      */
 288     if (s->packet != pkt) {     /* len > 0 */
 289         memmove(pkt, s->packet, len + left);
 290         s->packet = pkt;
 291         rb->offset = len + align;
 292     }
 293
 294     if (n > (int)(rb->len - rb->offset)) { /* does not happen */
 295         SSLerr(SSL_F_SSL3_READ_N, ERR_R_INTERNAL_ERROR);
 296         return -1;
 297     }
 298
 299     /* We always act like read_ahead is set for DTLS */
 300     if (!RECORD_LAYER_get_read_ahead(&s->rlayer) && !SSL_IS_DTLS(s))
 301         /* ignore max parameter */
 302         max = n;
 303     else {
 304         if (max < n)
 305             max = n;
 306         if (max > (int)(rb->len - rb->offset))
 307             max = rb->len - rb->offset;
 308     }
 309
 310     while (left < n) {
 311         /*
 312          * Now we have len+left bytes at the front of s->s3->rbuf.buf and
 313          * need to read in more until we have len+n (up to len+max if
 314          * possible)
 315          */
 316
 317         clear_sys_error();
 318         if (s->rbio != NULL) {
 319             s->rwstate = SSL_READING;
 320             i = BIO_read(s->rbio, pkt + len + left, max - left);
 321         } else {
 322             SSLerr(SSL_F_SSL3_READ_N, SSL_R_READ_BIO_NOT_SET);
 323             i = -1;
 324         }
 325
 326         if (i <= 0) {
 327             rb->left = left;
 328             if (s->mode & SSL_MODE_RELEASE_BUFFERS && !SSL_IS_DTLS(s))
 329                 if (len + left == 0)
 330                     ssl3_release_read_buffer(s);
 331             return (i);
 332         }
 333         left += i;
 334         /*
 335          * reads should *never* span multiple packets for DTLS because the
 336          * underlying transport protocol is message oriented as opposed to
 337          * byte oriented as in the TLS case.
 338          */
 339         if (SSL_IS_DTLS(s)) {
 340             if (n > left)
 341                 n = left;       /* makes the while condition false */
 342         }
 343     }
 344
 345     /* done reading, now the book-keeping */
 346     rb->offset += n;
 347     rb->left = left - n;
 348     s->packet_length += n;
 349     s->rwstate = SSL_NOTHING;
 350     return (n);
 351 }
 352
 353
 354 /*
 355  * Call this to write data in records of type 'type' It will return <= 0 if
 356  * not all data has been sent or non-blocking IO.
 357  */
 358 int ssl3_write_bytes(SSL *s, int type, const void *buf_, int len)
 359 {
 360     const unsigned char *buf = buf_;
 361     int tot;
 362     unsigned int n, nw;
 363 #if !defined(OPENSSL_NO_MULTIBLOCK) && EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
 364     unsigned int max_send_fragment;
 365 #endif
 366     SSL3_BUFFER *wb = RECORD_LAYER_get_wbuf(&s->rlayer);
 367     int i;
 368     unsigned int u_len = (unsigned int)len;
 369
 370     if (len < 0) {
 371         SSLerr(SSL_F_SSL3_WRITE_BYTES, SSL_R_SSL_NEGATIVE_LENGTH);
 372         return -1;
 373     }
 374
 375     s->rwstate = SSL_NOTHING;
 376     OPENSSL_assert(s->s3->wnum <= INT_MAX);
 377     tot = s->s3->wnum;
 378     s->s3->wnum = 0;
 379
 380     if (SSL_in_init(s) && !s->in_handshake) {
 381         i = s->handshake_func(s);
 382         if (i < 0)
 383             return (i);
 384         if (i == 0) {
 385             SSLerr(SSL_F_SSL3_WRITE_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);
 386             return -1;
 387         }
 388     }
 389
 390     /*
 391      * ensure that if we end up with a smaller value of data to write out
 392      * than the the original len from a write which didn't complete for
 393      * non-blocking I/O and also somehow ended up avoiding the check for
 394      * this in ssl3_write_pending/SSL_R_BAD_WRITE_RETRY as it must never be
 395      * possible to end up with (len-tot) as a large number that will then
 396      * promptly send beyond the end of the users buffer ... so we trap and
 397      * report the error in a way the user will notice
 398      */
 399     if (len < tot) {
 400         SSLerr(SSL_F_SSL3_WRITE_BYTES, SSL_R_BAD_LENGTH);
 401         return (-1);
 402     }
 403
 404     /*
 405      * first check if there is a SSL3_BUFFER still being written out.  This
 406      * will happen with non blocking IO
 407      */
 408     if (wb->left != 0) {
 409         i = ssl3_write_pending(s, type, &buf[tot], s->s3->wpend_tot);
 410         if (i <= 0) {
 411             /* XXX should we ssl3_release_write_buffer if i<0? */
 412             s->s3->wnum = tot;
 413             return i;
 414         }
 415         tot += i;               /* this might be last fragment */
 416     }
 417 #if !defined(OPENSSL_NO_MULTIBLOCK) && EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
 418     /*
 419      * Depending on platform multi-block can deliver several *times*
 420      * better performance. Downside is that it has to allocate
 421      * jumbo buffer to accomodate up to 8 records, but the
 422      * compromise is considered worthy.
 423      */
 424     if (type == SSL3_RT_APPLICATION_DATA &&
 425         u_len >= 4 * (max_send_fragment = s->max_send_fragment) &&
 426         s->compress == NULL && s->msg_callback == NULL &&
 427         !SSL_USE_ETM(s) && SSL_USE_EXPLICIT_IV(s) &&
 428         EVP_CIPHER_flags(s->enc_write_ctx->cipher) &
 429         EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK) {
 430         unsigned char aad[13];
 431         EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
 432         int packlen;
 433
 434         /* minimize address aliasing conflicts */
 435         if ((max_send_fragment & 0xfff) == 0)
 436             max_send_fragment -= 512;
 437
 438         if (tot == 0 || wb->buf == NULL) { /* allocate jumbo buffer */
 439             ssl3_release_write_buffer(s);
 440
 441             packlen = EVP_CIPHER_CTX_ctrl(s->enc_write_ctx,
 442                                           EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE,
 443                                           max_send_fragment, NULL);
 444
 445             if (u_len >= 8 * max_send_fragment)
 446                 packlen *= 8;
 447             else
 448                 packlen *= 4;
 449
 450             wb->buf = OPENSSL_malloc(packlen);
 451             if(!wb->buf) {
 452                 SSLerr(SSL_F_SSL3_WRITE_BYTES, ERR_R_MALLOC_FAILURE);
 453                 return -1;
 454             }
 455             wb->len = packlen;
 456         } else if (tot == len) { /* done? */
 457             OPENSSL_free(wb->buf); /* free jumbo buffer */
 458             wb->buf = NULL;
 459             return tot;
 460         }
 461
 462         n = (len - tot);
 463         for (;;) {
 464             if (n < 4 * max_send_fragment) {
 465                 OPENSSL_free(wb->buf); /* free jumbo buffer */
 466                 wb->buf = NULL;
 467                 break;
 468             }
 469
 470             if (s->s3->alert_dispatch) {
 471                 i = s->method->ssl_dispatch_alert(s);
 472                 if (i <= 0) {
 473                     s->s3->wnum = tot;
 474                     return i;
 475                 }
 476             }
 477
 478             if (n >= 8 * max_send_fragment)
 479                 nw = max_send_fragment * (mb_param.interleave = 8);
 480             else
 481                 nw = max_send_fragment * (mb_param.interleave = 4);
 482
 483             memcpy(aad, s->s3->write_sequence, 8);
 484             aad[8] = type;
 485             aad[9] = (unsigned char)(s->version >> 8);
 486             aad[10] = (unsigned char)(s->version);
 487             aad[11] = 0;
 488             aad[12] = 0;
 489             mb_param.out = NULL;
 490             mb_param.inp = aad;
 491             mb_param.len = nw;
 492
 493             packlen = EVP_CIPHER_CTX_ctrl(s->enc_write_ctx,
 494                                           EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
 495                                           sizeof(mb_param), &mb_param);
 496
 497             if (packlen <= 0 || packlen > (int)wb->len) { /* never happens */
 498                 OPENSSL_free(wb->buf); /* free jumbo buffer */
 499                 wb->buf = NULL;
 500                 break;
 501             }
 502
 503             mb_param.out = wb->buf;
 504             mb_param.inp = &buf[tot];
 505             mb_param.len = nw;
 506
 507             if (EVP_CIPHER_CTX_ctrl(s->enc_write_ctx,
 508                                     EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
 509                                     sizeof(mb_param), &mb_param) <= 0)
 510                 return -1;
 511
 512             s->s3->write_sequence[7] += mb_param.interleave;
 513             if (s->s3->write_sequence[7] < mb_param.interleave) {
 514                 int j = 6;
 515                 while (j >= 0 && (++s->s3->write_sequence[j--]) == 0) ;
 516             }
 517
 518             wb->offset = 0;
 519             wb->left = packlen;
 520
 521             s->s3->wpend_tot = nw;
 522             s->s3->wpend_buf = &buf[tot];
 523             s->s3->wpend_type = type;
 524             s->s3->wpend_ret = nw;
 525
 526             i = ssl3_write_pending(s, type, &buf[tot], nw);
 527             if (i <= 0) {
 528                 if (i < 0 && (!s->wbio || !BIO_should_retry(s->wbio))) {
 529                     OPENSSL_free(wb->buf);
 530                     wb->buf = NULL;
 531                 }
 532                 s->s3->wnum = tot;
 533                 return i;
 534             }
 535             if (i == (int)n) {
 536                 OPENSSL_free(wb->buf); /* free jumbo buffer */
 537                 wb->buf = NULL;
 538                 return tot + i;
 539             }
 540             n -= i;
 541             tot += i;
 542         }
 543     } else
 544 #endif
 545     if (tot == len) {           /* done? */
 546         if (s->mode & SSL_MODE_RELEASE_BUFFERS && !SSL_IS_DTLS(s))
 547             ssl3_release_write_buffer(s);
 548
 549         return tot;
 550     }
 551
 552     n = (len - tot);
 553     for (;;) {
 554         if (n > s->max_send_fragment)
 555             nw = s->max_send_fragment;
 556         else
 557             nw = n;
 558
 559         i = do_ssl3_write(s, type, &(buf[tot]), nw, 0);
 560         if (i <= 0) {
 561             /* XXX should we ssl3_release_write_buffer if i<0? */
 562             s->s3->wnum = tot;
 563             return i;
 564         }
 565
 566         if ((i == (int)n) ||
 567             (type == SSL3_RT_APPLICATION_DATA &&
 568              (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE))) {
 569             /*
 570              * next chunk of data should get another prepended empty fragment
 571              * in ciphersuites with known-IV weakness:
 572              */
 573             s->s3->empty_fragment_done = 0;
 574
 575             if ((i == (int)n) && s->mode & SSL_MODE_RELEASE_BUFFERS &&
 576                 !SSL_IS_DTLS(s))
 577                 ssl3_release_write_buffer(s);
 578
 579             return tot + i;
 580         }
 581
 582         n -= i;
 583         tot += i;
 584     }
 585 }
 586
 587 int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
 588                   unsigned int len, int create_empty_fragment)
 589 {
 590     unsigned char *p, *plen;
 591     int i, mac_size, clear = 0;
 592     int prefix_len = 0;
 593     int eivlen;
 594     long align = 0;
 595     SSL3_RECORD *wr;
 596     SSL3_BUFFER *wb = RECORD_LAYER_get_wbuf(&s->rlayer);
 597     SSL_SESSION *sess;
 598
 599     /*
 600      * first check if there is a SSL3_BUFFER still being written out.  This
 601      * will happen with non blocking IO
 602      */
 603     if (wb->left != 0)
 604         return (ssl3_write_pending(s, type, buf, len));
 605
 606     /* If we have an alert to send, lets send it */
 607     if (s->s3->alert_dispatch) {
 608         i = s->method->ssl_dispatch_alert(s);
 609         if (i <= 0)
 610             return (i);
 611         /* if it went, fall through and send more stuff */
 612     }
 613
 614     if (wb->buf == NULL)
 615         if (!ssl3_setup_write_buffer(s))
 616             return -1;
 617
 618     if (len == 0 && !create_empty_fragment)
 619         return 0;
 620
 621     wr = RECORD_LAYER_get_wrec(&s->rlayer);
 622     sess = s->session;
 623
 624     if ((sess == NULL) ||
 625         (s->enc_write_ctx == NULL) ||
 626         (EVP_MD_CTX_md(s->write_hash) == NULL)) {
 627         clear = s->enc_write_ctx ? 0 : 1; /* must be AEAD cipher */
 628         mac_size = 0;
 629     } else {
 630         mac_size = EVP_MD_CTX_size(s->write_hash);
 631         if (mac_size < 0)
 632             goto err;
 633     }
 634
 635     /*
 636      * 'create_empty_fragment' is true only when this function calls itself
 637      */
 638     if (!clear && !create_empty_fragment && !s->s3->empty_fragment_done) {
 639         /*
 640          * countermeasure against known-IV weakness in CBC ciphersuites (see
 641          * http://www.openssl.org/~bodo/tls-cbc.txt)
 642          */
 643
 644         if (s->s3->need_empty_fragments && type == SSL3_RT_APPLICATION_DATA) {
 645             /*
 646              * recursive function call with 'create_empty_fragment' set; this
 647              * prepares and buffers the data for an empty fragment (these
 648              * 'prefix_len' bytes are sent out later together with the actual
 649              * payload)
 650              */
 651             prefix_len = do_ssl3_write(s, type, buf, 0, 1);
 652             if (prefix_len <= 0)
 653                 goto err;
 654
 655             if (prefix_len >
 656                 (SSL3_RT_HEADER_LENGTH + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD))
 657             {
 658                 /* insufficient space */
 659                 SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);
 660                 goto err;
 661             }
 662         }
 663
 664         s->s3->empty_fragment_done = 1;
 665     }
 666
 667     if (create_empty_fragment) {
 668 #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0
 669         /*
 670          * extra fragment would be couple of cipher blocks, which would be
 671          * multiple of SSL3_ALIGN_PAYLOAD, so if we want to align the real
 672          * payload, then we can just pretent we simply have two headers.
 673          */
 674         align = (long)wb->buf + 2 * SSL3_RT_HEADER_LENGTH;
 675         align = (-align) & (SSL3_ALIGN_PAYLOAD - 1);
 676 #endif
 677         p = wb->buf + align;
 678         wb->offset = align;
 679     } else if (prefix_len) {
 680         p = wb->buf + wb->offset + prefix_len;
 681     } else {
 682 #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0
 683         align = (long)wb->buf + SSL3_RT_HEADER_LENGTH;
 684         align = (-align) & (SSL3_ALIGN_PAYLOAD - 1);
 685 #endif
 686         p = wb->buf + align;
 687         wb->offset = align;
 688     }
 689
 690     /* write the header */
 691
 692     *(p++) = type & 0xff;
 693     wr->type = type;
 694
 695     *(p++) = (s->version >> 8);
 696     /*
 697      * Some servers hang if iniatial client hello is larger than 256 bytes
 698      * and record version number > TLS 1.0
 699      */
 700     if (s->state == SSL3_ST_CW_CLNT_HELLO_B
 701         && !s->renegotiate && TLS1_get_version(s) > TLS1_VERSION)
 702         *(p++) = 0x1;
 703     else
 704         *(p++) = s->version & 0xff;
 705
 706     /* field where we are to write out packet length */
 707     plen = p;
 708     p += 2;
 709     /* Explicit IV length, block ciphers appropriate version flag */
 710     if (s->enc_write_ctx && SSL_USE_EXPLICIT_IV(s)) {
 711         int mode = EVP_CIPHER_CTX_mode(s->enc_write_ctx);
 712         if (mode == EVP_CIPH_CBC_MODE) {
 713             eivlen = EVP_CIPHER_CTX_iv_length(s->enc_write_ctx);
 714             if (eivlen <= 1)
 715                 eivlen = 0;
 716         }
 717         /* Need explicit part of IV for GCM mode */
 718         else if (mode == EVP_CIPH_GCM_MODE)
 719             eivlen = EVP_GCM_TLS_EXPLICIT_IV_LEN;
 720         else
 721             eivlen = 0;
 722     } else
 723         eivlen = 0;
 724
 725     /* lets setup the record stuff. */
 726     wr->data = p + eivlen;
 727     wr->length = (int)len;
 728     wr->input = (unsigned char *)buf;
 729
 730     /*
 731      * we now 'read' from wr->input, wr->length bytes into wr->data
 732      */
 733
 734     /* first we compress */
 735     if (s->compress != NULL) {
 736         if (!ssl3_do_compress(s)) {
 737             SSLerr(SSL_F_DO_SSL3_WRITE, SSL_R_COMPRESSION_FAILURE);
 738             goto err;
 739         }
 740     } else {
 741         memcpy(wr->data, wr->input, wr->length);
 742         wr->input = wr->data;
 743     }
 744
 745     /*
 746      * we should still have the output to wr->data and the input from
 747      * wr->input.  Length should be wr->length. wr->data still points in the
 748      * wb->buf
 749      */
 750
 751     if (!SSL_USE_ETM(s) && mac_size != 0) {
 752         if (s->method->ssl3_enc->mac(s, &(p[wr->length + eivlen]), 1) < 0)
 753             goto err;
 754         wr->length += mac_size;
 755     }
 756
 757     wr->input = p;
 758     wr->data = p;
 759
 760     if (eivlen) {
 761         /*
 762          * if (RAND_pseudo_bytes(p, eivlen) <= 0) goto err;
 763          */
 764         wr->length += eivlen;
 765     }
 766
 767     if (s->method->ssl3_enc->enc(s, 1) < 1)
 768         goto err;
 769
 770     if (SSL_USE_ETM(s) && mac_size != 0) {
 771         if (s->method->ssl3_enc->mac(s, p + wr->length, 1) < 0)
 772             goto err;
 773         wr->length += mac_size;
 774     }
 775
 776     /* record length after mac and block padding */
 777     s2n(wr->length, plen);
 778
 779     if (s->msg_callback)
 780         s->msg_callback(1, 0, SSL3_RT_HEADER, plen - 5, 5, s,
 781                         s->msg_callback_arg);
 782
 783     /*
 784      * we should now have wr->data pointing to the encrypted data, which is
 785      * wr->length long
 786      */
 787     wr->type = type;            /* not needed but helps for debugging */
 788     wr->length += SSL3_RT_HEADER_LENGTH;
 789
 790     if (create_empty_fragment) {
 791         /*
 792          * we are in a recursive call; just return the length, don't write
 793          * out anything here
 794          */
 795         return wr->length;
 796     }
 797
 798     /* now let's set up wb */
 799     wb->left = prefix_len + wr->length;
 800
 801     /*
 802      * memorize arguments so that ssl3_write_pending can detect bad write
 803      * retries later
 804      */
 805     s->s3->wpend_tot = len;
 806     s->s3->wpend_buf = buf;
 807     s->s3->wpend_type = type;
 808     s->s3->wpend_ret = len;
 809
 810     /* we now just need to write the buffer */
 811     return ssl3_write_pending(s, type, buf, len);
 812  err:
 813     return -1;
 814 }
 815
 816 /* if s->s3->wbuf.left != 0, we need to call this */
 817 int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
 818                        unsigned int len)
 819 {
 820     int i;
 821     SSL3_BUFFER *wb = RECORD_LAYER_get_wbuf(&s->rlayer);
 822
 823 /* XXXX */
 824     if ((s->s3->wpend_tot > (int)len)
 825         || ((s->s3->wpend_buf != buf) &&
 826             !(s->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER))
 827         || (s->s3->wpend_type != type)) {
 828         SSLerr(SSL_F_SSL3_WRITE_PENDING, SSL_R_BAD_WRITE_RETRY);
 829         return (-1);
 830     }
 831
 832     for (;;) {
 833         clear_sys_error();
 834         if (s->wbio != NULL) {
 835             s->rwstate = SSL_WRITING;
 836             i = BIO_write(s->wbio,
 837                           (char *)&(wb->buf[wb->offset]),
 838                           (unsigned int)wb->left);
 839         } else {
 840             SSLerr(SSL_F_SSL3_WRITE_PENDING, SSL_R_BIO_NOT_SET);
 841             i = -1;
 842         }
 843         if (i == wb->left) {
 844             wb->left = 0;
 845             wb->offset += i;
 846             s->rwstate = SSL_NOTHING;
 847             return (s->s3->wpend_ret);
 848         } else if (i <= 0) {
 849             if (s->version == DTLS1_VERSION || s->version == DTLS1_BAD_VER) {
 850                 /*
 851                  * For DTLS, just drop it. That's kind of the whole point in
 852                  * using a datagram service
 853                  */
 854                 wb->left = 0;
 855             }
 856             return (i);
 857         }
 858         wb->offset += i;
 859         wb->left -= i;
 860     }
 861 }
 862
 863 /*-
 864  * Return up to 'len' payload bytes received in 'type' records.
 865  * 'type' is one of the following:
 866  *
 867  *   -  SSL3_RT_HANDSHAKE (when ssl3_get_message calls us)
 868  *   -  SSL3_RT_APPLICATION_DATA (when ssl3_read calls us)
 869  *   -  0 (during a shutdown, no data has to be returned)
 870  *
 871  * If we don't have stored data to work from, read a SSL/TLS record first
 872  * (possibly multiple records if we still don't have anything to return).
 873  *
 874  * This function must handle any surprises the peer may have for us, such as
 875  * Alert records (e.g. close_notify), ChangeCipherSpec records (not really
 876  * a surprise, but handled as if it were), or renegotiation requests.
 877  * Also if record payloads contain fragments too small to process, we store
 878  * them until there is enough for the respective protocol (the record protocol
 879  * may use arbitrary fragmentation and even interleaving):
 880  *     Change cipher spec protocol
 881  *             just 1 byte needed, no need for keeping anything stored
 882  *     Alert protocol
 883  *             2 bytes needed (AlertLevel, AlertDescription)
 884  *     Handshake protocol
 885  *             4 bytes needed (HandshakeType, uint24 length) -- we just have
 886  *             to detect unexpected Client Hello and Hello Request messages
 887  *             here, anything else is handled by higher layers
 888  *     Application data protocol
 889  *             none of our business
 890  */
 891 int ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
 892 {
 893     int al, i, j, ret;
 894     unsigned int n;
 895     SSL3_RECORD *rr;
 896     void (*cb) (const SSL *ssl, int type2, int val) = NULL;
 897
 898     if (!SSL3_BUFFER_is_initialised(RECORD_LAYER_get_rbuf(&s->rlayer))) {
 899         /* Not initialized yet */
 900         if (!ssl3_setup_read_buffer(s))
 901             return (-1);
 902     }
 903
 904     if ((type && (type != SSL3_RT_APPLICATION_DATA)
 905          && (type != SSL3_RT_HANDSHAKE)) || (peek
 906                                              && (type !=
 907                                                  SSL3_RT_APPLICATION_DATA))) {
 908         SSLerr(SSL_F_SSL3_READ_BYTES, ERR_R_INTERNAL_ERROR);
 909         return -1;
 910     }
 911
 912     if ((type == SSL3_RT_HANDSHAKE) && (s->s3->handshake_fragment_len > 0))
 913         /* (partially) satisfy request from storage */
 914     {
 915         unsigned char *src = s->s3->handshake_fragment;
 916         unsigned char *dst = buf;
 917         unsigned int k;
 918
 919         /* peek == 0 */
 920         n = 0;
 921         while ((len > 0) && (s->s3->handshake_fragment_len > 0)) {
 922             *dst++ = *src++;
 923             len--;
 924             s->s3->handshake_fragment_len--;
 925             n++;
 926         }
 927         /* move any remaining fragment bytes: */
 928         for (k = 0; k < s->s3->handshake_fragment_len; k++)
 929             s->s3->handshake_fragment[k] = *src++;
 930         return n;
 931     }
 932
 933     /*
 934      * Now s->s3->handshake_fragment_len == 0 if type == SSL3_RT_HANDSHAKE.
 935      */
 936
 937     if (!s->in_handshake && SSL_in_init(s)) {
 938         /* type == SSL3_RT_APPLICATION_DATA */
 939         i = s->handshake_func(s);
 940         if (i < 0)
 941             return (i);
 942         if (i == 0) {
 943             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);
 944             return (-1);
 945         }
 946     }
 947  start:
 948     s->rwstate = SSL_NOTHING;
 949
 950     /*-
 951      * s->s3->rrec.type         - is the type of record
 952      * s->s3->rrec.data,    - data
 953      * s->s3->rrec.off,     - offset into 'data' for next read
 954      * s->s3->rrec.length,  - number of bytes.
 955      */
 956     rr = RECORD_LAYER_get_rrec(&s->rlayer);
 957
 958     /* get new packet if necessary */
 959     if ((rr->length == 0) || (s->rstate == SSL_ST_READ_BODY)) {
 960         ret = ssl3_get_record(s);
 961         if (ret <= 0)
 962             return (ret);
 963     }
 964
 965     /* we now have a packet which can be read and processed */
 966
 967     if (s->s3->change_cipher_spec /* set when we receive ChangeCipherSpec,
 968                                    * reset by ssl3_get_finished */
 969         && (rr->type != SSL3_RT_HANDSHAKE)) {
 970         al = SSL_AD_UNEXPECTED_MESSAGE;
 971         SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_DATA_BETWEEN_CCS_AND_FINISHED);
 972         goto f_err;
 973     }
 974
 975     /*
 976      * If the other end has shut down, throw anything we read away (even in
 977      * 'peek' mode)
 978      */
 979     if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
 980         rr->length = 0;
 981         s->rwstate = SSL_NOTHING;
 982         return (0);
 983     }
 984
 985     if (type == rr->type) {     /* SSL3_RT_APPLICATION_DATA or
 986                                  * SSL3_RT_HANDSHAKE */
 987         /*
 988          * make sure that we are not getting application data when we are
 989          * doing a handshake for the first time
 990          */
 991         if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) &&
 992             (s->enc_read_ctx == NULL)) {
 993             al = SSL_AD_UNEXPECTED_MESSAGE;
 994             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_APP_DATA_IN_HANDSHAKE);
 995             goto f_err;
 996         }
 997
 998         if (len <= 0)
 999             return (len);
1000
1001         if ((unsigned int)len > rr->length)
1002             n = rr->length;
1003         else
1004             n = (unsigned int)len;
1005
1006         memcpy(buf, &(rr->data[rr->off]), n);
1007         if (!peek) {
1008             rr->length -= n;
1009             rr->off += n;
1010             if (rr->length == 0) {
1011                 s->rstate = SSL_ST_READ_HEADER;
1012                 rr->off = 0;
1013                 if (s->mode & SSL_MODE_RELEASE_BUFFERS
1014                     && SSL3_BUFFER_get_left(
1015                         RECORD_LAYER_get_rbuf(&s->rlayer)) == 0)
1016                     ssl3_release_read_buffer(s);
1017             }
1018         }
1019         return (n);
1020     }
1021
1022     /*
1023      * If we get here, then type != rr->type; if we have a handshake message,
1024      * then it was unexpected (Hello Request or Client Hello).
1025      */
1026
1027     /*
1028      * In case of record types for which we have 'fragment' storage, fill
1029      * that so that we can process the data at a fixed place.
1030      */
1031     {
1032         unsigned int dest_maxlen = 0;
1033         unsigned char *dest = NULL;
1034         unsigned int *dest_len = NULL;
1035
1036         if (rr->type == SSL3_RT_HANDSHAKE) {
1037             dest_maxlen = sizeof s->s3->handshake_fragment;
1038             dest = s->s3->handshake_fragment;
1039             dest_len = &s->s3->handshake_fragment_len;
1040         } else if (rr->type == SSL3_RT_ALERT) {
1041             dest_maxlen = sizeof s->s3->alert_fragment;
1042             dest = s->s3->alert_fragment;
1043             dest_len = &s->s3->alert_fragment_len;
1044         }
1045 #ifndef OPENSSL_NO_HEARTBEATS
1046         else if (rr->type == TLS1_RT_HEARTBEAT) {
1047             /* We can ignore 0 return values */
1048             if(tls1_process_heartbeat(s) < 0) {
1049                 return -1;
1050             }
1051
1052             /* Exit and notify application to read again */
1053             rr->length = 0;
1054             s->rwstate = SSL_READING;
1055             BIO_clear_retry_flags(SSL_get_rbio(s));
1056             BIO_set_retry_read(SSL_get_rbio(s));
1057             return (-1);
1058         }
1059 #endif
1060
1061         if (dest_maxlen > 0) {
1062             n = dest_maxlen - *dest_len; /* available space in 'dest' */
1063             if (rr->length < n)
1064                 n = rr->length; /* available bytes */
1065
1066             /* now move 'n' bytes: */
1067             while (n-- > 0) {
1068                 dest[(*dest_len)++] = rr->data[rr->off++];
1069                 rr->length--;
1070             }
1071
1072             if (*dest_len < dest_maxlen)
1073                 goto start;     /* fragment was too small */
1074         }
1075     }
1076
1077     /*-
1078      * s->s3->handshake_fragment_len == 4  iff  rr->type == SSL3_RT_HANDSHAKE;
1079      * s->s3->alert_fragment_len == 2      iff  rr->type == SSL3_RT_ALERT.
1080      * (Possibly rr is 'empty' now, i.e. rr->length may be 0.)
1081      */
1082
1083     /* If we are a client, check for an incoming 'Hello Request': */
1084     if ((!s->server) &&
1085         (s->s3->handshake_fragment_len >= 4) &&
1086         (s->s3->handshake_fragment[0] == SSL3_MT_HELLO_REQUEST) &&
1087         (s->session != NULL) && (s->session->cipher != NULL)) {
1088         s->s3->handshake_fragment_len = 0;
1089
1090         if ((s->s3->handshake_fragment[1] != 0) ||
1091             (s->s3->handshake_fragment[2] != 0) ||
1092             (s->s3->handshake_fragment[3] != 0)) {
1093             al = SSL_AD_DECODE_ERROR;
1094             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_BAD_HELLO_REQUEST);
1095             goto f_err;
1096         }
1097
1098         if (s->msg_callback)
1099             s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE,
1100                             s->s3->handshake_fragment, 4, s,
1101                             s->msg_callback_arg);
1102
1103         if (SSL_is_init_finished(s) &&
1104             !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS) &&
1105             !s->s3->renegotiate) {
1106             ssl3_renegotiate(s);
1107             if (ssl3_renegotiate_check(s)) {
1108                 i = s->handshake_func(s);
1109                 if (i < 0)
1110                     return (i);
1111                 if (i == 0) {
1112                     SSLerr(SSL_F_SSL3_READ_BYTES,
1113                            SSL_R_SSL_HANDSHAKE_FAILURE);
1114                     return (-1);
1115                 }
1116
1117                 if (!(s->mode & SSL_MODE_AUTO_RETRY)) {
1118                     if (SSL3_BUFFER_get_left(
1119                         RECORD_LAYER_get_rbuf(&s->rlayer)) == 0) {
1120                         /* no read-ahead left? */
1121                         BIO *bio;
1122                         /*
1123                          * In the case where we try to read application data,
1124                          * but we trigger an SSL handshake, we return -1 with
1125                          * the retry option set.  Otherwise renegotiation may
1126                          * cause nasty problems in the blocking world
1127                          */
1128                         s->rwstate = SSL_READING;
1129                         bio = SSL_get_rbio(s);
1130                         BIO_clear_retry_flags(bio);
1131                         BIO_set_retry_read(bio);
1132                         return (-1);
1133                     }
1134                 }
1135             }
1136         }
1137         /*
1138          * we either finished a handshake or ignored the request, now try
1139          * again to obtain the (application) data we were asked for
1140          */
1141         goto start;
1142     }
1143     /*
1144      * If we are a server and get a client hello when renegotiation isn't
1145      * allowed send back a no renegotiation alert and carry on. WARNING:
1146      * experimental code, needs reviewing (steve)
1147      */
1148     if (s->server &&
1149         SSL_is_init_finished(s) &&
1150         !s->s3->send_connection_binding &&
1151         (s->version > SSL3_VERSION) &&
1152         (s->s3->handshake_fragment_len >= 4) &&
1153         (s->s3->handshake_fragment[0] == SSL3_MT_CLIENT_HELLO) &&
1154         (s->session != NULL) && (s->session->cipher != NULL) &&
1155         !(s->ctx->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
1156         /*
1157          * s->s3->handshake_fragment_len = 0;
1158          */
1159         rr->length = 0;
1160         ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_RENEGOTIATION);
1161         goto start;
1162     }
1163     if (s->s3->alert_fragment_len >= 2) {
1164         int alert_level = s->s3->alert_fragment[0];
1165         int alert_descr = s->s3->alert_fragment[1];
1166
1167         s->s3->alert_fragment_len = 0;
1168
1169         if (s->msg_callback)
1170             s->msg_callback(0, s->version, SSL3_RT_ALERT,
1171                             s->s3->alert_fragment, 2, s, s->msg_callback_arg);
1172
1173         if (s->info_callback != NULL)
1174             cb = s->info_callback;
1175         else if (s->ctx->info_callback != NULL)
1176             cb = s->ctx->info_callback;
1177
1178         if (cb != NULL) {
1179             j = (alert_level << 8) | alert_descr;
1180             cb(s, SSL_CB_READ_ALERT, j);
1181         }
1182
1183         if (alert_level == SSL3_AL_WARNING) {
1184             s->s3->warn_alert = alert_descr;
1185             if (alert_descr == SSL_AD_CLOSE_NOTIFY) {
1186                 s->shutdown |= SSL_RECEIVED_SHUTDOWN;
1187                 return (0);
1188             }
1189             /*
1190              * This is a warning but we receive it if we requested
1191              * renegotiation and the peer denied it. Terminate with a fatal
1192              * alert because if application tried to renegotiatie it
1193              * presumably had a good reason and expects it to succeed. In
1194              * future we might have a renegotiation where we don't care if
1195              * the peer refused it where we carry on.
1196              */
1197             else if (alert_descr == SSL_AD_NO_RENEGOTIATION) {
1198                 al = SSL_AD_HANDSHAKE_FAILURE;
1199                 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_NO_RENEGOTIATION);
1200                 goto f_err;
1201             }
1202 #ifdef SSL_AD_MISSING_SRP_USERNAME
1203             else if (alert_descr == SSL_AD_MISSING_SRP_USERNAME)
1204                 return (0);
1205 #endif
1206         } else if (alert_level == SSL3_AL_FATAL) {
1207             char tmp[16];
1208
1209             s->rwstate = SSL_NOTHING;
1210             s->s3->fatal_alert = alert_descr;
1211             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_AD_REASON_OFFSET + alert_descr);
1212             BIO_snprintf(tmp, sizeof tmp, "%d", alert_descr);
1213             ERR_add_error_data(2, "SSL alert number ", tmp);
1214             s->shutdown |= SSL_RECEIVED_SHUTDOWN;
1215             SSL_CTX_remove_session(s->ctx, s->session);
1216             return (0);
1217         } else {
1218             al = SSL_AD_ILLEGAL_PARAMETER;
1219             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_UNKNOWN_ALERT_TYPE);
1220             goto f_err;
1221         }
1222
1223         goto start;
1224     }
1225
1226     if (s->shutdown & SSL_SENT_SHUTDOWN) { /* but we have not received a
1227                                             * shutdown */
1228         s->rwstate = SSL_NOTHING;
1229         rr->length = 0;
1230         return (0);
1231     }
1232
1233     if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) {
1234         /*
1235          * 'Change Cipher Spec' is just a single byte, so we know exactly
1236          * what the record payload has to look like
1237          */
1238         if ((rr->length != 1) || (rr->off != 0) ||
1239             (rr->data[0] != SSL3_MT_CCS)) {
1240             al = SSL_AD_ILLEGAL_PARAMETER;
1241             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_BAD_CHANGE_CIPHER_SPEC);
1242             goto f_err;
1243         }
1244
1245         /* Check we have a cipher to change to */
1246         if (s->s3->tmp.new_cipher == NULL) {
1247             al = SSL_AD_UNEXPECTED_MESSAGE;
1248             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_CCS_RECEIVED_EARLY);
1249             goto f_err;
1250         }
1251
1252         if (!(s->s3->flags & SSL3_FLAGS_CCS_OK)) {
1253             al = SSL_AD_UNEXPECTED_MESSAGE;
1254             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_CCS_RECEIVED_EARLY);
1255             goto f_err;
1256         }
1257
1258         s->s3->flags &= ~SSL3_FLAGS_CCS_OK;
1259
1260         rr->length = 0;
1261
1262         if (s->msg_callback)
1263             s->msg_callback(0, s->version, SSL3_RT_CHANGE_CIPHER_SPEC,
1264                             rr->data, 1, s, s->msg_callback_arg);
1265
1266         s->s3->change_cipher_spec = 1;
1267         if (!ssl3_do_change_cipher_spec(s))
1268             goto err;
1269         else
1270             goto start;
1271     }
1272
1273     /*
1274      * Unexpected handshake message (Client Hello, or protocol violation)
1275      */
1276     if ((s->s3->handshake_fragment_len >= 4) && !s->in_handshake) {
1277         if (((s->state & SSL_ST_MASK) == SSL_ST_OK) &&
1278             !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS)) {
1279             s->state = s->server ? SSL_ST_ACCEPT : SSL_ST_CONNECT;
1280             s->renegotiate = 1;
1281             s->new_session = 1;
1282         }
1283         i = s->handshake_func(s);
1284         if (i < 0)
1285             return (i);
1286         if (i == 0) {
1287             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);
1288             return (-1);
1289         }
1290
1291         if (!(s->mode & SSL_MODE_AUTO_RETRY)) {
1292             if (SSL3_BUFFER_get_left(RECORD_LAYER_get_rbuf(&s->rlayer)) == 0) {
1293                 /* no read-ahead left? */
1294                 BIO *bio;
1295                 /*
1296                  * In the case where we try to read application data, but we
1297                  * trigger an SSL handshake, we return -1 with the retry
1298                  * option set.  Otherwise renegotiation may cause nasty
1299                  * problems in the blocking world
1300                  */
1301                 s->rwstate = SSL_READING;
1302                 bio = SSL_get_rbio(s);
1303                 BIO_clear_retry_flags(bio);
1304                 BIO_set_retry_read(bio);
1305                 return (-1);
1306             }
1307         }
1308         goto start;
1309     }
1310
1311     switch (rr->type) {
1312     default:
1313         /*
1314          * TLS up to v1.1 just ignores unknown message types: TLS v1.2 give
1315          * an unexpected message alert.
1316          */
1317         if (s->version >= TLS1_VERSION && s->version <= TLS1_1_VERSION) {
1318             rr->length = 0;
1319             goto start;
1320         }
1321         al = SSL_AD_UNEXPECTED_MESSAGE;
1322         SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_UNEXPECTED_RECORD);
1323         goto f_err;
1324     case SSL3_RT_CHANGE_CIPHER_SPEC:
1325     case SSL3_RT_ALERT:
1326     case SSL3_RT_HANDSHAKE:
1327         /*
1328          * we already handled all of these, with the possible exception of
1329          * SSL3_RT_HANDSHAKE when s->in_handshake is set, but that should not
1330          * happen when type != rr->type
1331          */
1332         al = SSL_AD_UNEXPECTED_MESSAGE;
1333         SSLerr(SSL_F_SSL3_READ_BYTES, ERR_R_INTERNAL_ERROR);
1334         goto f_err;
1335     case SSL3_RT_APPLICATION_DATA:
1336         /*
1337          * At this point, we were expecting handshake data, but have
1338          * application data.  If the library was running inside ssl3_read()
1339          * (i.e. in_read_app_data is set) and it makes sense to read
1340          * application data at this point (session renegotiation not yet
1341          * started), we will indulge it.
1342          */
1343         if (s->s3->in_read_app_data &&
1344             (s->s3->total_renegotiations != 0) &&
1345             (((s->state & SSL_ST_CONNECT) &&
1346               (s->state >= SSL3_ST_CW_CLNT_HELLO_A) &&
1347               (s->state <= SSL3_ST_CR_SRVR_HELLO_A)
1348              ) || ((s->state & SSL_ST_ACCEPT) &&
1349                    (s->state <= SSL3_ST_SW_HELLO_REQ_A) &&
1350                    (s->state >= SSL3_ST_SR_CLNT_HELLO_A)
1351              )
1352             )) {
1353             s->s3->in_read_app_data = 2;
1354             return (-1);
1355         } else {
1356             al = SSL_AD_UNEXPECTED_MESSAGE;
1357             SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_UNEXPECTED_RECORD);
1358             goto f_err;
1359         }
1360     }
1361     /* not reached */
1362
1363  f_err:
1364     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1365  err:
1366     return (-1);
1367 }
1368
1369