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