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