Branch data Line data Source code
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 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 : : static unsigned char ssl3_pad_2[48]={
152 : : 0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,
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 : : static int ssl3_handshake_mac(SSL *s, int md_nid,
159 : : const char *sender, int len, unsigned char *p);
160 : 506 : static int ssl3_generate_key_block(SSL *s, unsigned char *km, int num)
161 : : {
162 : : EVP_MD_CTX m5;
163 : : EVP_MD_CTX s1;
164 : : unsigned char buf[16],smd[SHA_DIGEST_LENGTH];
165 : 506 : unsigned char c='A';
166 : : unsigned int i,j,k;
167 : :
168 : : #ifdef CHARSET_EBCDIC
169 : : c = os_toascii[c]; /*'A' in ASCII */
170 : : #endif
171 : 506 : k=0;
172 : 506 : EVP_MD_CTX_init(&m5);
173 : 506 : EVP_MD_CTX_set_flags(&m5, EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
174 : 506 : EVP_MD_CTX_init(&s1);
175 [ + + ]: 3960 : for (i=0; (int)i<num; i+=MD5_DIGEST_LENGTH)
176 : : {
177 : 3454 : k++;
178 [ + - ]: 3454 : if (k > sizeof buf)
179 : : {
180 : : /* bug: 'buf' is too small for this ciphersuite */
181 : 0 : SSLerr(SSL_F_SSL3_GENERATE_KEY_BLOCK, ERR_R_INTERNAL_ERROR);
182 : : return 0;
183 : : }
184 : :
185 [ + + ]: 18238 : for (j=0; j<k; j++)
186 : 14784 : buf[j]=c;
187 : 3454 : c++;
188 : 3454 : EVP_DigestInit_ex(&s1,EVP_sha1(), NULL);
189 : 3454 : EVP_DigestUpdate(&s1,buf,k);
190 : 3454 : EVP_DigestUpdate(&s1,s->session->master_key,
191 : 3454 : s->session->master_key_length);
192 : 3454 : EVP_DigestUpdate(&s1,s->s3->server_random,SSL3_RANDOM_SIZE);
193 : 3454 : EVP_DigestUpdate(&s1,s->s3->client_random,SSL3_RANDOM_SIZE);
194 : 3454 : EVP_DigestFinal_ex(&s1,smd,NULL);
195 : :
196 : 3454 : EVP_DigestInit_ex(&m5,EVP_md5(), NULL);
197 : 3454 : EVP_DigestUpdate(&m5,s->session->master_key,
198 : 3454 : s->session->master_key_length);
199 : 3454 : EVP_DigestUpdate(&m5,smd,SHA_DIGEST_LENGTH);
200 [ + + ]: 3454 : if ((int)(i+MD5_DIGEST_LENGTH) > num)
201 : : {
202 : 418 : EVP_DigestFinal_ex(&m5,smd,NULL);
203 : 418 : memcpy(km,smd,(num-i));
204 : : }
205 : : else
206 : 3036 : EVP_DigestFinal_ex(&m5,km,NULL);
207 : :
208 : 3454 : km+=MD5_DIGEST_LENGTH;
209 : : }
210 : 506 : OPENSSL_cleanse(smd,SHA_DIGEST_LENGTH);
211 : 506 : EVP_MD_CTX_cleanup(&m5);
212 : 506 : EVP_MD_CTX_cleanup(&s1);
213 : : return 1;
214 : : }
215 : :
216 : 1012 : int ssl3_change_cipher_state(SSL *s, int which)
217 : : {
218 : : unsigned char *p,*mac_secret;
219 : : unsigned char exp_key[EVP_MAX_KEY_LENGTH];
220 : : unsigned char exp_iv[EVP_MAX_IV_LENGTH];
221 : : unsigned char *ms,*key,*iv,*er1,*er2;
222 : : EVP_CIPHER_CTX *dd;
223 : : const EVP_CIPHER *c;
224 : : #ifndef OPENSSL_NO_COMP
225 : : COMP_METHOD *comp;
226 : : #endif
227 : : const EVP_MD *m;
228 : : EVP_MD_CTX md;
229 : : int is_exp,n,i,j,k,cl;
230 : 1012 : int reuse_dd = 0;
231 : :
232 : 1012 : is_exp=SSL_C_IS_EXPORT(s->s3->tmp.new_cipher);
233 : 1012 : c=s->s3->tmp.new_sym_enc;
234 : 1012 : m=s->s3->tmp.new_hash;
235 : : /* m == NULL will lead to a crash later */
236 [ - + ]: 1012 : OPENSSL_assert(m);
237 : : #ifndef OPENSSL_NO_COMP
238 [ - + ]: 1012 : if (s->s3->tmp.new_compression == NULL)
239 : : comp=NULL;
240 : : else
241 : 0 : comp=s->s3->tmp.new_compression->method;
242 : : #endif
243 : :
244 [ + + ]: 1012 : if (which & SSL3_CC_READ)
245 : : {
246 [ + - ]: 506 : if (s->enc_read_ctx != NULL)
247 : : reuse_dd = 1;
248 [ + - ]: 506 : else if ((s->enc_read_ctx=OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL)
249 : : goto err;
250 : : else
251 : : /* make sure it's intialized in case we exit later with an error */
252 : 506 : EVP_CIPHER_CTX_init(s->enc_read_ctx);
253 : 506 : dd= s->enc_read_ctx;
254 : :
255 : 506 : ssl_replace_hash(&s->read_hash,m);
256 : : #ifndef OPENSSL_NO_COMP
257 : : /* COMPRESS */
258 [ - + ]: 506 : if (s->expand != NULL)
259 : : {
260 : 0 : COMP_CTX_free(s->expand);
261 : 0 : s->expand=NULL;
262 : : }
263 [ - + ]: 506 : if (comp != NULL)
264 : : {
265 : 0 : s->expand=COMP_CTX_new(comp);
266 [ # # ]: 0 : if (s->expand == NULL)
267 : : {
268 : 0 : SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,SSL_R_COMPRESSION_LIBRARY_ERROR);
269 : 0 : goto err2;
270 : : }
271 [ # # ]: 0 : if (s->s3->rrec.comp == NULL)
272 : 0 : s->s3->rrec.comp=(unsigned char *)
273 : 0 : OPENSSL_malloc(SSL3_RT_MAX_PLAIN_LENGTH);
274 [ # # ]: 0 : if (s->s3->rrec.comp == NULL)
275 : : goto err;
276 : : }
277 : : #endif
278 : 506 : memset(&(s->s3->read_sequence[0]),0,8);
279 : 506 : mac_secret= &(s->s3->read_mac_secret[0]);
280 : : }
281 : : else
282 : : {
283 [ + - ]: 506 : if (s->enc_write_ctx != NULL)
284 : : reuse_dd = 1;
285 [ + - ]: 506 : else if ((s->enc_write_ctx=OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL)
286 : : goto err;
287 : : else
288 : : /* make sure it's intialized in case we exit later with an error */
289 : 506 : EVP_CIPHER_CTX_init(s->enc_write_ctx);
290 : 506 : dd= s->enc_write_ctx;
291 : 506 : ssl_replace_hash(&s->write_hash,m);
292 : : #ifndef OPENSSL_NO_COMP
293 : : /* COMPRESS */
294 [ - + ]: 506 : if (s->compress != NULL)
295 : : {
296 : 0 : COMP_CTX_free(s->compress);
297 : 0 : s->compress=NULL;
298 : : }
299 [ - + ]: 506 : if (comp != NULL)
300 : : {
301 : 0 : s->compress=COMP_CTX_new(comp);
302 [ # # ]: 0 : if (s->compress == NULL)
303 : : {
304 : 0 : SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,SSL_R_COMPRESSION_LIBRARY_ERROR);
305 : 0 : goto err2;
306 : : }
307 : : }
308 : : #endif
309 : 506 : memset(&(s->s3->write_sequence[0]),0,8);
310 : 506 : mac_secret= &(s->s3->write_mac_secret[0]);
311 : : }
312 : :
313 [ - + ]: 1012 : if (reuse_dd)
314 : 0 : EVP_CIPHER_CTX_cleanup(dd);
315 : :
316 : 1012 : p=s->s3->tmp.key_block;
317 : 1012 : i=EVP_MD_size(m);
318 [ + - ]: 1012 : if (i < 0)
319 : : goto err2;
320 : 1012 : cl=EVP_CIPHER_key_length(c);
321 : 1012 : j=is_exp ? (cl < SSL_C_EXPORT_KEYLENGTH(s->s3->tmp.new_cipher) ?
322 [ + + ][ - + ]: 1012 : cl : SSL_C_EXPORT_KEYLENGTH(s->s3->tmp.new_cipher)) : cl;
[ # # ]
323 : : /* Was j=(is_exp)?5:EVP_CIPHER_key_length(c); */
324 : 1012 : k=EVP_CIPHER_iv_length(c);
325 [ + + ]: 1012 : if ( (which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) ||
326 : 1012 : (which == SSL3_CHANGE_CIPHER_SERVER_READ))
327 : : {
328 : 506 : ms= &(p[ 0]); n=i+i;
329 : 506 : key= &(p[ n]); n+=j+j;
330 : 506 : iv= &(p[ n]); n+=k+k;
331 : 506 : er1= &(s->s3->client_random[0]);
332 : 506 : er2= &(s->s3->server_random[0]);
333 : : }
334 : : else
335 : : {
336 : 506 : n=i;
337 : 506 : ms= &(p[ n]); n+=i+j;
338 : 506 : key= &(p[ n]); n+=j+k;
339 : 506 : iv= &(p[ n]); n+=k;
340 : 506 : er1= &(s->s3->server_random[0]);
341 : 506 : er2= &(s->s3->client_random[0]);
342 : : }
343 : :
344 [ - + ]: 1012 : if (n > s->s3->tmp.key_block_length)
345 : : {
346 : 0 : SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,ERR_R_INTERNAL_ERROR);
347 : 0 : goto err2;
348 : : }
349 : :
350 : 1012 : EVP_MD_CTX_init(&md);
351 : 1012 : memcpy(mac_secret,ms,i);
352 [ + + ]: 1012 : if (is_exp)
353 : : {
354 : : /* In here I set both the read and write key/iv to the
355 : : * same value since only the correct one will be used :-).
356 : : */
357 : 132 : EVP_DigestInit_ex(&md,EVP_md5(), NULL);
358 : 132 : EVP_DigestUpdate(&md,key,j);
359 : 132 : EVP_DigestUpdate(&md,er1,SSL3_RANDOM_SIZE);
360 : 132 : EVP_DigestUpdate(&md,er2,SSL3_RANDOM_SIZE);
361 : 132 : EVP_DigestFinal_ex(&md,&(exp_key[0]),NULL);
362 : 132 : key= &(exp_key[0]);
363 : :
364 [ + + ]: 132 : if (k > 0)
365 : : {
366 : 88 : EVP_DigestInit_ex(&md,EVP_md5(), NULL);
367 : 88 : EVP_DigestUpdate(&md,er1,SSL3_RANDOM_SIZE);
368 : 88 : EVP_DigestUpdate(&md,er2,SSL3_RANDOM_SIZE);
369 : 88 : EVP_DigestFinal_ex(&md,&(exp_iv[0]),NULL);
370 : 88 : iv= &(exp_iv[0]);
371 : : }
372 : : }
373 : :
374 : 1012 : s->session->key_arg_length=0;
375 : :
376 : 1012 : EVP_CipherInit_ex(dd,c,NULL,key,iv,(which & SSL3_CC_WRITE));
377 : :
378 : : #ifdef OPENSSL_SSL_TRACE_CRYPTO
379 : : if (s->msg_callback)
380 : : {
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),
386 : : s, s->msg_callback_arg);
387 : : if (c->key_len)
388 : : s->msg_callback(2, s->version, wh | TLS1_RT_CRYPTO_KEY,
389 : : key, c->key_len,
390 : : s, s->msg_callback_arg);
391 : : if (k)
392 : : {
393 : : s->msg_callback(2, s->version, wh | TLS1_RT_CRYPTO_IV,
394 : : iv, k, s, s->msg_callback_arg);
395 : : }
396 : : }
397 : : #endif
398 : :
399 : 1012 : OPENSSL_cleanse(&(exp_key[0]),sizeof(exp_key));
400 : 1012 : OPENSSL_cleanse(&(exp_iv[0]),sizeof(exp_iv));
401 : 1012 : EVP_MD_CTX_cleanup(&md);
402 : 1012 : return(1);
403 : : err:
404 : 0 : SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,ERR_R_MALLOC_FAILURE);
405 : : err2:
406 : : return(0);
407 : : }
408 : :
409 : 759 : int ssl3_setup_key_block(SSL *s)
410 : : {
411 : : unsigned char *p;
412 : : const EVP_CIPHER *c;
413 : : const EVP_MD *hash;
414 : : int num;
415 : 759 : int ret = 0;
416 : : SSL_COMP *comp;
417 : :
418 [ + + ]: 759 : if (s->s3->tmp.key_block_length != 0)
419 : : return(1);
420 : :
421 [ - + ]: 506 : if (!ssl_cipher_get_evp(s->session,&c,&hash,NULL,NULL,&comp, 0))
422 : : {
423 : 0 : SSLerr(SSL_F_SSL3_SETUP_KEY_BLOCK,SSL_R_CIPHER_OR_HASH_UNAVAILABLE);
424 : 0 : return(0);
425 : : }
426 : :
427 : 506 : s->s3->tmp.new_sym_enc=c;
428 : 506 : s->s3->tmp.new_hash=hash;
429 : : #ifdef OPENSSL_NO_COMP
430 : : s->s3->tmp.new_compression=NULL;
431 : : #else
432 : 506 : s->s3->tmp.new_compression=comp;
433 : : #endif
434 : :
435 : 506 : num=EVP_MD_size(hash);
436 [ + - ]: 506 : if (num < 0)
437 : : return 0;
438 : :
439 : 506 : num=EVP_CIPHER_key_length(c)+num+EVP_CIPHER_iv_length(c);
440 : 506 : num*=2;
441 : :
442 : 506 : ssl3_cleanup_key_block(s);
443 : :
444 [ + - ]: 506 : if ((p=OPENSSL_malloc(num)) == NULL)
445 : : goto err;
446 : :
447 : 506 : s->s3->tmp.key_block_length=num;
448 : 506 : s->s3->tmp.key_block=p;
449 : :
450 : 506 : ret = ssl3_generate_key_block(s,p,num);
451 : :
452 [ + - ]: 506 : if (!(s->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS))
453 : : {
454 : : /* enable vulnerability countermeasure for CBC ciphers with
455 : : * known-IV problem (http://www.openssl.org/~bodo/tls-cbc.txt)
456 : : */
457 : 506 : s->s3->need_empty_fragments = 1;
458 : :
459 [ + - ]: 506 : if (s->session->cipher != NULL)
460 : : {
461 [ + + ]: 506 : if (s->session->cipher->algorithm_enc == SSL_eNULL)
462 : 44 : s->s3->need_empty_fragments = 0;
463 : :
464 : : #ifndef OPENSSL_NO_RC4
465 [ + + ]: 506 : if (s->session->cipher->algorithm_enc == SSL_RC4)
466 : 66 : s->s3->need_empty_fragments = 0;
467 : : #endif
468 : : }
469 : : }
470 : :
471 : 506 : return ret;
472 : :
473 : : err:
474 : 0 : SSLerr(SSL_F_SSL3_SETUP_KEY_BLOCK,ERR_R_MALLOC_FAILURE);
475 : 0 : return(0);
476 : : }
477 : :
478 : 12150 : void ssl3_cleanup_key_block(SSL *s)
479 : : {
480 [ + + ]: 12150 : if (s->s3->tmp.key_block != NULL)
481 : : {
482 : 2160 : OPENSSL_cleanse(s->s3->tmp.key_block,
483 : 2160 : s->s3->tmp.key_block_length);
484 : 2160 : OPENSSL_free(s->s3->tmp.key_block);
485 : 2160 : s->s3->tmp.key_block=NULL;
486 : : }
487 : 12150 : s->s3->tmp.key_block_length=0;
488 : 12150 : }
489 : :
490 : : /* ssl3_enc encrypts/decrypts the record in |s->wrec| / |s->rrec|, respectively.
491 : : *
492 : : * Returns:
493 : : * 0: (in non-constant time) if the record is publically invalid (i.e. too
494 : : * short etc).
495 : : * 1: if the record's padding is valid / the encryption was successful.
496 : : * -1: if the record's padding is invalid or, if sending, an internal error
497 : : * occurred.
498 : : */
499 : 7282 : int ssl3_enc(SSL *s, int send)
500 : : {
501 : : SSL3_RECORD *rec;
502 : : EVP_CIPHER_CTX *ds;
503 : : unsigned long l;
504 : 7282 : int bs,i,mac_size=0;
505 : : const EVP_CIPHER *enc;
506 : :
507 [ + + ]: 7282 : if (send)
508 : : {
509 : 3894 : ds=s->enc_write_ctx;
510 : 3894 : rec= &(s->s3->wrec);
511 [ + + ]: 3894 : if (s->enc_write_ctx == NULL)
512 : : enc=NULL;
513 : : else
514 : 1914 : enc=EVP_CIPHER_CTX_cipher(s->enc_write_ctx);
515 : : }
516 : : else
517 : : {
518 : 3388 : ds=s->enc_read_ctx;
519 : 3388 : rec= &(s->s3->rrec);
520 [ + + ]: 3388 : if (s->enc_read_ctx == NULL)
521 : : enc=NULL;
522 : : else
523 : 1408 : enc=EVP_CIPHER_CTX_cipher(s->enc_read_ctx);
524 : : }
525 : :
526 [ + + ][ + + ]: 7282 : if ((s->session == NULL) || (ds == NULL) ||
527 : 7029 : (enc == NULL))
528 : : {
529 : 3960 : memmove(rec->data,rec->input,rec->length);
530 : 3960 : rec->input=rec->data;
531 : : }
532 : : else
533 : : {
534 : 3322 : l=rec->length;
535 : 3322 : bs=EVP_CIPHER_block_size(ds->cipher);
536 : :
537 : : /* COMPRESS */
538 : :
539 [ + + ]: 3322 : if ((bs != 1) && send)
540 : : {
541 : 1584 : i=bs-((int)l%bs);
542 : :
543 : : /* we need to add 'i-1' padding bytes */
544 : 1584 : l+=i;
545 : : /* the last of these zero bytes will be overwritten
546 : : * with the padding length. */
547 : 1584 : memset(&rec->input[rec->length], 0, i);
548 : 1584 : rec->length+=i;
549 : 1584 : rec->input[l-1]=(i-1);
550 : : }
551 : :
552 [ + + ]: 3322 : if (!send)
553 : : {
554 [ + - ][ + - ]: 1408 : if (l == 0 || l%bs != 0)
555 : : return 0;
556 : : /* otherwise, rec->length >= bs */
557 : : }
558 : :
559 : 3322 : EVP_Cipher(ds,rec->data,rec->input,l);
560 : :
561 [ + + ]: 3322 : if (EVP_MD_CTX_md(s->read_hash) != NULL)
562 : 3069 : mac_size = EVP_MD_CTX_size(s->read_hash);
563 [ + + ]: 3322 : if ((bs != 1) && !send)
564 : 1188 : return ssl3_cbc_remove_padding(s, rec, bs, mac_size);
565 : : }
566 : : return(1);
567 : : }
568 : :
569 : 2160 : void ssl3_init_finished_mac(SSL *s)
570 : : {
571 [ - + ]: 2160 : if (s->s3->handshake_buffer) BIO_free(s->s3->handshake_buffer);
572 [ - + ]: 2160 : if (s->s3->handshake_dgst) ssl3_free_digest_list(s);
573 : 2160 : s->s3->handshake_buffer=BIO_new(BIO_s_mem());
574 : 2160 : (void)BIO_set_close(s->s3->handshake_buffer,BIO_CLOSE);
575 : 2160 : }
576 : :
577 : 4320 : void ssl3_free_digest_list(SSL *s)
578 : : {
579 : : int i;
580 [ + + ]: 4320 : if (!s->s3->handshake_dgst) return;
581 [ + + ]: 15120 : for (i=0;i<SSL_MAX_DIGEST;i++)
582 : : {
583 [ + + ]: 12960 : if (s->s3->handshake_dgst[i])
584 : 3920 : EVP_MD_CTX_destroy(s->s3->handshake_dgst[i]);
585 : : }
586 : 2160 : OPENSSL_free(s->s3->handshake_dgst);
587 : 2160 : s->s3->handshake_dgst=NULL;
588 : : }
589 : :
590 : :
591 : :
592 : 18501 : void ssl3_finish_mac(SSL *s, const unsigned char *buf, int len)
593 : : {
594 [ + + ][ + + ]: 18501 : if (s->s3->handshake_buffer && !(s->s3->flags & TLS1_FLAGS_KEEP_HANDSHAKE))
595 : : {
596 : 4245 : BIO_write (s->s3->handshake_buffer,(void *)buf,len);
597 : : }
598 : : else
599 : : {
600 : : int i;
601 [ + + ]: 99792 : for (i=0;i< SSL_MAX_DIGEST;i++)
602 : : {
603 [ + + ]: 85536 : if (s->s3->handshake_dgst[i]!= NULL)
604 : 26422 : EVP_DigestUpdate(s->s3->handshake_dgst[i],buf,len);
605 : : }
606 : : }
607 : 18501 : }
608 : :
609 : 2160 : int ssl3_digest_cached_records(SSL *s)
610 : : {
611 : : int i;
612 : : long mask;
613 : : const EVP_MD *md;
614 : : long hdatalen;
615 : : void *hdata;
616 : :
617 : : /* Allocate handshake_dgst array */
618 : 2160 : ssl3_free_digest_list(s);
619 : 2160 : s->s3->handshake_dgst = OPENSSL_malloc(SSL_MAX_DIGEST * sizeof(EVP_MD_CTX *));
620 : 2160 : memset(s->s3->handshake_dgst,0,SSL_MAX_DIGEST *sizeof(EVP_MD_CTX *));
621 : 2160 : hdatalen = BIO_get_mem_data(s->s3->handshake_buffer,&hdata);
622 [ + - ]: 2160 : if (hdatalen <= 0)
623 : : {
624 : 0 : SSLerr(SSL_F_SSL3_DIGEST_CACHED_RECORDS, SSL_R_BAD_HANDSHAKE_LENGTH);
625 : 0 : return 0;
626 : : }
627 : :
628 : : /* Loop through bitso of algorithm2 field and create MD_CTX-es */
629 [ + + ]: 15120 : for (i=0;ssl_get_handshake_digest(i,&mask,&md); i++)
630 : : {
631 [ + + ][ + - ]: 12960 : if ((mask & ssl_get_algorithm2(s)) && md)
632 : : {
633 : 3920 : s->s3->handshake_dgst[i]=EVP_MD_CTX_create();
634 : : #ifdef OPENSSL_FIPS
635 : : if (EVP_MD_nid(md) == NID_md5)
636 : : {
637 : : EVP_MD_CTX_set_flags(s->s3->handshake_dgst[i],
638 : : EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
639 : : }
640 : : #endif
641 : 3920 : EVP_DigestInit_ex(s->s3->handshake_dgst[i],md,NULL);
642 : 3920 : EVP_DigestUpdate(s->s3->handshake_dgst[i],hdata,hdatalen);
643 : : }
644 : : else
645 : : {
646 : 9040 : s->s3->handshake_dgst[i]=NULL;
647 : : }
648 : : }
649 [ + + ]: 2160 : if (!(s->s3->flags & TLS1_FLAGS_KEEP_HANDSHAKE))
650 : : {
651 : : /* Free handshake_buffer BIO */
652 : 2105 : BIO_free(s->s3->handshake_buffer);
653 : 2105 : s->s3->handshake_buffer = NULL;
654 : : }
655 : :
656 : : return 1;
657 : : }
658 : :
659 : 594 : int ssl3_cert_verify_mac(SSL *s, int md_nid, unsigned char *p)
660 : : {
661 : 594 : return(ssl3_handshake_mac(s,md_nid,NULL,0,p));
662 : : }
663 : 1518 : int ssl3_final_finish_mac(SSL *s,
664 : : const char *sender, int len, unsigned char *p)
665 : : {
666 : : int ret, sha1len;
667 : 1518 : ret=ssl3_handshake_mac(s,NID_md5,sender,len,p);
668 [ + - ]: 1518 : if(ret == 0)
669 : : return 0;
670 : :
671 : 1518 : p+=ret;
672 : :
673 : 1518 : sha1len=ssl3_handshake_mac(s,NID_sha1,sender,len,p);
674 [ + - ]: 1518 : if(sha1len == 0)
675 : : return 0;
676 : :
677 : 1518 : ret+=sha1len;
678 : 1518 : return(ret);
679 : : }
680 : 3630 : static int ssl3_handshake_mac(SSL *s, int md_nid,
681 : : const char *sender, int len, unsigned char *p)
682 : : {
683 : : unsigned int ret;
684 : : int npad,n;
685 : : unsigned int i;
686 : : unsigned char md_buf[EVP_MAX_MD_SIZE];
687 : 3630 : EVP_MD_CTX ctx,*d=NULL;
688 : :
689 [ - + ]: 3630 : if (s->s3->handshake_buffer)
690 [ # # ]: 0 : if (!ssl3_digest_cached_records(s))
691 : : return 0;
692 : :
693 : : /* Search for digest of specified type in the handshake_dgst
694 : : * array*/
695 [ + - ]: 5445 : for (i=0;i<SSL_MAX_DIGEST;i++)
696 : : {
697 [ + - ][ + + ]: 5445 : if (s->s3->handshake_dgst[i]&&EVP_MD_CTX_type(s->s3->handshake_dgst[i])==md_nid)
698 : : {
699 : 3630 : d=s->s3->handshake_dgst[i];
700 : 3630 : break;
701 : : }
702 : : }
703 [ - + ]: 3630 : if (!d) {
704 : 0 : SSLerr(SSL_F_SSL3_HANDSHAKE_MAC,SSL_R_NO_REQUIRED_DIGEST);
705 : 0 : return 0;
706 : : }
707 : 3630 : EVP_MD_CTX_init(&ctx);
708 : 3630 : EVP_MD_CTX_set_flags(&ctx, EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
709 : 3630 : EVP_MD_CTX_copy_ex(&ctx,d);
710 : 3630 : n=EVP_MD_CTX_size(&ctx);
711 [ + - ]: 3630 : if (n < 0)
712 : : return 0;
713 : :
714 : 3630 : npad=(48/n)*n;
715 [ + + ]: 3630 : if (sender != NULL)
716 : 3036 : EVP_DigestUpdate(&ctx,sender,len);
717 : 3630 : EVP_DigestUpdate(&ctx,s->session->master_key,
718 : 3630 : s->session->master_key_length);
719 : 3630 : EVP_DigestUpdate(&ctx,ssl3_pad_1,npad);
720 : 3630 : EVP_DigestFinal_ex(&ctx,md_buf,&i);
721 : :
722 : 3630 : EVP_DigestInit_ex(&ctx,EVP_MD_CTX_md(&ctx), NULL);
723 : 3630 : EVP_DigestUpdate(&ctx,s->session->master_key,
724 : 3630 : s->session->master_key_length);
725 : 3630 : EVP_DigestUpdate(&ctx,ssl3_pad_2,npad);
726 : 3630 : EVP_DigestUpdate(&ctx,md_buf,i);
727 : 3630 : EVP_DigestFinal_ex(&ctx,p,&ret);
728 : :
729 : 3630 : EVP_MD_CTX_cleanup(&ctx);
730 : :
731 : 3630 : return((int)ret);
732 : : }
733 : :
734 : 3322 : int n_ssl3_mac(SSL *ssl, unsigned char *md, int send)
735 : : {
736 : : SSL3_RECORD *rec;
737 : : unsigned char *mac_sec,*seq;
738 : : EVP_MD_CTX md_ctx;
739 : : const EVP_MD_CTX *hash;
740 : : unsigned char *p,rec_char;
741 : : size_t md_size;
742 : : int npad;
743 : : int t;
744 : :
745 [ + + ]: 3322 : if (send)
746 : : {
747 : 1914 : rec= &(ssl->s3->wrec);
748 : 1914 : mac_sec= &(ssl->s3->write_mac_secret[0]);
749 : 1914 : seq= &(ssl->s3->write_sequence[0]);
750 : 1914 : hash=ssl->write_hash;
751 : : }
752 : : else
753 : : {
754 : 1408 : rec= &(ssl->s3->rrec);
755 : 1408 : mac_sec= &(ssl->s3->read_mac_secret[0]);
756 : 1408 : seq= &(ssl->s3->read_sequence[0]);
757 : 1408 : hash=ssl->read_hash;
758 : : }
759 : :
760 : 3322 : t=EVP_MD_CTX_size(hash);
761 [ + - ]: 3322 : if (t < 0)
762 : : return -1;
763 : 3322 : md_size=t;
764 : 3322 : npad=(48/md_size)*md_size;
765 : :
766 [ + + + + ]: 4730 : if (!send &&
767 [ + - ]: 2596 : EVP_CIPHER_CTX_mode(ssl->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
768 : 1188 : ssl3_cbc_record_digest_supported(hash))
769 : 1188 : {
770 : : /* This is a CBC-encrypted record. We must avoid leaking any
771 : : * timing-side channel information about how many blocks of
772 : : * data we are hashing because that gives an attacker a
773 : : * timing-oracle. */
774 : :
775 : : /* npad is, at most, 48 bytes and that's with MD5:
776 : : * 16 + 48 + 8 (sequence bytes) + 1 + 2 = 75.
777 : : *
778 : : * With SHA-1 (the largest hash speced for SSLv3) the hash size
779 : : * goes up 4, but npad goes down by 8, resulting in a smaller
780 : : * total size. */
781 : : unsigned char header[75];
782 : 1188 : unsigned j = 0;
783 : 1188 : memcpy(header+j, mac_sec, md_size);
784 : 1188 : j += md_size;
785 : 1188 : memcpy(header+j, ssl3_pad_1, npad);
786 : 1188 : j += npad;
787 : 1188 : memcpy(header+j, seq, 8);
788 : 1188 : j += 8;
789 : 1188 : header[j++] = rec->type;
790 : 1188 : header[j++] = rec->length >> 8;
791 : 1188 : header[j++] = rec->length & 0xff;
792 : :
793 : 1188 : ssl3_cbc_digest_record(
794 : : hash,
795 : : md, &md_size,
796 : 1188 : header, rec->input,
797 : 2376 : rec->length + md_size, rec->orig_len,
798 : : mac_sec, md_size,
799 : : 1 /* is SSLv3 */);
800 : : }
801 : : else
802 : : {
803 : : unsigned int md_size_u;
804 : : /* Chop the digest off the end :-) */
805 : 2134 : EVP_MD_CTX_init(&md_ctx);
806 : :
807 : 2134 : EVP_MD_CTX_copy_ex( &md_ctx,hash);
808 : 2134 : EVP_DigestUpdate(&md_ctx,mac_sec,md_size);
809 : 2134 : EVP_DigestUpdate(&md_ctx,ssl3_pad_1,npad);
810 : 2134 : EVP_DigestUpdate(&md_ctx,seq,8);
811 : 2134 : rec_char=rec->type;
812 : 2134 : EVP_DigestUpdate(&md_ctx,&rec_char,1);
813 : 2134 : p=md;
814 : 2134 : s2n(rec->length,p);
815 : 2134 : EVP_DigestUpdate(&md_ctx,md,2);
816 : 2134 : EVP_DigestUpdate(&md_ctx,rec->input,rec->length);
817 : 2134 : EVP_DigestFinal_ex( &md_ctx,md,NULL);
818 : :
819 : 2134 : EVP_MD_CTX_copy_ex( &md_ctx,hash);
820 : 2134 : EVP_DigestUpdate(&md_ctx,mac_sec,md_size);
821 : 2134 : EVP_DigestUpdate(&md_ctx,ssl3_pad_2,npad);
822 : 2134 : EVP_DigestUpdate(&md_ctx,md,md_size);
823 : 2134 : EVP_DigestFinal_ex( &md_ctx,md,&md_size_u);
824 : 2134 : md_size = md_size_u;
825 : :
826 : 2134 : EVP_MD_CTX_cleanup(&md_ctx);
827 : : }
828 : :
829 : 3322 : ssl3_record_sequence_update(seq);
830 : 3322 : return(md_size);
831 : : }
832 : :
833 : 3322 : void ssl3_record_sequence_update(unsigned char *seq)
834 : : {
835 : : int i;
836 : :
837 [ + - ]: 3322 : for (i=7; i>=0; i--)
838 : : {
839 : 3322 : ++seq[i];
840 [ - + ]: 3322 : if (seq[i] != 0) break;
841 : : }
842 : 3322 : }
843 : :
844 : 506 : int ssl3_generate_master_secret(SSL *s, unsigned char *out, unsigned char *p,
845 : : int len)
846 : : {
847 : : static const unsigned char *salt[3]={
848 : : #ifndef CHARSET_EBCDIC
849 : : (const unsigned char *)"A",
850 : : (const unsigned char *)"BB",
851 : : (const unsigned char *)"CCC",
852 : : #else
853 : : (const unsigned char *)"\x41",
854 : : (const unsigned char *)"\x42\x42",
855 : : (const unsigned char *)"\x43\x43\x43",
856 : : #endif
857 : : };
858 : : unsigned char buf[EVP_MAX_MD_SIZE];
859 : : EVP_MD_CTX ctx;
860 : 506 : int i,ret=0;
861 : : unsigned int n;
862 : : #ifdef OPENSSL_SSL_TRACE_CRYPTO
863 : : unsigned char *tmpout = out;
864 : : #endif
865 : :
866 : 506 : EVP_MD_CTX_init(&ctx);
867 [ + + ]: 2024 : for (i=0; i<3; i++)
868 : : {
869 : 1518 : EVP_DigestInit_ex(&ctx,s->ctx->sha1, NULL);
870 : 1518 : EVP_DigestUpdate(&ctx,salt[i],strlen((const char *)salt[i]));
871 : 1518 : EVP_DigestUpdate(&ctx,p,len);
872 : 1518 : EVP_DigestUpdate(&ctx,&(s->s3->client_random[0]),
873 : : SSL3_RANDOM_SIZE);
874 : 1518 : EVP_DigestUpdate(&ctx,&(s->s3->server_random[0]),
875 : : SSL3_RANDOM_SIZE);
876 : 1518 : EVP_DigestFinal_ex(&ctx,buf,&n);
877 : :
878 : 1518 : EVP_DigestInit_ex(&ctx,s->ctx->md5, NULL);
879 : 1518 : EVP_DigestUpdate(&ctx,p,len);
880 : 1518 : EVP_DigestUpdate(&ctx,buf,n);
881 : 1518 : EVP_DigestFinal_ex(&ctx,out,&n);
882 : 1518 : out+=n;
883 : 1518 : ret+=n;
884 : : }
885 : 506 : EVP_MD_CTX_cleanup(&ctx);
886 : :
887 : : #ifdef OPENSSL_SSL_TRACE_CRYPTO
888 : : if (s->msg_callback)
889 : : {
890 : : s->msg_callback(2, s->version, TLS1_RT_CRYPTO_PREMASTER,
891 : : p, len, s, s->msg_callback_arg);
892 : : s->msg_callback(2, s->version, TLS1_RT_CRYPTO_CLIENT_RANDOM,
893 : : s->s3->client_random, SSL3_RANDOM_SIZE,
894 : : s, s->msg_callback_arg);
895 : : s->msg_callback(2, s->version, TLS1_RT_CRYPTO_SERVER_RANDOM,
896 : : s->s3->server_random, SSL3_RANDOM_SIZE,
897 : : s, s->msg_callback_arg);
898 : : s->msg_callback(2, s->version, TLS1_RT_CRYPTO_MASTER,
899 : : tmpout, SSL3_MASTER_SECRET_SIZE,
900 : : s, s->msg_callback_arg);
901 : : }
902 : : #endif
903 : 506 : return(ret);
904 : : }
905 : :
906 [ - + ]: 1012 : int ssl3_alert_code(int code)
907 : : {
908 : : switch (code)
909 : : {
910 : : case SSL_AD_CLOSE_NOTIFY: return(SSL3_AD_CLOSE_NOTIFY);
911 : : case SSL_AD_UNEXPECTED_MESSAGE: return(SSL3_AD_UNEXPECTED_MESSAGE);
912 : : case SSL_AD_BAD_RECORD_MAC: return(SSL3_AD_BAD_RECORD_MAC);
913 : : case SSL_AD_DECRYPTION_FAILED: return(SSL3_AD_BAD_RECORD_MAC);
914 : : case SSL_AD_RECORD_OVERFLOW: return(SSL3_AD_BAD_RECORD_MAC);
915 : : case SSL_AD_DECOMPRESSION_FAILURE:return(SSL3_AD_DECOMPRESSION_FAILURE);
916 : : case SSL_AD_HANDSHAKE_FAILURE: return(SSL3_AD_HANDSHAKE_FAILURE);
917 : : case SSL_AD_NO_CERTIFICATE: return(SSL3_AD_NO_CERTIFICATE);
918 : : case SSL_AD_BAD_CERTIFICATE: return(SSL3_AD_BAD_CERTIFICATE);
919 : : case SSL_AD_UNSUPPORTED_CERTIFICATE:return(SSL3_AD_UNSUPPORTED_CERTIFICATE);
920 : : case SSL_AD_CERTIFICATE_REVOKED:return(SSL3_AD_CERTIFICATE_REVOKED);
921 : : case SSL_AD_CERTIFICATE_EXPIRED:return(SSL3_AD_CERTIFICATE_EXPIRED);
922 : : case SSL_AD_CERTIFICATE_UNKNOWN:return(SSL3_AD_CERTIFICATE_UNKNOWN);
923 : : case SSL_AD_ILLEGAL_PARAMETER: return(SSL3_AD_ILLEGAL_PARAMETER);
924 : : case SSL_AD_UNKNOWN_CA: return(SSL3_AD_BAD_CERTIFICATE);
925 : : case SSL_AD_ACCESS_DENIED: return(SSL3_AD_HANDSHAKE_FAILURE);
926 : : case SSL_AD_DECODE_ERROR: return(SSL3_AD_HANDSHAKE_FAILURE);
927 : : case SSL_AD_DECRYPT_ERROR: return(SSL3_AD_HANDSHAKE_FAILURE);
928 : : case SSL_AD_EXPORT_RESTRICTION: return(SSL3_AD_HANDSHAKE_FAILURE);
929 : : case SSL_AD_PROTOCOL_VERSION: return(SSL3_AD_HANDSHAKE_FAILURE);
930 : : case SSL_AD_INSUFFICIENT_SECURITY:return(SSL3_AD_HANDSHAKE_FAILURE);
931 : : case SSL_AD_INTERNAL_ERROR: return(SSL3_AD_HANDSHAKE_FAILURE);
932 : : case SSL_AD_USER_CANCELLED: return(SSL3_AD_HANDSHAKE_FAILURE);
933 : : case SSL_AD_NO_RENEGOTIATION: return(-1); /* Don't send it :-) */
934 : : case SSL_AD_UNSUPPORTED_EXTENSION: return(SSL3_AD_HANDSHAKE_FAILURE);
935 : : case SSL_AD_CERTIFICATE_UNOBTAINABLE: return(SSL3_AD_HANDSHAKE_FAILURE);
936 : : case SSL_AD_UNRECOGNIZED_NAME: return(SSL3_AD_HANDSHAKE_FAILURE);
937 : : case SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE: return(SSL3_AD_HANDSHAKE_FAILURE);
938 : : case SSL_AD_BAD_CERTIFICATE_HASH_VALUE: return(SSL3_AD_HANDSHAKE_FAILURE);
939 : : case SSL_AD_UNKNOWN_PSK_IDENTITY:return(TLS1_AD_UNKNOWN_PSK_IDENTITY);
940 : : default: return(-1);
941 : : }
942 : : }
943 : :
|
