ssl/record/rec_layer_s3.c

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