Unify ssl3_get_cipher_by_std_name() implementation
[openssl.git] / ssl / s3_cbc.c
1 /*
2  * Copyright 2012-2020 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /*
11  * This file has no dependencies on the rest of libssl because it is shared
12  * with the providers. It contains functions for low level MAC calculations.
13  * Responsibility for this lies with the HMAC implementation in the
14  * providers. However there are legacy code paths in libssl which also need to
15  * do this. In time those legacy code paths can be removed and this file can be
16  * moved out of libssl.
17  */
18
19
20 /*
21  * MD5 and SHA-1 low level APIs are deprecated for public use, but still ok for
22  * internal use.
23  */
24 #include "internal/deprecated.h"
25
26 #include "internal/constant_time.h"
27 #include "internal/cryptlib.h"
28
29 #include <openssl/evp.h>
30 #include <openssl/md5.h>
31 #include <openssl/sha.h>
32
33 char ssl3_cbc_record_digest_supported(const EVP_MD_CTX *ctx);
34 int ssl3_cbc_digest_record(const EVP_MD *md,
35                            unsigned char *md_out,
36                            size_t *md_out_size,
37                            const unsigned char header[13],
38                            const unsigned char *data,
39                            size_t data_size,
40                            size_t data_plus_mac_plus_padding_size,
41                            const unsigned char *mac_secret,
42                            size_t mac_secret_length, char is_sslv3);
43
44 # define l2n(l,c)        (*((c)++)=(unsigned char)(((l)>>24)&0xff), \
45                          *((c)++)=(unsigned char)(((l)>>16)&0xff), \
46                          *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
47                          *((c)++)=(unsigned char)(((l)    )&0xff))
48
49 # define l2n6(l,c)       (*((c)++)=(unsigned char)(((l)>>40)&0xff), \
50                          *((c)++)=(unsigned char)(((l)>>32)&0xff), \
51                          *((c)++)=(unsigned char)(((l)>>24)&0xff), \
52                          *((c)++)=(unsigned char)(((l)>>16)&0xff), \
53                          *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
54                          *((c)++)=(unsigned char)(((l)    )&0xff))
55
56 # define l2n8(l,c)       (*((c)++)=(unsigned char)(((l)>>56)&0xff), \
57                          *((c)++)=(unsigned char)(((l)>>48)&0xff), \
58                          *((c)++)=(unsigned char)(((l)>>40)&0xff), \
59                          *((c)++)=(unsigned char)(((l)>>32)&0xff), \
60                          *((c)++)=(unsigned char)(((l)>>24)&0xff), \
61                          *((c)++)=(unsigned char)(((l)>>16)&0xff), \
62                          *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
63                          *((c)++)=(unsigned char)(((l)    )&0xff))
64
65 /*
66  * MAX_HASH_BIT_COUNT_BYTES is the maximum number of bytes in the hash's
67  * length field. (SHA-384/512 have 128-bit length.)
68  */
69 #define MAX_HASH_BIT_COUNT_BYTES 16
70
71 /*
72  * MAX_HASH_BLOCK_SIZE is the maximum hash block size that we'll support.
73  * Currently SHA-384/512 has a 128-byte block size and that's the largest
74  * supported by TLS.)
75  */
76 #define MAX_HASH_BLOCK_SIZE 128
77
78 /*
79  * u32toLE serializes an unsigned, 32-bit number (n) as four bytes at (p) in
80  * little-endian order. The value of p is advanced by four.
81  */
82 #define u32toLE(n, p) \
83         (*((p)++)=(unsigned char)(n), \
84          *((p)++)=(unsigned char)(n>>8), \
85          *((p)++)=(unsigned char)(n>>16), \
86          *((p)++)=(unsigned char)(n>>24))
87
88 /*
89  * These functions serialize the state of a hash and thus perform the
90  * standard "final" operation without adding the padding and length that such
91  * a function typically does.
92  */
93 static void tls1_md5_final_raw(void *ctx, unsigned char *md_out)
94 {
95     MD5_CTX *md5 = ctx;
96     u32toLE(md5->A, md_out);
97     u32toLE(md5->B, md_out);
98     u32toLE(md5->C, md_out);
99     u32toLE(md5->D, md_out);
100 }
101
102 static void tls1_sha1_final_raw(void *ctx, unsigned char *md_out)
103 {
104     SHA_CTX *sha1 = ctx;
105     l2n(sha1->h0, md_out);
106     l2n(sha1->h1, md_out);
107     l2n(sha1->h2, md_out);
108     l2n(sha1->h3, md_out);
109     l2n(sha1->h4, md_out);
110 }
111
112 static void tls1_sha256_final_raw(void *ctx, unsigned char *md_out)
113 {
114     SHA256_CTX *sha256 = ctx;
115     unsigned i;
116
117     for (i = 0; i < 8; i++) {
118         l2n(sha256->h[i], md_out);
119     }
120 }
121
122 static void tls1_sha512_final_raw(void *ctx, unsigned char *md_out)
123 {
124     SHA512_CTX *sha512 = ctx;
125     unsigned i;
126
127     for (i = 0; i < 8; i++) {
128         l2n8(sha512->h[i], md_out);
129     }
130 }
131
132 #undef  LARGEST_DIGEST_CTX
133 #define LARGEST_DIGEST_CTX SHA512_CTX
134
135 /*-
136  * ssl3_cbc_digest_record computes the MAC of a decrypted, padded SSLv3/TLS
137  * record.
138  *
139  *   ctx: the EVP_MD_CTX from which we take the hash function.
140  *     ssl3_cbc_record_digest_supported must return true for this EVP_MD_CTX.
141  *   md_out: the digest output. At most EVP_MAX_MD_SIZE bytes will be written.
142  *   md_out_size: if non-NULL, the number of output bytes is written here.
143  *   header: the 13-byte, TLS record header.
144  *   data: the record data itself, less any preceding explicit IV.
145  *   data_size: the secret, reported length of the data once the MAC and padding
146  *              has been removed.
147  *   data_plus_mac_plus_padding_size: the public length of the whole
148  *     record, including MAC and padding.
149  *   is_sslv3: non-zero if we are to use SSLv3. Otherwise, TLS.
150  *
151  * On entry: we know that data is data_plus_mac_plus_padding_size in length
152  * Returns 1 on success or 0 on error
153  */
154 int ssl3_cbc_digest_record(const EVP_MD *md,
155                            unsigned char *md_out,
156                            size_t *md_out_size,
157                            const unsigned char header[13],
158                            const unsigned char *data,
159                            size_t data_size,
160                            size_t data_plus_mac_plus_padding_size,
161                            const unsigned char *mac_secret,
162                            size_t mac_secret_length, char is_sslv3)
163 {
164     union {
165         OSSL_UNION_ALIGN;
166         unsigned char c[sizeof(LARGEST_DIGEST_CTX)];
167     } md_state;
168     void (*md_final_raw) (void *ctx, unsigned char *md_out);
169     void (*md_transform) (void *ctx, const unsigned char *block);
170     size_t md_size, md_block_size = 64;
171     size_t sslv3_pad_length = 40, header_length, variance_blocks,
172         len, max_mac_bytes, num_blocks,
173         num_starting_blocks, k, mac_end_offset, c, index_a, index_b;
174     size_t bits;          /* at most 18 bits */
175     unsigned char length_bytes[MAX_HASH_BIT_COUNT_BYTES];
176     /* hmac_pad is the masked HMAC key. */
177     unsigned char hmac_pad[MAX_HASH_BLOCK_SIZE];
178     unsigned char first_block[MAX_HASH_BLOCK_SIZE];
179     unsigned char mac_out[EVP_MAX_MD_SIZE];
180     size_t i, j;
181     unsigned md_out_size_u;
182     EVP_MD_CTX *md_ctx = NULL;
183     /*
184      * mdLengthSize is the number of bytes in the length field that
185      * terminates * the hash.
186      */
187     size_t md_length_size = 8;
188     char length_is_big_endian = 1;
189     int ret = 0;
190
191     /*
192      * This is a, hopefully redundant, check that allows us to forget about
193      * many possible overflows later in this function.
194      */
195     if (!ossl_assert(data_plus_mac_plus_padding_size < 1024 * 1024))
196         return 0;
197
198     if (EVP_MD_is_a(md, "MD5")) {
199         if (MD5_Init((MD5_CTX *)md_state.c) <= 0)
200             return 0;
201         md_final_raw = tls1_md5_final_raw;
202         md_transform =
203             (void (*)(void *ctx, const unsigned char *block))MD5_Transform;
204         md_size = 16;
205         sslv3_pad_length = 48;
206         length_is_big_endian = 0;
207     } else if (EVP_MD_is_a(md, "SHA1")) {
208         if (SHA1_Init((SHA_CTX *)md_state.c) <= 0)
209             return 0;
210         md_final_raw = tls1_sha1_final_raw;
211         md_transform =
212             (void (*)(void *ctx, const unsigned char *block))SHA1_Transform;
213         md_size = 20;
214     } else if (EVP_MD_is_a(md, "SHA2-224")) {
215         if (SHA224_Init((SHA256_CTX *)md_state.c) <= 0)
216             return 0;
217         md_final_raw = tls1_sha256_final_raw;
218         md_transform =
219             (void (*)(void *ctx, const unsigned char *block))SHA256_Transform;
220         md_size = 224 / 8;
221      } else if (EVP_MD_is_a(md, "SHA2-256")) {
222         if (SHA256_Init((SHA256_CTX *)md_state.c) <= 0)
223             return 0;
224         md_final_raw = tls1_sha256_final_raw;
225         md_transform =
226             (void (*)(void *ctx, const unsigned char *block))SHA256_Transform;
227         md_size = 32;
228      } else if (EVP_MD_is_a(md, "SHA2-384")) {
229         if (SHA384_Init((SHA512_CTX *)md_state.c) <= 0)
230             return 0;
231         md_final_raw = tls1_sha512_final_raw;
232         md_transform =
233             (void (*)(void *ctx, const unsigned char *block))SHA512_Transform;
234         md_size = 384 / 8;
235         md_block_size = 128;
236         md_length_size = 16;
237     } else if (EVP_MD_is_a(md, "SHA2-512")) {
238         if (SHA512_Init((SHA512_CTX *)md_state.c) <= 0)
239             return 0;
240         md_final_raw = tls1_sha512_final_raw;
241         md_transform =
242             (void (*)(void *ctx, const unsigned char *block))SHA512_Transform;
243         md_size = 64;
244         md_block_size = 128;
245         md_length_size = 16;
246     } else {
247         /*
248          * ssl3_cbc_record_digest_supported should have been called first to
249          * check that the hash function is supported.
250          */
251         if (md_out_size != NULL)
252             *md_out_size = 0;
253         return ossl_assert(0);
254     }
255
256     if (!ossl_assert(md_length_size <= MAX_HASH_BIT_COUNT_BYTES)
257             || !ossl_assert(md_block_size <= MAX_HASH_BLOCK_SIZE)
258             || !ossl_assert(md_size <= EVP_MAX_MD_SIZE))
259         return 0;
260
261     header_length = 13;
262     if (is_sslv3) {
263         header_length = mac_secret_length + sslv3_pad_length + 8 /* sequence
264                                                                   * number */  +
265             1 /* record type */  +
266             2 /* record length */ ;
267     }
268
269     /*
270      * variance_blocks is the number of blocks of the hash that we have to
271      * calculate in constant time because they could be altered by the
272      * padding value. In SSLv3, the padding must be minimal so the end of
273      * the plaintext varies by, at most, 15+20 = 35 bytes. (We conservatively
274      * assume that the MAC size varies from 0..20 bytes.) In case the 9 bytes
275      * of hash termination (0x80 + 64-bit length) don't fit in the final
276      * block, we say that the final two blocks can vary based on the padding.
277      * TLSv1 has MACs up to 48 bytes long (SHA-384) and the padding is not
278      * required to be minimal. Therefore we say that the final |variance_blocks|
279      * blocks can
280      * vary based on the padding. Later in the function, if the message is
281      * short and there obviously cannot be this many blocks then
282      * variance_blocks can be reduced.
283      */
284     variance_blocks = is_sslv3 ? 2 : ( ((255 + 1 + md_size + md_block_size - 1) / md_block_size) + 1);
285     /*
286      * From now on we're dealing with the MAC, which conceptually has 13
287      * bytes of `header' before the start of the data (TLS) or 71/75 bytes
288      * (SSLv3)
289      */
290     len = data_plus_mac_plus_padding_size + header_length;
291     /*
292      * max_mac_bytes contains the maximum bytes of bytes in the MAC,
293      * including * |header|, assuming that there's no padding.
294      */
295     max_mac_bytes = len - md_size - 1;
296     /* num_blocks is the maximum number of hash blocks. */
297     num_blocks =
298         (max_mac_bytes + 1 + md_length_size + md_block_size -
299          1) / md_block_size;
300     /*
301      * In order to calculate the MAC in constant time we have to handle the
302      * final blocks specially because the padding value could cause the end
303      * to appear somewhere in the final |variance_blocks| blocks and we can't
304      * leak where. However, |num_starting_blocks| worth of data can be hashed
305      * right away because no padding value can affect whether they are
306      * plaintext.
307      */
308     num_starting_blocks = 0;
309     /*
310      * k is the starting byte offset into the conceptual header||data where
311      * we start processing.
312      */
313     k = 0;
314     /*
315      * mac_end_offset is the index just past the end of the data to be MACed.
316      */
317     mac_end_offset = data_size + header_length;
318     /*
319      * c is the index of the 0x80 byte in the final hash block that contains
320      * application data.
321      */
322     c = mac_end_offset % md_block_size;
323     /*
324      * index_a is the hash block number that contains the 0x80 terminating
325      * value.
326      */
327     index_a = mac_end_offset / md_block_size;
328     /*
329      * index_b is the hash block number that contains the 64-bit hash length,
330      * in bits.
331      */
332     index_b = (mac_end_offset + md_length_size) / md_block_size;
333     /*
334      * bits is the hash-length in bits. It includes the additional hash block
335      * for the masked HMAC key, or whole of |header| in the case of SSLv3.
336      */
337
338     /*
339      * For SSLv3, if we're going to have any starting blocks then we need at
340      * least two because the header is larger than a single block.
341      */
342     if (num_blocks > variance_blocks + (is_sslv3 ? 1 : 0)) {
343         num_starting_blocks = num_blocks - variance_blocks;
344         k = md_block_size * num_starting_blocks;
345     }
346
347     bits = 8 * mac_end_offset;
348     if (!is_sslv3) {
349         /*
350          * Compute the initial HMAC block. For SSLv3, the padding and secret
351          * bytes are included in |header| because they take more than a
352          * single block.
353          */
354         bits += 8 * md_block_size;
355         memset(hmac_pad, 0, md_block_size);
356         if (!ossl_assert(mac_secret_length <= sizeof(hmac_pad)))
357             return 0;
358         memcpy(hmac_pad, mac_secret, mac_secret_length);
359         for (i = 0; i < md_block_size; i++)
360             hmac_pad[i] ^= 0x36;
361
362         md_transform(md_state.c, hmac_pad);
363     }
364
365     if (length_is_big_endian) {
366         memset(length_bytes, 0, md_length_size - 4);
367         length_bytes[md_length_size - 4] = (unsigned char)(bits >> 24);
368         length_bytes[md_length_size - 3] = (unsigned char)(bits >> 16);
369         length_bytes[md_length_size - 2] = (unsigned char)(bits >> 8);
370         length_bytes[md_length_size - 1] = (unsigned char)bits;
371     } else {
372         memset(length_bytes, 0, md_length_size);
373         length_bytes[md_length_size - 5] = (unsigned char)(bits >> 24);
374         length_bytes[md_length_size - 6] = (unsigned char)(bits >> 16);
375         length_bytes[md_length_size - 7] = (unsigned char)(bits >> 8);
376         length_bytes[md_length_size - 8] = (unsigned char)bits;
377     }
378
379     if (k > 0) {
380         if (is_sslv3) {
381             size_t overhang;
382
383             /*
384              * The SSLv3 header is larger than a single block. overhang is
385              * the number of bytes beyond a single block that the header
386              * consumes: either 7 bytes (SHA1) or 11 bytes (MD5). There are no
387              * ciphersuites in SSLv3 that are not SHA1 or MD5 based and
388              * therefore we can be confident that the header_length will be
389              * greater than |md_block_size|. However we add a sanity check just
390              * in case
391              */
392             if (header_length <= md_block_size) {
393                 /* Should never happen */
394                 return 0;
395             }
396             overhang = header_length - md_block_size;
397             md_transform(md_state.c, header);
398             memcpy(first_block, header + md_block_size, overhang);
399             memcpy(first_block + overhang, data, md_block_size - overhang);
400             md_transform(md_state.c, first_block);
401             for (i = 1; i < k / md_block_size - 1; i++)
402                 md_transform(md_state.c, data + md_block_size * i - overhang);
403         } else {
404             /* k is a multiple of md_block_size. */
405             memcpy(first_block, header, 13);
406             memcpy(first_block + 13, data, md_block_size - 13);
407             md_transform(md_state.c, first_block);
408             for (i = 1; i < k / md_block_size; i++)
409                 md_transform(md_state.c, data + md_block_size * i - 13);
410         }
411     }
412
413     memset(mac_out, 0, sizeof(mac_out));
414
415     /*
416      * We now process the final hash blocks. For each block, we construct it
417      * in constant time. If the |i==index_a| then we'll include the 0x80
418      * bytes and zero pad etc. For each block we selectively copy it, in
419      * constant time, to |mac_out|.
420      */
421     for (i = num_starting_blocks; i <= num_starting_blocks + variance_blocks;
422          i++) {
423         unsigned char block[MAX_HASH_BLOCK_SIZE];
424         unsigned char is_block_a = constant_time_eq_8_s(i, index_a);
425         unsigned char is_block_b = constant_time_eq_8_s(i, index_b);
426         for (j = 0; j < md_block_size; j++) {
427             unsigned char b = 0, is_past_c, is_past_cp1;
428             if (k < header_length)
429                 b = header[k];
430             else if (k < data_plus_mac_plus_padding_size + header_length)
431                 b = data[k - header_length];
432             k++;
433
434             is_past_c = is_block_a & constant_time_ge_8_s(j, c);
435             is_past_cp1 = is_block_a & constant_time_ge_8_s(j, c + 1);
436             /*
437              * If this is the block containing the end of the application
438              * data, and we are at the offset for the 0x80 value, then
439              * overwrite b with 0x80.
440              */
441             b = constant_time_select_8(is_past_c, 0x80, b);
442             /*
443              * If this block contains the end of the application data
444              * and we're past the 0x80 value then just write zero.
445              */
446             b = b & ~is_past_cp1;
447             /*
448              * If this is index_b (the final block), but not index_a (the end
449              * of the data), then the 64-bit length didn't fit into index_a
450              * and we're having to add an extra block of zeros.
451              */
452             b &= ~is_block_b | is_block_a;
453
454             /*
455              * The final bytes of one of the blocks contains the length.
456              */
457             if (j >= md_block_size - md_length_size) {
458                 /* If this is index_b, write a length byte. */
459                 b = constant_time_select_8(is_block_b,
460                                            length_bytes[j -
461                                                         (md_block_size -
462                                                          md_length_size)], b);
463             }
464             block[j] = b;
465         }
466
467         md_transform(md_state.c, block);
468         md_final_raw(md_state.c, block);
469         /* If this is index_b, copy the hash value to |mac_out|. */
470         for (j = 0; j < md_size; j++)
471             mac_out[j] |= block[j] & is_block_b;
472     }
473
474     md_ctx = EVP_MD_CTX_new();
475     if (md_ctx == NULL)
476         goto err;
477
478     if (EVP_DigestInit_ex(md_ctx, md, NULL /* engine */ ) <= 0)
479         goto err;
480     if (is_sslv3) {
481         /* We repurpose |hmac_pad| to contain the SSLv3 pad2 block. */
482         memset(hmac_pad, 0x5c, sslv3_pad_length);
483
484         if (EVP_DigestUpdate(md_ctx, mac_secret, mac_secret_length) <= 0
485             || EVP_DigestUpdate(md_ctx, hmac_pad, sslv3_pad_length) <= 0
486             || EVP_DigestUpdate(md_ctx, mac_out, md_size) <= 0)
487             goto err;
488     } else {
489         /* Complete the HMAC in the standard manner. */
490         for (i = 0; i < md_block_size; i++)
491             hmac_pad[i] ^= 0x6a;
492
493         if (EVP_DigestUpdate(md_ctx, hmac_pad, md_block_size) <= 0
494             || EVP_DigestUpdate(md_ctx, mac_out, md_size) <= 0)
495             goto err;
496     }
497     /* TODO(size_t): Convert me */
498     ret = EVP_DigestFinal(md_ctx, md_out, &md_out_size_u);
499     if (ret && md_out_size)
500         *md_out_size = md_out_size_u;
501
502     ret = 1;
503  err:
504     EVP_MD_CTX_free(md_ctx);
505     return ret;
506 }