1865f242413cc68c7c1906a72880f95953597167
[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 (EVP_CIPHER_mode(enc) == EVP_CIPH_GCM_MODE && !send) {
768             rec->data += EVP_GCM_TLS_EXPLICIT_IV_LEN;
769             rec->input += EVP_GCM_TLS_EXPLICIT_IV_LEN;
770             rec->length -= EVP_GCM_TLS_EXPLICIT_IV_LEN;
771         }
772
773         ret = 1;
774         if (!SSL_USE_ETM(s) && EVP_MD_CTX_md(s->read_hash) != NULL)
775             mac_size = EVP_MD_CTX_size(s->read_hash);
776         if ((bs != 1) && !send)
777             ret = tls1_cbc_remove_padding(s, rec, bs, mac_size);
778         if (pad && !send)
779             rec->length -= pad;
780     }
781     return ret;
782 }
783
784 int n_ssl3_mac(SSL *ssl, unsigned char *md, int send)
785 {
786     SSL3_RECORD *rec;
787     unsigned char *mac_sec, *seq;
788     EVP_MD_CTX md_ctx;
789     const EVP_MD_CTX *hash;
790     unsigned char *p, rec_char;
791     size_t md_size;
792     int npad;
793     int t;
794
795     if (send) {
796         rec = RECORD_LAYER_get_wrec(&ssl->rlayer);
797         mac_sec = &(ssl->s3->write_mac_secret[0]);
798         seq = RECORD_LAYER_get_write_sequence(&ssl->rlayer);
799         hash = ssl->write_hash;
800     } else {
801         rec = RECORD_LAYER_get_rrec(&ssl->rlayer);
802         mac_sec = &(ssl->s3->read_mac_secret[0]);
803         seq = RECORD_LAYER_get_read_sequence(&ssl->rlayer);
804         hash = ssl->read_hash;
805     }
806
807     t = EVP_MD_CTX_size(hash);
808     if (t < 0)
809         return -1;
810     md_size = t;
811     npad = (48 / md_size) * md_size;
812
813     if (!send &&
814         EVP_CIPHER_CTX_mode(ssl->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
815         ssl3_cbc_record_digest_supported(hash)) {
816         /*
817          * This is a CBC-encrypted record. We must avoid leaking any
818          * timing-side channel information about how many blocks of data we
819          * are hashing because that gives an attacker a timing-oracle.
820          */
821
822         /*-
823          * npad is, at most, 48 bytes and that's with MD5:
824          *   16 + 48 + 8 (sequence bytes) + 1 + 2 = 75.
825          *
826          * With SHA-1 (the largest hash speced for SSLv3) the hash size
827          * goes up 4, but npad goes down by 8, resulting in a smaller
828          * total size.
829          */
830         unsigned char header[75];
831         unsigned j = 0;
832         memcpy(header + j, mac_sec, md_size);
833         j += md_size;
834         memcpy(header + j, ssl3_pad_1, npad);
835         j += npad;
836         memcpy(header + j, seq, 8);
837         j += 8;
838         header[j++] = rec->type;
839         header[j++] = rec->length >> 8;
840         header[j++] = rec->length & 0xff;
841
842         /* Final param == is SSLv3 */
843         ssl3_cbc_digest_record(hash,
844                                md, &md_size,
845                                header, rec->input,
846                                rec->length + md_size, rec->orig_len,
847                                mac_sec, md_size, 1);
848     } else {
849         unsigned int md_size_u;
850         /* Chop the digest off the end :-) */
851         EVP_MD_CTX_init(&md_ctx);
852
853         EVP_MD_CTX_copy_ex(&md_ctx, hash);
854         EVP_DigestUpdate(&md_ctx, mac_sec, md_size);
855         EVP_DigestUpdate(&md_ctx, ssl3_pad_1, npad);
856         EVP_DigestUpdate(&md_ctx, seq, 8);
857         rec_char = rec->type;
858         EVP_DigestUpdate(&md_ctx, &rec_char, 1);
859         p = md;
860         s2n(rec->length, p);
861         EVP_DigestUpdate(&md_ctx, md, 2);
862         EVP_DigestUpdate(&md_ctx, rec->input, rec->length);
863         EVP_DigestFinal_ex(&md_ctx, md, NULL);
864
865         EVP_MD_CTX_copy_ex(&md_ctx, hash);
866         EVP_DigestUpdate(&md_ctx, mac_sec, md_size);
867         EVP_DigestUpdate(&md_ctx, ssl3_pad_2, npad);
868         EVP_DigestUpdate(&md_ctx, md, md_size);
869         EVP_DigestFinal_ex(&md_ctx, md, &md_size_u);
870         md_size = md_size_u;
871
872         EVP_MD_CTX_cleanup(&md_ctx);
873     }
874
875     ssl3_record_sequence_update(seq);
876     return (md_size);
877 }
878
879 int tls1_mac(SSL *ssl, unsigned char *md, int send)
880 {
881     SSL3_RECORD *rec;
882     unsigned char *seq;
883     EVP_MD_CTX *hash;
884     size_t md_size;
885     int i;
886     EVP_MD_CTX hmac, *mac_ctx;
887     unsigned char header[13];
888     int stream_mac = (send ? (ssl->mac_flags & SSL_MAC_FLAG_WRITE_MAC_STREAM)
889                       : (ssl->mac_flags & SSL_MAC_FLAG_READ_MAC_STREAM));
890     int t;
891
892     if (send) {
893         rec = RECORD_LAYER_get_wrec(&ssl->rlayer);
894         seq = RECORD_LAYER_get_write_sequence(&ssl->rlayer);
895         hash = ssl->write_hash;
896     } else {
897         rec = RECORD_LAYER_get_rrec(&ssl->rlayer);
898         seq = RECORD_LAYER_get_read_sequence(&ssl->rlayer);
899         hash = ssl->read_hash;
900     }
901
902     t = EVP_MD_CTX_size(hash);
903     OPENSSL_assert(t >= 0);
904     md_size = t;
905
906     /* I should fix this up TLS TLS TLS TLS TLS XXXXXXXX */
907     if (stream_mac) {
908         mac_ctx = hash;
909     } else {
910         if (!EVP_MD_CTX_copy(&hmac, hash))
911             return -1;
912         mac_ctx = &hmac;
913     }
914
915     if (SSL_IS_DTLS(ssl)) {
916         unsigned char dtlsseq[8], *p = dtlsseq;
917
918         s2n(send ? DTLS_RECORD_LAYER_get_w_epoch(&ssl->rlayer) :
919             DTLS_RECORD_LAYER_get_r_epoch(&ssl->rlayer), p);
920         memcpy(p, &seq[2], 6);
921
922         memcpy(header, dtlsseq, 8);
923     } else
924         memcpy(header, seq, 8);
925
926     header[8] = rec->type;
927     header[9] = (unsigned char)(ssl->version >> 8);
928     header[10] = (unsigned char)(ssl->version);
929     header[11] = (rec->length) >> 8;
930     header[12] = (rec->length) & 0xff;
931
932     if (!send && !SSL_USE_ETM(ssl) &&
933         EVP_CIPHER_CTX_mode(ssl->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
934         ssl3_cbc_record_digest_supported(mac_ctx)) {
935         /*
936          * This is a CBC-encrypted record. We must avoid leaking any
937          * timing-side channel information about how many blocks of data we
938          * are hashing because that gives an attacker a timing-oracle.
939          */
940         /* Final param == not SSLv3 */
941         ssl3_cbc_digest_record(mac_ctx,
942                                md, &md_size,
943                                header, rec->input,
944                                rec->length + md_size, rec->orig_len,
945                                ssl->s3->read_mac_secret,
946                                ssl->s3->read_mac_secret_size, 0);
947     } else {
948         EVP_DigestSignUpdate(mac_ctx, header, sizeof(header));
949         EVP_DigestSignUpdate(mac_ctx, rec->input, rec->length);
950         t = EVP_DigestSignFinal(mac_ctx, md, &md_size);
951         OPENSSL_assert(t > 0);
952         if (!send && !SSL_USE_ETM(ssl) && FIPS_mode())
953             tls_fips_digest_extra(ssl->enc_read_ctx,
954                                   mac_ctx, rec->input,
955                                   rec->length, rec->orig_len);
956     }
957
958     if (!stream_mac)
959         EVP_MD_CTX_cleanup(&hmac);
960 #ifdef TLS_DEBUG
961     fprintf(stderr, "seq=");
962     {
963         int z;
964         for (z = 0; z < 8; z++)
965             fprintf(stderr, "%02X ", seq[z]);
966         fprintf(stderr, "\n");
967     }
968     fprintf(stderr, "rec=");
969     {
970         unsigned int z;
971         for (z = 0; z < rec->length; z++)
972             fprintf(stderr, "%02X ", rec->data[z]);
973         fprintf(stderr, "\n");
974     }
975 #endif
976
977     if (!SSL_IS_DTLS(ssl)) {
978         for (i = 7; i >= 0; i--) {
979             ++seq[i];
980             if (seq[i] != 0)
981                 break;
982         }
983     }
984 #ifdef TLS_DEBUG
985     {
986         unsigned int z;
987         for (z = 0; z < md_size; z++)
988             fprintf(stderr, "%02X ", md[z]);
989         fprintf(stderr, "\n");
990     }
991 #endif
992     return (md_size);
993 }
994
995 /*-
996  * ssl3_cbc_remove_padding removes padding from the decrypted, SSLv3, CBC
997  * record in |rec| by updating |rec->length| in constant time.
998  *
999  * block_size: the block size of the cipher used to encrypt the record.
1000  * returns:
1001  *   0: (in non-constant time) if the record is publicly invalid.
1002  *   1: if the padding was valid
1003  *  -1: otherwise.
1004  */
1005 int ssl3_cbc_remove_padding(const SSL *s,
1006                             SSL3_RECORD *rec,
1007                             unsigned block_size, unsigned mac_size)
1008 {
1009     unsigned padding_length, good;
1010     const unsigned overhead = 1 /* padding length byte */  + mac_size;
1011
1012     /*
1013      * These lengths are all public so we can test them in non-constant time.
1014      */
1015     if (overhead > rec->length)
1016         return 0;
1017
1018     padding_length = rec->data[rec->length - 1];
1019     good = constant_time_ge(rec->length, padding_length + overhead);
1020     /* SSLv3 requires that the padding is minimal. */
1021     good &= constant_time_ge(block_size, padding_length + 1);
1022     rec->length -= good & (padding_length + 1);
1023     return constant_time_select_int(good, 1, -1);
1024 }
1025
1026 /*-
1027  * tls1_cbc_remove_padding removes the CBC padding from the decrypted, TLS, CBC
1028  * record in |rec| in constant time and returns 1 if the padding is valid and
1029  * -1 otherwise. It also removes any explicit IV from the start of the record
1030  * without leaking any timing about whether there was enough space after the
1031  * padding was removed.
1032  *
1033  * block_size: the block size of the cipher used to encrypt the record.
1034  * returns:
1035  *   0: (in non-constant time) if the record is publicly invalid.
1036  *   1: if the padding was valid
1037  *  -1: otherwise.
1038  */
1039 int tls1_cbc_remove_padding(const SSL *s,
1040                             SSL3_RECORD *rec,
1041                             unsigned block_size, unsigned mac_size)
1042 {
1043     unsigned padding_length, good, to_check, i;
1044     const unsigned overhead = 1 /* padding length byte */  + mac_size;
1045     /* Check if version requires explicit IV */
1046     if (SSL_USE_EXPLICIT_IV(s)) {
1047         /*
1048          * These lengths are all public so we can test them in non-constant
1049          * time.
1050          */
1051         if (overhead + block_size > rec->length)
1052             return 0;
1053         /* We can now safely skip explicit IV */
1054         rec->data += block_size;
1055         rec->input += block_size;
1056         rec->length -= block_size;
1057         rec->orig_len -= block_size;
1058     } else if (overhead > rec->length)
1059         return 0;
1060
1061     padding_length = rec->data[rec->length - 1];
1062
1063     if (EVP_CIPHER_flags(s->enc_read_ctx->cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) {
1064         /* padding is already verified */
1065         rec->length -= padding_length + 1;
1066         return 1;
1067     }
1068
1069     good = constant_time_ge(rec->length, overhead + padding_length);
1070     /*
1071      * The padding consists of a length byte at the end of the record and
1072      * then that many bytes of padding, all with the same value as the length
1073      * byte. Thus, with the length byte included, there are i+1 bytes of
1074      * padding. We can't check just |padding_length+1| bytes because that
1075      * leaks decrypted information. Therefore we always have to check the
1076      * maximum amount of padding possible. (Again, the length of the record
1077      * is public information so we can use it.)
1078      */
1079     to_check = 255;             /* maximum amount of padding. */
1080     if (to_check > rec->length - 1)
1081         to_check = rec->length - 1;
1082
1083     for (i = 0; i < to_check; i++) {
1084         unsigned char mask = constant_time_ge_8(padding_length, i);
1085         unsigned char b = rec->data[rec->length - 1 - i];
1086         /*
1087          * The final |padding_length+1| bytes should all have the value
1088          * |padding_length|. Therefore the XOR should be zero.
1089          */
1090         good &= ~(mask & (padding_length ^ b));
1091     }
1092
1093     /*
1094      * If any of the final |padding_length+1| bytes had the wrong value, one
1095      * or more of the lower eight bits of |good| will be cleared.
1096      */
1097     good = constant_time_eq(0xff, good & 0xff);
1098     rec->length -= good & (padding_length + 1);
1099
1100     return constant_time_select_int(good, 1, -1);
1101 }
1102
1103 /*-
1104  * ssl3_cbc_copy_mac copies |md_size| bytes from the end of |rec| to |out| in
1105  * constant time (independent of the concrete value of rec->length, which may
1106  * vary within a 256-byte window).
1107  *
1108  * ssl3_cbc_remove_padding or tls1_cbc_remove_padding must be called prior to
1109  * this function.
1110  *
1111  * On entry:
1112  *   rec->orig_len >= md_size
1113  *   md_size <= EVP_MAX_MD_SIZE
1114  *
1115  * If CBC_MAC_ROTATE_IN_PLACE is defined then the rotation is performed with
1116  * variable accesses in a 64-byte-aligned buffer. Assuming that this fits into
1117  * a single or pair of cache-lines, then the variable memory accesses don't
1118  * actually affect the timing. CPUs with smaller cache-lines [if any] are
1119  * not multi-core and are not considered vulnerable to cache-timing attacks.
1120  */
1121 #define CBC_MAC_ROTATE_IN_PLACE
1122
1123 void ssl3_cbc_copy_mac(unsigned char *out,
1124                        const SSL3_RECORD *rec, unsigned md_size)
1125 {
1126 #if defined(CBC_MAC_ROTATE_IN_PLACE)
1127     unsigned char rotated_mac_buf[64 + EVP_MAX_MD_SIZE];
1128     unsigned char *rotated_mac;
1129 #else
1130     unsigned char rotated_mac[EVP_MAX_MD_SIZE];
1131 #endif
1132
1133     /*
1134      * mac_end is the index of |rec->data| just after the end of the MAC.
1135      */
1136     unsigned mac_end = rec->length;
1137     unsigned mac_start = mac_end - md_size;
1138     /*
1139      * scan_start contains the number of bytes that we can ignore because the
1140      * MAC's position can only vary by 255 bytes.
1141      */
1142     unsigned scan_start = 0;
1143     unsigned i, j;
1144     unsigned div_spoiler;
1145     unsigned rotate_offset;
1146
1147     OPENSSL_assert(rec->orig_len >= md_size);
1148     OPENSSL_assert(md_size <= EVP_MAX_MD_SIZE);
1149
1150 #if defined(CBC_MAC_ROTATE_IN_PLACE)
1151     rotated_mac = rotated_mac_buf + ((0 - (size_t)rotated_mac_buf) & 63);
1152 #endif
1153
1154     /* This information is public so it's safe to branch based on it. */
1155     if (rec->orig_len > md_size + 255 + 1)
1156         scan_start = rec->orig_len - (md_size + 255 + 1);
1157     /*
1158      * div_spoiler contains a multiple of md_size that is used to cause the
1159      * modulo operation to be constant time. Without this, the time varies
1160      * based on the amount of padding when running on Intel chips at least.
1161      * The aim of right-shifting md_size is so that the compiler doesn't
1162      * figure out that it can remove div_spoiler as that would require it to
1163      * prove that md_size is always even, which I hope is beyond it.
1164      */
1165     div_spoiler = md_size >> 1;
1166     div_spoiler <<= (sizeof(div_spoiler) - 1) * 8;
1167     rotate_offset = (div_spoiler + mac_start - scan_start) % md_size;
1168
1169     memset(rotated_mac, 0, md_size);
1170     for (i = scan_start, j = 0; i < rec->orig_len; i++) {
1171         unsigned char mac_started = constant_time_ge_8(i, mac_start);
1172         unsigned char mac_ended = constant_time_ge_8(i, mac_end);
1173         unsigned char b = rec->data[i];
1174         rotated_mac[j++] |= b & mac_started & ~mac_ended;
1175         j &= constant_time_lt(j, md_size);
1176     }
1177
1178     /* Now rotate the MAC */
1179 #if defined(CBC_MAC_ROTATE_IN_PLACE)
1180     j = 0;
1181     for (i = 0; i < md_size; i++) {
1182         /* in case cache-line is 32 bytes, touch second line */
1183         ((volatile unsigned char *)rotated_mac)[rotate_offset ^ 32];
1184         out[j++] = rotated_mac[rotate_offset++];
1185         rotate_offset &= constant_time_lt(rotate_offset, md_size);
1186     }
1187 #else
1188     memset(out, 0, md_size);
1189     rotate_offset = md_size - rotate_offset;
1190     rotate_offset &= constant_time_lt(rotate_offset, md_size);
1191     for (i = 0; i < md_size; i++) {
1192         for (j = 0; j < md_size; j++)
1193             out[j] |= rotated_mac[i] & constant_time_eq_8(j, rotate_offset);
1194         rotate_offset++;
1195         rotate_offset &= constant_time_lt(rotate_offset, md_size);
1196     }
1197 #endif
1198 }
1199
1200 int dtls1_process_record(SSL *s)
1201 {
1202     int i, al;
1203     int enc_err;
1204     SSL_SESSION *sess;
1205     SSL3_RECORD *rr;
1206     unsigned int mac_size;
1207     unsigned char md[EVP_MAX_MD_SIZE];
1208
1209     rr = RECORD_LAYER_get_rrec(&s->rlayer);
1210     sess = s->session;
1211
1212     /*
1213      * At this point, s->packet_length == SSL3_RT_HEADER_LNGTH + rr->length,
1214      * and we have that many bytes in s->packet
1215      */
1216     rr->input = &(RECORD_LAYER_get_packet(&s->rlayer)[DTLS1_RT_HEADER_LENGTH]);
1217
1218     /*
1219      * ok, we can now read from 's->packet' data into 'rr' rr->input points
1220      * at rr->length bytes, which need to be copied into rr->data by either
1221      * the decryption or by the decompression When the data is 'copied' into
1222      * the rr->data buffer, rr->input will be pointed at the new buffer
1223      */
1224
1225     /*
1226      * We now have - encrypted [ MAC [ compressed [ plain ] ] ] rr->length
1227      * bytes of encrypted compressed stuff.
1228      */
1229
1230     /* check is not needed I believe */
1231     if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) {
1232         al = SSL_AD_RECORD_OVERFLOW;
1233         SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
1234         goto f_err;
1235     }
1236
1237     /* decrypt in place in 'rr->input' */
1238     rr->data = rr->input;
1239     rr->orig_len = rr->length;
1240
1241     enc_err = s->method->ssl3_enc->enc(s, 0);
1242     /*-
1243      * enc_err is:
1244      *    0: (in non-constant time) if the record is publically invalid.
1245      *    1: if the padding is valid
1246      *   -1: if the padding is invalid
1247      */
1248     if (enc_err == 0) {
1249         /* For DTLS we simply ignore bad packets. */
1250         rr->length = 0;
1251         RECORD_LAYER_reset_packet_length(&s->rlayer);
1252         goto err;
1253     }
1254 #ifdef TLS_DEBUG
1255     printf("dec %d\n", rr->length);
1256     {
1257         unsigned int z;
1258         for (z = 0; z < rr->length; z++)
1259             printf("%02X%c", rr->data[z], ((z + 1) % 16) ? ' ' : '\n');
1260     }
1261     printf("\n");
1262 #endif
1263
1264     /* r->length is now the compressed data plus mac */
1265     if ((sess != NULL) &&
1266         (s->enc_read_ctx != NULL) && (EVP_MD_CTX_md(s->read_hash) != NULL)) {
1267         /* s->read_hash != NULL => mac_size != -1 */
1268         unsigned char *mac = NULL;
1269         unsigned char mac_tmp[EVP_MAX_MD_SIZE];
1270         mac_size = EVP_MD_CTX_size(s->read_hash);
1271         OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);
1272
1273         /*
1274          * orig_len is the length of the record before any padding was
1275          * removed. This is public information, as is the MAC in use,
1276          * therefore we can safely process the record in a different amount
1277          * of time if it's too short to possibly contain a MAC.
1278          */
1279         if (rr->orig_len < mac_size ||
1280             /* CBC records must have a padding length byte too. */
1281             (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
1282              rr->orig_len < mac_size + 1)) {
1283             al = SSL_AD_DECODE_ERROR;
1284             SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_LENGTH_TOO_SHORT);
1285             goto f_err;
1286         }
1287
1288         if (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE) {
1289             /*
1290              * We update the length so that the TLS header bytes can be
1291              * constructed correctly but we need to extract the MAC in
1292              * constant time from within the record, without leaking the
1293              * contents of the padding bytes.
1294              */
1295             mac = mac_tmp;
1296             ssl3_cbc_copy_mac(mac_tmp, rr, mac_size);
1297             rr->length -= mac_size;
1298         } else {
1299             /*
1300              * In this case there's no padding, so |rec->orig_len| equals
1301              * |rec->length| and we checked that there's enough bytes for
1302              * |mac_size| above.
1303              */
1304             rr->length -= mac_size;
1305             mac = &rr->data[rr->length];
1306         }
1307
1308         i = s->method->ssl3_enc->mac(s, md, 0 /* not send */ );
1309         if (i < 0 || mac == NULL
1310             || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0)
1311             enc_err = -1;
1312         if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size)
1313             enc_err = -1;
1314     }
1315
1316     if (enc_err < 0) {
1317         /* decryption failed, silently discard message */
1318         rr->length = 0;
1319         RECORD_LAYER_reset_packet_length(&s->rlayer);
1320         goto err;
1321     }
1322
1323     /* r->length is now just compressed */
1324     if (s->expand != NULL) {
1325         if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH) {
1326             al = SSL_AD_RECORD_OVERFLOW;
1327             SSLerr(SSL_F_DTLS1_PROCESS_RECORD,
1328                    SSL_R_COMPRESSED_LENGTH_TOO_LONG);
1329             goto f_err;
1330         }
1331         if (!ssl3_do_uncompress(s)) {
1332             al = SSL_AD_DECOMPRESSION_FAILURE;
1333             SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_BAD_DECOMPRESSION);
1334             goto f_err;
1335         }
1336     }
1337
1338     if (rr->length > SSL3_RT_MAX_PLAIN_LENGTH) {
1339         al = SSL_AD_RECORD_OVERFLOW;
1340         SSLerr(SSL_F_DTLS1_PROCESS_RECORD, SSL_R_DATA_LENGTH_TOO_LONG);
1341         goto f_err;
1342     }
1343
1344     rr->off = 0;
1345     /*-
1346      * So at this point the following is true
1347      * ssl->s3->rrec.type   is the type of record
1348      * ssl->s3->rrec.length == number of bytes in record
1349      * ssl->s3->rrec.off    == offset to first valid byte
1350      * ssl->s3->rrec.data   == where to take bytes from, increment
1351      *                         after use :-).
1352      */
1353
1354     /* we have pulled in a full packet so zero things */
1355     RECORD_LAYER_reset_packet_length(&s->rlayer);
1356     return (1);
1357
1358  f_err:
1359     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1360  err:
1361     return (0);
1362 }
1363
1364
1365 /*
1366  * retrieve a buffered record that belongs to the current epoch, ie,
1367  * processed
1368  */
1369 #define dtls1_get_processed_record(s) \
1370                    dtls1_retrieve_buffered_record((s), \
1371                    &(DTLS_RECORD_LAYER_get_processed_rcds(&s->rlayer)))
1372
1373 /*-
1374  * Call this to get a new input record.
1375  * It will return <= 0 if more data is needed, normally due to an error
1376  * or non-blocking IO.
1377  * When it finishes, one packet has been decoded and can be found in
1378  * ssl->s3->rrec.type    - is the type of record
1379  * ssl->s3->rrec.data,   - data
1380  * ssl->s3->rrec.length, - number of bytes
1381  */
1382 /* used only by dtls1_read_bytes */
1383 int dtls1_get_record(SSL *s)
1384 {
1385     int ssl_major, ssl_minor;
1386     int i, n;
1387     SSL3_RECORD *rr;
1388     unsigned char *p = NULL;
1389     unsigned short version;
1390     DTLS1_BITMAP *bitmap;
1391     unsigned int is_next_epoch;
1392
1393     rr = RECORD_LAYER_get_rrec(&s->rlayer);
1394
1395     /*
1396      * The epoch may have changed.  If so, process all the pending records.
1397      * This is a non-blocking operation.
1398      */
1399     if (dtls1_process_buffered_records(s) < 0)
1400         return -1;
1401
1402     /* if we're renegotiating, then there may be buffered records */
1403     if (dtls1_get_processed_record(s))
1404         return 1;
1405
1406     /* get something from the wire */
1407  again:
1408     /* check if we have the header */
1409     if ((RECORD_LAYER_get_rstate(&s->rlayer) != SSL_ST_READ_BODY) ||
1410         (RECORD_LAYER_get_packet_length(&s->rlayer) < DTLS1_RT_HEADER_LENGTH)) {
1411         n = ssl3_read_n(s, DTLS1_RT_HEADER_LENGTH,
1412             SSL3_BUFFER_get_len(&s->rlayer.rbuf), 0);
1413         /* read timeout is handled by dtls1_read_bytes */
1414         if (n <= 0)
1415             return (n);         /* error or non-blocking */
1416
1417         /* this packet contained a partial record, dump it */
1418         if (RECORD_LAYER_get_packet_length(&s->rlayer) != DTLS1_RT_HEADER_LENGTH) {
1419             RECORD_LAYER_reset_packet_length(&s->rlayer);
1420             goto again;
1421         }
1422
1423         RECORD_LAYER_set_rstate(&s->rlayer, SSL_ST_READ_BODY);
1424
1425         p = RECORD_LAYER_get_packet(&s->rlayer);
1426
1427         if (s->msg_callback)
1428             s->msg_callback(0, 0, SSL3_RT_HEADER, p, DTLS1_RT_HEADER_LENGTH,
1429                             s, s->msg_callback_arg);
1430
1431         /* Pull apart the header into the DTLS1_RECORD */
1432         rr->type = *(p++);
1433         ssl_major = *(p++);
1434         ssl_minor = *(p++);
1435         version = (ssl_major << 8) | ssl_minor;
1436
1437         /* sequence number is 64 bits, with top 2 bytes = epoch */
1438         n2s(p, rr->epoch);
1439
1440         memcpy(&(RECORD_LAYER_get_read_sequence(&s->rlayer)[2]), p, 6);
1441         p += 6;
1442
1443         n2s(p, rr->length);
1444
1445         /* Lets check version */
1446         if (!s->first_packet) {
1447             if (version != s->version) {
1448                 /* unexpected version, silently discard */
1449                 rr->length = 0;
1450                 RECORD_LAYER_reset_packet_length(&s->rlayer);
1451                 goto again;
1452             }
1453         }
1454
1455         if ((version & 0xff00) != (s->version & 0xff00)) {
1456             /* wrong version, silently discard record */
1457             rr->length = 0;
1458             RECORD_LAYER_reset_packet_length(&s->rlayer);
1459             goto again;
1460         }
1461
1462         if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) {
1463             /* record too long, silently discard it */
1464             rr->length = 0;
1465             RECORD_LAYER_reset_packet_length(&s->rlayer);
1466             goto again;
1467         }
1468
1469         /* now s->rlayer.rstate == SSL_ST_READ_BODY */
1470     }
1471
1472     /* s->rlayer.rstate == SSL_ST_READ_BODY, get and decode the data */
1473
1474     if (rr->length >
1475         RECORD_LAYER_get_packet_length(&s->rlayer) - DTLS1_RT_HEADER_LENGTH) {
1476         /* now s->packet_length == DTLS1_RT_HEADER_LENGTH */
1477         i = rr->length;
1478         n = ssl3_read_n(s, i, i, 1);
1479         /* this packet contained a partial record, dump it */
1480         if (n != i) {
1481             rr->length = 0;
1482             RECORD_LAYER_reset_packet_length(&s->rlayer);
1483             goto again;
1484         }
1485
1486         /*
1487          * now n == rr->length, and s->packet_length ==
1488          * DTLS1_RT_HEADER_LENGTH + rr->length
1489          */
1490     }
1491     /* set state for later operations */
1492     RECORD_LAYER_set_rstate(&s->rlayer, SSL_ST_READ_HEADER);
1493
1494     /* match epochs.  NULL means the packet is dropped on the floor */
1495     bitmap = dtls1_get_bitmap(s, rr, &is_next_epoch);
1496     if (bitmap == NULL) {
1497         rr->length = 0;
1498         RECORD_LAYER_reset_packet_length(&s->rlayer);   /* dump this record */
1499         goto again;             /* get another record */
1500     }
1501 #ifndef OPENSSL_NO_SCTP
1502     /* Only do replay check if no SCTP bio */
1503     if (!BIO_dgram_is_sctp(SSL_get_rbio(s))) {
1504 #endif
1505         /*
1506          * Check whether this is a repeat, or aged record. Don't check if
1507          * we're listening and this message is a ClientHello. They can look
1508          * as if they're replayed, since they arrive from different
1509          * connections and would be dropped unnecessarily.
1510          */
1511         if (!(s->d1->listen && rr->type == SSL3_RT_HANDSHAKE &&
1512               RECORD_LAYER_get_packet_length(&s->rlayer)
1513                   > DTLS1_RT_HEADER_LENGTH &&
1514               RECORD_LAYER_get_packet(&s->rlayer)[DTLS1_RT_HEADER_LENGTH]
1515                   == SSL3_MT_CLIENT_HELLO) &&
1516             !dtls1_record_replay_check(s, bitmap)) {
1517             rr->length = 0;
1518             RECORD_LAYER_reset_packet_length(&s->rlayer); /* dump this record */
1519             goto again;         /* get another record */
1520         }
1521 #ifndef OPENSSL_NO_SCTP
1522     }
1523 #endif
1524
1525     /* just read a 0 length packet */
1526     if (rr->length == 0)
1527         goto again;
1528
1529     /*
1530      * If this record is from the next epoch (either HM or ALERT), and a
1531      * handshake is currently in progress, buffer it since it cannot be
1532      * processed at this time. However, do not buffer anything while
1533      * listening.
1534      */
1535     if (is_next_epoch) {
1536         if ((SSL_in_init(s) || s->in_handshake) && !s->d1->listen) {
1537             if (dtls1_buffer_record
1538                 (s, &(DTLS_RECORD_LAYER_get_unprocessed_rcds(&s->rlayer)),
1539                 rr->seq_num) < 0)
1540                 return -1;
1541             /* Mark receipt of record. */
1542             dtls1_record_bitmap_update(s, bitmap);
1543         }
1544         rr->length = 0;
1545         RECORD_LAYER_reset_packet_length(&s->rlayer);
1546         goto again;
1547     }
1548
1549     if (!dtls1_process_record(s)) {
1550         rr->length = 0;
1551         RECORD_LAYER_reset_packet_length(&s->rlayer);   /* dump this record */
1552         goto again;             /* get another record */
1553     }
1554     dtls1_record_bitmap_update(s, bitmap); /* Mark receipt of record. */
1555
1556     return (1);
1557
1558 }