Send an illegal parameter alert if the update type in a KeyUpdate is wrong
[openssl.git] / ssl / record / ssl3_record.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 <assert.h>
11 #include "../ssl_locl.h"
12 #include "internal/constant_time_locl.h"
13 #include <openssl/rand.h>
14 #include "record_locl.h"
15
16 static const unsigned char ssl3_pad_1[48] = {
17     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
18     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
19     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
20     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
21     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
22     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36
23 };
24
25 static const unsigned char ssl3_pad_2[48] = {
26     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
27     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
28     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
29     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
30     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
31     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c
32 };
33
34 /*
35  * Clear the contents of an SSL3_RECORD but retain any memory allocated
36  */
37 void SSL3_RECORD_clear(SSL3_RECORD *r, size_t num_recs)
38 {
39     unsigned char *comp;
40     size_t i;
41
42     for (i = 0; i < num_recs; i++) {
43         comp = r[i].comp;
44
45         memset(&r[i], 0, sizeof(*r));
46         r[i].comp = comp;
47     }
48 }
49
50 void SSL3_RECORD_release(SSL3_RECORD *r, size_t num_recs)
51 {
52     size_t i;
53
54     for (i = 0; i < num_recs; i++) {
55         OPENSSL_free(r[i].comp);
56         r[i].comp = NULL;
57     }
58 }
59
60 void SSL3_RECORD_set_seq_num(SSL3_RECORD *r, const unsigned char *seq_num)
61 {
62     memcpy(r->seq_num, seq_num, SEQ_NUM_SIZE);
63 }
64
65 /*
66  * Peeks ahead into "read_ahead" data to see if we have a whole record waiting
67  * for us in the buffer.
68  */
69 static int ssl3_record_app_data_waiting(SSL *s)
70 {
71     SSL3_BUFFER *rbuf;
72     size_t left, len;
73     unsigned char *p;
74
75     rbuf = RECORD_LAYER_get_rbuf(&s->rlayer);
76
77     p = SSL3_BUFFER_get_buf(rbuf);
78     if (p == NULL)
79         return 0;
80
81     left = SSL3_BUFFER_get_left(rbuf);
82
83     if (left < SSL3_RT_HEADER_LENGTH)
84         return 0;
85
86     p += SSL3_BUFFER_get_offset(rbuf);
87
88     /*
89      * We only check the type and record length, we will sanity check version
90      * etc later
91      */
92     if (*p != SSL3_RT_APPLICATION_DATA)
93         return 0;
94
95     p += 3;
96     n2s(p, len);
97
98     if (left < SSL3_RT_HEADER_LENGTH + len)
99         return 0;
100
101     return 1;
102 }
103
104 int early_data_count_ok(SSL *s, size_t length, size_t overhead, int *al)
105 {
106     uint32_t max_early_data = s->max_early_data;
107
108     /*
109      * If we are a client then we always use the max_early_data from the
110      * session. Otherwise we go with the lowest out of the max early data set in
111      * the session and the configured max_early_data.
112      */
113     if (!s->server || (s->hit
114                        && s->session->ext.max_early_data < s->max_early_data))
115         max_early_data = s->session->ext.max_early_data;
116
117     if (max_early_data == 0) {
118         if (al != NULL)
119             *al = SSL_AD_UNEXPECTED_MESSAGE;
120         SSLerr(SSL_F_EARLY_DATA_COUNT_OK, SSL_R_TOO_MUCH_EARLY_DATA);
121         return 0;
122     }
123
124     /* If we are dealing with ciphertext we need to allow for the overhead */
125     max_early_data += overhead;
126
127     if (s->early_data_count + length > max_early_data) {
128         if (al != NULL)
129             *al = SSL_AD_UNEXPECTED_MESSAGE;
130         SSLerr(SSL_F_EARLY_DATA_COUNT_OK, SSL_R_TOO_MUCH_EARLY_DATA);
131         return 0;
132     }
133     s->early_data_count += length;
134
135     return 1;
136 }
137
138 /*
139  * MAX_EMPTY_RECORDS defines the number of consecutive, empty records that
140  * will be processed per call to ssl3_get_record. Without this limit an
141  * attacker could send empty records at a faster rate than we can process and
142  * cause ssl3_get_record to loop forever.
143  */
144 #define MAX_EMPTY_RECORDS 32
145
146 #define SSL2_RT_HEADER_LENGTH   2
147 /*-
148  * Call this to get new input records.
149  * It will return <= 0 if more data is needed, normally due to an error
150  * or non-blocking IO.
151  * When it finishes, |numrpipes| records have been decoded. For each record 'i':
152  * rr[i].type    - is the type of record
153  * rr[i].data,   - data
154  * rr[i].length, - number of bytes
155  * Multiple records will only be returned if the record types are all
156  * SSL3_RT_APPLICATION_DATA. The number of records returned will always be <=
157  * |max_pipelines|
158  */
159 /* used only by ssl3_read_bytes */
160 int ssl3_get_record(SSL *s)
161 {
162     int al;
163     int enc_err, rret, ret = -1;
164     int i;
165     size_t more, n;
166     SSL3_RECORD *rr, *thisrr;
167     SSL3_BUFFER *rbuf;
168     SSL_SESSION *sess;
169     unsigned char *p;
170     unsigned char md[EVP_MAX_MD_SIZE];
171     unsigned int version;
172     size_t mac_size;
173     int imac_size;
174     size_t num_recs = 0, max_recs, j;
175     PACKET pkt, sslv2pkt;
176     size_t first_rec_len;
177
178     rr = RECORD_LAYER_get_rrec(&s->rlayer);
179     rbuf = RECORD_LAYER_get_rbuf(&s->rlayer);
180     max_recs = s->max_pipelines;
181     if (max_recs == 0)
182         max_recs = 1;
183     sess = s->session;
184
185     do {
186         thisrr = &rr[num_recs];
187
188         /* check if we have the header */
189         if ((RECORD_LAYER_get_rstate(&s->rlayer) != SSL_ST_READ_BODY) ||
190             (RECORD_LAYER_get_packet_length(&s->rlayer)
191              < SSL3_RT_HEADER_LENGTH)) {
192             size_t sslv2len;
193             unsigned int type;
194
195             rret = ssl3_read_n(s, SSL3_RT_HEADER_LENGTH,
196                                SSL3_BUFFER_get_len(rbuf), 0,
197                                num_recs == 0 ? 1 : 0, &n);
198             if (rret <= 0)
199                 return rret;     /* error or non-blocking */
200             RECORD_LAYER_set_rstate(&s->rlayer, SSL_ST_READ_BODY);
201
202             p = RECORD_LAYER_get_packet(&s->rlayer);
203             if (!PACKET_buf_init(&pkt, RECORD_LAYER_get_packet(&s->rlayer),
204                                  RECORD_LAYER_get_packet_length(&s->rlayer))) {
205                 al = SSL_AD_INTERNAL_ERROR;
206                 SSLerr(SSL_F_SSL3_GET_RECORD, ERR_R_INTERNAL_ERROR);
207                 goto f_err;
208             }
209             sslv2pkt = pkt;
210             if (!PACKET_get_net_2_len(&sslv2pkt, &sslv2len)
211                     || !PACKET_get_1(&sslv2pkt, &type)) {
212                 al = SSL_AD_INTERNAL_ERROR;
213                 SSLerr(SSL_F_SSL3_GET_RECORD, ERR_R_INTERNAL_ERROR);
214                 goto f_err;
215             }
216             /*
217              * The first record received by the server may be a V2ClientHello.
218              */
219             if (s->server && RECORD_LAYER_is_first_record(&s->rlayer)
220                     && (sslv2len & 0x8000) != 0
221                     && (type == SSL2_MT_CLIENT_HELLO)) {
222                 /*
223                  *  SSLv2 style record
224                  *
225                  * |num_recs| here will actually always be 0 because
226                  * |num_recs > 0| only ever occurs when we are processing
227                  * multiple app data records - which we know isn't the case here
228                  * because it is an SSLv2ClientHello. We keep it using
229                  * |num_recs| for the sake of consistency
230                  */
231                 thisrr->type = SSL3_RT_HANDSHAKE;
232                 thisrr->rec_version = SSL2_VERSION;
233
234                 thisrr->length = sslv2len & 0x7fff;
235
236                 if (thisrr->length > SSL3_BUFFER_get_len(rbuf)
237                     - SSL2_RT_HEADER_LENGTH) {
238                     al = SSL_AD_RECORD_OVERFLOW;
239                     SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_PACKET_LENGTH_TOO_LONG);
240                     goto f_err;
241                 }
242
243                 if (thisrr->length < MIN_SSL2_RECORD_LEN) {
244                     al = SSL_AD_HANDSHAKE_FAILURE;
245                     SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_LENGTH_TOO_SHORT);
246                     goto f_err;
247                 }
248             } else {
249                 /* SSLv3+ style record */
250                 if (s->msg_callback)
251                     s->msg_callback(0, 0, SSL3_RT_HEADER, p, 5, s,
252                                     s->msg_callback_arg);
253
254                 /* Pull apart the header into the SSL3_RECORD */
255                 if (!PACKET_get_1(&pkt, &type)
256                         || !PACKET_get_net_2(&pkt, &version)
257                         || !PACKET_get_net_2_len(&pkt, &thisrr->length)) {
258                     al = SSL_AD_INTERNAL_ERROR;
259                     SSLerr(SSL_F_SSL3_GET_RECORD, ERR_R_INTERNAL_ERROR);
260                     goto f_err;
261                 }
262                 thisrr->type = type;
263                 thisrr->rec_version = version;
264
265                 /* Lets check version. In TLSv1.3 we ignore this field */
266                 if (!s->first_packet && !SSL_IS_TLS13(s)
267                         && version != (unsigned int)s->version) {
268                     SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_WRONG_VERSION_NUMBER);
269                     if ((s->version & 0xFF00) == (version & 0xFF00)
270                         && !s->enc_write_ctx && !s->write_hash) {
271                         if (thisrr->type == SSL3_RT_ALERT) {
272                             /*
273                              * The record is using an incorrect version number,
274                              * but what we've got appears to be an alert. We
275                              * haven't read the body yet to check whether its a
276                              * fatal or not - but chances are it is. We probably
277                              * shouldn't send a fatal alert back. We'll just
278                              * end.
279                              */
280                             goto err;
281                         }
282                         /*
283                          * Send back error using their minor version number :-)
284                          */
285                         s->version = (unsigned short)version;
286                     }
287                     al = SSL_AD_PROTOCOL_VERSION;
288                     goto f_err;
289                 }
290
291                 if ((version >> 8) != SSL3_VERSION_MAJOR) {
292                     if (RECORD_LAYER_is_first_record(&s->rlayer)) {
293                         /* Go back to start of packet, look at the five bytes
294                          * that we have. */
295                         p = RECORD_LAYER_get_packet(&s->rlayer);
296                         if (strncmp((char *)p, "GET ", 4) == 0 ||
297                             strncmp((char *)p, "POST ", 5) == 0 ||
298                             strncmp((char *)p, "HEAD ", 5) == 0 ||
299                             strncmp((char *)p, "PUT ", 4) == 0) {
300                             SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_HTTP_REQUEST);
301                             goto err;
302                         } else if (strncmp((char *)p, "CONNE", 5) == 0) {
303                             SSLerr(SSL_F_SSL3_GET_RECORD,
304                                    SSL_R_HTTPS_PROXY_REQUEST);
305                             goto err;
306                         }
307
308                         /* Doesn't look like TLS - don't send an alert */
309                         SSLerr(SSL_F_SSL3_GET_RECORD,
310                                SSL_R_WRONG_VERSION_NUMBER);
311                         goto err;
312                     } else {
313                         SSLerr(SSL_F_SSL3_GET_RECORD,
314                                SSL_R_WRONG_VERSION_NUMBER);
315                         al = SSL_AD_PROTOCOL_VERSION;
316                         goto f_err;
317                     }
318                 }
319
320                 if (SSL_IS_TLS13(s) && s->enc_read_ctx != NULL
321                         && thisrr->type != SSL3_RT_APPLICATION_DATA) {
322                     SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BAD_RECORD_TYPE);
323                     al = SSL_AD_UNEXPECTED_MESSAGE;
324                     goto f_err;
325                 }
326
327                 if (thisrr->length >
328                     SSL3_BUFFER_get_len(rbuf) - SSL3_RT_HEADER_LENGTH) {
329                     al = SSL_AD_RECORD_OVERFLOW;
330                     SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_PACKET_LENGTH_TOO_LONG);
331                     goto f_err;
332                 }
333             }
334
335             /* now s->rlayer.rstate == SSL_ST_READ_BODY */
336         }
337
338         if (SSL_IS_TLS13(s)) {
339             if (thisrr->length > SSL3_RT_MAX_TLS13_ENCRYPTED_LENGTH) {
340                 al = SSL_AD_RECORD_OVERFLOW;
341                 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
342                 goto f_err;
343             }
344         } else {
345             size_t len = SSL3_RT_MAX_ENCRYPTED_LENGTH;
346
347 #ifndef OPENSSL_NO_COMP
348             /*
349              * If OPENSSL_NO_COMP is defined then SSL3_RT_MAX_ENCRYPTED_LENGTH
350              * does not include the compression overhead anyway.
351              */
352             if (s->expand == NULL)
353                 len -= SSL3_RT_MAX_COMPRESSED_OVERHEAD;
354 #endif
355
356             if (thisrr->length > len) {
357                 al = SSL_AD_RECORD_OVERFLOW;
358                 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
359                 goto f_err;
360             }
361         }
362
363         /*
364          * s->rlayer.rstate == SSL_ST_READ_BODY, get and decode the data.
365          * Calculate how much more data we need to read for the rest of the
366          * record
367          */
368         if (thisrr->rec_version == SSL2_VERSION) {
369             more = thisrr->length + SSL2_RT_HEADER_LENGTH
370                 - SSL3_RT_HEADER_LENGTH;
371         } else {
372             more = thisrr->length;
373         }
374         if (more > 0) {
375             /* now s->packet_length == SSL3_RT_HEADER_LENGTH */
376
377             rret = ssl3_read_n(s, more, more, 1, 0, &n);
378             if (rret <= 0)
379                 return rret;     /* error or non-blocking io */
380         }
381
382         /* set state for later operations */
383         RECORD_LAYER_set_rstate(&s->rlayer, SSL_ST_READ_HEADER);
384
385         /*
386          * At this point, s->packet_length == SSL3_RT_HEADER_LENGTH
387          * + thisrr->length, or s->packet_length == SSL2_RT_HEADER_LENGTH
388          * + thisrr->length and we have that many bytes in s->packet
389          */
390         if (thisrr->rec_version == SSL2_VERSION) {
391             thisrr->input =
392                 &(RECORD_LAYER_get_packet(&s->rlayer)[SSL2_RT_HEADER_LENGTH]);
393         } else {
394             thisrr->input =
395                 &(RECORD_LAYER_get_packet(&s->rlayer)[SSL3_RT_HEADER_LENGTH]);
396         }
397
398         /*
399          * ok, we can now read from 's->packet' data into 'thisrr' thisrr->input
400          * points at thisrr->length bytes, which need to be copied into
401          * thisrr->data by either the decryption or by the decompression When
402          * the data is 'copied' into the thisrr->data buffer, thisrr->input will
403          * be pointed at the new buffer
404          */
405
406         /*
407          * We now have - encrypted [ MAC [ compressed [ plain ] ] ]
408          * thisrr->length bytes of encrypted compressed stuff.
409          */
410
411         /* decrypt in place in 'thisrr->input' */
412         thisrr->data = thisrr->input;
413         thisrr->orig_len = thisrr->length;
414
415         /* Mark this record as not read by upper layers yet */
416         thisrr->read = 0;
417
418         num_recs++;
419
420         /* we have pulled in a full packet so zero things */
421         RECORD_LAYER_reset_packet_length(&s->rlayer);
422         RECORD_LAYER_clear_first_record(&s->rlayer);
423     } while (num_recs < max_recs
424              && thisrr->type == SSL3_RT_APPLICATION_DATA
425              && SSL_USE_EXPLICIT_IV(s)
426              && s->enc_read_ctx != NULL
427              && (EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(s->enc_read_ctx))
428                  & EVP_CIPH_FLAG_PIPELINE)
429              && ssl3_record_app_data_waiting(s));
430
431     /*
432      * If in encrypt-then-mac mode calculate mac from encrypted record. All
433      * the details below are public so no timing details can leak.
434      */
435     if (SSL_READ_ETM(s) && s->read_hash) {
436         unsigned char *mac;
437         /* TODO(size_t): convert this to do size_t properly */
438         imac_size = EVP_MD_CTX_size(s->read_hash);
439         assert(imac_size >= 0 && imac_size <= EVP_MAX_MD_SIZE);
440         if (imac_size < 0 || imac_size > EVP_MAX_MD_SIZE) {
441                 al = SSL_AD_INTERNAL_ERROR;
442                 SSLerr(SSL_F_SSL3_GET_RECORD, ERR_LIB_EVP);
443                 goto f_err;
444         }
445         mac_size = (size_t)imac_size;
446         for (j = 0; j < num_recs; j++) {
447             thisrr = &rr[j];
448
449             if (thisrr->length < mac_size) {
450                 al = SSL_AD_DECODE_ERROR;
451                 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_LENGTH_TOO_SHORT);
452                 goto f_err;
453             }
454             thisrr->length -= mac_size;
455             mac = thisrr->data + thisrr->length;
456             i = s->method->ssl3_enc->mac(s, thisrr, md, 0 /* not send */ );
457             if (i == 0 || CRYPTO_memcmp(md, mac, mac_size) != 0) {
458                 al = SSL_AD_BAD_RECORD_MAC;
459                 SSLerr(SSL_F_SSL3_GET_RECORD,
460                        SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
461                 goto f_err;
462             }
463         }
464     }
465
466     first_rec_len = rr[0].length;
467
468     enc_err = s->method->ssl3_enc->enc(s, rr, num_recs, 0);
469
470     /*-
471      * enc_err is:
472      *    0: (in non-constant time) if the record is publicly invalid.
473      *    1: if the padding is valid
474      *    -1: if the padding is invalid
475      */
476     if (enc_err == 0) {
477         if (num_recs == 1 && ossl_statem_skip_early_data(s)) {
478             /*
479              * Valid early_data that we cannot decrypt might fail here as
480              * publicly invalid. We treat it like an empty record.
481              */
482
483             thisrr = &rr[0];
484
485             if (!early_data_count_ok(s, thisrr->length,
486                                      EARLY_DATA_CIPHERTEXT_OVERHEAD, &al))
487                 goto f_err;
488
489             thisrr->length = 0;
490             thisrr->read = 1;
491             RECORD_LAYER_set_numrpipes(&s->rlayer, 1);
492             RECORD_LAYER_reset_read_sequence(&s->rlayer);
493             return 1;
494         }
495         al = SSL_AD_DECRYPTION_FAILED;
496         SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BLOCK_CIPHER_PAD_IS_WRONG);
497         goto f_err;
498     }
499 #ifdef SSL_DEBUG
500     printf("dec %"OSSLzu"\n", rr[0].length);
501     {
502         size_t z;
503         for (z = 0; z < rr[0].length; z++)
504             printf("%02X%c", rr[0].data[z], ((z + 1) % 16) ? ' ' : '\n');
505     }
506     printf("\n");
507 #endif
508
509     /* r->length is now the compressed data plus mac */
510     if ((sess != NULL) &&
511         (s->enc_read_ctx != NULL) &&
512         (!SSL_READ_ETM(s) && EVP_MD_CTX_md(s->read_hash) != NULL)) {
513         /* s->read_hash != NULL => mac_size != -1 */
514         unsigned char *mac = NULL;
515         unsigned char mac_tmp[EVP_MAX_MD_SIZE];
516
517         mac_size = EVP_MD_CTX_size(s->read_hash);
518         OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);
519
520         for (j = 0; j < num_recs; j++) {
521             thisrr = &rr[j];
522             /*
523              * orig_len is the length of the record before any padding was
524              * removed. This is public information, as is the MAC in use,
525              * therefore we can safely process the record in a different amount
526              * of time if it's too short to possibly contain a MAC.
527              */
528             if (thisrr->orig_len < mac_size ||
529                 /* CBC records must have a padding length byte too. */
530                 (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
531                  thisrr->orig_len < mac_size + 1)) {
532                 al = SSL_AD_DECODE_ERROR;
533                 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_LENGTH_TOO_SHORT);
534                 goto f_err;
535             }
536
537             if (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE) {
538                 /*
539                  * We update the length so that the TLS header bytes can be
540                  * constructed correctly but we need to extract the MAC in
541                  * constant time from within the record, without leaking the
542                  * contents of the padding bytes.
543                  */
544                 mac = mac_tmp;
545                 ssl3_cbc_copy_mac(mac_tmp, thisrr, mac_size);
546                 thisrr->length -= mac_size;
547             } else {
548                 /*
549                  * In this case there's no padding, so |rec->orig_len| equals
550                  * |rec->length| and we checked that there's enough bytes for
551                  * |mac_size| above.
552                  */
553                 thisrr->length -= mac_size;
554                 mac = &thisrr->data[thisrr->length];
555             }
556
557             i = s->method->ssl3_enc->mac(s, thisrr, md, 0 /* not send */ );
558             if (i == 0 || mac == NULL
559                 || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0)
560                 enc_err = -1;
561             if (thisrr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size)
562                 enc_err = -1;
563         }
564     }
565
566     if (enc_err < 0) {
567         if (num_recs == 1 && ossl_statem_skip_early_data(s)) {
568             /*
569              * We assume this is unreadable early_data - we treat it like an
570              * empty record
571              */
572
573             /*
574              * The record length may have been modified by the mac check above
575              * so we use the previously saved value
576              */
577             if (!early_data_count_ok(s, first_rec_len,
578                                      EARLY_DATA_CIPHERTEXT_OVERHEAD, &al))
579                 goto f_err;
580
581             thisrr = &rr[0];
582             thisrr->length = 0;
583             thisrr->read = 1;
584             RECORD_LAYER_set_numrpipes(&s->rlayer, 1);
585             RECORD_LAYER_reset_read_sequence(&s->rlayer);
586             return 1;
587         }
588         /*
589          * A separate 'decryption_failed' alert was introduced with TLS 1.0,
590          * SSL 3.0 only has 'bad_record_mac'.  But unless a decryption
591          * failure is directly visible from the ciphertext anyway, we should
592          * not reveal which kind of error occurred -- this might become
593          * visible to an attacker (e.g. via a logfile)
594          */
595         al = SSL_AD_BAD_RECORD_MAC;
596         SSLerr(SSL_F_SSL3_GET_RECORD,
597                SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
598         goto f_err;
599     }
600
601     for (j = 0; j < num_recs; j++) {
602         thisrr = &rr[j];
603
604         /* thisrr->length is now just compressed */
605         if (s->expand != NULL) {
606             if (thisrr->length > SSL3_RT_MAX_COMPRESSED_LENGTH) {
607                 al = SSL_AD_RECORD_OVERFLOW;
608                 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_COMPRESSED_LENGTH_TOO_LONG);
609                 goto f_err;
610             }
611             if (!ssl3_do_uncompress(s, thisrr)) {
612                 al = SSL_AD_DECOMPRESSION_FAILURE;
613                 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BAD_DECOMPRESSION);
614                 goto f_err;
615             }
616         }
617
618         if (SSL_IS_TLS13(s) && s->enc_read_ctx != NULL) {
619             size_t end;
620
621             if (thisrr->length == 0) {
622                 al = SSL_AD_UNEXPECTED_MESSAGE;
623                 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BAD_RECORD_TYPE);
624                 goto f_err;
625             }
626
627             /* Strip trailing padding */
628             for (end = thisrr->length - 1; end > 0 && thisrr->data[end] == 0;
629                  end--)
630                 continue;
631
632             thisrr->length = end;
633             thisrr->type = thisrr->data[end];
634             if (thisrr->type != SSL3_RT_APPLICATION_DATA
635                     && thisrr->type != SSL3_RT_ALERT
636                     && thisrr->type != SSL3_RT_HANDSHAKE) {
637                 al = SSL_AD_UNEXPECTED_MESSAGE;
638                 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BAD_RECORD_TYPE);
639                 goto f_err;
640             }
641             if (s->msg_callback)
642                 s->msg_callback(0, s->version, SSL3_RT_INNER_CONTENT_TYPE,
643                                 &thisrr->data[end], 1, s, s->msg_callback_arg);
644         }
645
646         if (thisrr->length > SSL3_RT_MAX_PLAIN_LENGTH) {
647             al = SSL_AD_RECORD_OVERFLOW;
648             SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_DATA_LENGTH_TOO_LONG);
649             goto f_err;
650         }
651
652         thisrr->off = 0;
653         /*-
654          * So at this point the following is true
655          * thisrr->type   is the type of record
656          * thisrr->length == number of bytes in record
657          * thisrr->off    == offset to first valid byte
658          * thisrr->data   == where to take bytes from, increment after use :-).
659          */
660
661         /* just read a 0 length packet */
662         if (thisrr->length == 0) {
663             RECORD_LAYER_inc_empty_record_count(&s->rlayer);
664             if (RECORD_LAYER_get_empty_record_count(&s->rlayer)
665                 > MAX_EMPTY_RECORDS) {
666                 al = SSL_AD_UNEXPECTED_MESSAGE;
667                 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_RECORD_TOO_SMALL);
668                 goto f_err;
669             }
670         } else {
671             RECORD_LAYER_reset_empty_record_count(&s->rlayer);
672         }
673     }
674
675     if (s->early_data_state == SSL_EARLY_DATA_READING) {
676         thisrr = &rr[0];
677         if (thisrr->type == SSL3_RT_APPLICATION_DATA
678                 && !early_data_count_ok(s, thisrr->length, 0, &al))
679             goto f_err;
680     }
681
682     RECORD_LAYER_set_numrpipes(&s->rlayer, num_recs);
683     return 1;
684
685  f_err:
686     ssl3_send_alert(s, SSL3_AL_FATAL, al);
687  err:
688     return ret;
689 }
690
691 int ssl3_do_uncompress(SSL *ssl, SSL3_RECORD *rr)
692 {
693 #ifndef OPENSSL_NO_COMP
694     int i;
695
696     if (rr->comp == NULL) {
697         rr->comp = (unsigned char *)
698             OPENSSL_malloc(SSL3_RT_MAX_ENCRYPTED_LENGTH);
699     }
700     if (rr->comp == NULL)
701         return 0;
702
703     /* TODO(size_t): Convert this call */
704     i = COMP_expand_block(ssl->expand, rr->comp,
705                           SSL3_RT_MAX_PLAIN_LENGTH, rr->data, (int)rr->length);
706     if (i < 0)
707         return 0;
708     else
709         rr->length = i;
710     rr->data = rr->comp;
711 #endif
712     return 1;
713 }
714
715 int ssl3_do_compress(SSL *ssl, SSL3_RECORD *wr)
716 {
717 #ifndef OPENSSL_NO_COMP
718     int i;
719
720     /* TODO(size_t): Convert this call */
721     i = COMP_compress_block(ssl->compress, wr->data,
722                             (int)(wr->length + SSL3_RT_MAX_COMPRESSED_OVERHEAD),
723                             wr->input, (int)wr->length);
724     if (i < 0)
725         return (0);
726     else
727         wr->length = i;
728
729     wr->input = wr->data;
730 #endif
731     return (1);
732 }
733
734 /*-
735  * ssl3_enc encrypts/decrypts |n_recs| records in |inrecs|
736  *
737  * Returns:
738  *   0: (in non-constant time) if the record is publically invalid (i.e. too
739  *       short etc).
740  *   1: if the record's padding is valid / the encryption was successful.
741  *   -1: if the record's padding is invalid or, if sending, an internal error
742  *       occurred.
743  */
744 int ssl3_enc(SSL *s, SSL3_RECORD *inrecs, size_t n_recs, int sending)
745 {
746     SSL3_RECORD *rec;
747     EVP_CIPHER_CTX *ds;
748     size_t l, i;
749     size_t bs, mac_size = 0;
750     int imac_size;
751     const EVP_CIPHER *enc;
752
753     rec = inrecs;
754     /*
755      * We shouldn't ever be called with more than one record in the SSLv3 case
756      */
757     if (n_recs != 1)
758         return 0;
759     if (sending) {
760         ds = s->enc_write_ctx;
761         if (s->enc_write_ctx == NULL)
762             enc = NULL;
763         else
764             enc = EVP_CIPHER_CTX_cipher(s->enc_write_ctx);
765     } else {
766         ds = s->enc_read_ctx;
767         if (s->enc_read_ctx == NULL)
768             enc = NULL;
769         else
770             enc = EVP_CIPHER_CTX_cipher(s->enc_read_ctx);
771     }
772
773     if ((s->session == NULL) || (ds == NULL) || (enc == NULL)) {
774         memmove(rec->data, rec->input, rec->length);
775         rec->input = rec->data;
776     } else {
777         l = rec->length;
778         /* TODO(size_t): Convert this call */
779         bs = EVP_CIPHER_CTX_block_size(ds);
780
781         /* COMPRESS */
782
783         if ((bs != 1) && sending) {
784             i = bs - (l % bs);
785
786             /* we need to add 'i-1' padding bytes */
787             l += i;
788             /*
789              * the last of these zero bytes will be overwritten with the
790              * padding length.
791              */
792             memset(&rec->input[rec->length], 0, i);
793             rec->length += i;
794             rec->input[l - 1] = (unsigned char)(i - 1);
795         }
796
797         if (!sending) {
798             if (l == 0 || l % bs != 0)
799                 return 0;
800             /* otherwise, rec->length >= bs */
801         }
802
803         /* TODO(size_t): Convert this call */
804         if (EVP_Cipher(ds, rec->data, rec->input, (unsigned int)l) < 1)
805             return -1;
806
807         if (EVP_MD_CTX_md(s->read_hash) != NULL) {
808             /* TODO(size_t): convert me */
809             imac_size = EVP_MD_CTX_size(s->read_hash);
810             if (imac_size < 0)
811                 return -1;
812             mac_size = (size_t)imac_size;
813         }
814         if ((bs != 1) && !sending)
815             return ssl3_cbc_remove_padding(rec, bs, mac_size);
816     }
817     return (1);
818 }
819
820 #define MAX_PADDING 256
821 /*-
822  * tls1_enc encrypts/decrypts |n_recs| in |recs|.
823  *
824  * Returns:
825  *   0: (in non-constant time) if the record is publically invalid (i.e. too
826  *       short etc).
827  *   1: if the record's padding is valid / the encryption was successful.
828  *   -1: if the record's padding/AEAD-authenticator is invalid or, if sending,
829  *       an internal error occurred.
830  */
831 int tls1_enc(SSL *s, SSL3_RECORD *recs, size_t n_recs, int sending)
832 {
833     EVP_CIPHER_CTX *ds;
834     size_t reclen[SSL_MAX_PIPELINES];
835     unsigned char buf[SSL_MAX_PIPELINES][EVP_AEAD_TLS1_AAD_LEN];
836     int i, pad = 0, ret, tmpr;
837     size_t bs, mac_size = 0, ctr, padnum, loop;
838     unsigned char padval;
839     int imac_size;
840     const EVP_CIPHER *enc;
841
842     if (n_recs == 0)
843         return 0;
844
845     if (sending) {
846         if (EVP_MD_CTX_md(s->write_hash)) {
847             int n = EVP_MD_CTX_size(s->write_hash);
848             OPENSSL_assert(n >= 0);
849         }
850         ds = s->enc_write_ctx;
851         if (s->enc_write_ctx == NULL)
852             enc = NULL;
853         else {
854             int ivlen;
855             enc = EVP_CIPHER_CTX_cipher(s->enc_write_ctx);
856             /* For TLSv1.1 and later explicit IV */
857             if (SSL_USE_EXPLICIT_IV(s)
858                 && EVP_CIPHER_mode(enc) == EVP_CIPH_CBC_MODE)
859                 ivlen = EVP_CIPHER_iv_length(enc);
860             else
861                 ivlen = 0;
862             if (ivlen > 1) {
863                 for (ctr = 0; ctr < n_recs; ctr++) {
864                     if (recs[ctr].data != recs[ctr].input) {
865                         /*
866                          * we can't write into the input stream: Can this ever
867                          * happen?? (steve)
868                          */
869                         SSLerr(SSL_F_TLS1_ENC, ERR_R_INTERNAL_ERROR);
870                         return -1;
871                     } else if (RAND_bytes(recs[ctr].input, ivlen) <= 0) {
872                         SSLerr(SSL_F_TLS1_ENC, ERR_R_INTERNAL_ERROR);
873                         return -1;
874                     }
875                 }
876             }
877         }
878     } else {
879         if (EVP_MD_CTX_md(s->read_hash)) {
880             int n = EVP_MD_CTX_size(s->read_hash);
881             OPENSSL_assert(n >= 0);
882         }
883         ds = s->enc_read_ctx;
884         if (s->enc_read_ctx == NULL)
885             enc = NULL;
886         else
887             enc = EVP_CIPHER_CTX_cipher(s->enc_read_ctx);
888     }
889
890     if ((s->session == NULL) || (ds == NULL) || (enc == NULL)) {
891         for (ctr = 0; ctr < n_recs; ctr++) {
892             memmove(recs[ctr].data, recs[ctr].input, recs[ctr].length);
893             recs[ctr].input = recs[ctr].data;
894         }
895         ret = 1;
896     } else {
897         bs = EVP_CIPHER_block_size(EVP_CIPHER_CTX_cipher(ds));
898
899         if (n_recs > 1) {
900             if (!(EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ds))
901                   & EVP_CIPH_FLAG_PIPELINE)) {
902                 /*
903                  * We shouldn't have been called with pipeline data if the
904                  * cipher doesn't support pipelining
905                  */
906                 SSLerr(SSL_F_TLS1_ENC, SSL_R_PIPELINE_FAILURE);
907                 return -1;
908             }
909         }
910         for (ctr = 0; ctr < n_recs; ctr++) {
911             reclen[ctr] = recs[ctr].length;
912
913             if (EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ds))
914                 & EVP_CIPH_FLAG_AEAD_CIPHER) {
915                 unsigned char *seq;
916
917                 seq = sending ? RECORD_LAYER_get_write_sequence(&s->rlayer)
918                     : RECORD_LAYER_get_read_sequence(&s->rlayer);
919
920                 if (SSL_IS_DTLS(s)) {
921                     /* DTLS does not support pipelining */
922                     unsigned char dtlsseq[9], *p = dtlsseq;
923
924                     s2n(sending ? DTLS_RECORD_LAYER_get_w_epoch(&s->rlayer) :
925                         DTLS_RECORD_LAYER_get_r_epoch(&s->rlayer), p);
926                     memcpy(p, &seq[2], 6);
927                     memcpy(buf[ctr], dtlsseq, 8);
928                 } else {
929                     memcpy(buf[ctr], seq, 8);
930                     for (i = 7; i >= 0; i--) { /* increment */
931                         ++seq[i];
932                         if (seq[i] != 0)
933                             break;
934                     }
935                 }
936
937                 buf[ctr][8] = recs[ctr].type;
938                 buf[ctr][9] = (unsigned char)(s->version >> 8);
939                 buf[ctr][10] = (unsigned char)(s->version);
940                 buf[ctr][11] = (unsigned char)(recs[ctr].length >> 8);
941                 buf[ctr][12] = (unsigned char)(recs[ctr].length & 0xff);
942                 pad = EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_AEAD_TLS1_AAD,
943                                           EVP_AEAD_TLS1_AAD_LEN, buf[ctr]);
944                 if (pad <= 0)
945                     return -1;
946
947                 if (sending) {
948                     reclen[ctr] += pad;
949                     recs[ctr].length += pad;
950                 }
951
952             } else if ((bs != 1) && sending) {
953                 padnum = bs - (reclen[ctr] % bs);
954
955                 /* Add weird padding of upto 256 bytes */
956
957                 if (padnum > MAX_PADDING)
958                     return -1;
959                 /* we need to add 'padnum' padding bytes of value padval */
960                 padval = (unsigned char)(padnum - 1);
961                 for (loop = reclen[ctr]; loop < reclen[ctr] + padnum; loop++)
962                     recs[ctr].input[loop] = padval;
963                 reclen[ctr] += padnum;
964                 recs[ctr].length += padnum;
965             }
966
967             if (!sending) {
968                 if (reclen[ctr] == 0 || reclen[ctr] % bs != 0)
969                     return 0;
970             }
971         }
972         if (n_recs > 1) {
973             unsigned char *data[SSL_MAX_PIPELINES];
974
975             /* Set the output buffers */
976             for (ctr = 0; ctr < n_recs; ctr++) {
977                 data[ctr] = recs[ctr].data;
978             }
979             if (EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS,
980                                     (int)n_recs, data) <= 0) {
981                 SSLerr(SSL_F_TLS1_ENC, SSL_R_PIPELINE_FAILURE);
982             }
983             /* Set the input buffers */
984             for (ctr = 0; ctr < n_recs; ctr++) {
985                 data[ctr] = recs[ctr].input;
986             }
987             if (EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_INPUT_BUFS,
988                                     (int)n_recs, data) <= 0
989                 || EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_INPUT_LENS,
990                                        (int)n_recs, reclen) <= 0) {
991                 SSLerr(SSL_F_TLS1_ENC, SSL_R_PIPELINE_FAILURE);
992                 return -1;
993             }
994         }
995
996         /* TODO(size_t): Convert this call */
997         tmpr = EVP_Cipher(ds, recs[0].data, recs[0].input,
998                           (unsigned int)reclen[0]);
999         if ((EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(ds))
1000              & EVP_CIPH_FLAG_CUSTOM_CIPHER)
1001             ? (tmpr < 0)
1002             : (tmpr == 0))
1003             return -1;          /* AEAD can fail to verify MAC */
1004         if (sending == 0) {
1005             if (EVP_CIPHER_mode(enc) == EVP_CIPH_GCM_MODE) {
1006                 for (ctr = 0; ctr < n_recs; ctr++) {
1007                     recs[ctr].data += EVP_GCM_TLS_EXPLICIT_IV_LEN;
1008                     recs[ctr].input += EVP_GCM_TLS_EXPLICIT_IV_LEN;
1009                     recs[ctr].length -= EVP_GCM_TLS_EXPLICIT_IV_LEN;
1010                 }
1011             } else if (EVP_CIPHER_mode(enc) == EVP_CIPH_CCM_MODE) {
1012                 for (ctr = 0; ctr < n_recs; ctr++) {
1013                     recs[ctr].data += EVP_CCM_TLS_EXPLICIT_IV_LEN;
1014                     recs[ctr].input += EVP_CCM_TLS_EXPLICIT_IV_LEN;
1015                     recs[ctr].length -= EVP_CCM_TLS_EXPLICIT_IV_LEN;
1016                 }
1017             }
1018         }
1019
1020         ret = 1;
1021         if (!SSL_READ_ETM(s) && EVP_MD_CTX_md(s->read_hash) != NULL) {
1022             imac_size = EVP_MD_CTX_size(s->read_hash);
1023             if (imac_size < 0)
1024                 return -1;
1025             mac_size = (size_t)imac_size;
1026         }
1027         if ((bs != 1) && !sending) {
1028             int tmpret;
1029             for (ctr = 0; ctr < n_recs; ctr++) {
1030                 tmpret = tls1_cbc_remove_padding(s, &recs[ctr], bs, mac_size);
1031                 /*
1032                  * If tmpret == 0 then this means publicly invalid so we can
1033                  * short circuit things here. Otherwise we must respect constant
1034                  * time behaviour.
1035                  */
1036                 if (tmpret == 0)
1037                     return 0;
1038                 ret = constant_time_select_int(constant_time_eq_int(tmpret, 1),
1039                                                ret, -1);
1040             }
1041         }
1042         if (pad && !sending) {
1043             for (ctr = 0; ctr < n_recs; ctr++) {
1044                 recs[ctr].length -= pad;
1045             }
1046         }
1047     }
1048     return ret;
1049 }
1050
1051 int n_ssl3_mac(SSL *ssl, SSL3_RECORD *rec, unsigned char *md, int sending)
1052 {
1053     unsigned char *mac_sec, *seq;
1054     const EVP_MD_CTX *hash;
1055     unsigned char *p, rec_char;
1056     size_t md_size;
1057     size_t npad;
1058     int t;
1059
1060     if (sending) {
1061         mac_sec = &(ssl->s3->write_mac_secret[0]);
1062         seq = RECORD_LAYER_get_write_sequence(&ssl->rlayer);
1063         hash = ssl->write_hash;
1064     } else {
1065         mac_sec = &(ssl->s3->read_mac_secret[0]);
1066         seq = RECORD_LAYER_get_read_sequence(&ssl->rlayer);
1067         hash = ssl->read_hash;
1068     }
1069
1070     t = EVP_MD_CTX_size(hash);
1071     if (t < 0)
1072         return 0;
1073     md_size = t;
1074     npad = (48 / md_size) * md_size;
1075
1076     if (!sending &&
1077         EVP_CIPHER_CTX_mode(ssl->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
1078         ssl3_cbc_record_digest_supported(hash)) {
1079         /*
1080          * This is a CBC-encrypted record. We must avoid leaking any
1081          * timing-side channel information about how many blocks of data we
1082          * are hashing because that gives an attacker a timing-oracle.
1083          */
1084
1085         /*-
1086          * npad is, at most, 48 bytes and that's with MD5:
1087          *   16 + 48 + 8 (sequence bytes) + 1 + 2 = 75.
1088          *
1089          * With SHA-1 (the largest hash speced for SSLv3) the hash size
1090          * goes up 4, but npad goes down by 8, resulting in a smaller
1091          * total size.
1092          */
1093         unsigned char header[75];
1094         size_t j = 0;
1095         memcpy(header + j, mac_sec, md_size);
1096         j += md_size;
1097         memcpy(header + j, ssl3_pad_1, npad);
1098         j += npad;
1099         memcpy(header + j, seq, 8);
1100         j += 8;
1101         header[j++] = rec->type;
1102         header[j++] = (unsigned char)(rec->length >> 8);
1103         header[j++] = (unsigned char)(rec->length & 0xff);
1104
1105         /* Final param == is SSLv3 */
1106         if (ssl3_cbc_digest_record(hash,
1107                                    md, &md_size,
1108                                    header, rec->input,
1109                                    rec->length + md_size, rec->orig_len,
1110                                    mac_sec, md_size, 1) <= 0)
1111             return 0;
1112     } else {
1113         unsigned int md_size_u;
1114         /* Chop the digest off the end :-) */
1115         EVP_MD_CTX *md_ctx = EVP_MD_CTX_new();
1116
1117         if (md_ctx == NULL)
1118             return 0;
1119
1120         rec_char = rec->type;
1121         p = md;
1122         s2n(rec->length, p);
1123         if (EVP_MD_CTX_copy_ex(md_ctx, hash) <= 0
1124             || EVP_DigestUpdate(md_ctx, mac_sec, md_size) <= 0
1125             || EVP_DigestUpdate(md_ctx, ssl3_pad_1, npad) <= 0
1126             || EVP_DigestUpdate(md_ctx, seq, 8) <= 0
1127             || EVP_DigestUpdate(md_ctx, &rec_char, 1) <= 0
1128             || EVP_DigestUpdate(md_ctx, md, 2) <= 0
1129             || EVP_DigestUpdate(md_ctx, rec->input, rec->length) <= 0
1130             || EVP_DigestFinal_ex(md_ctx, md, NULL) <= 0
1131             || EVP_MD_CTX_copy_ex(md_ctx, hash) <= 0
1132             || EVP_DigestUpdate(md_ctx, mac_sec, md_size) <= 0
1133             || EVP_DigestUpdate(md_ctx, ssl3_pad_2, npad) <= 0
1134             || EVP_DigestUpdate(md_ctx, md, md_size) <= 0
1135             || EVP_DigestFinal_ex(md_ctx, md, &md_size_u) <= 0) {
1136             EVP_MD_CTX_reset(md_ctx);
1137             return 0;
1138         }
1139
1140         EVP_MD_CTX_free(md_ctx);
1141     }
1142
1143     ssl3_record_sequence_update(seq);
1144     return 1;
1145 }
1146
1147 int tls1_mac(SSL *ssl, SSL3_RECORD *rec, unsigned char *md, int sending)
1148 {
1149     unsigned char *seq;
1150     EVP_MD_CTX *hash;
1151     size_t md_size;
1152     int i;
1153     EVP_MD_CTX *hmac = NULL, *mac_ctx;
1154     unsigned char header[13];
1155     int stream_mac = (sending ? (ssl->mac_flags & SSL_MAC_FLAG_WRITE_MAC_STREAM)
1156                       : (ssl->mac_flags & SSL_MAC_FLAG_READ_MAC_STREAM));
1157     int t;
1158
1159     if (sending) {
1160         seq = RECORD_LAYER_get_write_sequence(&ssl->rlayer);
1161         hash = ssl->write_hash;
1162     } else {
1163         seq = RECORD_LAYER_get_read_sequence(&ssl->rlayer);
1164         hash = ssl->read_hash;
1165     }
1166
1167     t = EVP_MD_CTX_size(hash);
1168     OPENSSL_assert(t >= 0);
1169     md_size = t;
1170
1171     /* I should fix this up TLS TLS TLS TLS TLS XXXXXXXX */
1172     if (stream_mac) {
1173         mac_ctx = hash;
1174     } else {
1175         hmac = EVP_MD_CTX_new();
1176         if (hmac == NULL || !EVP_MD_CTX_copy(hmac, hash))
1177             return 0;
1178         mac_ctx = hmac;
1179     }
1180
1181     if (SSL_IS_DTLS(ssl)) {
1182         unsigned char dtlsseq[8], *p = dtlsseq;
1183
1184         s2n(sending ? DTLS_RECORD_LAYER_get_w_epoch(&ssl->rlayer) :
1185             DTLS_RECORD_LAYER_get_r_epoch(&ssl->rlayer), p);
1186         memcpy(p, &seq[2], 6);
1187
1188         memcpy(header, dtlsseq, 8);
1189     } else
1190         memcpy(header, seq, 8);
1191
1192     header[8] = rec->type;
1193     header[9] = (unsigned char)(ssl->version >> 8);
1194     header[10] = (unsigned char)(ssl->version);
1195     header[11] = (unsigned char)(rec->length >> 8);
1196     header[12] = (unsigned char)(rec->length & 0xff);
1197
1198     if (!sending && !SSL_READ_ETM(ssl) &&
1199         EVP_CIPHER_CTX_mode(ssl->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
1200         ssl3_cbc_record_digest_supported(mac_ctx)) {
1201         /*
1202          * This is a CBC-encrypted record. We must avoid leaking any
1203          * timing-side channel information about how many blocks of data we
1204          * are hashing because that gives an attacker a timing-oracle.
1205          */
1206         /* Final param == not SSLv3 */
1207         if (ssl3_cbc_digest_record(mac_ctx,
1208                                    md, &md_size,
1209                                    header, rec->input,
1210                                    rec->length + md_size, rec->orig_len,
1211                                    ssl->s3->read_mac_secret,
1212                                    ssl->s3->read_mac_secret_size, 0) <= 0) {
1213             EVP_MD_CTX_free(hmac);
1214             return -1;
1215         }
1216     } else {
1217         /* TODO(size_t): Convert these calls */
1218         if (EVP_DigestSignUpdate(mac_ctx, header, sizeof(header)) <= 0
1219             || EVP_DigestSignUpdate(mac_ctx, rec->input, rec->length) <= 0
1220             || EVP_DigestSignFinal(mac_ctx, md, &md_size) <= 0) {
1221             EVP_MD_CTX_free(hmac);
1222             return 0;
1223         }
1224     }
1225
1226     EVP_MD_CTX_free(hmac);
1227
1228 #ifdef SSL_DEBUG
1229     fprintf(stderr, "seq=");
1230     {
1231         int z;
1232         for (z = 0; z < 8; z++)
1233             fprintf(stderr, "%02X ", seq[z]);
1234         fprintf(stderr, "\n");
1235     }
1236     fprintf(stderr, "rec=");
1237     {
1238         size_t z;
1239         for (z = 0; z < rec->length; z++)
1240             fprintf(stderr, "%02X ", rec->data[z]);
1241         fprintf(stderr, "\n");
1242     }
1243 #endif
1244
1245     if (!SSL_IS_DTLS(ssl)) {
1246         for (i = 7; i >= 0; i--) {
1247             ++seq[i];
1248             if (seq[i] != 0)
1249                 break;
1250         }
1251     }
1252 #ifdef SSL_DEBUG
1253     {
1254         unsigned int z;
1255         for (z = 0; z < md_size; z++)
1256             fprintf(stderr, "%02X ", md[z]);
1257         fprintf(stderr, "\n");
1258     }
1259 #endif
1260     return 1;
1261 }
1262
1263 /*-
1264  * ssl3_cbc_remove_padding removes padding from the decrypted, SSLv3, CBC
1265  * record in |rec| by updating |rec->length| in constant time.
1266  *
1267  * block_size: the block size of the cipher used to encrypt the record.
1268  * returns:
1269  *   0: (in non-constant time) if the record is publicly invalid.
1270  *   1: if the padding was valid
1271  *  -1: otherwise.
1272  */
1273 int ssl3_cbc_remove_padding(SSL3_RECORD *rec,
1274                             size_t block_size, size_t mac_size)
1275 {
1276     size_t padding_length;
1277     size_t good;
1278     const size_t overhead = 1 /* padding length byte */  + mac_size;
1279
1280     /*
1281      * These lengths are all public so we can test them in non-constant time.
1282      */
1283     if (overhead > rec->length)
1284         return 0;
1285
1286     padding_length = rec->data[rec->length - 1];
1287     good = constant_time_ge_s(rec->length, padding_length + overhead);
1288     /* SSLv3 requires that the padding is minimal. */
1289     good &= constant_time_ge_s(block_size, padding_length + 1);
1290     rec->length -= good & (padding_length + 1);
1291     return constant_time_select_int_s(good, 1, -1);
1292 }
1293
1294 /*-
1295  * tls1_cbc_remove_padding removes the CBC padding from the decrypted, TLS, CBC
1296  * record in |rec| in constant time and returns 1 if the padding is valid and
1297  * -1 otherwise. It also removes any explicit IV from the start of the record
1298  * without leaking any timing about whether there was enough space after the
1299  * padding was removed.
1300  *
1301  * block_size: the block size of the cipher used to encrypt the record.
1302  * returns:
1303  *   0: (in non-constant time) if the record is publicly invalid.
1304  *   1: if the padding was valid
1305  *  -1: otherwise.
1306  */
1307 int tls1_cbc_remove_padding(const SSL *s,
1308                             SSL3_RECORD *rec,
1309                             size_t block_size, size_t mac_size)
1310 {
1311     size_t good;
1312     size_t padding_length, to_check, i;
1313     const size_t overhead = 1 /* padding length byte */  + mac_size;
1314     /* Check if version requires explicit IV */
1315     if (SSL_USE_EXPLICIT_IV(s)) {
1316         /*
1317          * These lengths are all public so we can test them in non-constant
1318          * time.
1319          */
1320         if (overhead + block_size > rec->length)
1321             return 0;
1322         /* We can now safely skip explicit IV */
1323         rec->data += block_size;
1324         rec->input += block_size;
1325         rec->length -= block_size;
1326         rec->orig_len -= block_size;
1327     } else if (overhead > rec->length)
1328         return 0;
1329
1330     padding_length = rec->data[rec->length - 1];
1331
1332     if (EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(s->enc_read_ctx)) &
1333         EVP_CIPH_FLAG_AEAD_CIPHER) {
1334         /* padding is already verified */
1335         rec->length -= padding_length + 1;
1336         return 1;
1337     }
1338
1339     good = constant_time_ge_s(rec->length, overhead + padding_length);
1340     /*
1341      * The padding consists of a length byte at the end of the record and
1342      * then that many bytes of padding, all with the same value as the length
1343      * byte. Thus, with the length byte included, there are i+1 bytes of
1344      * padding. We can't check just |padding_length+1| bytes because that
1345      * leaks decrypted information. Therefore we always have to check the
1346      * maximum amount of padding possible. (Again, the length of the record
1347      * is public information so we can use it.)
1348      */
1349     to_check = 256;            /* maximum amount of padding, inc length byte. */
1350     if (to_check > rec->length)
1351         to_check = rec->length;
1352
1353     for (i = 0; i < to_check; i++) {
1354         unsigned char mask = constant_time_ge_8_s(padding_length, i);
1355         unsigned char b = rec->data[rec->length - 1 - i];
1356         /*
1357          * The final |padding_length+1| bytes should all have the value
1358          * |padding_length|. Therefore the XOR should be zero.
1359          */
1360         good &= ~(mask & (padding_length ^ b));
1361     }
1362
1363     /*
1364      * If any of the final |padding_length+1| bytes had the wrong value, one
1365      * or more of the lower eight bits of |good| will be cleared.
1366      */
1367     good = constant_time_eq_s(0xff, good & 0xff);
1368     rec->length -= good & (padding_length + 1);
1369
1370     return constant_time_select_int_s(good, 1, -1);
1371 }
1372
1373 /*-
1374  * ssl3_cbc_copy_mac copies |md_size| bytes from the end of |rec| to |out| in
1375  * constant time (independent of the concrete value of rec->length, which may
1376  * vary within a 256-byte window).
1377  *
1378  * ssl3_cbc_remove_padding or tls1_cbc_remove_padding must be called prior to
1379  * this function.
1380  *
1381  * On entry:
1382  *   rec->orig_len >= md_size
1383  *   md_size <= EVP_MAX_MD_SIZE
1384  *
1385  * If CBC_MAC_ROTATE_IN_PLACE is defined then the rotation is performed with
1386  * variable accesses in a 64-byte-aligned buffer. Assuming that this fits into
1387  * a single or pair of cache-lines, then the variable memory accesses don't
1388  * actually affect the timing. CPUs with smaller cache-lines [if any] are
1389  * not multi-core and are not considered vulnerable to cache-timing attacks.
1390  */
1391 #define CBC_MAC_ROTATE_IN_PLACE
1392
1393 void ssl3_cbc_copy_mac(unsigned char *out,
1394                        const SSL3_RECORD *rec, size_t md_size)
1395 {
1396 #if defined(CBC_MAC_ROTATE_IN_PLACE)
1397     unsigned char rotated_mac_buf[64 + EVP_MAX_MD_SIZE];
1398     unsigned char *rotated_mac;
1399 #else
1400     unsigned char rotated_mac[EVP_MAX_MD_SIZE];
1401 #endif
1402
1403     /*
1404      * mac_end is the index of |rec->data| just after the end of the MAC.
1405      */
1406     size_t mac_end = rec->length;
1407     size_t mac_start = mac_end - md_size;
1408     size_t in_mac;
1409     /*
1410      * scan_start contains the number of bytes that we can ignore because the
1411      * MAC's position can only vary by 255 bytes.
1412      */
1413     size_t scan_start = 0;
1414     size_t i, j;
1415     size_t rotate_offset;
1416
1417     OPENSSL_assert(rec->orig_len >= md_size);
1418     OPENSSL_assert(md_size <= EVP_MAX_MD_SIZE);
1419
1420 #if defined(CBC_MAC_ROTATE_IN_PLACE)
1421     rotated_mac = rotated_mac_buf + ((0 - (size_t)rotated_mac_buf) & 63);
1422 #endif
1423
1424     /* This information is public so it's safe to branch based on it. */
1425     if (rec->orig_len > md_size + 255 + 1)
1426         scan_start = rec->orig_len - (md_size + 255 + 1);
1427
1428     in_mac = 0;
1429     rotate_offset = 0;
1430     memset(rotated_mac, 0, md_size);
1431     for (i = scan_start, j = 0; i < rec->orig_len; i++) {
1432         size_t mac_started = constant_time_eq_s(i, mac_start);
1433         size_t mac_ended = constant_time_lt_s(i, mac_end);
1434         unsigned char b = rec->data[i];
1435
1436         in_mac |= mac_started;
1437         in_mac &= mac_ended;
1438         rotate_offset |= j & mac_started;
1439         rotated_mac[j++] |= b & in_mac;
1440         j &= constant_time_lt_s(j, md_size);
1441     }
1442
1443     /* Now rotate the MAC */
1444 #if defined(CBC_MAC_ROTATE_IN_PLACE)
1445     j = 0;
1446     for (i = 0; i < md_size; i++) {
1447         /* in case cache-line is 32 bytes, touch second line */
1448         ((volatile unsigned char *)rotated_mac)[rotate_offset ^ 32];
1449         out[j++] = rotated_mac[rotate_offset++];
1450         rotate_offset &= constant_time_lt_s(rotate_offset, md_size);
1451     }
1452 #else
1453     memset(out, 0, md_size);
1454     rotate_offset = md_size - rotate_offset;
1455     rotate_offset &= constant_time_lt_s(rotate_offset, md_size);
1456     for (i = 0; i < md_size; i++) {
1457         for (j = 0; j < md_size; j++)
1458             out[j] |= rotated_mac[i] & constant_time_eq_8_s(j, rotate_offset);
1459         rotate_offset++;
1460         rotate_offset &= constant_time_lt_s(rotate_offset, md_size);
1461     }
1462 #endif
1463 }
1464
1465 int dtls1_process_record(SSL *s, DTLS1_BITMAP *bitmap)
1466 {
1467     int i, al;
1468     int enc_err;
1469     SSL_SESSION *sess;
1470     SSL3_RECORD *rr;
1471     int imac_size;
1472     size_t mac_size;
1473     unsigned char md[EVP_MAX_MD_SIZE];
1474
1475     rr = RECORD_LAYER_get_rrec(&s->rlayer);
1476     sess = s->session;
1477
1478     /*
1479      * At this point, s->packet_length == SSL3_RT_HEADER_LNGTH + rr->length,
1480      * and we have that many bytes in s->packet
1481      */
1482     rr->input = &(RECORD_LAYER_get_packet(&s->rlayer)[DTLS1_RT_HEADER_LENGTH]);
1483
1484     /*
1485      * ok, we can now read from 's->packet' data into 'rr' rr->input points
1486      * at rr->length bytes, which need to be copied into rr->data by either
1487      * the decryption or by the decompression When the data is 'copied' into
1488      * the rr->data buffer, rr->input will be pointed at the new buffer
1489      */
1490
1491     /*
1492      * We now have - encrypted [ MAC [ compressed [ plain ] ] ] rr->length
1493      * bytes of encrypted compressed stuff.
1494      */
1495
1496     /* check is not needed I believe */
1497     if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) {
1498         al = SSL_AD_RECORD_OVERFLOW;
1499         SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
1500         goto f_err;
1501     }
1502
1503     /* decrypt in place in 'rr->input' */
1504     rr->data = rr->input;
1505     rr->orig_len = rr->length;
1506
1507     if (SSL_READ_ETM(s) && s->read_hash) {
1508         unsigned char *mac;
1509         mac_size = EVP_MD_CTX_size(s->read_hash);
1510         OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);
1511         if (rr->orig_len < mac_size) {
1512             al = SSL_AD_DECODE_ERROR;
1513             SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_LENGTH_TOO_SHORT);
1514             goto f_err;
1515         }
1516         rr->length -= mac_size;
1517         mac = rr->data + rr->length;
1518         i = s->method->ssl3_enc->mac(s, rr, md, 0 /* not send */ );
1519         if (i == 0 || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0) {
1520             al = SSL_AD_BAD_RECORD_MAC;
1521             SSLerr(SSL_F_DTLS1_PROCESS_RECORD,
1522                    SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
1523             goto f_err;
1524         }
1525     }
1526
1527     enc_err = s->method->ssl3_enc->enc(s, rr, 1, 0);
1528     /*-
1529      * enc_err is:
1530      *    0: (in non-constant time) if the record is publically invalid.
1531      *    1: if the padding is valid
1532      *   -1: if the padding is invalid
1533      */
1534     if (enc_err == 0) {
1535         /* For DTLS we simply ignore bad packets. */
1536         rr->length = 0;
1537         RECORD_LAYER_reset_packet_length(&s->rlayer);
1538         goto err;
1539     }
1540 #ifdef SSL_DEBUG
1541     printf("dec %ld\n", rr->length);
1542     {
1543         size_t z;
1544         for (z = 0; z < rr->length; z++)
1545             printf("%02X%c", rr->data[z], ((z + 1) % 16) ? ' ' : '\n');
1546     }
1547     printf("\n");
1548 #endif
1549
1550     /* r->length is now the compressed data plus mac */
1551     if ((sess != NULL) && !SSL_READ_ETM(s) &&
1552         (s->enc_read_ctx != NULL) && (EVP_MD_CTX_md(s->read_hash) != NULL)) {
1553         /* s->read_hash != NULL => mac_size != -1 */
1554         unsigned char *mac = NULL;
1555         unsigned char mac_tmp[EVP_MAX_MD_SIZE];
1556
1557         /* TODO(size_t): Convert this to do size_t properly */
1558         imac_size = EVP_MD_CTX_size(s->read_hash);
1559         if (imac_size < 0) {
1560             al = SSL_AD_INTERNAL_ERROR;
1561             SSLerr(SSL_F_DTLS1_PROCESS_RECORD, ERR_LIB_EVP);
1562             goto f_err;
1563         }
1564         mac_size = (size_t)imac_size;
1565         OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);
1566
1567         /*
1568          * orig_len is the length of the record before any padding was
1569          * removed. This is public information, as is the MAC in use,
1570          * therefore we can safely process the record in a different amount
1571          * of time if it's too short to possibly contain a MAC.
1572          */
1573         if (rr->orig_len < mac_size ||
1574             /* CBC records must have a padding length byte too. */
1575             (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
1576              rr->orig_len < mac_size + 1)) {
1577             al = SSL_AD_DECODE_ERROR;
1578             SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_LENGTH_TOO_SHORT);
1579             goto f_err;
1580         }
1581
1582         if (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE) {
1583             /*
1584              * We update the length so that the TLS header bytes can be
1585              * constructed correctly but we need to extract the MAC in
1586              * constant time from within the record, without leaking the
1587              * contents of the padding bytes.
1588              */
1589             mac = mac_tmp;
1590             ssl3_cbc_copy_mac(mac_tmp, rr, mac_size);
1591             rr->length -= mac_size;
1592         } else {
1593             /*
1594              * In this case there's no padding, so |rec->orig_len| equals
1595              * |rec->length| and we checked that there's enough bytes for
1596              * |mac_size| above.
1597              */
1598             rr->length -= mac_size;
1599             mac = &rr->data[rr->length];
1600         }
1601
1602         i = s->method->ssl3_enc->mac(s, rr, md, 0 /* not send */ );
1603         if (i == 0 || mac == NULL
1604             || CRYPTO_memcmp(md, mac, mac_size) != 0)
1605             enc_err = -1;
1606         if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size)
1607             enc_err = -1;
1608     }
1609
1610     if (enc_err < 0) {
1611         /* decryption failed, silently discard message */
1612         rr->length = 0;
1613         RECORD_LAYER_reset_packet_length(&s->rlayer);
1614         goto err;
1615     }
1616
1617     /* r->length is now just compressed */
1618     if (s->expand != NULL) {
1619         if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH) {
1620             al = SSL_AD_RECORD_OVERFLOW;
1621             SSLerr(SSL_F_DTLS1_PROCESS_RECORD,
1622                    SSL_R_COMPRESSED_LENGTH_TOO_LONG);
1623             goto f_err;
1624         }
1625         if (!ssl3_do_uncompress(s, rr)) {
1626             al = SSL_AD_DECOMPRESSION_FAILURE;
1627             SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_BAD_DECOMPRESSION);
1628             goto f_err;
1629         }
1630     }
1631
1632     if (rr->length > SSL3_RT_MAX_PLAIN_LENGTH) {
1633         al = SSL_AD_RECORD_OVERFLOW;
1634         SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_DATA_LENGTH_TOO_LONG);
1635         goto f_err;
1636     }
1637
1638     rr->off = 0;
1639     /*-
1640      * So at this point the following is true
1641      * ssl->s3->rrec.type   is the type of record
1642      * ssl->s3->rrec.length == number of bytes in record
1643      * ssl->s3->rrec.off    == offset to first valid byte
1644      * ssl->s3->rrec.data   == where to take bytes from, increment
1645      *                         after use :-).
1646      */
1647
1648     /* we have pulled in a full packet so zero things */
1649     RECORD_LAYER_reset_packet_length(&s->rlayer);
1650
1651     /* Mark receipt of record. */
1652     dtls1_record_bitmap_update(s, bitmap);
1653
1654     return (1);
1655
1656  f_err:
1657     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1658  err:
1659     return (0);
1660 }
1661
1662 /*
1663  * Retrieve a buffered record that belongs to the current epoch, i.e. processed
1664  */
1665 #define dtls1_get_processed_record(s) \
1666                    dtls1_retrieve_buffered_record((s), \
1667                    &(DTLS_RECORD_LAYER_get_processed_rcds(&s->rlayer)))
1668
1669 /*-
1670  * Call this to get a new input record.
1671  * It will return <= 0 if more data is needed, normally due to an error
1672  * or non-blocking IO.
1673  * When it finishes, one packet has been decoded and can be found in
1674  * ssl->s3->rrec.type    - is the type of record
1675  * ssl->s3->rrec.data,   - data
1676  * ssl->s3->rrec.length, - number of bytes
1677  */
1678 /* used only by dtls1_read_bytes */
1679 int dtls1_get_record(SSL *s)
1680 {
1681     int ssl_major, ssl_minor;
1682     int rret;
1683     size_t more, n;
1684     SSL3_RECORD *rr;
1685     unsigned char *p = NULL;
1686     unsigned short version;
1687     DTLS1_BITMAP *bitmap;
1688     unsigned int is_next_epoch;
1689
1690     rr = RECORD_LAYER_get_rrec(&s->rlayer);
1691
1692  again:
1693     /*
1694      * The epoch may have changed.  If so, process all the pending records.
1695      * This is a non-blocking operation.
1696      */
1697     if (!dtls1_process_buffered_records(s))
1698         return -1;
1699
1700     /* if we're renegotiating, then there may be buffered records */
1701     if (dtls1_get_processed_record(s))
1702         return 1;
1703
1704     /* get something from the wire */
1705
1706     /* check if we have the header */
1707     if ((RECORD_LAYER_get_rstate(&s->rlayer) != SSL_ST_READ_BODY) ||
1708         (RECORD_LAYER_get_packet_length(&s->rlayer) < DTLS1_RT_HEADER_LENGTH)) {
1709         rret = ssl3_read_n(s, DTLS1_RT_HEADER_LENGTH,
1710                            SSL3_BUFFER_get_len(&s->rlayer.rbuf), 0, 1, &n);
1711         /* read timeout is handled by dtls1_read_bytes */
1712         if (rret <= 0)
1713             return rret;         /* error or non-blocking */
1714
1715         /* this packet contained a partial record, dump it */
1716         if (RECORD_LAYER_get_packet_length(&s->rlayer) !=
1717             DTLS1_RT_HEADER_LENGTH) {
1718             RECORD_LAYER_reset_packet_length(&s->rlayer);
1719             goto again;
1720         }
1721
1722         RECORD_LAYER_set_rstate(&s->rlayer, SSL_ST_READ_BODY);
1723
1724         p = RECORD_LAYER_get_packet(&s->rlayer);
1725
1726         if (s->msg_callback)
1727             s->msg_callback(0, 0, SSL3_RT_HEADER, p, DTLS1_RT_HEADER_LENGTH,
1728                             s, s->msg_callback_arg);
1729
1730         /* Pull apart the header into the DTLS1_RECORD */
1731         rr->type = *(p++);
1732         ssl_major = *(p++);
1733         ssl_minor = *(p++);
1734         version = (ssl_major << 8) | ssl_minor;
1735
1736         /* sequence number is 64 bits, with top 2 bytes = epoch */
1737         n2s(p, rr->epoch);
1738
1739         memcpy(&(RECORD_LAYER_get_read_sequence(&s->rlayer)[2]), p, 6);
1740         p += 6;
1741
1742         n2s(p, rr->length);
1743
1744         /* Lets check version */
1745         if (!s->first_packet) {
1746             if (version != s->version) {
1747                 /* unexpected version, silently discard */
1748                 rr->length = 0;
1749                 RECORD_LAYER_reset_packet_length(&s->rlayer);
1750                 goto again;
1751             }
1752         }
1753
1754         if ((version & 0xff00) != (s->version & 0xff00)) {
1755             /* wrong version, silently discard record */
1756             rr->length = 0;
1757             RECORD_LAYER_reset_packet_length(&s->rlayer);
1758             goto again;
1759         }
1760
1761         if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) {
1762             /* record too long, silently discard it */
1763             rr->length = 0;
1764             RECORD_LAYER_reset_packet_length(&s->rlayer);
1765             goto again;
1766         }
1767
1768         /* now s->rlayer.rstate == SSL_ST_READ_BODY */
1769     }
1770
1771     /* s->rlayer.rstate == SSL_ST_READ_BODY, get and decode the data */
1772
1773     if (rr->length >
1774         RECORD_LAYER_get_packet_length(&s->rlayer) - DTLS1_RT_HEADER_LENGTH) {
1775         /* now s->packet_length == DTLS1_RT_HEADER_LENGTH */
1776         more = rr->length;
1777         rret = ssl3_read_n(s, more, more, 1, 1, &n);
1778         /* this packet contained a partial record, dump it */
1779         if (rret <= 0 || n != more) {
1780             rr->length = 0;
1781             RECORD_LAYER_reset_packet_length(&s->rlayer);
1782             goto again;
1783         }
1784
1785         /*
1786          * now n == rr->length, and s->packet_length ==
1787          * DTLS1_RT_HEADER_LENGTH + rr->length
1788          */
1789     }
1790     /* set state for later operations */
1791     RECORD_LAYER_set_rstate(&s->rlayer, SSL_ST_READ_HEADER);
1792
1793     /* match epochs.  NULL means the packet is dropped on the floor */
1794     bitmap = dtls1_get_bitmap(s, rr, &is_next_epoch);
1795     if (bitmap == NULL) {
1796         rr->length = 0;
1797         RECORD_LAYER_reset_packet_length(&s->rlayer); /* dump this record */
1798         goto again;             /* get another record */
1799     }
1800 #ifndef OPENSSL_NO_SCTP
1801     /* Only do replay check if no SCTP bio */
1802     if (!BIO_dgram_is_sctp(SSL_get_rbio(s))) {
1803 #endif
1804         /* Check whether this is a repeat, or aged record. */
1805         /*
1806          * TODO: Does it make sense to have replay protection in epoch 0 where
1807          * we have no integrity negotiated yet?
1808          */
1809         if (!dtls1_record_replay_check(s, bitmap)) {
1810             rr->length = 0;
1811             RECORD_LAYER_reset_packet_length(&s->rlayer); /* dump this record */
1812             goto again;         /* get another record */
1813         }
1814 #ifndef OPENSSL_NO_SCTP
1815     }
1816 #endif
1817
1818     /* just read a 0 length packet */
1819     if (rr->length == 0)
1820         goto again;
1821
1822     /*
1823      * If this record is from the next epoch (either HM or ALERT), and a
1824      * handshake is currently in progress, buffer it since it cannot be
1825      * processed at this time.
1826      */
1827     if (is_next_epoch) {
1828         if ((SSL_in_init(s) || ossl_statem_get_in_handshake(s))) {
1829             if (dtls1_buffer_record
1830                 (s, &(DTLS_RECORD_LAYER_get_unprocessed_rcds(&s->rlayer)),
1831                  rr->seq_num) < 0)
1832                 return -1;
1833         }
1834         rr->length = 0;
1835         RECORD_LAYER_reset_packet_length(&s->rlayer);
1836         goto again;
1837     }
1838
1839     if (!dtls1_process_record(s, bitmap)) {
1840         rr->length = 0;
1841         RECORD_LAYER_reset_packet_length(&s->rlayer); /* dump this record */
1842         goto again;             /* get another record */
1843     }
1844
1845     return (1);
1846
1847 }