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