86aaf4fcd8be4c442fa91abff98f9a82d1b8a574
[openssl.git] / ssl / record / ssl3_record.c
1 /* ssl/record/ssl3_record.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  *
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  *
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  *
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  *
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  *
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58 /* ====================================================================
59  * Copyright (c) 1998-2015 The OpenSSL Project.  All rights reserved.
60  *
61  * Redistribution and use in source and binary forms, with or without
62  * modification, are permitted provided that the following conditions
63  * are met:
64  *
65  * 1. Redistributions of source code must retain the above copyright
66  *    notice, this list of conditions and the following disclaimer.
67  *
68  * 2. Redistributions in binary form must reproduce the above copyright
69  *    notice, this list of conditions and the following disclaimer in
70  *    the documentation and/or other materials provided with the
71  *    distribution.
72  *
73  * 3. All advertising materials mentioning features or use of this
74  *    software must display the following acknowledgment:
75  *    "This product includes software developed by the OpenSSL Project
76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
77  *
78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79  *    endorse or promote products derived from this software without
80  *    prior written permission. For written permission, please contact
81  *    openssl-core@openssl.org.
82  *
83  * 5. Products derived from this software may not be called "OpenSSL"
84  *    nor may "OpenSSL" appear in their names without prior written
85  *    permission of the OpenSSL Project.
86  *
87  * 6. Redistributions of any form whatsoever must retain the following
88  *    acknowledgment:
89  *    "This product includes software developed by the OpenSSL Project
90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
91  *
92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103  * OF THE POSSIBILITY OF SUCH DAMAGE.
104  * ====================================================================
105  *
106  * This product includes cryptographic software written by Eric Young
107  * (eay@cryptsoft.com).  This product includes software written by Tim
108  * Hudson (tjh@cryptsoft.com).
109  *
110  */
111
112 #include "../ssl_locl.h"
113 #include "internal/constant_time_locl.h"
114 #include <openssl/rand.h>
115 #include "record_locl.h"
116
117 static const unsigned char ssl3_pad_1[48] = {
118     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
119     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
120     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
121     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
122     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
123     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36
124 };
125
126 static const unsigned char ssl3_pad_2[48] = {
127     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
128     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
129     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
130     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
131     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
132     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c
133 };
134
135 /*
136  * Clear the contents of an SSL3_RECORD but retain any memory allocated
137  */
138 void SSL3_RECORD_clear(SSL3_RECORD *r)
139 {
140     unsigned char *comp = r->comp;
141
142     memset(r, 0, sizeof(*r));
143     r->comp = comp;
144 }
145
146 void SSL3_RECORD_release(SSL3_RECORD *r)
147 {
148     OPENSSL_free(r->comp);
149     r->comp = NULL;
150 }
151
152 int SSL3_RECORD_setup(SSL3_RECORD *r)
153 {
154     if (r->comp == NULL)
155         r->comp = (unsigned char *)
156             OPENSSL_malloc(SSL3_RT_MAX_ENCRYPTED_LENGTH);
157     if (r->comp == NULL)
158         return 0;
159     return 1;
160 }
161
162 void SSL3_RECORD_set_seq_num(SSL3_RECORD *r, const unsigned char *seq_num)
163 {
164     memcpy(r->seq_num, seq_num, SEQ_NUM_SIZE);
165 }
166
167 /*
168  * MAX_EMPTY_RECORDS defines the number of consecutive, empty records that
169  * will be processed per call to ssl3_get_record. Without this limit an
170  * attacker could send empty records at a faster rate than we can process and
171  * cause ssl3_get_record to loop forever.
172  */
173 #define MAX_EMPTY_RECORDS 32
174
175 #define SSL2_RT_HEADER_LENGTH   2
176 /*-
177  * Call this to get a new input record.
178  * It will return <= 0 if more data is needed, normally due to an error
179  * or non-blocking IO.
180  * When it finishes, one packet has been decoded and can be found in
181  * ssl->s3->rrec.type    - is the type of record
182  * ssl->s3->rrec.data,   - data
183  * ssl->s3->rrec.length, - number of bytes
184  */
185 /* used only by ssl3_read_bytes */
186 int ssl3_get_record(SSL *s)
187 {
188     int ssl_major, ssl_minor, al;
189     int enc_err, n, i, ret = -1;
190     SSL3_RECORD *rr;
191     SSL_SESSION *sess;
192     unsigned char *p;
193     unsigned char md[EVP_MAX_MD_SIZE];
194     short version;
195     unsigned mac_size;
196     size_t extra;
197     unsigned empty_record_count = 0;
198
199     rr = RECORD_LAYER_get_rrec(&s->rlayer);
200     sess = s->session;
201
202     if (s->options & SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER)
203         extra = SSL3_RT_MAX_EXTRA;
204     else
205         extra = 0;
206     if (extra && !s->s3->init_extra) {
207         /*
208          * An application error: SLS_OP_MICROSOFT_BIG_SSLV3_BUFFER set after
209          * ssl3_setup_buffers() was done
210          */
211         SSLerr(SSL_F_SSL3_GET_RECORD, ERR_R_INTERNAL_ERROR);
212         return -1;
213     }
214
215  again:
216     /* check if we have the header */
217     if ((RECORD_LAYER_get_rstate(&s->rlayer) != SSL_ST_READ_BODY) ||
218         (RECORD_LAYER_get_packet_length(&s->rlayer) < SSL3_RT_HEADER_LENGTH)) {
219         n = ssl3_read_n(s, SSL3_RT_HEADER_LENGTH,
220             SSL3_BUFFER_get_len(&s->rlayer.rbuf), 0);
221         if (n <= 0)
222             return (n);         /* error or non-blocking */
223         RECORD_LAYER_set_rstate(&s->rlayer, SSL_ST_READ_BODY);
224
225         p = RECORD_LAYER_get_packet(&s->rlayer);
226
227         /*
228          * Check whether this is a regular record or an SSLv2 style record. The
229          * latter is only used in an initial ClientHello for old clients. We
230          * check s->read_hash and s->enc_read_ctx to ensure this does not apply
231          * during renegotiation
232          */
233         if (s->first_packet && s->server && !s->read_hash && !s->enc_read_ctx
234                 && (p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO)) {
235             /* SSLv2 style record */
236             rr->type = SSL3_RT_HANDSHAKE;
237             rr->rec_version = SSL2_VERSION;
238
239             rr->length = ((p[0] & 0x7f) << 8) | p[1];
240
241             if (rr->length > SSL3_BUFFER_get_len(&s->rlayer.rbuf)
242                                     - SSL2_RT_HEADER_LENGTH) {
243                 al = SSL_AD_RECORD_OVERFLOW;
244                 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_PACKET_LENGTH_TOO_LONG);
245                 goto f_err;
246             }
247
248             if (rr->length < MIN_SSL2_RECORD_LEN) {
249                 al = SSL_AD_HANDSHAKE_FAILURE;
250                 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_LENGTH_TOO_SHORT);
251                 goto f_err;
252             }
253         } else {
254             /* SSLv3+ style record */
255             if (s->msg_callback)
256                 s->msg_callback(0, 0, SSL3_RT_HEADER, p, 5, s,
257                                 s->msg_callback_arg);
258
259             /* Pull apart the header into the SSL3_RECORD */
260             rr->type = *(p++);
261             ssl_major = *(p++);
262             ssl_minor = *(p++);
263             version = (ssl_major << 8) | ssl_minor;
264             rr->rec_version = version;
265             n2s(p, rr->length);
266
267             /* Lets check version */
268             if (!s->first_packet && version != s->version) {
269                 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_WRONG_VERSION_NUMBER);
270                 if ((s->version & 0xFF00) == (version & 0xFF00)
271                     && !s->enc_write_ctx && !s->write_hash) {
272                     if (rr->type == SSL3_RT_ALERT) {
273                         /*
274                          * The record is using an incorrect version number, but
275                          * what we've got appears to be an alert. We haven't
276                          * read the body yet to check whether its a fatal or
277                          * not - but chances are it is. We probably shouldn't
278                          * send a fatal alert back. We'll just end.
279                          */
280                          goto err;
281                     }
282                     /*
283                      * Send back error using their minor version number :-)
284                      */
285                     s->version = (unsigned short)version;
286                 }
287                 al = SSL_AD_PROTOCOL_VERSION;
288                 goto f_err;
289             }
290
291             if ((version >> 8) != SSL3_VERSION_MAJOR) {
292                 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_WRONG_VERSION_NUMBER);
293                 goto err;
294             }
295
296             if (rr->length >
297                     SSL3_BUFFER_get_len(&s->rlayer.rbuf)
298                     - 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 record
311      */
312     if (rr->rec_version == SSL2_VERSION) {
313         i = rr->length + SSL2_RT_HEADER_LENGTH - SSL3_RT_HEADER_LENGTH;
314     } else {
315         i = rr->length;
316     }
317     if (i > 0) {
318         /* now s->packet_length == SSL3_RT_HEADER_LENGTH */
319
320         n = ssl3_read_n(s, i, i, 1);
321         if (n <= 0)
322             return (n);         /* error or non-blocking io */
323     }
324
325     /* set state for later operations */
326     RECORD_LAYER_set_rstate(&s->rlayer, SSL_ST_READ_HEADER);
327
328     /*
329      * At this point, s->packet_length == SSL3_RT_HEADER_LENGTH + rr->length,
330      * or s->packet_length == SSL2_RT_HEADER_LENGTH + rr->length
331      * and we have that many bytes in s->packet
332      */
333     if(rr->rec_version == SSL2_VERSION) {
334         rr->input = &(RECORD_LAYER_get_packet(&s->rlayer)[SSL2_RT_HEADER_LENGTH]);
335     } else {
336         rr->input = &(RECORD_LAYER_get_packet(&s->rlayer)[SSL3_RT_HEADER_LENGTH]);
337     }
338
339     /*
340      * ok, we can now read from 's->packet' data into 'rr' rr->input points
341      * at rr->length bytes, which need to be copied into rr->data by either
342      * the decryption or by the decompression When the data is 'copied' into
343      * the rr->data buffer, rr->input will be pointed at the new buffer
344      */
345
346     /*
347      * We now have - encrypted [ MAC [ compressed [ plain ] ] ] rr->length
348      * bytes of encrypted compressed stuff.
349      */
350
351     /* check is not needed I believe */
352     if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH + extra) {
353         al = SSL_AD_RECORD_OVERFLOW;
354         SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
355         goto f_err;
356     }
357
358     /* decrypt in place in 'rr->input' */
359     rr->data = rr->input;
360     rr->orig_len = rr->length;
361     /*
362      * If in encrypt-then-mac mode calculate mac from encrypted record. All
363      * the details below are public so no timing details can leak.
364      */
365     if (SSL_USE_ETM(s) && s->read_hash) {
366         unsigned char *mac;
367         mac_size = EVP_MD_CTX_size(s->read_hash);
368         OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);
369         if (rr->length < mac_size) {
370             al = SSL_AD_DECODE_ERROR;
371             SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_LENGTH_TOO_SHORT);
372             goto f_err;
373         }
374         rr->length -= mac_size;
375         mac = rr->data + rr->length;
376         i = s->method->ssl3_enc->mac(s, md, 0 /* not send */ );
377         if (i < 0 || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0) {
378             al = SSL_AD_BAD_RECORD_MAC;
379             SSLerr(SSL_F_SSL3_GET_RECORD,
380                    SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
381             goto f_err;
382         }
383     }
384
385     enc_err = s->method->ssl3_enc->enc(s, 0);
386     /*-
387      * enc_err is:
388      *    0: (in non-constant time) if the record is publically invalid.
389      *    1: if the padding is valid
390      *    -1: if the padding is invalid
391      */
392     if (enc_err == 0) {
393         al = SSL_AD_DECRYPTION_FAILED;
394         SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BLOCK_CIPHER_PAD_IS_WRONG);
395         goto f_err;
396     }
397 #ifdef TLS_DEBUG
398     printf("dec %d\n", rr->length);
399     {
400         unsigned int z;
401         for (z = 0; z < rr->length; z++)
402             printf("%02X%c", rr->data[z], ((z + 1) % 16) ? ' ' : '\n');
403     }
404     printf("\n");
405 #endif
406
407     /* r->length is now the compressed data plus mac */
408     if ((sess != NULL) &&
409         (s->enc_read_ctx != NULL) &&
410         (EVP_MD_CTX_md(s->read_hash) != NULL) && !SSL_USE_ETM(s)) {
411         /* s->read_hash != NULL => mac_size != -1 */
412         unsigned char *mac = NULL;
413         unsigned char mac_tmp[EVP_MAX_MD_SIZE];
414         mac_size = EVP_MD_CTX_size(s->read_hash);
415         OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);
416
417         /*
418          * orig_len is the length of the record before any padding was
419          * removed. This is public information, as is the MAC in use,
420          * therefore we can safely process the record in a different amount
421          * of time if it's too short to possibly contain a MAC.
422          */
423         if (rr->orig_len < mac_size ||
424             /* CBC records must have a padding length byte too. */
425             (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
426              rr->orig_len < mac_size + 1)) {
427             al = SSL_AD_DECODE_ERROR;
428             SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_LENGTH_TOO_SHORT);
429             goto f_err;
430         }
431
432         if (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE) {
433             /*
434              * We update the length so that the TLS header bytes can be
435              * constructed correctly but we need to extract the MAC in
436              * constant time from within the record, without leaking the
437              * contents of the padding bytes.
438              */
439             mac = mac_tmp;
440             ssl3_cbc_copy_mac(mac_tmp, rr, mac_size);
441             rr->length -= mac_size;
442         } else {
443             /*
444              * In this case there's no padding, so |rec->orig_len| equals
445              * |rec->length| and we checked that there's enough bytes for
446              * |mac_size| above.
447              */
448             rr->length -= mac_size;
449             mac = &rr->data[rr->length];
450         }
451
452         i = s->method->ssl3_enc->mac(s, md, 0 /* not send */ );
453         if (i < 0 || mac == NULL
454             || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0)
455             enc_err = -1;
456         if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + extra + mac_size)
457             enc_err = -1;
458     }
459
460     if (enc_err < 0) {
461         /*
462          * A separate 'decryption_failed' alert was introduced with TLS 1.0,
463          * SSL 3.0 only has 'bad_record_mac'.  But unless a decryption
464          * failure is directly visible from the ciphertext anyway, we should
465          * not reveal which kind of error occurred -- this might become
466          * visible to an attacker (e.g. via a logfile)
467          */
468         al = SSL_AD_BAD_RECORD_MAC;
469         SSLerr(SSL_F_SSL3_GET_RECORD,
470                SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
471         goto f_err;
472     }
473
474     /* r->length is now just compressed */
475     if (s->expand != NULL) {
476         if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + extra) {
477             al = SSL_AD_RECORD_OVERFLOW;
478             SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_COMPRESSED_LENGTH_TOO_LONG);
479             goto f_err;
480         }
481         if (!ssl3_do_uncompress(s)) {
482             al = SSL_AD_DECOMPRESSION_FAILURE;
483             SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_BAD_DECOMPRESSION);
484             goto f_err;
485         }
486     }
487
488     if (rr->length > SSL3_RT_MAX_PLAIN_LENGTH + extra) {
489         al = SSL_AD_RECORD_OVERFLOW;
490         SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_DATA_LENGTH_TOO_LONG);
491         goto f_err;
492     }
493
494     rr->off = 0;
495     /*-
496      * So at this point the following is true
497      * ssl->s3->rrec.type   is the type of record
498      * ssl->s3->rrec.length == number of bytes in record
499      * ssl->s3->rrec.off    == offset to first valid byte
500      * ssl->s3->rrec.data   == where to take bytes from, increment
501      *                         after use :-).
502      */
503
504     /* we have pulled in a full packet so zero things */
505     RECORD_LAYER_reset_packet_length(&s->rlayer);
506
507     /* just read a 0 length packet */
508     if (rr->length == 0) {
509         empty_record_count++;
510         if (empty_record_count > MAX_EMPTY_RECORDS) {
511             al = SSL_AD_UNEXPECTED_MESSAGE;
512             SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_RECORD_TOO_SMALL);
513             goto f_err;
514         }
515         goto again;
516     }
517
518     return (1);
519
520  f_err:
521     ssl3_send_alert(s, SSL3_AL_FATAL, al);
522  err:
523     return (ret);
524 }
525
526 int ssl3_do_uncompress(SSL *ssl)
527 {
528 #ifndef OPENSSL_NO_COMP
529     int i;
530     SSL3_RECORD *rr;
531
532     rr = RECORD_LAYER_get_rrec(&ssl->rlayer);
533     i = COMP_expand_block(ssl->expand, rr->comp,
534                           SSL3_RT_MAX_PLAIN_LENGTH, rr->data,
535                           (int)rr->length);
536     if (i < 0)
537         return (0);
538     else
539         rr->length = i;
540     rr->data = rr->comp;
541 #endif
542     return (1);
543 }
544
545 int ssl3_do_compress(SSL *ssl)
546 {
547 #ifndef OPENSSL_NO_COMP
548     int i;
549     SSL3_RECORD *wr;
550
551     wr = RECORD_LAYER_get_wrec(&ssl->rlayer);
552     i = COMP_compress_block(ssl->compress, wr->data,
553                             SSL3_RT_MAX_COMPRESSED_LENGTH,
554                             wr->input, (int)wr->length);
555     if (i < 0)
556         return (0);
557     else
558         wr->length = i;
559
560     wr->input = wr->data;
561 #endif
562     return (1);
563 }
564
565 /*-
566  * ssl3_enc encrypts/decrypts the record in |s->wrec| / |s->rrec|, respectively.
567  *
568  * Returns:
569  *   0: (in non-constant time) if the record is publically invalid (i.e. too
570  *       short etc).
571  *   1: if the record's padding is valid / the encryption was successful.
572  *   -1: if the record's padding is invalid or, if sending, an internal error
573  *       occurred.
574  */
575 int ssl3_enc(SSL *s, int send)
576 {
577     SSL3_RECORD *rec;
578     EVP_CIPHER_CTX *ds;
579     unsigned long l;
580     int bs, i, mac_size = 0;
581     const EVP_CIPHER *enc;
582
583     if (send) {
584         ds = s->enc_write_ctx;
585         rec = RECORD_LAYER_get_wrec(&s->rlayer);
586         if (s->enc_write_ctx == NULL)
587             enc = NULL;
588         else
589             enc = EVP_CIPHER_CTX_cipher(s->enc_write_ctx);
590     } else {
591         ds = s->enc_read_ctx;
592         rec = RECORD_LAYER_get_rrec(&s->rlayer);
593         if (s->enc_read_ctx == NULL)
594             enc = NULL;
595         else
596             enc = EVP_CIPHER_CTX_cipher(s->enc_read_ctx);
597     }
598
599     if ((s->session == NULL) || (ds == NULL) || (enc == NULL)) {
600         memmove(rec->data, rec->input, rec->length);
601         rec->input = rec->data;
602     } else {
603         l = rec->length;
604         bs = EVP_CIPHER_block_size(ds->cipher);
605
606         /* COMPRESS */
607
608         if ((bs != 1) && send) {
609             i = bs - ((int)l % bs);
610
611             /* we need to add 'i-1' padding bytes */
612             l += i;
613             /*
614              * the last of these zero bytes will be overwritten with the
615              * padding length.
616              */
617             memset(&rec->input[rec->length], 0, i);
618             rec->length += i;
619             rec->input[l - 1] = (i - 1);
620         }
621
622         if (!send) {
623             if (l == 0 || l % bs != 0)
624                 return 0;
625             /* otherwise, rec->length >= bs */
626         }
627
628         if (EVP_Cipher(ds, rec->data, rec->input, l) < 1)
629             return -1;
630
631         if (EVP_MD_CTX_md(s->read_hash) != NULL)
632             mac_size = EVP_MD_CTX_size(s->read_hash);
633         if ((bs != 1) && !send)
634             return ssl3_cbc_remove_padding(s, rec, bs, mac_size);
635     }
636     return (1);
637 }
638
639 /*-
640  * tls1_enc encrypts/decrypts the record in |s->wrec| / |s->rrec|, respectively.
641  *
642  * Returns:
643  *   0: (in non-constant time) if the record is publically invalid (i.e. too
644  *       short etc).
645  *   1: if the record's padding is valid / the encryption was successful.
646  *   -1: if the record's padding/AEAD-authenticator is invalid or, if sending,
647  *       an internal error occurred.
648  */
649 int tls1_enc(SSL *s, int send)
650 {
651     SSL3_RECORD *rec;
652     EVP_CIPHER_CTX *ds;
653     unsigned long l;
654     int bs, i, j, k, pad = 0, ret, mac_size = 0;
655     const EVP_CIPHER *enc;
656
657     if (send) {
658         if (EVP_MD_CTX_md(s->write_hash)) {
659             int n = EVP_MD_CTX_size(s->write_hash);
660             OPENSSL_assert(n >= 0);
661         }
662         ds = s->enc_write_ctx;
663         rec = RECORD_LAYER_get_wrec(&s->rlayer);
664         if (s->enc_write_ctx == NULL)
665             enc = NULL;
666         else {
667             int ivlen;
668             enc = EVP_CIPHER_CTX_cipher(s->enc_write_ctx);
669             /* For TLSv1.1 and later explicit IV */
670             if (SSL_USE_EXPLICIT_IV(s)
671                 && EVP_CIPHER_mode(enc) == EVP_CIPH_CBC_MODE)
672                 ivlen = EVP_CIPHER_iv_length(enc);
673             else
674                 ivlen = 0;
675             if (ivlen > 1) {
676                 if (rec->data != rec->input)
677                     /*
678                      * we can't write into the input stream: Can this ever
679                      * happen?? (steve)
680                      */
681                     fprintf(stderr,
682                             "%s:%d: rec->data != rec->input\n",
683                             __FILE__, __LINE__);
684                 else if (RAND_bytes(rec->input, ivlen) <= 0)
685                     return -1;
686             }
687         }
688     } else {
689         if (EVP_MD_CTX_md(s->read_hash)) {
690             int n = EVP_MD_CTX_size(s->read_hash);
691             OPENSSL_assert(n >= 0);
692         }
693         ds = s->enc_read_ctx;
694         rec = RECORD_LAYER_get_rrec(&s->rlayer);
695         if (s->enc_read_ctx == NULL)
696             enc = NULL;
697         else
698             enc = EVP_CIPHER_CTX_cipher(s->enc_read_ctx);
699     }
700
701     if ((s->session == NULL) || (ds == NULL) || (enc == NULL)) {
702         memmove(rec->data, rec->input, rec->length);
703         rec->input = rec->data;
704         ret = 1;
705     } else {
706         l = rec->length;
707         bs = EVP_CIPHER_block_size(ds->cipher);
708
709         if (EVP_CIPHER_flags(ds->cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) {
710             unsigned char buf[EVP_AEAD_TLS1_AAD_LEN], *seq;
711
712             seq = send ? RECORD_LAYER_get_write_sequence(&s->rlayer)
713                 : RECORD_LAYER_get_read_sequence(&s->rlayer);
714
715             if (SSL_IS_DTLS(s)) {
716                 unsigned char dtlsseq[9], *p = dtlsseq;
717
718                 s2n(send ? DTLS_RECORD_LAYER_get_w_epoch(&s->rlayer) :
719                     DTLS_RECORD_LAYER_get_r_epoch(&s->rlayer), p);
720                 memcpy(p, &seq[2], 6);
721                 memcpy(buf, dtlsseq, 8);
722             } else {
723                 memcpy(buf, seq, 8);
724                 for (i = 7; i >= 0; i--) { /* increment */
725                     ++seq[i];
726                     if (seq[i] != 0)
727                         break;
728                 }
729             }
730
731             buf[8] = rec->type;
732             buf[9] = (unsigned char)(s->version >> 8);
733             buf[10] = (unsigned char)(s->version);
734             buf[11] = rec->length >> 8;
735             buf[12] = rec->length & 0xff;
736             pad = EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_AEAD_TLS1_AAD,
737                                       EVP_AEAD_TLS1_AAD_LEN, buf);
738             if (pad <= 0)
739                 return -1;
740             if (send) {
741                 l += pad;
742                 rec->length += pad;
743             }
744         } else if ((bs != 1) && send) {
745             i = bs - ((int)l % bs);
746
747             /* Add weird padding of upto 256 bytes */
748
749             /* we need to add 'i' padding bytes of value j */
750             j = i - 1;
751             for (k = (int)l; k < (int)(l + i); k++)
752                 rec->input[k] = j;
753             l += i;
754             rec->length += i;
755         }
756
757         if (!send) {
758             if (l == 0 || l % bs != 0)
759                 return 0;
760         }
761
762         i = EVP_Cipher(ds, rec->data, rec->input, l);
763         if ((EVP_CIPHER_flags(ds->cipher) & EVP_CIPH_FLAG_CUSTOM_CIPHER)
764             ? (i < 0)
765             : (i == 0))
766             return -1;          /* AEAD can fail to verify MAC */
767         if (send == 0) {
768             if (EVP_CIPHER_mode(enc) == EVP_CIPH_GCM_MODE) {
769                 rec->data += EVP_GCM_TLS_EXPLICIT_IV_LEN;
770                 rec->input += EVP_GCM_TLS_EXPLICIT_IV_LEN;
771                 rec->length -= EVP_GCM_TLS_EXPLICIT_IV_LEN;
772             } else if (EVP_CIPHER_mode(enc) == EVP_CIPH_CCM_MODE) {
773                 rec->data += EVP_CCM_TLS_EXPLICIT_IV_LEN;
774                 rec->input += EVP_CCM_TLS_EXPLICIT_IV_LEN;
775                 rec->length -= EVP_CCM_TLS_EXPLICIT_IV_LEN;
776             }
777         }
778
779         ret = 1;
780         if (!SSL_USE_ETM(s) && EVP_MD_CTX_md(s->read_hash) != NULL)
781             mac_size = EVP_MD_CTX_size(s->read_hash);
782         if ((bs != 1) && !send)
783             ret = tls1_cbc_remove_padding(s, rec, bs, mac_size);
784         if (pad && !send)
785             rec->length -= pad;
786     }
787     return ret;
788 }
789
790 int n_ssl3_mac(SSL *ssl, unsigned char *md, int send)
791 {
792     SSL3_RECORD *rec;
793     unsigned char *mac_sec, *seq;
794     EVP_MD_CTX md_ctx;
795     const EVP_MD_CTX *hash;
796     unsigned char *p, rec_char;
797     size_t md_size;
798     int npad;
799     int t;
800
801     if (send) {
802         rec = RECORD_LAYER_get_wrec(&ssl->rlayer);
803         mac_sec = &(ssl->s3->write_mac_secret[0]);
804         seq = RECORD_LAYER_get_write_sequence(&ssl->rlayer);
805         hash = ssl->write_hash;
806     } else {
807         rec = RECORD_LAYER_get_rrec(&ssl->rlayer);
808         mac_sec = &(ssl->s3->read_mac_secret[0]);
809         seq = RECORD_LAYER_get_read_sequence(&ssl->rlayer);
810         hash = ssl->read_hash;
811     }
812
813     t = EVP_MD_CTX_size(hash);
814     if (t < 0)
815         return -1;
816     md_size = t;
817     npad = (48 / md_size) * md_size;
818
819     if (!send &&
820         EVP_CIPHER_CTX_mode(ssl->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
821         ssl3_cbc_record_digest_supported(hash)) {
822         /*
823          * This is a CBC-encrypted record. We must avoid leaking any
824          * timing-side channel information about how many blocks of data we
825          * are hashing because that gives an attacker a timing-oracle.
826          */
827
828         /*-
829          * npad is, at most, 48 bytes and that's with MD5:
830          *   16 + 48 + 8 (sequence bytes) + 1 + 2 = 75.
831          *
832          * With SHA-1 (the largest hash speced for SSLv3) the hash size
833          * goes up 4, but npad goes down by 8, resulting in a smaller
834          * total size.
835          */
836         unsigned char header[75];
837         unsigned j = 0;
838         memcpy(header + j, mac_sec, md_size);
839         j += md_size;
840         memcpy(header + j, ssl3_pad_1, npad);
841         j += npad;
842         memcpy(header + j, seq, 8);
843         j += 8;
844         header[j++] = rec->type;
845         header[j++] = rec->length >> 8;
846         header[j++] = rec->length & 0xff;
847
848         /* Final param == is SSLv3 */
849         ssl3_cbc_digest_record(hash,
850                                md, &md_size,
851                                header, rec->input,
852                                rec->length + md_size, rec->orig_len,
853                                mac_sec, md_size, 1);
854     } else {
855         unsigned int md_size_u;
856         /* Chop the digest off the end :-) */
857         EVP_MD_CTX_init(&md_ctx);
858
859         EVP_MD_CTX_copy_ex(&md_ctx, hash);
860         EVP_DigestUpdate(&md_ctx, mac_sec, md_size);
861         EVP_DigestUpdate(&md_ctx, ssl3_pad_1, npad);
862         EVP_DigestUpdate(&md_ctx, seq, 8);
863         rec_char = rec->type;
864         EVP_DigestUpdate(&md_ctx, &rec_char, 1);
865         p = md;
866         s2n(rec->length, p);
867         EVP_DigestUpdate(&md_ctx, md, 2);
868         EVP_DigestUpdate(&md_ctx, rec->input, rec->length);
869         EVP_DigestFinal_ex(&md_ctx, md, NULL);
870
871         EVP_MD_CTX_copy_ex(&md_ctx, hash);
872         EVP_DigestUpdate(&md_ctx, mac_sec, md_size);
873         EVP_DigestUpdate(&md_ctx, ssl3_pad_2, npad);
874         EVP_DigestUpdate(&md_ctx, md, md_size);
875         EVP_DigestFinal_ex(&md_ctx, md, &md_size_u);
876         md_size = md_size_u;
877
878         EVP_MD_CTX_cleanup(&md_ctx);
879     }
880
881     ssl3_record_sequence_update(seq);
882     return (md_size);
883 }
884
885 int tls1_mac(SSL *ssl, unsigned char *md, int send)
886 {
887     SSL3_RECORD *rec;
888     unsigned char *seq;
889     EVP_MD_CTX *hash;
890     size_t md_size;
891     int i;
892     EVP_MD_CTX hmac, *mac_ctx;
893     unsigned char header[13];
894     int stream_mac = (send ? (ssl->mac_flags & SSL_MAC_FLAG_WRITE_MAC_STREAM)
895                       : (ssl->mac_flags & SSL_MAC_FLAG_READ_MAC_STREAM));
896     int t;
897
898     if (send) {
899         rec = RECORD_LAYER_get_wrec(&ssl->rlayer);
900         seq = RECORD_LAYER_get_write_sequence(&ssl->rlayer);
901         hash = ssl->write_hash;
902     } else {
903         rec = RECORD_LAYER_get_rrec(&ssl->rlayer);
904         seq = RECORD_LAYER_get_read_sequence(&ssl->rlayer);
905         hash = ssl->read_hash;
906     }
907
908     t = EVP_MD_CTX_size(hash);
909     OPENSSL_assert(t >= 0);
910     md_size = t;
911
912     /* I should fix this up TLS TLS TLS TLS TLS XXXXXXXX */
913     if (stream_mac) {
914         mac_ctx = hash;
915     } else {
916         if (!EVP_MD_CTX_copy(&hmac, hash))
917             return -1;
918         mac_ctx = &hmac;
919     }
920
921     if (SSL_IS_DTLS(ssl)) {
922         unsigned char dtlsseq[8], *p = dtlsseq;
923
924         s2n(send ? DTLS_RECORD_LAYER_get_w_epoch(&ssl->rlayer) :
925             DTLS_RECORD_LAYER_get_r_epoch(&ssl->rlayer), p);
926         memcpy(p, &seq[2], 6);
927
928         memcpy(header, dtlsseq, 8);
929     } else
930         memcpy(header, seq, 8);
931
932     header[8] = rec->type;
933     header[9] = (unsigned char)(ssl->version >> 8);
934     header[10] = (unsigned char)(ssl->version);
935     header[11] = (rec->length) >> 8;
936     header[12] = (rec->length) & 0xff;
937
938     if (!send && !SSL_USE_ETM(ssl) &&
939         EVP_CIPHER_CTX_mode(ssl->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
940         ssl3_cbc_record_digest_supported(mac_ctx)) {
941         /*
942          * This is a CBC-encrypted record. We must avoid leaking any
943          * timing-side channel information about how many blocks of data we
944          * are hashing because that gives an attacker a timing-oracle.
945          */
946         /* Final param == not SSLv3 */
947         ssl3_cbc_digest_record(mac_ctx,
948                                md, &md_size,
949                                header, rec->input,
950                                rec->length + md_size, rec->orig_len,
951                                ssl->s3->read_mac_secret,
952                                ssl->s3->read_mac_secret_size, 0);
953     } else {
954         EVP_DigestSignUpdate(mac_ctx, header, sizeof(header));
955         EVP_DigestSignUpdate(mac_ctx, rec->input, rec->length);
956         t = EVP_DigestSignFinal(mac_ctx, md, &md_size);
957         OPENSSL_assert(t > 0);
958         if (!send && !SSL_USE_ETM(ssl) && FIPS_mode())
959             tls_fips_digest_extra(ssl->enc_read_ctx,
960                                   mac_ctx, rec->input,
961                                   rec->length, rec->orig_len);
962     }
963
964     if (!stream_mac)
965         EVP_MD_CTX_cleanup(&hmac);
966 #ifdef TLS_DEBUG
967     fprintf(stderr, "seq=");
968     {
969         int z;
970         for (z = 0; z < 8; z++)
971             fprintf(stderr, "%02X ", seq[z]);
972         fprintf(stderr, "\n");
973     }
974     fprintf(stderr, "rec=");
975     {
976         unsigned int z;
977         for (z = 0; z < rec->length; z++)
978             fprintf(stderr, "%02X ", rec->data[z]);
979         fprintf(stderr, "\n");
980     }
981 #endif
982
983     if (!SSL_IS_DTLS(ssl)) {
984         for (i = 7; i >= 0; i--) {
985             ++seq[i];
986             if (seq[i] != 0)
987                 break;
988         }
989     }
990 #ifdef TLS_DEBUG
991     {
992         unsigned int z;
993         for (z = 0; z < md_size; z++)
994             fprintf(stderr, "%02X ", md[z]);
995         fprintf(stderr, "\n");
996     }
997 #endif
998     return (md_size);
999 }
1000
1001 /*-
1002  * ssl3_cbc_remove_padding removes padding from the decrypted, SSLv3, CBC
1003  * record in |rec| by updating |rec->length| in constant time.
1004  *
1005  * block_size: the block size of the cipher used to encrypt the record.
1006  * returns:
1007  *   0: (in non-constant time) if the record is publicly invalid.
1008  *   1: if the padding was valid
1009  *  -1: otherwise.
1010  */
1011 int ssl3_cbc_remove_padding(const SSL *s,
1012                             SSL3_RECORD *rec,
1013                             unsigned block_size, unsigned mac_size)
1014 {
1015     unsigned padding_length, good;
1016     const unsigned overhead = 1 /* padding length byte */  + mac_size;
1017
1018     /*
1019      * These lengths are all public so we can test them in non-constant time.
1020      */
1021     if (overhead > rec->length)
1022         return 0;
1023
1024     padding_length = rec->data[rec->length - 1];
1025     good = constant_time_ge(rec->length, padding_length + overhead);
1026     /* SSLv3 requires that the padding is minimal. */
1027     good &= constant_time_ge(block_size, padding_length + 1);
1028     rec->length -= good & (padding_length + 1);
1029     return constant_time_select_int(good, 1, -1);
1030 }
1031
1032 /*-
1033  * tls1_cbc_remove_padding removes the CBC padding from the decrypted, TLS, CBC
1034  * record in |rec| in constant time and returns 1 if the padding is valid and
1035  * -1 otherwise. It also removes any explicit IV from the start of the record
1036  * without leaking any timing about whether there was enough space after the
1037  * padding was removed.
1038  *
1039  * block_size: the block size of the cipher used to encrypt the record.
1040  * returns:
1041  *   0: (in non-constant time) if the record is publicly invalid.
1042  *   1: if the padding was valid
1043  *  -1: otherwise.
1044  */
1045 int tls1_cbc_remove_padding(const SSL *s,
1046                             SSL3_RECORD *rec,
1047                             unsigned block_size, unsigned mac_size)
1048 {
1049     unsigned padding_length, good, to_check, i;
1050     const unsigned overhead = 1 /* padding length byte */  + mac_size;
1051     /* Check if version requires explicit IV */
1052     if (SSL_USE_EXPLICIT_IV(s)) {
1053         /*
1054          * These lengths are all public so we can test them in non-constant
1055          * time.
1056          */
1057         if (overhead + block_size > rec->length)
1058             return 0;
1059         /* We can now safely skip explicit IV */
1060         rec->data += block_size;
1061         rec->input += block_size;
1062         rec->length -= block_size;
1063         rec->orig_len -= block_size;
1064     } else if (overhead > rec->length)
1065         return 0;
1066
1067     padding_length = rec->data[rec->length - 1];
1068
1069     if (EVP_CIPHER_flags(s->enc_read_ctx->cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) {
1070         /* padding is already verified */
1071         rec->length -= padding_length + 1;
1072         return 1;
1073     }
1074
1075     good = constant_time_ge(rec->length, overhead + padding_length);
1076     /*
1077      * The padding consists of a length byte at the end of the record and
1078      * then that many bytes of padding, all with the same value as the length
1079      * byte. Thus, with the length byte included, there are i+1 bytes of
1080      * padding. We can't check just |padding_length+1| bytes because that
1081      * leaks decrypted information. Therefore we always have to check the
1082      * maximum amount of padding possible. (Again, the length of the record
1083      * is public information so we can use it.)
1084      */
1085     to_check = 255;             /* maximum amount of padding. */
1086     if (to_check > rec->length - 1)
1087         to_check = rec->length - 1;
1088
1089     for (i = 0; i < to_check; i++) {
1090         unsigned char mask = constant_time_ge_8(padding_length, i);
1091         unsigned char b = rec->data[rec->length - 1 - i];
1092         /*
1093          * The final |padding_length+1| bytes should all have the value
1094          * |padding_length|. Therefore the XOR should be zero.
1095          */
1096         good &= ~(mask & (padding_length ^ b));
1097     }
1098
1099     /*
1100      * If any of the final |padding_length+1| bytes had the wrong value, one
1101      * or more of the lower eight bits of |good| will be cleared.
1102      */
1103     good = constant_time_eq(0xff, good & 0xff);
1104     rec->length -= good & (padding_length + 1);
1105
1106     return constant_time_select_int(good, 1, -1);
1107 }
1108
1109 /*-
1110  * ssl3_cbc_copy_mac copies |md_size| bytes from the end of |rec| to |out| in
1111  * constant time (independent of the concrete value of rec->length, which may
1112  * vary within a 256-byte window).
1113  *
1114  * ssl3_cbc_remove_padding or tls1_cbc_remove_padding must be called prior to
1115  * this function.
1116  *
1117  * On entry:
1118  *   rec->orig_len >= md_size
1119  *   md_size <= EVP_MAX_MD_SIZE
1120  *
1121  * If CBC_MAC_ROTATE_IN_PLACE is defined then the rotation is performed with
1122  * variable accesses in a 64-byte-aligned buffer. Assuming that this fits into
1123  * a single or pair of cache-lines, then the variable memory accesses don't
1124  * actually affect the timing. CPUs with smaller cache-lines [if any] are
1125  * not multi-core and are not considered vulnerable to cache-timing attacks.
1126  */
1127 #define CBC_MAC_ROTATE_IN_PLACE
1128
1129 void ssl3_cbc_copy_mac(unsigned char *out,
1130                        const SSL3_RECORD *rec, unsigned md_size)
1131 {
1132 #if defined(CBC_MAC_ROTATE_IN_PLACE)
1133     unsigned char rotated_mac_buf[64 + EVP_MAX_MD_SIZE];
1134     unsigned char *rotated_mac;
1135 #else
1136     unsigned char rotated_mac[EVP_MAX_MD_SIZE];
1137 #endif
1138
1139     /*
1140      * mac_end is the index of |rec->data| just after the end of the MAC.
1141      */
1142     unsigned mac_end = rec->length;
1143     unsigned mac_start = mac_end - md_size;
1144     /*
1145      * scan_start contains the number of bytes that we can ignore because the
1146      * MAC's position can only vary by 255 bytes.
1147      */
1148     unsigned scan_start = 0;
1149     unsigned i, j;
1150     unsigned div_spoiler;
1151     unsigned rotate_offset;
1152
1153     OPENSSL_assert(rec->orig_len >= md_size);
1154     OPENSSL_assert(md_size <= EVP_MAX_MD_SIZE);
1155
1156 #if defined(CBC_MAC_ROTATE_IN_PLACE)
1157     rotated_mac = rotated_mac_buf + ((0 - (size_t)rotated_mac_buf) & 63);
1158 #endif
1159
1160     /* This information is public so it's safe to branch based on it. */
1161     if (rec->orig_len > md_size + 255 + 1)
1162         scan_start = rec->orig_len - (md_size + 255 + 1);
1163     /*
1164      * div_spoiler contains a multiple of md_size that is used to cause the
1165      * modulo operation to be constant time. Without this, the time varies
1166      * based on the amount of padding when running on Intel chips at least.
1167      * The aim of right-shifting md_size is so that the compiler doesn't
1168      * figure out that it can remove div_spoiler as that would require it to
1169      * prove that md_size is always even, which I hope is beyond it.
1170      */
1171     div_spoiler = md_size >> 1;
1172     div_spoiler <<= (sizeof(div_spoiler) - 1) * 8;
1173     rotate_offset = (div_spoiler + mac_start - scan_start) % md_size;
1174
1175     memset(rotated_mac, 0, md_size);
1176     for (i = scan_start, j = 0; i < rec->orig_len; i++) {
1177         unsigned char mac_started = constant_time_ge_8(i, mac_start);
1178         unsigned char mac_ended = constant_time_ge_8(i, mac_end);
1179         unsigned char b = rec->data[i];
1180         rotated_mac[j++] |= b & mac_started & ~mac_ended;
1181         j &= constant_time_lt(j, md_size);
1182     }
1183
1184     /* Now rotate the MAC */
1185 #if defined(CBC_MAC_ROTATE_IN_PLACE)
1186     j = 0;
1187     for (i = 0; i < md_size; i++) {
1188         /* in case cache-line is 32 bytes, touch second line */
1189         ((volatile unsigned char *)rotated_mac)[rotate_offset ^ 32];
1190         out[j++] = rotated_mac[rotate_offset++];
1191         rotate_offset &= constant_time_lt(rotate_offset, md_size);
1192     }
1193 #else
1194     memset(out, 0, md_size);
1195     rotate_offset = md_size - rotate_offset;
1196     rotate_offset &= constant_time_lt(rotate_offset, md_size);
1197     for (i = 0; i < md_size; i++) {
1198         for (j = 0; j < md_size; j++)
1199             out[j] |= rotated_mac[i] & constant_time_eq_8(j, rotate_offset);
1200         rotate_offset++;
1201         rotate_offset &= constant_time_lt(rotate_offset, md_size);
1202     }
1203 #endif
1204 }
1205
1206 int dtls1_process_record(SSL *s)
1207 {
1208     int i, al;
1209     int enc_err;
1210     SSL_SESSION *sess;
1211     SSL3_RECORD *rr;
1212     unsigned int mac_size;
1213     unsigned char md[EVP_MAX_MD_SIZE];
1214
1215     rr = RECORD_LAYER_get_rrec(&s->rlayer);
1216     sess = s->session;
1217
1218     /*
1219      * At this point, s->packet_length == SSL3_RT_HEADER_LNGTH + rr->length,
1220      * and we have that many bytes in s->packet
1221      */
1222     rr->input = &(RECORD_LAYER_get_packet(&s->rlayer)[DTLS1_RT_HEADER_LENGTH]);
1223
1224     /*
1225      * ok, we can now read from 's->packet' data into 'rr' rr->input points
1226      * at rr->length bytes, which need to be copied into rr->data by either
1227      * the decryption or by the decompression When the data is 'copied' into
1228      * the rr->data buffer, rr->input will be pointed at the new buffer
1229      */
1230
1231     /*
1232      * We now have - encrypted [ MAC [ compressed [ plain ] ] ] rr->length
1233      * bytes of encrypted compressed stuff.
1234      */
1235
1236     /* check is not needed I believe */
1237     if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) {
1238         al = SSL_AD_RECORD_OVERFLOW;
1239         SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
1240         goto f_err;
1241     }
1242
1243     /* decrypt in place in 'rr->input' */
1244     rr->data = rr->input;
1245     rr->orig_len = rr->length;
1246
1247     enc_err = s->method->ssl3_enc->enc(s, 0);
1248     /*-
1249      * enc_err is:
1250      *    0: (in non-constant time) if the record is publically invalid.
1251      *    1: if the padding is valid
1252      *   -1: if the padding is invalid
1253      */
1254     if (enc_err == 0) {
1255         /* For DTLS we simply ignore bad packets. */
1256         rr->length = 0;
1257         RECORD_LAYER_reset_packet_length(&s->rlayer);
1258         goto err;
1259     }
1260 #ifdef TLS_DEBUG
1261     printf("dec %d\n", rr->length);
1262     {
1263         unsigned int z;
1264         for (z = 0; z < rr->length; z++)
1265             printf("%02X%c", rr->data[z], ((z + 1) % 16) ? ' ' : '\n');
1266     }
1267     printf("\n");
1268 #endif
1269
1270     /* r->length is now the compressed data plus mac */
1271     if ((sess != NULL) &&
1272         (s->enc_read_ctx != NULL) && (EVP_MD_CTX_md(s->read_hash) != NULL)) {
1273         /* s->read_hash != NULL => mac_size != -1 */
1274         unsigned char *mac = NULL;
1275         unsigned char mac_tmp[EVP_MAX_MD_SIZE];
1276         mac_size = EVP_MD_CTX_size(s->read_hash);
1277         OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);
1278
1279         /*
1280          * orig_len is the length of the record before any padding was
1281          * removed. This is public information, as is the MAC in use,
1282          * therefore we can safely process the record in a different amount
1283          * of time if it's too short to possibly contain a MAC.
1284          */
1285         if (rr->orig_len < mac_size ||
1286             /* CBC records must have a padding length byte too. */
1287             (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
1288              rr->orig_len < mac_size + 1)) {
1289             al = SSL_AD_DECODE_ERROR;
1290             SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_LENGTH_TOO_SHORT);
1291             goto f_err;
1292         }
1293
1294         if (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE) {
1295             /*
1296              * We update the length so that the TLS header bytes can be
1297              * constructed correctly but we need to extract the MAC in
1298              * constant time from within the record, without leaking the
1299              * contents of the padding bytes.
1300              */
1301             mac = mac_tmp;
1302             ssl3_cbc_copy_mac(mac_tmp, rr, mac_size);
1303             rr->length -= mac_size;
1304         } else {
1305             /*
1306              * In this case there's no padding, so |rec->orig_len| equals
1307              * |rec->length| and we checked that there's enough bytes for
1308              * |mac_size| above.
1309              */
1310             rr->length -= mac_size;
1311             mac = &rr->data[rr->length];
1312         }
1313
1314         i = s->method->ssl3_enc->mac(s, md, 0 /* not send */ );
1315         if (i < 0 || mac == NULL
1316             || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0)
1317             enc_err = -1;
1318         if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size)
1319             enc_err = -1;
1320     }
1321
1322     if (enc_err < 0) {
1323         /* decryption failed, silently discard message */
1324         rr->length = 0;
1325         RECORD_LAYER_reset_packet_length(&s->rlayer);
1326         goto err;
1327     }
1328
1329     /* r->length is now just compressed */
1330     if (s->expand != NULL) {
1331         if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH) {
1332             al = SSL_AD_RECORD_OVERFLOW;
1333             SSLerr(SSL_F_DTLS1_PROCESS_RECORD,
1334                    SSL_R_COMPRESSED_LENGTH_TOO_LONG);
1335             goto f_err;
1336         }
1337         if (!ssl3_do_uncompress(s)) {
1338             al = SSL_AD_DECOMPRESSION_FAILURE;
1339             SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_BAD_DECOMPRESSION);
1340             goto f_err;
1341         }
1342     }
1343
1344     if (rr->length > SSL3_RT_MAX_PLAIN_LENGTH) {
1345         al = SSL_AD_RECORD_OVERFLOW;
1346         SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_DATA_LENGTH_TOO_LONG);
1347         goto f_err;
1348     }
1349
1350     rr->off = 0;
1351     /*-
1352      * So at this point the following is true
1353      * ssl->s3->rrec.type   is the type of record
1354      * ssl->s3->rrec.length == number of bytes in record
1355      * ssl->s3->rrec.off    == offset to first valid byte
1356      * ssl->s3->rrec.data   == where to take bytes from, increment
1357      *                         after use :-).
1358      */
1359
1360     /* we have pulled in a full packet so zero things */
1361     RECORD_LAYER_reset_packet_length(&s->rlayer);
1362     return (1);
1363
1364  f_err:
1365     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1366  err:
1367     return (0);
1368 }
1369
1370
1371 /*
1372  * retrieve a buffered record that belongs to the current epoch, ie,
1373  * processed
1374  */
1375 #define dtls1_get_processed_record(s) \
1376                    dtls1_retrieve_buffered_record((s), \
1377                    &(DTLS_RECORD_LAYER_get_processed_rcds(&s->rlayer)))
1378
1379 /*-
1380  * Call this to get a new input record.
1381  * It will return <= 0 if more data is needed, normally due to an error
1382  * or non-blocking IO.
1383  * When it finishes, one packet has been decoded and can be found in
1384  * ssl->s3->rrec.type    - is the type of record
1385  * ssl->s3->rrec.data,   - data
1386  * ssl->s3->rrec.length, - number of bytes
1387  */
1388 /* used only by dtls1_read_bytes */
1389 int dtls1_get_record(SSL *s)
1390 {
1391     int ssl_major, ssl_minor;
1392     int i, n;
1393     SSL3_RECORD *rr;
1394     unsigned char *p = NULL;
1395     unsigned short version;
1396     DTLS1_BITMAP *bitmap;
1397     unsigned int is_next_epoch;
1398
1399     rr = RECORD_LAYER_get_rrec(&s->rlayer);
1400
1401     /*
1402      * The epoch may have changed.  If so, process all the pending records.
1403      * This is a non-blocking operation.
1404      */
1405     if (dtls1_process_buffered_records(s) < 0)
1406         return -1;
1407
1408     /* if we're renegotiating, then there may be buffered records */
1409     if (dtls1_get_processed_record(s))
1410         return 1;
1411
1412     /* get something from the wire */
1413  again:
1414     /* check if we have the header */
1415     if ((RECORD_LAYER_get_rstate(&s->rlayer) != SSL_ST_READ_BODY) ||
1416         (RECORD_LAYER_get_packet_length(&s->rlayer) < DTLS1_RT_HEADER_LENGTH)) {
1417         n = ssl3_read_n(s, DTLS1_RT_HEADER_LENGTH,
1418             SSL3_BUFFER_get_len(&s->rlayer.rbuf), 0);
1419         /* read timeout is handled by dtls1_read_bytes */
1420         if (n <= 0)
1421             return (n);         /* error or non-blocking */
1422
1423         /* this packet contained a partial record, dump it */
1424         if (RECORD_LAYER_get_packet_length(&s->rlayer) != DTLS1_RT_HEADER_LENGTH) {
1425             RECORD_LAYER_reset_packet_length(&s->rlayer);
1426             goto again;
1427         }
1428
1429         RECORD_LAYER_set_rstate(&s->rlayer, SSL_ST_READ_BODY);
1430
1431         p = RECORD_LAYER_get_packet(&s->rlayer);
1432
1433         if (s->msg_callback)
1434             s->msg_callback(0, 0, SSL3_RT_HEADER, p, DTLS1_RT_HEADER_LENGTH,
1435                             s, s->msg_callback_arg);
1436
1437         /* Pull apart the header into the DTLS1_RECORD */
1438         rr->type = *(p++);
1439         ssl_major = *(p++);
1440         ssl_minor = *(p++);
1441         version = (ssl_major << 8) | ssl_minor;
1442
1443         /* sequence number is 64 bits, with top 2 bytes = epoch */
1444         n2s(p, rr->epoch);
1445
1446         memcpy(&(RECORD_LAYER_get_read_sequence(&s->rlayer)[2]), p, 6);
1447         p += 6;
1448
1449         n2s(p, rr->length);
1450
1451         /* Lets check version */
1452         if (!s->first_packet) {
1453             if (version != s->version) {
1454                 /* unexpected version, silently discard */
1455                 rr->length = 0;
1456                 RECORD_LAYER_reset_packet_length(&s->rlayer);
1457                 goto again;
1458             }
1459         }
1460
1461         if ((version & 0xff00) != (s->version & 0xff00)) {
1462             /* wrong version, silently discard record */
1463             rr->length = 0;
1464             RECORD_LAYER_reset_packet_length(&s->rlayer);
1465             goto again;
1466         }
1467
1468         if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) {
1469             /* record too long, silently discard it */
1470             rr->length = 0;
1471             RECORD_LAYER_reset_packet_length(&s->rlayer);
1472             goto again;
1473         }
1474
1475         /* now s->rlayer.rstate == SSL_ST_READ_BODY */
1476     }
1477
1478     /* s->rlayer.rstate == SSL_ST_READ_BODY, get and decode the data */
1479
1480     if (rr->length >
1481         RECORD_LAYER_get_packet_length(&s->rlayer) - DTLS1_RT_HEADER_LENGTH) {
1482         /* now s->packet_length == DTLS1_RT_HEADER_LENGTH */
1483         i = rr->length;
1484         n = ssl3_read_n(s, i, i, 1);
1485         /* this packet contained a partial record, dump it */
1486         if (n != i) {
1487             rr->length = 0;
1488             RECORD_LAYER_reset_packet_length(&s->rlayer);
1489             goto again;
1490         }
1491
1492         /*
1493          * now n == rr->length, and s->packet_length ==
1494          * DTLS1_RT_HEADER_LENGTH + rr->length
1495          */
1496     }
1497     /* set state for later operations */
1498     RECORD_LAYER_set_rstate(&s->rlayer, SSL_ST_READ_HEADER);
1499
1500     /* match epochs.  NULL means the packet is dropped on the floor */
1501     bitmap = dtls1_get_bitmap(s, rr, &is_next_epoch);
1502     if (bitmap == NULL) {
1503         rr->length = 0;
1504         RECORD_LAYER_reset_packet_length(&s->rlayer);   /* dump this record */
1505         goto again;             /* get another record */
1506     }
1507 #ifndef OPENSSL_NO_SCTP
1508     /* Only do replay check if no SCTP bio */
1509     if (!BIO_dgram_is_sctp(SSL_get_rbio(s))) {
1510 #endif
1511         /* Check whether this is a repeat, or aged record. */
1512         if (!dtls1_record_replay_check(s, bitmap)) {
1513             rr->length = 0;
1514             RECORD_LAYER_reset_packet_length(&s->rlayer); /* dump this record */
1515             goto again;         /* get another record */
1516         }
1517 #ifndef OPENSSL_NO_SCTP
1518     }
1519 #endif
1520
1521     /* just read a 0 length packet */
1522     if (rr->length == 0)
1523         goto again;
1524
1525     /*
1526      * If this record is from the next epoch (either HM or ALERT), and a
1527      * handshake is currently in progress, buffer it since it cannot be
1528      * processed at this time.
1529      */
1530     if (is_next_epoch) {
1531         if ((SSL_in_init(s) || ossl_statem_get_in_handshake(s))) {
1532             if (dtls1_buffer_record
1533                 (s, &(DTLS_RECORD_LAYER_get_unprocessed_rcds(&s->rlayer)),
1534                 rr->seq_num) < 0)
1535                 return -1;
1536             /* Mark receipt of record. */
1537             dtls1_record_bitmap_update(s, bitmap);
1538         }
1539         rr->length = 0;
1540         RECORD_LAYER_reset_packet_length(&s->rlayer);
1541         goto again;
1542     }
1543
1544     if (!dtls1_process_record(s)) {
1545         rr->length = 0;
1546         RECORD_LAYER_reset_packet_length(&s->rlayer);   /* dump this record */
1547         goto again;             /* get another record */
1548     }
1549     dtls1_record_bitmap_update(s, bitmap); /* Mark receipt of record. */
1550
1551     return (1);
1552
1553 }