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 #include <stdio.h> 60 #include <openssl/md5.h> 61 #include <openssl/sha.h> 62 #include <openssl/evp.h> 63 #include "ssl_locl.h" 64 65 static unsigned char ssl3_pad_1[48]={ 66 0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, 67 0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, 68 0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, 69 0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, 70 0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, 71 0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36 }; 72 73 static unsigned char ssl3_pad_2[48]={ 74 0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,0x5c, 75 0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,0x5c, 76 0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,0x5c, 77 0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,0x5c, 78 0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,0x5c, 79 0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,0x5c,0x5c }; 80 81 #ifndef NO_PROTO 82 static int ssl3_handshake_mac(SSL *s, EVP_MD_CTX *in_ctx, 83 unsigned char *sender, int len, unsigned char *p); 84 #else 85 static int ssl3_handshake_mac(); 86 #endif 87 88 static void ssl3_generate_key_block(SSL *s, unsigned char *km, int num) 89 { 90 MD5_CTX m5; 91 SHA_CTX s1; 92 unsigned char buf[8],smd[SHA_DIGEST_LENGTH]; 93 unsigned char c='A'; 94 int i,j,k; 95 96 #ifdef CHARSET_EBCDIC 97 c = os_toascii[c]; /*'A' in ASCII */ 98 #endif 99 k=0; 100 for (i=0; i<num; i+=MD5_DIGEST_LENGTH) 101 { 102 k++; 103 for (j=0; j<k; j++) 104 buf[j]=c; 105 c++; 106 SHA1_Init( &s1); 107 SHA1_Update(&s1,buf,k); 108 SHA1_Update(&s1,s->session->master_key, 109 s->session->master_key_length); 110 SHA1_Update(&s1,s->s3->server_random,SSL3_RANDOM_SIZE); 111 SHA1_Update(&s1,s->s3->client_random,SSL3_RANDOM_SIZE); 112 SHA1_Final( smd,&s1); 113 114 MD5_Init( &m5); 115 MD5_Update(&m5,s->session->master_key, 116 s->session->master_key_length); 117 MD5_Update(&m5,smd,SHA_DIGEST_LENGTH); 118 if ((i+MD5_DIGEST_LENGTH) > num) 119 { 120 MD5_Final(smd,&m5); 121 memcpy(km,smd,(num-i)); 122 } 123 else 124 MD5_Final(km,&m5); 125 126 km+=MD5_DIGEST_LENGTH; 127 } 128 memset(smd,0,SHA_DIGEST_LENGTH); 129 } 130 131 int ssl3_change_cipher_state(SSL *s, int which) 132 { 133 unsigned char *p,*key_block,*mac_secret; 134 unsigned char exp_key[EVP_MAX_KEY_LENGTH]; 135 unsigned char exp_iv[EVP_MAX_KEY_LENGTH]; 136 unsigned char *ms,*key,*iv,*er1,*er2; 137 EVP_CIPHER_CTX *dd; 138 const EVP_CIPHER *c; 139 COMP_METHOD *comp; 140 const EVP_MD *m; 141 MD5_CTX md; 142 int exp,n,i,j,k,cl; 143 144 exp=SSL_C_IS_EXPORT(s->s3->tmp.new_cipher); 145 c=s->s3->tmp.new_sym_enc; 146 m=s->s3->tmp.new_hash; 147 if (s->s3->tmp.new_compression == NULL) 148 comp=NULL; 149 else 150 comp=s->s3->tmp.new_compression->method; 151 key_block=s->s3->tmp.key_block; 152 153 if (which & SSL3_CC_READ) 154 { 155 if ((s->enc_read_ctx == NULL) && 156 ((s->enc_read_ctx=(EVP_CIPHER_CTX *) 157 Malloc(sizeof(EVP_CIPHER_CTX))) == NULL)) 158 goto err; 159 dd= s->enc_read_ctx; 160 s->read_hash=m; 161 /* COMPRESS */ 162 if (s->expand != NULL) 163 { 164 COMP_CTX_free(s->expand); 165 s->expand=NULL; 166 } 167 if (comp != NULL) 168 { 169 s->expand=COMP_CTX_new(comp); 170 if (s->expand == NULL) 171 { 172 SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,SSL_R_COMPRESSION_LIBRARY_ERROR); 173 goto err2; 174 } 175 if (s->s3->rrec.comp == NULL) 176 s->s3->rrec.comp=(unsigned char *) 177 Malloc(SSL3_RT_MAX_PLAIN_LENGTH); 178 if (s->s3->rrec.comp == NULL) 179 goto err; 180 } 181 memset(&(s->s3->read_sequence[0]),0,8); 182 mac_secret= &(s->s3->read_mac_secret[0]); 183 } 184 else 185 { 186 if ((s->enc_write_ctx == NULL) && 187 ((s->enc_write_ctx=(EVP_CIPHER_CTX *) 188 Malloc(sizeof(EVP_CIPHER_CTX))) == NULL)) 189 goto err; 190 dd= s->enc_write_ctx; 191 s->write_hash=m; 192 /* COMPRESS */ 193 if (s->compress != NULL) 194 { 195 COMP_CTX_free(s->compress); 196 s->compress=NULL; 197 } 198 if (comp != NULL) 199 { 200 s->compress=COMP_CTX_new(comp); 201 if (s->compress == NULL) 202 { 203 SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,SSL_R_COMPRESSION_LIBRARY_ERROR); 204 goto err2; 205 } 206 } 207 memset(&(s->s3->write_sequence[0]),0,8); 208 mac_secret= &(s->s3->write_mac_secret[0]); 209 } 210 211 EVP_CIPHER_CTX_init(dd); 212 213 p=s->s3->tmp.key_block; 214 i=EVP_MD_size(m); 215 cl=EVP_CIPHER_key_length(c); 216 j=exp ? (cl < SSL_C_EXPORT_KEYLENGTH(s->s3->tmp.new_cipher) ? 217 cl : SSL_C_EXPORT_KEYLENGTH(s->s3->tmp.new_cipher)) : cl; 218 /* Was j=(exp)?5:EVP_CIPHER_key_length(c); */ 219 k=EVP_CIPHER_iv_length(c); 220 if ( (which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) || 221 (which == SSL3_CHANGE_CIPHER_SERVER_READ)) 222 { 223 ms= &(p[ 0]); n=i+i; 224 key= &(p[ n]); n+=j+j; 225 iv= &(p[ n]); n+=k+k; 226 er1= &(s->s3->client_random[0]); 227 er2= &(s->s3->server_random[0]); 228 } 229 else 230 { 231 n=i; 232 ms= &(p[ n]); n+=i+j; 233 key= &(p[ n]); n+=j+k; 234 iv= &(p[ n]); n+=k; 235 er1= &(s->s3->server_random[0]); 236 er2= &(s->s3->client_random[0]); 237 } 238 239 if (n > s->s3->tmp.key_block_length) 240 { 241 SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,SSL_R_INTERNAL_ERROR); 242 goto err2; 243 } 244 245 memcpy(mac_secret,ms,i); 246 if (exp) 247 { 248 /* In here I set both the read and write key/iv to the 249 * same value since only the correct one will be used :-). 250 */ 251 MD5_Init(&md); 252 MD5_Update(&md,key,j); 253 MD5_Update(&md,er1,SSL3_RANDOM_SIZE); 254 MD5_Update(&md,er2,SSL3_RANDOM_SIZE); 255 MD5_Final(&(exp_key[0]),&md); 256 key= &(exp_key[0]); 257 258 if (k > 0) 259 { 260 MD5_Init(&md); 261 MD5_Update(&md,er1,SSL3_RANDOM_SIZE); 262 MD5_Update(&md,er2,SSL3_RANDOM_SIZE); 263 MD5_Final(&(exp_iv[0]),&md); 264 iv= &(exp_iv[0]); 265 } 266 } 267 268 s->session->key_arg_length=0; 269 270 EVP_CipherInit(dd,c,key,iv,(which & SSL3_CC_WRITE)); 271 272 memset(&(exp_key[0]),0,sizeof(exp_key)); 273 memset(&(exp_iv[0]),0,sizeof(exp_iv)); 274 return(1); 275 err: 276 SSLerr(SSL_F_SSL3_CHANGE_CIPHER_STATE,ERR_R_MALLOC_FAILURE); 277 err2: 278 return(0); 279 } 280 281 int ssl3_setup_key_block(SSL *s) 282 { 283 unsigned char *p; 284 const EVP_CIPHER *c; 285 const EVP_MD *hash; 286 int num; 287 SSL_COMP *comp; 288 289 if (s->s3->tmp.key_block_length != 0) 290 return(1); 291 292 if (!ssl_cipher_get_evp(s->session,&c,&hash,&comp)) 293 { 294 SSLerr(SSL_F_SSL3_SETUP_KEY_BLOCK,SSL_R_CIPHER_OR_HASH_UNAVAILABLE); 295 return(0); 296 } 297 298 s->s3->tmp.new_sym_enc=c; 299 s->s3->tmp.new_hash=hash; 300 s->s3->tmp.new_compression=comp; 301 302 num=EVP_CIPHER_key_length(c)+EVP_MD_size(hash)+EVP_CIPHER_iv_length(c); 303 num*=2; 304 305 ssl3_cleanup_key_block(s); 306 307 if ((p=(unsigned char *)Malloc(num)) == NULL) 308 goto err; 309 310 s->s3->tmp.key_block_length=num; 311 s->s3->tmp.key_block=p; 312 313 ssl3_generate_key_block(s,p,num); 314 315 return(1); 316 err: 317 SSLerr(SSL_F_SSL3_SETUP_KEY_BLOCK,ERR_R_MALLOC_FAILURE); 318 return(0); 319 } 320 321 void ssl3_cleanup_key_block(SSL *s) 322 { 323 if (s->s3->tmp.key_block != NULL) 324 { 325 memset(s->s3->tmp.key_block,0, 326 s->s3->tmp.key_block_length); 327 Free(s->s3->tmp.key_block); 328 s->s3->tmp.key_block=NULL; 329 } 330 s->s3->tmp.key_block_length=0; 331 } 332 333 int ssl3_enc(SSL *s, int send) 334 { 335 SSL3_RECORD *rec; 336 EVP_CIPHER_CTX *ds; 337 unsigned long l; 338 int bs,i; 339 const EVP_CIPHER *enc; 340 341 if (send) 342 { 343 ds=s->enc_write_ctx; 344 rec= &(s->s3->wrec); 345 if (s->enc_write_ctx == NULL) 346 enc=NULL; 347 else 348 enc=EVP_CIPHER_CTX_cipher(s->enc_write_ctx); 349 } 350 else 351 { 352 ds=s->enc_read_ctx; 353 rec= &(s->s3->rrec); 354 if (s->enc_read_ctx == NULL) 355 enc=NULL; 356 else 357 enc=EVP_CIPHER_CTX_cipher(s->enc_read_ctx); 358 } 359 360 if ((s->session == NULL) || (ds == NULL) || 361 (enc == NULL)) 362 { 363 memcpy(rec->data,rec->input,rec->length); 364 rec->input=rec->data; 365 } 366 else 367 { 368 l=rec->length; 369 bs=EVP_CIPHER_block_size(ds->cipher); 370 371 /* COMPRESS */ 372 373 /* This should be using (bs-1) and bs instead of 7 and 8 */ 374 if ((bs != 1) && send) 375 { 376 i=bs-((int)l%bs); 377 378 /* we need to add 'i-1' padding bytes */ 379 l+=i; 380 rec->length+=i; 381 rec->input[l-1]=(i-1); 382 } 383 384 EVP_Cipher(ds,rec->data,rec->input,l); 385 386 if ((bs != 1) && !send) 387 { 388 i=rec->data[l-1]+1; 389 if (i > bs) 390 { 391 SSLerr(SSL_F_SSL3_ENC,SSL_R_BLOCK_CIPHER_PAD_IS_WRONG); 392 ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECRYPT_ERROR); 393 return(0); 394 } 395 rec->length-=i; 396 } 397 } 398 return(1); 399 } 400 401 void ssl3_init_finished_mac(SSL *s) 402 { 403 EVP_DigestInit(&(s->s3->finish_dgst1),s->ctx->md5); 404 EVP_DigestInit(&(s->s3->finish_dgst2),s->ctx->sha1); 405 } 406 407 void ssl3_finish_mac(SSL *s, const unsigned char *buf, int len) 408 { 409 EVP_DigestUpdate(&(s->s3->finish_dgst1),buf,len); 410 EVP_DigestUpdate(&(s->s3->finish_dgst2),buf,len); 411 } 412 413 int ssl3_cert_verify_mac(SSL *s, EVP_MD_CTX *ctx, unsigned char *p) 414 { 415 return(ssl3_handshake_mac(s,ctx,NULL,0,p)); 416 } 417 418 int ssl3_final_finish_mac(SSL *s, EVP_MD_CTX *ctx1, EVP_MD_CTX *ctx2, 419 unsigned char *sender, int len, unsigned char *p) 420 { 421 int ret; 422 423 ret=ssl3_handshake_mac(s,ctx1,sender,len,p); 424 p+=ret; 425 ret+=ssl3_handshake_mac(s,ctx2,sender,len,p); 426 return(ret); 427 } 428 429 static int ssl3_handshake_mac(SSL *s, EVP_MD_CTX *in_ctx, 430 unsigned char *sender, int len, unsigned char *p) 431 { 432 unsigned int ret; 433 int npad,n; 434 unsigned int i; 435 unsigned char md_buf[EVP_MAX_MD_SIZE]; 436 EVP_MD_CTX ctx; 437 438 EVP_MD_CTX_copy(&ctx,in_ctx); 439 440 n=EVP_MD_CTX_size(&ctx); 441 npad=(48/n)*n; 442 443 if (sender != NULL) 444 EVP_DigestUpdate(&ctx,sender,len); 445 EVP_DigestUpdate(&ctx,s->session->master_key, 446 s->session->master_key_length); 447 EVP_DigestUpdate(&ctx,ssl3_pad_1,npad); 448 EVP_DigestFinal(&ctx,md_buf,&i); 449 450 EVP_DigestInit(&ctx,EVP_MD_CTX_type(&ctx)); 451 EVP_DigestUpdate(&ctx,s->session->master_key, 452 s->session->master_key_length); 453 EVP_DigestUpdate(&ctx,ssl3_pad_2,npad); 454 EVP_DigestUpdate(&ctx,md_buf,i); 455 EVP_DigestFinal(&ctx,p,&ret); 456 457 memset(&ctx,0,sizeof(EVP_MD_CTX)); 458 459 return((int)ret); 460 } 461 462 int ssl3_mac(SSL *ssl, unsigned char *md, int send) 463 { 464 SSL3_RECORD *rec; 465 unsigned char *mac_sec,*seq; 466 EVP_MD_CTX md_ctx; 467 const EVP_MD *hash; 468 unsigned char *p,rec_char; 469 unsigned int md_size; 470 int npad,i; 471 472 if (send) 473 { 474 rec= &(ssl->s3->wrec); 475 mac_sec= &(ssl->s3->write_mac_secret[0]); 476 seq= &(ssl->s3->write_sequence[0]); 477 hash=ssl->write_hash; 478 } 479 else 480 { 481 rec= &(ssl->s3->rrec); 482 mac_sec= &(ssl->s3->read_mac_secret[0]); 483 seq= &(ssl->s3->read_sequence[0]); 484 hash=ssl->read_hash; 485 } 486 487 md_size=EVP_MD_size(hash); 488 npad=(48/md_size)*md_size; 489 490 /* Chop the digest off the end :-) */ 491 492 EVP_DigestInit( &md_ctx,hash); 493 EVP_DigestUpdate(&md_ctx,mac_sec,md_size); 494 EVP_DigestUpdate(&md_ctx,ssl3_pad_1,npad); 495 EVP_DigestUpdate(&md_ctx,seq,8); 496 rec_char=rec->type; 497 EVP_DigestUpdate(&md_ctx,&rec_char,1); 498 p=md; 499 s2n(rec->length,p); 500 EVP_DigestUpdate(&md_ctx,md,2); 501 EVP_DigestUpdate(&md_ctx,rec->input,rec->length); 502 EVP_DigestFinal( &md_ctx,md,NULL); 503 504 EVP_DigestInit( &md_ctx,hash); 505 EVP_DigestUpdate(&md_ctx,mac_sec,md_size); 506 EVP_DigestUpdate(&md_ctx,ssl3_pad_2,npad); 507 EVP_DigestUpdate(&md_ctx,md,md_size); 508 EVP_DigestFinal( &md_ctx,md,&md_size); 509 510 for (i=7; i>=0; i--) 511 if (++seq[i]) break; 512 513 return(md_size); 514 } 515 516 int ssl3_generate_master_secret(SSL *s, unsigned char *out, unsigned char *p, 517 int len) 518 { 519 static const unsigned char *salt[3]={ 520 #ifndef CHARSET_EBCDIC 521 (const unsigned char *)"A", 522 (const unsigned char *)"BB", 523 (const unsigned char *)"CCC", 524 #else 525 (const unsigned char *)"\x41", 526 (const unsigned char *)"\x42\x42", 527 (const unsigned char *)"\x43\x43\x43", 528 #endif 529 }; 530 unsigned char buf[EVP_MAX_MD_SIZE]; 531 EVP_MD_CTX ctx; 532 int i,ret=0; 533 unsigned int n; 534 535 for (i=0; i<3; i++) 536 { 537 EVP_DigestInit(&ctx,s->ctx->sha1); 538 EVP_DigestUpdate(&ctx,salt[i],strlen((const char *)salt[i])); 539 EVP_DigestUpdate(&ctx,p,len); 540 EVP_DigestUpdate(&ctx,&(s->s3->client_random[0]), 541 SSL3_RANDOM_SIZE); 542 EVP_DigestUpdate(&ctx,&(s->s3->server_random[0]), 543 SSL3_RANDOM_SIZE); 544 EVP_DigestFinal(&ctx,buf,&n); 545 546 EVP_DigestInit(&ctx,s->ctx->md5); 547 EVP_DigestUpdate(&ctx,p,len); 548 EVP_DigestUpdate(&ctx,buf,n); 549 EVP_DigestFinal(&ctx,out,&n); 550 out+=n; 551 ret+=n; 552 } 553 return(ret); 554 } 555 556 int ssl3_alert_code(int code) 557 { 558 switch (code) 559 { 560 case SSL_AD_CLOSE_NOTIFY: return(SSL3_AD_CLOSE_NOTIFY); 561 case SSL_AD_UNEXPECTED_MESSAGE: return(SSL3_AD_UNEXPECTED_MESSAGE); 562 case SSL_AD_BAD_RECORD_MAC: return(SSL3_AD_BAD_RECORD_MAC); 563 case SSL_AD_DECRYPTION_FAILED: return(SSL3_AD_BAD_RECORD_MAC); 564 case SSL_AD_RECORD_OVERFLOW: return(SSL3_AD_BAD_RECORD_MAC); 565 case SSL_AD_DECOMPRESSION_FAILURE:return(SSL3_AD_DECOMPRESSION_FAILURE); 566 case SSL_AD_HANDSHAKE_FAILURE: return(SSL3_AD_HANDSHAKE_FAILURE); 567 case SSL_AD_NO_CERTIFICATE: return(SSL3_AD_NO_CERTIFICATE); 568 case SSL_AD_BAD_CERTIFICATE: return(SSL3_AD_BAD_CERTIFICATE); 569 case SSL_AD_UNSUPPORTED_CERTIFICATE:return(SSL3_AD_UNSUPPORTED_CERTIFICATE); 570 case SSL_AD_CERTIFICATE_REVOKED:return(SSL3_AD_CERTIFICATE_REVOKED); 571 case SSL_AD_CERTIFICATE_EXPIRED:return(SSL3_AD_CERTIFICATE_EXPIRED); 572 case SSL_AD_CERTIFICATE_UNKNOWN:return(SSL3_AD_CERTIFICATE_UNKNOWN); 573 case SSL_AD_ILLEGAL_PARAMETER: return(SSL3_AD_ILLEGAL_PARAMETER); 574 case SSL_AD_UNKNOWN_CA: return(SSL3_AD_BAD_CERTIFICATE); 575 case SSL_AD_ACCESS_DENIED: return(SSL3_AD_HANDSHAKE_FAILURE); 576 case SSL_AD_DECODE_ERROR: return(SSL3_AD_HANDSHAKE_FAILURE); 577 case SSL_AD_DECRYPT_ERROR: return(SSL3_AD_HANDSHAKE_FAILURE); 578 case SSL_AD_EXPORT_RESTRICION: return(SSL3_AD_HANDSHAKE_FAILURE); 579 case SSL_AD_PROTOCOL_VERSION: return(SSL3_AD_HANDSHAKE_FAILURE); 580 case SSL_AD_INSUFFICIENT_SECURITY:return(SSL3_AD_HANDSHAKE_FAILURE); 581 case SSL_AD_INTERNAL_ERROR: return(SSL3_AD_HANDSHAKE_FAILURE); 582 case SSL_AD_USER_CANCLED: return(SSL3_AD_HANDSHAKE_FAILURE); 583 case SSL_AD_NO_RENEGOTIATION: return(-1); /* Don't send it :-) */ 584 default: return(-1); 585 } 586 } 587 588