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