Move more SSL3_RECORD oriented functions into ssl3_record.c
[openssl.git] / ssl / s3_enc.c
1 /* ssl/s3_enc.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-2007 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  * Copyright 2005 Nokia. All rights reserved.
113  *
114  * The portions of the attached software ("Contribution") is developed by
115  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
116  * license.
117  *
118  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
119  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
120  * support (see RFC 4279) to OpenSSL.
121  *
122  * No patent licenses or other rights except those expressly stated in
123  * the OpenSSL open source license shall be deemed granted or received
124  * expressly, by implication, estoppel, or otherwise.
125  *
126  * No assurances are provided by Nokia that the Contribution does not
127  * infringe the patent or other intellectual property rights of any third
128  * party or that the license provides you with all the necessary rights
129  * to make use of the Contribution.
130  *
131  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
132  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
133  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
134  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
135  * OTHERWISE.
136  */
137
138 #include <stdio.h>
139 #include "ssl_locl.h"
140 #include <openssl/evp.h>
141 #include <openssl/md5.h>
142
143 static const unsigned char ssl3_pad_1[48] = {
144     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
145     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
146     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
147     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
148     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
149     0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36
150 };
151
152 static const unsigned char ssl3_pad_2[48] = {
153     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
154     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
155     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
156     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
157     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
158     0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c
159 };
160
161 static int ssl3_handshake_mac(SSL *s, int md_nid,
162                               const char *sender, int len, unsigned char *p);
163 static int ssl3_generate_key_block(SSL *s, unsigned char *km, int num)
164 {
165     EVP_MD_CTX m5;
166     EVP_MD_CTX s1;
167     unsigned char buf[16], smd[SHA_DIGEST_LENGTH];
168     unsigned char c = 'A';
169     unsigned int i, j, k;
170
171 #ifdef CHARSET_EBCDIC
172     c = os_toascii[c];          /* 'A' in ASCII */
173 #endif
174     k = 0;
175     EVP_MD_CTX_init(&m5);
176     EVP_MD_CTX_set_flags(&m5, EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
177     EVP_MD_CTX_init(&s1);
178     for (i = 0; (int)i < num; i += MD5_DIGEST_LENGTH) {
179         k++;
180         if (k > sizeof buf) {
181             /* bug: 'buf' is too small for this ciphersuite */
182             SSLerr(SSL_F_SSL3_GENERATE_KEY_BLOCK, ERR_R_INTERNAL_ERROR);
183             return 0;
184         }
185
186         for (j = 0; j < k; j++)
187             buf[j] = c;
188         c++;
189         EVP_DigestInit_ex(&s1, EVP_sha1(), NULL);
190         EVP_DigestUpdate(&s1, buf, k);
191         EVP_DigestUpdate(&s1, s->session->master_key,
192                          s->session->master_key_length);
193         EVP_DigestUpdate(&s1, s->s3->server_random, SSL3_RANDOM_SIZE);
194         EVP_DigestUpdate(&s1, s->s3->client_random, SSL3_RANDOM_SIZE);
195         EVP_DigestFinal_ex(&s1, smd, NULL);
196
197         EVP_DigestInit_ex(&m5, EVP_md5(), NULL);
198         EVP_DigestUpdate(&m5, s->session->master_key,
199                          s->session->master_key_length);
200         EVP_DigestUpdate(&m5, smd, SHA_DIGEST_LENGTH);
201         if ((int)(i + MD5_DIGEST_LENGTH) > num) {
202             EVP_DigestFinal_ex(&m5, smd, NULL);
203             memcpy(km, smd, (num - i));
204         } else
205             EVP_DigestFinal_ex(&m5, km, NULL);
206
207         km += MD5_DIGEST_LENGTH;
208     }
209     OPENSSL_cleanse(smd, SHA_DIGEST_LENGTH);
210     EVP_MD_CTX_cleanup(&m5);
211     EVP_MD_CTX_cleanup(&s1);
212     return 1;
213 }
214
215 int ssl3_change_cipher_state(SSL *s, int which)
216 {
217     unsigned char *p, *mac_secret;
218     unsigned char exp_key[EVP_MAX_KEY_LENGTH];
219     unsigned char exp_iv[EVP_MAX_IV_LENGTH];
220     unsigned char *ms, *key, *iv, *er1, *er2;
221     EVP_CIPHER_CTX *dd;
222     const EVP_CIPHER *c;
223 #ifndef OPENSSL_NO_COMP
224     COMP_METHOD *comp;
225 #endif
226     const EVP_MD *m;
227     EVP_MD_CTX md;
228     int is_exp, n, i, j, k, cl;
229     int reuse_dd = 0;
230
231     is_exp = SSL_C_IS_EXPORT(s->s3->tmp.new_cipher);
232     c = s->s3->tmp.new_sym_enc;
233     m = s->s3->tmp.new_hash;
234     /* m == NULL will lead to a crash later */
235     OPENSSL_assert(m);
236 #ifndef OPENSSL_NO_COMP
237     if (s->s3->tmp.new_compression == NULL)
238         comp = NULL;
239     else
240         comp = s->s3->tmp.new_compression->method;
241 #endif
242
243     if (which & SSL3_CC_READ) {
244         if (s->enc_read_ctx != NULL)
245             reuse_dd = 1;
246         else if ((s->enc_read_ctx =
247                   OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL)
248             goto err;
249         else
250             /*
251              * make sure it's intialized in case we exit later with an error
252              */
253             EVP_CIPHER_CTX_init(s->enc_read_ctx);
254         dd = s->enc_read_ctx;
255
256         if(!ssl_replace_hash(&s->read_hash, m)) {
257                 SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE, ERR_R_INTERNAL_ERROR);
258                 goto err2;
259         }
260 #ifndef OPENSSL_NO_COMP
261         /* COMPRESS */
262         if (s->expand != NULL) {
263             COMP_CTX_free(s->expand);
264             s->expand = NULL;
265         }
266         if (comp != NULL) {
267             s->expand = COMP_CTX_new(comp);
268             if (s->expand == NULL) {
269                 SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,
270                        SSL_R_COMPRESSION_LIBRARY_ERROR);
271                 goto err2;
272             }
273             if(!SSL3_RECORD_setup(RECORD_LAYER_get_rrec(&s->rlayer),
274                 SSL3_RT_MAX_PLAIN_LENGTH))
275                 goto err;
276         }
277 #endif
278         memset(&(s->s3->read_sequence[0]), 0, 8);
279         mac_secret = &(s->s3->read_mac_secret[0]);
280     } else {
281         if (s->enc_write_ctx != NULL)
282             reuse_dd = 1;
283         else if ((s->enc_write_ctx =
284                   OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL)
285             goto err;
286         else
287             /*
288              * make sure it's intialized in case we exit later with an error
289              */
290             EVP_CIPHER_CTX_init(s->enc_write_ctx);
291         dd = s->enc_write_ctx;
292         if(!ssl_replace_hash(&s->write_hash, m)) {
293                 SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE, ERR_R_INTERNAL_ERROR);
294                 goto err2;
295         }
296 #ifndef OPENSSL_NO_COMP
297         /* COMPRESS */
298         if (s->compress != NULL) {
299             COMP_CTX_free(s->compress);
300             s->compress = NULL;
301         }
302         if (comp != NULL) {
303             s->compress = COMP_CTX_new(comp);
304             if (s->compress == NULL) {
305                 SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,
306                        SSL_R_COMPRESSION_LIBRARY_ERROR);
307                 goto err2;
308             }
309         }
310 #endif
311         memset(&(s->s3->write_sequence[0]), 0, 8);
312         mac_secret = &(s->s3->write_mac_secret[0]);
313     }
314
315     if (reuse_dd)
316         EVP_CIPHER_CTX_cleanup(dd);
317
318     p = s->s3->tmp.key_block;
319     i = EVP_MD_size(m);
320     if (i < 0)
321         goto err2;
322     cl = EVP_CIPHER_key_length(c);
323     j = is_exp ? (cl < SSL_C_EXPORT_KEYLENGTH(s->s3->tmp.new_cipher) ?
324                   cl : SSL_C_EXPORT_KEYLENGTH(s->s3->tmp.new_cipher)) : cl;
325     /* Was j=(is_exp)?5:EVP_CIPHER_key_length(c); */
326     k = EVP_CIPHER_iv_length(c);
327     if ((which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) ||
328         (which == SSL3_CHANGE_CIPHER_SERVER_READ)) {
329         ms = &(p[0]);
330         n = i + i;
331         key = &(p[n]);
332         n += j + j;
333         iv = &(p[n]);
334         n += k + k;
335         er1 = &(s->s3->client_random[0]);
336         er2 = &(s->s3->server_random[0]);
337     } else {
338         n = i;
339         ms = &(p[n]);
340         n += i + j;
341         key = &(p[n]);
342         n += j + k;
343         iv = &(p[n]);
344         n += k;
345         er1 = &(s->s3->server_random[0]);
346         er2 = &(s->s3->client_random[0]);
347     }
348
349     if (n > s->s3->tmp.key_block_length) {
350         SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE, ERR_R_INTERNAL_ERROR);
351         goto err2;
352     }
353
354     EVP_MD_CTX_init(&md);
355     memcpy(mac_secret, ms, i);
356     if (is_exp) {
357         /*
358          * In here I set both the read and write key/iv to the same value
359          * since only the correct one will be used :-).
360          */
361         EVP_DigestInit_ex(&md, EVP_md5(), NULL);
362         EVP_DigestUpdate(&md, key, j);
363         EVP_DigestUpdate(&md, er1, SSL3_RANDOM_SIZE);
364         EVP_DigestUpdate(&md, er2, SSL3_RANDOM_SIZE);
365         EVP_DigestFinal_ex(&md, &(exp_key[0]), NULL);
366         key = &(exp_key[0]);
367
368         if (k > 0) {
369             EVP_DigestInit_ex(&md, EVP_md5(), NULL);
370             EVP_DigestUpdate(&md, er1, SSL3_RANDOM_SIZE);
371             EVP_DigestUpdate(&md, er2, SSL3_RANDOM_SIZE);
372             EVP_DigestFinal_ex(&md, &(exp_iv[0]), NULL);
373             iv = &(exp_iv[0]);
374         }
375     }
376
377     EVP_CipherInit_ex(dd, c, NULL, key, iv, (which & SSL3_CC_WRITE));
378
379 #ifdef OPENSSL_SSL_TRACE_CRYPTO
380     if (s->msg_callback) {
381
382         int wh = which & SSL3_CC_WRITE ?
383             TLS1_RT_CRYPTO_WRITE : TLS1_RT_CRYPTO_READ;
384         s->msg_callback(2, s->version, wh | TLS1_RT_CRYPTO_MAC,
385                         mac_secret, EVP_MD_size(m), s, s->msg_callback_arg);
386         if (c->key_len)
387             s->msg_callback(2, s->version, wh | TLS1_RT_CRYPTO_KEY,
388                             key, c->key_len, s, s->msg_callback_arg);
389         if (k) {
390             s->msg_callback(2, s->version, wh | TLS1_RT_CRYPTO_IV,
391                             iv, k, s, s->msg_callback_arg);
392         }
393     }
394 #endif
395
396     OPENSSL_cleanse(&(exp_key[0]), sizeof(exp_key));
397     OPENSSL_cleanse(&(exp_iv[0]), sizeof(exp_iv));
398     EVP_MD_CTX_cleanup(&md);
399     return (1);
400  err:
401     SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE, ERR_R_MALLOC_FAILURE);
402  err2:
403     return (0);
404 }
405
406 int ssl3_setup_key_block(SSL *s)
407 {
408     unsigned char *p;
409     const EVP_CIPHER *c;
410     const EVP_MD *hash;
411     int num;
412     int ret = 0;
413     SSL_COMP *comp;
414
415     if (s->s3->tmp.key_block_length != 0)
416         return (1);
417
418     if (!ssl_cipher_get_evp(s->session, &c, &hash, NULL, NULL, &comp, 0)) {
419         SSLerr(SSL_F_SSL3_SETUP_KEY_BLOCK, SSL_R_CIPHER_OR_HASH_UNAVAILABLE);
420         return (0);
421     }
422
423     s->s3->tmp.new_sym_enc = c;
424     s->s3->tmp.new_hash = hash;
425 #ifdef OPENSSL_NO_COMP
426     s->s3->tmp.new_compression = NULL;
427 #else
428     s->s3->tmp.new_compression = comp;
429 #endif
430
431     num = EVP_MD_size(hash);
432     if (num < 0)
433         return 0;
434
435     num = EVP_CIPHER_key_length(c) + num + EVP_CIPHER_iv_length(c);
436     num *= 2;
437
438     ssl3_cleanup_key_block(s);
439
440     if ((p = OPENSSL_malloc(num)) == NULL)
441         goto err;
442
443     s->s3->tmp.key_block_length = num;
444     s->s3->tmp.key_block = p;
445
446     ret = ssl3_generate_key_block(s, p, num);
447
448     if (!(s->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS)) {
449         /*
450          * enable vulnerability countermeasure for CBC ciphers with known-IV
451          * problem (http://www.openssl.org/~bodo/tls-cbc.txt)
452          */
453         s->s3->need_empty_fragments = 1;
454
455         if (s->session->cipher != NULL) {
456             if (s->session->cipher->algorithm_enc == SSL_eNULL)
457                 s->s3->need_empty_fragments = 0;
458
459 #ifndef OPENSSL_NO_RC4
460             if (s->session->cipher->algorithm_enc == SSL_RC4)
461                 s->s3->need_empty_fragments = 0;
462 #endif
463         }
464     }
465
466     return ret;
467
468  err:
469     SSLerr(SSL_F_SSL3_SETUP_KEY_BLOCK, ERR_R_MALLOC_FAILURE);
470     return (0);
471 }
472
473 void ssl3_cleanup_key_block(SSL *s)
474 {
475     if (s->s3->tmp.key_block != NULL) {
476         OPENSSL_cleanse(s->s3->tmp.key_block, s->s3->tmp.key_block_length);
477         OPENSSL_free(s->s3->tmp.key_block);
478         s->s3->tmp.key_block = NULL;
479     }
480     s->s3->tmp.key_block_length = 0;
481 }
482
483 void ssl3_init_finished_mac(SSL *s)
484 {
485     BIO_free(s->s3->handshake_buffer);
486     if (s->s3->handshake_dgst)
487         ssl3_free_digest_list(s);
488     s->s3->handshake_buffer = BIO_new(BIO_s_mem());
489     (void)BIO_set_close(s->s3->handshake_buffer, BIO_CLOSE);
490 }
491
492 void ssl3_free_digest_list(SSL *s)
493 {
494     int i;
495     if (!s->s3->handshake_dgst)
496         return;
497     for (i = 0; i < SSL_MAX_DIGEST; i++) {
498         if (s->s3->handshake_dgst[i])
499             EVP_MD_CTX_destroy(s->s3->handshake_dgst[i]);
500     }
501     OPENSSL_free(s->s3->handshake_dgst);
502     s->s3->handshake_dgst = NULL;
503 }
504
505 void ssl3_finish_mac(SSL *s, const unsigned char *buf, int len)
506 {
507     if (s->s3->handshake_buffer
508         && !(s->s3->flags & TLS1_FLAGS_KEEP_HANDSHAKE)) {
509         BIO_write(s->s3->handshake_buffer, (void *)buf, len);
510     } else {
511         int i;
512         for (i = 0; i < SSL_MAX_DIGEST; i++) {
513             if (s->s3->handshake_dgst[i] != NULL)
514                 EVP_DigestUpdate(s->s3->handshake_dgst[i], buf, len);
515         }
516     }
517 }
518
519 int ssl3_digest_cached_records(SSL *s)
520 {
521     int i;
522     long mask;
523     const EVP_MD *md;
524     long hdatalen;
525     void *hdata;
526
527     /* Allocate handshake_dgst array */
528     ssl3_free_digest_list(s);
529     s->s3->handshake_dgst =
530         OPENSSL_malloc(SSL_MAX_DIGEST * sizeof(EVP_MD_CTX *));
531     if (s->s3->handshake_dgst == NULL) {
532         SSLerr(SSL_F_SSL3_DIGEST_CACHED_RECORDS, ERR_R_MALLOC_FAILURE);
533         return 0;
534     }
535     memset(s->s3->handshake_dgst, 0, SSL_MAX_DIGEST * sizeof(EVP_MD_CTX *));
536     hdatalen = BIO_get_mem_data(s->s3->handshake_buffer, &hdata);
537     if (hdatalen <= 0) {
538         SSLerr(SSL_F_SSL3_DIGEST_CACHED_RECORDS, SSL_R_BAD_HANDSHAKE_LENGTH);
539         return 0;
540     }
541
542     /* Loop through bitso of algorithm2 field and create MD_CTX-es */
543     for (i = 0; ssl_get_handshake_digest(i, &mask, &md); i++) {
544         if ((mask & ssl_get_algorithm2(s)) && md) {
545             s->s3->handshake_dgst[i] = EVP_MD_CTX_create();
546             if (EVP_MD_nid(md) == NID_md5) {
547                 EVP_MD_CTX_set_flags(s->s3->handshake_dgst[i],
548                                      EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
549             }
550             EVP_DigestInit_ex(s->s3->handshake_dgst[i], md, NULL);
551             EVP_DigestUpdate(s->s3->handshake_dgst[i], hdata, hdatalen);
552         } else {
553             s->s3->handshake_dgst[i] = NULL;
554         }
555     }
556     if (!(s->s3->flags & TLS1_FLAGS_KEEP_HANDSHAKE)) {
557         /* Free handshake_buffer BIO */
558         BIO_free(s->s3->handshake_buffer);
559         s->s3->handshake_buffer = NULL;
560     }
561
562     return 1;
563 }
564
565 int ssl3_cert_verify_mac(SSL *s, int md_nid, unsigned char *p)
566 {
567     return (ssl3_handshake_mac(s, md_nid, NULL, 0, p));
568 }
569
570 int ssl3_final_finish_mac(SSL *s,
571                           const char *sender, int len, unsigned char *p)
572 {
573     int ret, sha1len;
574     ret = ssl3_handshake_mac(s, NID_md5, sender, len, p);
575     if (ret == 0)
576         return 0;
577
578     p += ret;
579
580     sha1len = ssl3_handshake_mac(s, NID_sha1, sender, len, p);
581     if (sha1len == 0)
582         return 0;
583
584     ret += sha1len;
585     return (ret);
586 }
587
588 static int ssl3_handshake_mac(SSL *s, int md_nid,
589                               const char *sender, int len, unsigned char *p)
590 {
591     unsigned int ret;
592     int npad, n;
593     unsigned int i;
594     unsigned char md_buf[EVP_MAX_MD_SIZE];
595     EVP_MD_CTX ctx, *d = NULL;
596
597     if (s->s3->handshake_buffer)
598         if (!ssl3_digest_cached_records(s))
599             return 0;
600
601     /*
602      * Search for digest of specified type in the handshake_dgst array
603      */
604     for (i = 0; i < SSL_MAX_DIGEST; i++) {
605         if (s->s3->handshake_dgst[i]
606             && EVP_MD_CTX_type(s->s3->handshake_dgst[i]) == md_nid) {
607             d = s->s3->handshake_dgst[i];
608             break;
609         }
610     }
611     if (!d) {
612         SSLerr(SSL_F_SSL3_HANDSHAKE_MAC, SSL_R_NO_REQUIRED_DIGEST);
613         return 0;
614     }
615     EVP_MD_CTX_init(&ctx);
616     EVP_MD_CTX_set_flags(&ctx, EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
617     EVP_MD_CTX_copy_ex(&ctx, d);
618     n = EVP_MD_CTX_size(&ctx);
619     if (n < 0)
620         return 0;
621
622     npad = (48 / n) * n;
623     if (sender != NULL)
624         EVP_DigestUpdate(&ctx, sender, len);
625     EVP_DigestUpdate(&ctx, s->session->master_key,
626                      s->session->master_key_length);
627     EVP_DigestUpdate(&ctx, ssl3_pad_1, npad);
628     EVP_DigestFinal_ex(&ctx, md_buf, &i);
629
630     EVP_DigestInit_ex(&ctx, EVP_MD_CTX_md(&ctx), NULL);
631     EVP_DigestUpdate(&ctx, s->session->master_key,
632                      s->session->master_key_length);
633     EVP_DigestUpdate(&ctx, ssl3_pad_2, npad);
634     EVP_DigestUpdate(&ctx, md_buf, i);
635     EVP_DigestFinal_ex(&ctx, p, &ret);
636
637     EVP_MD_CTX_cleanup(&ctx);
638
639     return ((int)ret);
640 }
641
642 void ssl3_record_sequence_update(unsigned char *seq)
643 {
644     int i;
645
646     for (i = 7; i >= 0; i--) {
647         ++seq[i];
648         if (seq[i] != 0)
649             break;
650     }
651 }
652
653 int ssl3_generate_master_secret(SSL *s, unsigned char *out, unsigned char *p,
654                                 int len)
655 {
656     static const unsigned char *salt[3] = {
657 #ifndef CHARSET_EBCDIC
658         (const unsigned char *)"A",
659         (const unsigned char *)"BB",
660         (const unsigned char *)"CCC",
661 #else
662         (const unsigned char *)"\x41",
663         (const unsigned char *)"\x42\x42",
664         (const unsigned char *)"\x43\x43\x43",
665 #endif
666     };
667     unsigned char buf[EVP_MAX_MD_SIZE];
668     EVP_MD_CTX ctx;
669     int i, ret = 0;
670     unsigned int n;
671 #ifdef OPENSSL_SSL_TRACE_CRYPTO
672     unsigned char *tmpout = out;
673 #endif
674
675     EVP_MD_CTX_init(&ctx);
676     for (i = 0; i < 3; i++) {
677         EVP_DigestInit_ex(&ctx, s->ctx->sha1, NULL);
678         EVP_DigestUpdate(&ctx, salt[i], strlen((const char *)salt[i]));
679         EVP_DigestUpdate(&ctx, p, len);
680         EVP_DigestUpdate(&ctx, &(s->s3->client_random[0]), SSL3_RANDOM_SIZE);
681         EVP_DigestUpdate(&ctx, &(s->s3->server_random[0]), SSL3_RANDOM_SIZE);
682         EVP_DigestFinal_ex(&ctx, buf, &n);
683
684         EVP_DigestInit_ex(&ctx, s->ctx->md5, NULL);
685         EVP_DigestUpdate(&ctx, p, len);
686         EVP_DigestUpdate(&ctx, buf, n);
687         EVP_DigestFinal_ex(&ctx, out, &n);
688         out += n;
689         ret += n;
690     }
691     EVP_MD_CTX_cleanup(&ctx);
692
693 #ifdef OPENSSL_SSL_TRACE_CRYPTO
694     if (s->msg_callback) {
695         s->msg_callback(2, s->version, TLS1_RT_CRYPTO_PREMASTER,
696                         p, len, s, s->msg_callback_arg);
697         s->msg_callback(2, s->version, TLS1_RT_CRYPTO_CLIENT_RANDOM,
698                         s->s3->client_random, SSL3_RANDOM_SIZE,
699                         s, s->msg_callback_arg);
700         s->msg_callback(2, s->version, TLS1_RT_CRYPTO_SERVER_RANDOM,
701                         s->s3->server_random, SSL3_RANDOM_SIZE,
702                         s, s->msg_callback_arg);
703         s->msg_callback(2, s->version, TLS1_RT_CRYPTO_MASTER,
704                         tmpout, SSL3_MASTER_SECRET_SIZE,
705                         s, s->msg_callback_arg);
706     }
707 #endif
708     OPENSSL_cleanse(buf, sizeof buf);
709     return (ret);
710 }
711
712 int ssl3_alert_code(int code)
713 {
714     switch (code) {
715     case SSL_AD_CLOSE_NOTIFY:
716         return (SSL3_AD_CLOSE_NOTIFY);
717     case SSL_AD_UNEXPECTED_MESSAGE:
718         return (SSL3_AD_UNEXPECTED_MESSAGE);
719     case SSL_AD_BAD_RECORD_MAC:
720         return (SSL3_AD_BAD_RECORD_MAC);
721     case SSL_AD_DECRYPTION_FAILED:
722         return (SSL3_AD_BAD_RECORD_MAC);
723     case SSL_AD_RECORD_OVERFLOW:
724         return (SSL3_AD_BAD_RECORD_MAC);
725     case SSL_AD_DECOMPRESSION_FAILURE:
726         return (SSL3_AD_DECOMPRESSION_FAILURE);
727     case SSL_AD_HANDSHAKE_FAILURE:
728         return (SSL3_AD_HANDSHAKE_FAILURE);
729     case SSL_AD_NO_CERTIFICATE:
730         return (SSL3_AD_NO_CERTIFICATE);
731     case SSL_AD_BAD_CERTIFICATE:
732         return (SSL3_AD_BAD_CERTIFICATE);
733     case SSL_AD_UNSUPPORTED_CERTIFICATE:
734         return (SSL3_AD_UNSUPPORTED_CERTIFICATE);
735     case SSL_AD_CERTIFICATE_REVOKED:
736         return (SSL3_AD_CERTIFICATE_REVOKED);
737     case SSL_AD_CERTIFICATE_EXPIRED:
738         return (SSL3_AD_CERTIFICATE_EXPIRED);
739     case SSL_AD_CERTIFICATE_UNKNOWN:
740         return (SSL3_AD_CERTIFICATE_UNKNOWN);
741     case SSL_AD_ILLEGAL_PARAMETER:
742         return (SSL3_AD_ILLEGAL_PARAMETER);
743     case SSL_AD_UNKNOWN_CA:
744         return (SSL3_AD_BAD_CERTIFICATE);
745     case SSL_AD_ACCESS_DENIED:
746         return (SSL3_AD_HANDSHAKE_FAILURE);
747     case SSL_AD_DECODE_ERROR:
748         return (SSL3_AD_HANDSHAKE_FAILURE);
749     case SSL_AD_DECRYPT_ERROR:
750         return (SSL3_AD_HANDSHAKE_FAILURE);
751     case SSL_AD_EXPORT_RESTRICTION:
752         return (SSL3_AD_HANDSHAKE_FAILURE);
753     case SSL_AD_PROTOCOL_VERSION:
754         return (SSL3_AD_HANDSHAKE_FAILURE);
755     case SSL_AD_INSUFFICIENT_SECURITY:
756         return (SSL3_AD_HANDSHAKE_FAILURE);
757     case SSL_AD_INTERNAL_ERROR:
758         return (SSL3_AD_HANDSHAKE_FAILURE);
759     case SSL_AD_USER_CANCELLED:
760         return (SSL3_AD_HANDSHAKE_FAILURE);
761     case SSL_AD_NO_RENEGOTIATION:
762         return (-1);            /* Don't send it :-) */
763     case SSL_AD_UNSUPPORTED_EXTENSION:
764         return (SSL3_AD_HANDSHAKE_FAILURE);
765     case SSL_AD_CERTIFICATE_UNOBTAINABLE:
766         return (SSL3_AD_HANDSHAKE_FAILURE);
767     case SSL_AD_UNRECOGNIZED_NAME:
768         return (SSL3_AD_HANDSHAKE_FAILURE);
769     case SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE:
770         return (SSL3_AD_HANDSHAKE_FAILURE);
771     case SSL_AD_BAD_CERTIFICATE_HASH_VALUE:
772         return (SSL3_AD_HANDSHAKE_FAILURE);
773     case SSL_AD_UNKNOWN_PSK_IDENTITY:
774         return (TLS1_AD_UNKNOWN_PSK_IDENTITY);
775     case SSL_AD_INAPPROPRIATE_FALLBACK:
776         return (TLS1_AD_INAPPROPRIATE_FALLBACK);
777     default:
778         return (-1);
779     }
780 }