1 /* ssl/d1_srvr.c */ 2 /* 3 * DTLS implementation written by Nagendra Modadugu 4 * (nagendra (at) cs.stanford.edu) for the OpenSSL project 2005. 5 */ 6 /* ==================================================================== 7 * Copyright (c) 1999-2007 The OpenSSL Project. All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in 18 * the documentation and/or other materials provided with the 19 * distribution. 20 * 21 * 3. All advertising materials mentioning features or use of this 22 * software must display the following acknowledgment: 23 * "This product includes software developed by the OpenSSL Project 24 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" 25 * 26 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 27 * endorse or promote products derived from this software without 28 * prior written permission. For written permission, please contact 29 * openssl-core (at) OpenSSL.org. 30 * 31 * 5. Products derived from this software may not be called "OpenSSL" 32 * nor may "OpenSSL" appear in their names without prior written 33 * permission of the OpenSSL Project. 34 * 35 * 6. Redistributions of any form whatsoever must retain the following 36 * acknowledgment: 37 * "This product includes software developed by the OpenSSL Project 38 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" 39 * 40 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 41 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 43 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 44 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 45 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 46 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 47 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 49 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 50 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 51 * OF THE POSSIBILITY OF SUCH DAMAGE. 52 * ==================================================================== 53 * 54 * This product includes cryptographic software written by Eric Young 55 * (eay (at) cryptsoft.com). This product includes software written by Tim 56 * Hudson (tjh (at) cryptsoft.com). 57 * 58 */ 59 /* Copyright (C) 1995-1998 Eric Young (eay (at) cryptsoft.com) 60 * All rights reserved. 61 * 62 * This package is an SSL implementation written 63 * by Eric Young (eay (at) cryptsoft.com). 64 * The implementation was written so as to conform with Netscapes SSL. 65 * 66 * This library is free for commercial and non-commercial use as long as 67 * the following conditions are aheared to. The following conditions 68 * apply to all code found in this distribution, be it the RC4, RSA, 69 * lhash, DES, etc., code; not just the SSL code. The SSL documentation 70 * included with this distribution is covered by the same copyright terms 71 * except that the holder is Tim Hudson (tjh (at) cryptsoft.com). 72 * 73 * Copyright remains Eric Young's, and as such any Copyright notices in 74 * the code are not to be removed. 75 * If this package is used in a product, Eric Young should be given attribution 76 * as the author of the parts of the library used. 77 * This can be in the form of a textual message at program startup or 78 * in documentation (online or textual) provided with the package. 79 * 80 * Redistribution and use in source and binary forms, with or without 81 * modification, are permitted provided that the following conditions 82 * are met: 83 * 1. Redistributions of source code must retain the copyright 84 * notice, this list of conditions and the following disclaimer. 85 * 2. Redistributions in binary form must reproduce the above copyright 86 * notice, this list of conditions and the following disclaimer in the 87 * documentation and/or other materials provided with the distribution. 88 * 3. All advertising materials mentioning features or use of this software 89 * must display the following acknowledgement: 90 * "This product includes cryptographic software written by 91 * Eric Young (eay (at) cryptsoft.com)" 92 * The word 'cryptographic' can be left out if the rouines from the library 93 * being used are not cryptographic related :-). 94 * 4. If you include any Windows specific code (or a derivative thereof) from 95 * the apps directory (application code) you must include an acknowledgement: 96 * "This product includes software written by Tim Hudson (tjh (at) cryptsoft.com)" 97 * 98 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 99 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 100 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 101 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 102 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 103 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 104 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 105 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 106 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 107 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 108 * SUCH DAMAGE. 109 * 110 * The licence and distribution terms for any publically available version or 111 * derivative of this code cannot be changed. i.e. this code cannot simply be 112 * copied and put under another distribution licence 113 * [including the GNU Public Licence.] 114 */ 115 116 #include <stdio.h> 117 #include "ssl_locl.h" 118 #include <openssl/buffer.h> 119 #include <openssl/rand.h> 120 #include <openssl/objects.h> 121 #include <openssl/evp.h> 122 #include <openssl/x509.h> 123 #include <openssl/md5.h> 124 #include <openssl/bn.h> 125 #ifndef OPENSSL_NO_DH 126 #include <openssl/dh.h> 127 #endif 128 129 static const SSL_METHOD *dtls1_get_server_method(int ver); 130 static int dtls1_send_hello_verify_request(SSL *s); 131 132 static const SSL_METHOD *dtls1_get_server_method(int ver) 133 { 134 if (ver == DTLS1_VERSION) 135 return(DTLSv1_server_method()); 136 else 137 return(NULL); 138 } 139 140 IMPLEMENT_dtls1_meth_func(DTLSv1_server_method, 141 dtls1_accept, 142 ssl_undefined_function, 143 dtls1_get_server_method) 144 145 int dtls1_accept(SSL *s) 146 { 147 BUF_MEM *buf; 148 unsigned long Time=(unsigned long)time(NULL); 149 void (*cb)(const SSL *ssl,int type,int val)=NULL; 150 unsigned long alg_k; 151 int ret= -1; 152 int new_state,state,skip=0; 153 154 RAND_add(&Time,sizeof(Time),0); 155 ERR_clear_error(); 156 clear_sys_error(); 157 158 if (s->info_callback != NULL) 159 cb=s->info_callback; 160 else if (s->ctx->info_callback != NULL) 161 cb=s->ctx->info_callback; 162 163 /* init things to blank */ 164 s->in_handshake++; 165 if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s); 166 167 if (s->cert == NULL) 168 { 169 SSLerr(SSL_F_DTLS1_ACCEPT,SSL_R_NO_CERTIFICATE_SET); 170 return(-1); 171 } 172 173 for (;;) 174 { 175 state=s->state; 176 177 switch (s->state) 178 { 179 case SSL_ST_RENEGOTIATE: 180 s->new_session=1; 181 /* s->state=SSL_ST_ACCEPT; */ 182 183 case SSL_ST_BEFORE: 184 case SSL_ST_ACCEPT: 185 case SSL_ST_BEFORE|SSL_ST_ACCEPT: 186 case SSL_ST_OK|SSL_ST_ACCEPT: 187 188 s->server=1; 189 if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1); 190 191 if ((s->version & 0xff00) != (DTLS1_VERSION & 0xff00)) 192 { 193 SSLerr(SSL_F_DTLS1_ACCEPT, ERR_R_INTERNAL_ERROR); 194 return -1; 195 } 196 s->type=SSL_ST_ACCEPT; 197 198 if (s->init_buf == NULL) 199 { 200 if ((buf=BUF_MEM_new()) == NULL) 201 { 202 ret= -1; 203 goto end; 204 } 205 if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH)) 206 { 207 ret= -1; 208 goto end; 209 } 210 s->init_buf=buf; 211 } 212 213 if (!ssl3_setup_buffers(s)) 214 { 215 ret= -1; 216 goto end; 217 } 218 219 s->init_num=0; 220 221 if (s->state != SSL_ST_RENEGOTIATE) 222 { 223 /* Ok, we now need to push on a buffering BIO so that 224 * the output is sent in a way that TCP likes :-) 225 */ 226 if (!ssl_init_wbio_buffer(s,1)) { ret= -1; goto end; } 227 228 ssl3_init_finished_mac(s); 229 s->state=SSL3_ST_SR_CLNT_HELLO_A; 230 s->ctx->stats.sess_accept++; 231 } 232 else 233 { 234 /* s->state == SSL_ST_RENEGOTIATE, 235 * we will just send a HelloRequest */ 236 s->ctx->stats.sess_accept_renegotiate++; 237 s->state=SSL3_ST_SW_HELLO_REQ_A; 238 } 239 240 break; 241 242 case SSL3_ST_SW_HELLO_REQ_A: 243 case SSL3_ST_SW_HELLO_REQ_B: 244 245 s->shutdown=0; 246 dtls1_start_timer(s); 247 ret=dtls1_send_hello_request(s); 248 if (ret <= 0) goto end; 249 s->s3->tmp.next_state=SSL3_ST_SW_HELLO_REQ_C; 250 s->state=SSL3_ST_SW_FLUSH; 251 s->init_num=0; 252 253 ssl3_init_finished_mac(s); 254 break; 255 256 case SSL3_ST_SW_HELLO_REQ_C: 257 s->state=SSL_ST_OK; 258 break; 259 260 case SSL3_ST_SR_CLNT_HELLO_A: 261 case SSL3_ST_SR_CLNT_HELLO_B: 262 case SSL3_ST_SR_CLNT_HELLO_C: 263 264 s->shutdown=0; 265 ret=ssl3_get_client_hello(s); 266 if (ret <= 0) goto end; 267 dtls1_stop_timer(s); 268 269 if (ret == 1 && (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE)) 270 s->state = DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A; 271 else 272 s->state = SSL3_ST_SW_SRVR_HELLO_A; 273 274 s->init_num=0; 275 276 /* If we're just listening, stop here */ 277 if (s->d1->listen && s->state == SSL3_ST_SW_SRVR_HELLO_A) 278 { 279 ret = 2; 280 s->d1->listen = 0; 281 goto end; 282 } 283 284 break; 285 286 case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A: 287 case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B: 288 289 dtls1_start_timer(s); 290 ret = dtls1_send_hello_verify_request(s); 291 if ( ret <= 0) goto end; 292 s->state=SSL3_ST_SW_FLUSH; 293 s->s3->tmp.next_state=SSL3_ST_SR_CLNT_HELLO_A; 294 295 /* HelloVerifyRequest resets Finished MAC */ 296 if (s->version != DTLS1_BAD_VER) 297 ssl3_init_finished_mac(s); 298 break; 299 300 case SSL3_ST_SW_SRVR_HELLO_A: 301 case SSL3_ST_SW_SRVR_HELLO_B: 302 s->new_session = 2; 303 dtls1_start_timer(s); 304 ret=dtls1_send_server_hello(s); 305 if (ret <= 0) goto end; 306 307 #ifndef OPENSSL_NO_TLSEXT 308 if (s->hit) 309 { 310 if (s->tlsext_ticket_expected) 311 s->state=SSL3_ST_SW_SESSION_TICKET_A; 312 else 313 s->state=SSL3_ST_SW_CHANGE_A; 314 } 315 #else 316 if (s->hit) 317 s->state=SSL3_ST_SW_CHANGE_A; 318 #endif 319 else 320 s->state=SSL3_ST_SW_CERT_A; 321 s->init_num=0; 322 break; 323 324 case SSL3_ST_SW_CERT_A: 325 case SSL3_ST_SW_CERT_B: 326 /* Check if it is anon DH or normal PSK */ 327 if (!(s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL) 328 && !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK)) 329 { 330 dtls1_start_timer(s); 331 ret=dtls1_send_server_certificate(s); 332 if (ret <= 0) goto end; 333 #ifndef OPENSSL_NO_TLSEXT 334 if (s->tlsext_status_expected) 335 s->state=SSL3_ST_SW_CERT_STATUS_A; 336 else 337 s->state=SSL3_ST_SW_KEY_EXCH_A; 338 } 339 else 340 { 341 skip = 1; 342 s->state=SSL3_ST_SW_KEY_EXCH_A; 343 } 344 #else 345 } 346 else 347 skip=1; 348 349 s->state=SSL3_ST_SW_KEY_EXCH_A; 350 #endif 351 s->init_num=0; 352 break; 353 354 case SSL3_ST_SW_KEY_EXCH_A: 355 case SSL3_ST_SW_KEY_EXCH_B: 356 alg_k = s->s3->tmp.new_cipher->algorithm_mkey; 357 358 /* clear this, it may get reset by 359 * send_server_key_exchange */ 360 if ((s->options & SSL_OP_EPHEMERAL_RSA) 361 #ifndef OPENSSL_NO_KRB5 362 && !(alg_k & SSL_kKRB5) 363 #endif /* OPENSSL_NO_KRB5 */ 364 ) 365 /* option SSL_OP_EPHEMERAL_RSA sends temporary RSA key 366 * even when forbidden by protocol specs 367 * (handshake may fail as clients are not required to 368 * be able to handle this) */ 369 s->s3->tmp.use_rsa_tmp=1; 370 else 371 s->s3->tmp.use_rsa_tmp=0; 372 373 /* only send if a DH key exchange or 374 * RSA but we have a sign only certificate */ 375 if (s->s3->tmp.use_rsa_tmp 376 /* PSK: send ServerKeyExchange if PSK identity 377 * hint if provided */ 378 #ifndef OPENSSL_NO_PSK 379 || ((alg_k & SSL_kPSK) && s->ctx->psk_identity_hint) 380 #endif 381 || (alg_k & (SSL_kEDH|SSL_kDHr|SSL_kDHd)) 382 || (alg_k & SSL_kEECDH) 383 || ((alg_k & SSL_kRSA) 384 && (s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey == NULL 385 || (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) 386 && EVP_PKEY_size(s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey)*8 > SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher) 387 ) 388 ) 389 ) 390 ) 391 { 392 dtls1_start_timer(s); 393 ret=dtls1_send_server_key_exchange(s); 394 if (ret <= 0) goto end; 395 } 396 else 397 skip=1; 398 399 s->state=SSL3_ST_SW_CERT_REQ_A; 400 s->init_num=0; 401 break; 402 403 case SSL3_ST_SW_CERT_REQ_A: 404 case SSL3_ST_SW_CERT_REQ_B: 405 if (/* don't request cert unless asked for it: */ 406 !(s->verify_mode & SSL_VERIFY_PEER) || 407 /* if SSL_VERIFY_CLIENT_ONCE is set, 408 * don't request cert during re-negotiation: */ 409 ((s->session->peer != NULL) && 410 (s->verify_mode & SSL_VERIFY_CLIENT_ONCE)) || 411 /* never request cert in anonymous ciphersuites 412 * (see section "Certificate request" in SSL 3 drafts 413 * and in RFC 2246): */ 414 ((s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL) && 415 /* ... except when the application insists on verification 416 * (against the specs, but s3_clnt.c accepts this for SSL 3) */ 417 !(s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) || 418 /* never request cert in Kerberos ciphersuites */ 419 (s->s3->tmp.new_cipher->algorithm_auth & SSL_aKRB5) 420 /* With normal PSK Certificates and 421 * Certificate Requests are omitted */ 422 || (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK)) 423 { 424 /* no cert request */ 425 skip=1; 426 s->s3->tmp.cert_request=0; 427 s->state=SSL3_ST_SW_SRVR_DONE_A; 428 } 429 else 430 { 431 s->s3->tmp.cert_request=1; 432 dtls1_start_timer(s); 433 ret=dtls1_send_certificate_request(s); 434 if (ret <= 0) goto end; 435 #ifndef NETSCAPE_HANG_BUG 436 s->state=SSL3_ST_SW_SRVR_DONE_A; 437 #else 438 s->state=SSL3_ST_SW_FLUSH; 439 s->s3->tmp.next_state=SSL3_ST_SR_CERT_A; 440 #endif 441 s->init_num=0; 442 } 443 break; 444 445 case SSL3_ST_SW_SRVR_DONE_A: 446 case SSL3_ST_SW_SRVR_DONE_B: 447 dtls1_start_timer(s); 448 ret=dtls1_send_server_done(s); 449 if (ret <= 0) goto end; 450 s->s3->tmp.next_state=SSL3_ST_SR_CERT_A; 451 s->state=SSL3_ST_SW_FLUSH; 452 s->init_num=0; 453 break; 454 455 case SSL3_ST_SW_FLUSH: 456 s->rwstate=SSL_WRITING; 457 if (BIO_flush(s->wbio) <= 0) 458 { 459 ret= -1; 460 goto end; 461 } 462 s->rwstate=SSL_NOTHING; 463 s->state=s->s3->tmp.next_state; 464 break; 465 466 case SSL3_ST_SR_CERT_A: 467 case SSL3_ST_SR_CERT_B: 468 /* Check for second client hello (MS SGC) */ 469 ret = ssl3_check_client_hello(s); 470 if (ret <= 0) 471 goto end; 472 dtls1_stop_timer(s); 473 if (ret == 2) 474 s->state = SSL3_ST_SR_CLNT_HELLO_C; 475 else { 476 /* could be sent for a DH cert, even if we 477 * have not asked for it :-) */ 478 ret=ssl3_get_client_certificate(s); 479 if (ret <= 0) goto end; 480 dtls1_stop_timer(s); 481 s->init_num=0; 482 s->state=SSL3_ST_SR_KEY_EXCH_A; 483 } 484 break; 485 486 case SSL3_ST_SR_KEY_EXCH_A: 487 case SSL3_ST_SR_KEY_EXCH_B: 488 ret=ssl3_get_client_key_exchange(s); 489 if (ret <= 0) goto end; 490 dtls1_stop_timer(s); 491 s->state=SSL3_ST_SR_CERT_VRFY_A; 492 s->init_num=0; 493 494 if (ret == 2) 495 { 496 /* For the ECDH ciphersuites when 497 * the client sends its ECDH pub key in 498 * a certificate, the CertificateVerify 499 * message is not sent. 500 */ 501 s->state=SSL3_ST_SR_FINISHED_A; 502 s->init_num = 0; 503 } 504 else 505 { 506 s->state=SSL3_ST_SR_CERT_VRFY_A; 507 s->init_num=0; 508 509 /* We need to get hashes here so if there is 510 * a client cert, it can be verified */ 511 s->method->ssl3_enc->cert_verify_mac(s, 512 NID_md5, 513 &(s->s3->tmp.cert_verify_md[0])); 514 s->method->ssl3_enc->cert_verify_mac(s, 515 NID_sha1, 516 &(s->s3->tmp.cert_verify_md[MD5_DIGEST_LENGTH])); 517 } 518 break; 519 520 case SSL3_ST_SR_CERT_VRFY_A: 521 case SSL3_ST_SR_CERT_VRFY_B: 522 523 s->d1->change_cipher_spec_ok = 1; 524 /* we should decide if we expected this one */ 525 ret=ssl3_get_cert_verify(s); 526 if (ret <= 0) goto end; 527 dtls1_stop_timer(s); 528 529 s->state=SSL3_ST_SR_FINISHED_A; 530 s->init_num=0; 531 break; 532 533 case SSL3_ST_SR_FINISHED_A: 534 case SSL3_ST_SR_FINISHED_B: 535 s->d1->change_cipher_spec_ok = 1; 536 ret=ssl3_get_finished(s,SSL3_ST_SR_FINISHED_A, 537 SSL3_ST_SR_FINISHED_B); 538 if (ret <= 0) goto end; 539 dtls1_stop_timer(s); 540 if (s->hit) 541 s->state=SSL_ST_OK; 542 #ifndef OPENSSL_NO_TLSEXT 543 else if (s->tlsext_ticket_expected) 544 s->state=SSL3_ST_SW_SESSION_TICKET_A; 545 #endif 546 else 547 s->state=SSL3_ST_SW_CHANGE_A; 548 s->init_num=0; 549 break; 550 551 #ifndef OPENSSL_NO_TLSEXT 552 case SSL3_ST_SW_SESSION_TICKET_A: 553 case SSL3_ST_SW_SESSION_TICKET_B: 554 ret=dtls1_send_newsession_ticket(s); 555 if (ret <= 0) goto end; 556 s->state=SSL3_ST_SW_CHANGE_A; 557 s->init_num=0; 558 break; 559 560 case SSL3_ST_SW_CERT_STATUS_A: 561 case SSL3_ST_SW_CERT_STATUS_B: 562 ret=ssl3_send_cert_status(s); 563 if (ret <= 0) goto end; 564 s->state=SSL3_ST_SW_KEY_EXCH_A; 565 s->init_num=0; 566 break; 567 568 #endif 569 570 case SSL3_ST_SW_CHANGE_A: 571 case SSL3_ST_SW_CHANGE_B: 572 573 s->session->cipher=s->s3->tmp.new_cipher; 574 if (!s->method->ssl3_enc->setup_key_block(s)) 575 { ret= -1; goto end; } 576 577 ret=dtls1_send_change_cipher_spec(s, 578 SSL3_ST_SW_CHANGE_A,SSL3_ST_SW_CHANGE_B); 579 580 if (ret <= 0) goto end; 581 s->state=SSL3_ST_SW_FINISHED_A; 582 s->init_num=0; 583 584 if (!s->method->ssl3_enc->change_cipher_state(s, 585 SSL3_CHANGE_CIPHER_SERVER_WRITE)) 586 { 587 ret= -1; 588 goto end; 589 } 590 591 dtls1_reset_seq_numbers(s, SSL3_CC_WRITE); 592 break; 593 594 case SSL3_ST_SW_FINISHED_A: 595 case SSL3_ST_SW_FINISHED_B: 596 ret=dtls1_send_finished(s, 597 SSL3_ST_SW_FINISHED_A,SSL3_ST_SW_FINISHED_B, 598 s->method->ssl3_enc->server_finished_label, 599 s->method->ssl3_enc->server_finished_label_len); 600 if (ret <= 0) goto end; 601 s->state=SSL3_ST_SW_FLUSH; 602 if (s->hit) 603 s->s3->tmp.next_state=SSL3_ST_SR_FINISHED_A; 604 else 605 s->s3->tmp.next_state=SSL_ST_OK; 606 s->init_num=0; 607 break; 608 609 case SSL_ST_OK: 610 /* clean a few things up */ 611 ssl3_cleanup_key_block(s); 612 613 #if 0 614 BUF_MEM_free(s->init_buf); 615 s->init_buf=NULL; 616 #endif 617 618 /* remove buffering on output */ 619 ssl_free_wbio_buffer(s); 620 621 s->init_num=0; 622 623 if (s->new_session == 2) /* skipped if we just sent a HelloRequest */ 624 { 625 /* actually not necessarily a 'new' session unless 626 * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION is set */ 627 628 s->new_session=0; 629 630 ssl_update_cache(s,SSL_SESS_CACHE_SERVER); 631 632 s->ctx->stats.sess_accept_good++; 633 /* s->server=1; */ 634 s->handshake_func=dtls1_accept; 635 636 if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_DONE,1); 637 } 638 639 ret = 1; 640 641 /* done handshaking, next message is client hello */ 642 s->d1->handshake_read_seq = 0; 643 /* next message is server hello */ 644 s->d1->handshake_write_seq = 0; 645 s->d1->next_handshake_write_seq = 0; 646 goto end; 647 /* break; */ 648 649 default: 650 SSLerr(SSL_F_DTLS1_ACCEPT,SSL_R_UNKNOWN_STATE); 651 ret= -1; 652 goto end; 653 /* break; */ 654 } 655 656 if (!s->s3->tmp.reuse_message && !skip) 657 { 658 if (s->debug) 659 { 660 if ((ret=BIO_flush(s->wbio)) <= 0) 661 goto end; 662 } 663 664 665 if ((cb != NULL) && (s->state != state)) 666 { 667 new_state=s->state; 668 s->state=state; 669 cb(s,SSL_CB_ACCEPT_LOOP,1); 670 s->state=new_state; 671 } 672 } 673 skip=0; 674 } 675 end: 676 /* BIO_flush(s->wbio); */ 677 678 s->in_handshake--; 679 if (cb != NULL) 680 cb(s,SSL_CB_ACCEPT_EXIT,ret); 681 return(ret); 682 } 683 684 int dtls1_send_hello_request(SSL *s) 685 { 686 unsigned char *p; 687 688 if (s->state == SSL3_ST_SW_HELLO_REQ_A) 689 { 690 p=(unsigned char *)s->init_buf->data; 691 p = dtls1_set_message_header(s, p, SSL3_MT_HELLO_REQUEST, 0, 0, 0); 692 693 s->state=SSL3_ST_SW_HELLO_REQ_B; 694 /* number of bytes to write */ 695 s->init_num=DTLS1_HM_HEADER_LENGTH; 696 s->init_off=0; 697 698 /* no need to buffer this message, since there are no retransmit 699 * requests for it */ 700 } 701 702 /* SSL3_ST_SW_HELLO_REQ_B */ 703 return(dtls1_do_write(s,SSL3_RT_HANDSHAKE)); 704 } 705 706 int dtls1_send_hello_verify_request(SSL *s) 707 { 708 unsigned int msg_len; 709 unsigned char *msg, *buf, *p; 710 711 if (s->state == DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A) 712 { 713 buf = (unsigned char *)s->init_buf->data; 714 715 msg = p = &(buf[DTLS1_HM_HEADER_LENGTH]); 716 *(p++) = s->version >> 8; 717 *(p++) = s->version & 0xFF; 718 719 if (s->ctx->app_gen_cookie_cb == NULL || 720 s->ctx->app_gen_cookie_cb(s, s->d1->cookie, 721 &(s->d1->cookie_len)) == 0) 722 { 723 SSLerr(SSL_F_DTLS1_SEND_HELLO_VERIFY_REQUEST,ERR_R_INTERNAL_ERROR); 724 return 0; 725 } 726 727 *(p++) = (unsigned char) s->d1->cookie_len; 728 memcpy(p, s->d1->cookie, s->d1->cookie_len); 729 p += s->d1->cookie_len; 730 msg_len = p - msg; 731 732 dtls1_set_message_header(s, buf, 733 DTLS1_MT_HELLO_VERIFY_REQUEST, msg_len, 0, msg_len); 734 735 s->state=DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B; 736 /* number of bytes to write */ 737 s->init_num=p-buf; 738 s->init_off=0; 739 740 /* buffer the message to handle re-xmits */ 741 dtls1_buffer_message(s, 0); 742 } 743 744 /* s->state = DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B */ 745 return(dtls1_do_write(s,SSL3_RT_HANDSHAKE)); 746 } 747 748 int dtls1_send_server_hello(SSL *s) 749 { 750 unsigned char *buf; 751 unsigned char *p,*d; 752 int i; 753 unsigned int sl; 754 unsigned long l,Time; 755 756 if (s->state == SSL3_ST_SW_SRVR_HELLO_A) 757 { 758 buf=(unsigned char *)s->init_buf->data; 759 p=s->s3->server_random; 760 Time=(unsigned long)time(NULL); /* Time */ 761 l2n(Time,p); 762 RAND_pseudo_bytes(p,SSL3_RANDOM_SIZE-sizeof(Time)); 763 /* Do the message type and length last */ 764 d=p= &(buf[DTLS1_HM_HEADER_LENGTH]); 765 766 *(p++)=s->version>>8; 767 *(p++)=s->version&0xff; 768 769 /* Random stuff */ 770 memcpy(p,s->s3->server_random,SSL3_RANDOM_SIZE); 771 p+=SSL3_RANDOM_SIZE; 772 773 /* now in theory we have 3 options to sending back the 774 * session id. If it is a re-use, we send back the 775 * old session-id, if it is a new session, we send 776 * back the new session-id or we send back a 0 length 777 * session-id if we want it to be single use. 778 * Currently I will not implement the '0' length session-id 779 * 12-Jan-98 - I'll now support the '0' length stuff. 780 */ 781 if (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_SERVER)) 782 s->session->session_id_length=0; 783 784 sl=s->session->session_id_length; 785 if (sl > sizeof s->session->session_id) 786 { 787 SSLerr(SSL_F_DTLS1_SEND_SERVER_HELLO, ERR_R_INTERNAL_ERROR); 788 return -1; 789 } 790 *(p++)=sl; 791 memcpy(p,s->session->session_id,sl); 792 p+=sl; 793 794 /* put the cipher */ 795 if (s->s3->tmp.new_cipher == NULL) 796 return -1; 797 i=ssl3_put_cipher_by_char(s->s3->tmp.new_cipher,p); 798 p+=i; 799 800 /* put the compression method */ 801 #ifdef OPENSSL_NO_COMP 802 *(p++)=0; 803 #else 804 if (s->s3->tmp.new_compression == NULL) 805 *(p++)=0; 806 else 807 *(p++)=s->s3->tmp.new_compression->id; 808 #endif 809 810 #ifndef OPENSSL_NO_TLSEXT 811 if ((p = ssl_add_serverhello_tlsext(s, p, buf+SSL3_RT_MAX_PLAIN_LENGTH)) == NULL) 812 { 813 SSLerr(SSL_F_DTLS1_SEND_SERVER_HELLO,ERR_R_INTERNAL_ERROR); 814 return -1; 815 } 816 #endif 817 818 /* do the header */ 819 l=(p-d); 820 d=buf; 821 822 d = dtls1_set_message_header(s, d, SSL3_MT_SERVER_HELLO, l, 0, l); 823 824 s->state=SSL3_ST_SW_SRVR_HELLO_B; 825 /* number of bytes to write */ 826 s->init_num=p-buf; 827 s->init_off=0; 828 829 /* buffer the message to handle re-xmits */ 830 dtls1_buffer_message(s, 0); 831 } 832 833 /* SSL3_ST_SW_SRVR_HELLO_B */ 834 return(dtls1_do_write(s,SSL3_RT_HANDSHAKE)); 835 } 836 837 int dtls1_send_server_done(SSL *s) 838 { 839 unsigned char *p; 840 841 if (s->state == SSL3_ST_SW_SRVR_DONE_A) 842 { 843 p=(unsigned char *)s->init_buf->data; 844 845 /* do the header */ 846 p = dtls1_set_message_header(s, p, SSL3_MT_SERVER_DONE, 0, 0, 0); 847 848 s->state=SSL3_ST_SW_SRVR_DONE_B; 849 /* number of bytes to write */ 850 s->init_num=DTLS1_HM_HEADER_LENGTH; 851 s->init_off=0; 852 853 /* buffer the message to handle re-xmits */ 854 dtls1_buffer_message(s, 0); 855 } 856 857 /* SSL3_ST_SW_SRVR_DONE_B */ 858 return(dtls1_do_write(s,SSL3_RT_HANDSHAKE)); 859 } 860 861 int dtls1_send_server_key_exchange(SSL *s) 862 { 863 #ifndef OPENSSL_NO_RSA 864 unsigned char *q; 865 int j,num; 866 RSA *rsa; 867 unsigned char md_buf[MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH]; 868 unsigned int u; 869 #endif 870 #ifndef OPENSSL_NO_DH 871 DH *dh=NULL,*dhp; 872 #endif 873 #ifndef OPENSSL_NO_ECDH 874 EC_KEY *ecdh=NULL, *ecdhp; 875 unsigned char *encodedPoint = NULL; 876 int encodedlen = 0; 877 int curve_id = 0; 878 BN_CTX *bn_ctx = NULL; 879 #endif 880 EVP_PKEY *pkey; 881 unsigned char *p,*d; 882 int al,i; 883 unsigned long type; 884 int n; 885 CERT *cert; 886 BIGNUM *r[4]; 887 int nr[4],kn; 888 BUF_MEM *buf; 889 EVP_MD_CTX md_ctx; 890 891 EVP_MD_CTX_init(&md_ctx); 892 if (s->state == SSL3_ST_SW_KEY_EXCH_A) 893 { 894 type=s->s3->tmp.new_cipher->algorithm_mkey; 895 cert=s->cert; 896 897 buf=s->init_buf; 898 899 r[0]=r[1]=r[2]=r[3]=NULL; 900 n=0; 901 #ifndef OPENSSL_NO_RSA 902 if (type & SSL_kRSA) 903 { 904 rsa=cert->rsa_tmp; 905 if ((rsa == NULL) && (s->cert->rsa_tmp_cb != NULL)) 906 { 907 rsa=s->cert->rsa_tmp_cb(s, 908 SSL_C_IS_EXPORT(s->s3->tmp.new_cipher), 909 SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)); 910 if(rsa == NULL) 911 { 912 al=SSL_AD_HANDSHAKE_FAILURE; 913 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,SSL_R_ERROR_GENERATING_TMP_RSA_KEY); 914 goto f_err; 915 } 916 RSA_up_ref(rsa); 917 cert->rsa_tmp=rsa; 918 } 919 if (rsa == NULL) 920 { 921 al=SSL_AD_HANDSHAKE_FAILURE; 922 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,SSL_R_MISSING_TMP_RSA_KEY); 923 goto f_err; 924 } 925 r[0]=rsa->n; 926 r[1]=rsa->e; 927 s->s3->tmp.use_rsa_tmp=1; 928 } 929 else 930 #endif 931 #ifndef OPENSSL_NO_DH 932 if (type & SSL_kEDH) 933 { 934 dhp=cert->dh_tmp; 935 if ((dhp == NULL) && (s->cert->dh_tmp_cb != NULL)) 936 dhp=s->cert->dh_tmp_cb(s, 937 SSL_C_IS_EXPORT(s->s3->tmp.new_cipher), 938 SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)); 939 if (dhp == NULL) 940 { 941 al=SSL_AD_HANDSHAKE_FAILURE; 942 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,SSL_R_MISSING_TMP_DH_KEY); 943 goto f_err; 944 } 945 946 if (s->s3->tmp.dh != NULL) 947 { 948 DH_free(dh); 949 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR); 950 goto err; 951 } 952 953 if ((dh=DHparams_dup(dhp)) == NULL) 954 { 955 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,ERR_R_DH_LIB); 956 goto err; 957 } 958 959 s->s3->tmp.dh=dh; 960 if ((dhp->pub_key == NULL || 961 dhp->priv_key == NULL || 962 (s->options & SSL_OP_SINGLE_DH_USE))) 963 { 964 if(!DH_generate_key(dh)) 965 { 966 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE, 967 ERR_R_DH_LIB); 968 goto err; 969 } 970 } 971 else 972 { 973 dh->pub_key=BN_dup(dhp->pub_key); 974 dh->priv_key=BN_dup(dhp->priv_key); 975 if ((dh->pub_key == NULL) || 976 (dh->priv_key == NULL)) 977 { 978 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,ERR_R_DH_LIB); 979 goto err; 980 } 981 } 982 r[0]=dh->p; 983 r[1]=dh->g; 984 r[2]=dh->pub_key; 985 } 986 else 987 #endif 988 #ifndef OPENSSL_NO_ECDH 989 if (type & SSL_kEECDH) 990 { 991 const EC_GROUP *group; 992 993 ecdhp=cert->ecdh_tmp; 994 if ((ecdhp == NULL) && (s->cert->ecdh_tmp_cb != NULL)) 995 { 996 ecdhp=s->cert->ecdh_tmp_cb(s, 997 SSL_C_IS_EXPORT(s->s3->tmp.new_cipher), 998 SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)); 999 } 1000 if (ecdhp == NULL) 1001 { 1002 al=SSL_AD_HANDSHAKE_FAILURE; 1003 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,SSL_R_MISSING_TMP_ECDH_KEY); 1004 goto f_err; 1005 } 1006 1007 if (s->s3->tmp.ecdh != NULL) 1008 { 1009 EC_KEY_free(s->s3->tmp.ecdh); 1010 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR); 1011 goto err; 1012 } 1013 1014 /* Duplicate the ECDH structure. */ 1015 if (ecdhp == NULL) 1016 { 1017 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB); 1018 goto err; 1019 } 1020 if (!EC_KEY_up_ref(ecdhp)) 1021 { 1022 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB); 1023 goto err; 1024 } 1025 ecdh = ecdhp; 1026 1027 s->s3->tmp.ecdh=ecdh; 1028 if ((EC_KEY_get0_public_key(ecdh) == NULL) || 1029 (EC_KEY_get0_private_key(ecdh) == NULL) || 1030 (s->options & SSL_OP_SINGLE_ECDH_USE)) 1031 { 1032 if(!EC_KEY_generate_key(ecdh)) 1033 { 1034 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB); 1035 goto err; 1036 } 1037 } 1038 1039 if (((group = EC_KEY_get0_group(ecdh)) == NULL) || 1040 (EC_KEY_get0_public_key(ecdh) == NULL) || 1041 (EC_KEY_get0_private_key(ecdh) == NULL)) 1042 { 1043 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB); 1044 goto err; 1045 } 1046 1047 if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) && 1048 (EC_GROUP_get_degree(group) > 163)) 1049 { 1050 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,SSL_R_ECGROUP_TOO_LARGE_FOR_CIPHER); 1051 goto err; 1052 } 1053 1054 /* XXX: For now, we only support ephemeral ECDH 1055 * keys over named (not generic) curves. For 1056 * supported named curves, curve_id is non-zero. 1057 */ 1058 if ((curve_id = 1059 tls1_ec_nid2curve_id(EC_GROUP_get_curve_name(group))) 1060 == 0) 1061 { 1062 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,SSL_R_UNSUPPORTED_ELLIPTIC_CURVE); 1063 goto err; 1064 } 1065 1066 /* Encode the public key. 1067 * First check the size of encoding and 1068 * allocate memory accordingly. 1069 */ 1070 encodedlen = EC_POINT_point2oct(group, 1071 EC_KEY_get0_public_key(ecdh), 1072 POINT_CONVERSION_UNCOMPRESSED, 1073 NULL, 0, NULL); 1074 1075 encodedPoint = (unsigned char *) 1076 OPENSSL_malloc(encodedlen*sizeof(unsigned char)); 1077 bn_ctx = BN_CTX_new(); 1078 if ((encodedPoint == NULL) || (bn_ctx == NULL)) 1079 { 1080 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,ERR_R_MALLOC_FAILURE); 1081 goto err; 1082 } 1083 1084 1085 encodedlen = EC_POINT_point2oct(group, 1086 EC_KEY_get0_public_key(ecdh), 1087 POINT_CONVERSION_UNCOMPRESSED, 1088 encodedPoint, encodedlen, bn_ctx); 1089 1090 if (encodedlen == 0) 1091 { 1092 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB); 1093 goto err; 1094 } 1095 1096 BN_CTX_free(bn_ctx); bn_ctx=NULL; 1097 1098 /* XXX: For now, we only support named (not 1099 * generic) curves in ECDH ephemeral key exchanges. 1100 * In this situation, we need four additional bytes 1101 * to encode the entire ServerECDHParams 1102 * structure. 1103 */ 1104 n = 4 + encodedlen; 1105 1106 /* We'll generate the serverKeyExchange message 1107 * explicitly so we can set these to NULLs 1108 */ 1109 r[0]=NULL; 1110 r[1]=NULL; 1111 r[2]=NULL; 1112 r[3]=NULL; 1113 } 1114 else 1115 #endif /* !OPENSSL_NO_ECDH */ 1116 #ifndef OPENSSL_NO_PSK 1117 if (type & SSL_kPSK) 1118 { 1119 /* reserve size for record length and PSK identity hint*/ 1120 n+=2+strlen(s->ctx->psk_identity_hint); 1121 } 1122 else 1123 #endif /* !OPENSSL_NO_PSK */ 1124 { 1125 al=SSL_AD_HANDSHAKE_FAILURE; 1126 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE); 1127 goto f_err; 1128 } 1129 for (i=0; r[i] != NULL; i++) 1130 { 1131 nr[i]=BN_num_bytes(r[i]); 1132 n+=2+nr[i]; 1133 } 1134 1135 if (!(s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL) 1136 && !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK)) 1137 { 1138 if ((pkey=ssl_get_sign_pkey(s,s->s3->tmp.new_cipher)) 1139 == NULL) 1140 { 1141 al=SSL_AD_DECODE_ERROR; 1142 goto f_err; 1143 } 1144 kn=EVP_PKEY_size(pkey); 1145 } 1146 else 1147 { 1148 pkey=NULL; 1149 kn=0; 1150 } 1151 1152 if (!BUF_MEM_grow_clean(buf,n+DTLS1_HM_HEADER_LENGTH+kn)) 1153 { 1154 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,ERR_LIB_BUF); 1155 goto err; 1156 } 1157 d=(unsigned char *)s->init_buf->data; 1158 p= &(d[DTLS1_HM_HEADER_LENGTH]); 1159 1160 for (i=0; r[i] != NULL; i++) 1161 { 1162 s2n(nr[i],p); 1163 BN_bn2bin(r[i],p); 1164 p+=nr[i]; 1165 } 1166 1167 #ifndef OPENSSL_NO_ECDH 1168 if (type & SSL_kEECDH) 1169 { 1170 /* XXX: For now, we only support named (not generic) curves. 1171 * In this situation, the serverKeyExchange message has: 1172 * [1 byte CurveType], [2 byte CurveName] 1173 * [1 byte length of encoded point], followed by 1174 * the actual encoded point itself 1175 */ 1176 *p = NAMED_CURVE_TYPE; 1177 p += 1; 1178 *p = 0; 1179 p += 1; 1180 *p = curve_id; 1181 p += 1; 1182 *p = encodedlen; 1183 p += 1; 1184 memcpy((unsigned char*)p, 1185 (unsigned char *)encodedPoint, 1186 encodedlen); 1187 OPENSSL_free(encodedPoint); 1188 p += encodedlen; 1189 } 1190 #endif 1191 1192 #ifndef OPENSSL_NO_PSK 1193 if (type & SSL_kPSK) 1194 { 1195 /* copy PSK identity hint */ 1196 s2n(strlen(s->ctx->psk_identity_hint), p); 1197 strncpy((char *)p, s->ctx->psk_identity_hint, strlen(s->ctx->psk_identity_hint)); 1198 p+=strlen(s->ctx->psk_identity_hint); 1199 } 1200 #endif 1201 1202 /* not anonymous */ 1203 if (pkey != NULL) 1204 { 1205 /* n is the length of the params, they start at 1206 * &(d[DTLS1_HM_HEADER_LENGTH]) and p points to the space 1207 * at the end. */ 1208 #ifndef OPENSSL_NO_RSA 1209 if (pkey->type == EVP_PKEY_RSA) 1210 { 1211 q=md_buf; 1212 j=0; 1213 for (num=2; num > 0; num--) 1214 { 1215 EVP_DigestInit_ex(&md_ctx,(num == 2) 1216 ?s->ctx->md5:s->ctx->sha1, NULL); 1217 EVP_DigestUpdate(&md_ctx,&(s->s3->client_random[0]),SSL3_RANDOM_SIZE); 1218 EVP_DigestUpdate(&md_ctx,&(s->s3->server_random[0]),SSL3_RANDOM_SIZE); 1219 EVP_DigestUpdate(&md_ctx,&(d[DTLS1_HM_HEADER_LENGTH]),n); 1220 EVP_DigestFinal_ex(&md_ctx,q, 1221 (unsigned int *)&i); 1222 q+=i; 1223 j+=i; 1224 } 1225 if (RSA_sign(NID_md5_sha1, md_buf, j, 1226 &(p[2]), &u, pkey->pkey.rsa) <= 0) 1227 { 1228 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,ERR_LIB_RSA); 1229 goto err; 1230 } 1231 s2n(u,p); 1232 n+=u+2; 1233 } 1234 else 1235 #endif 1236 #if !defined(OPENSSL_NO_DSA) 1237 if (pkey->type == EVP_PKEY_DSA) 1238 { 1239 /* lets do DSS */ 1240 EVP_SignInit_ex(&md_ctx,EVP_dss1(), NULL); 1241 EVP_SignUpdate(&md_ctx,&(s->s3->client_random[0]),SSL3_RANDOM_SIZE); 1242 EVP_SignUpdate(&md_ctx,&(s->s3->server_random[0]),SSL3_RANDOM_SIZE); 1243 EVP_SignUpdate(&md_ctx,&(d[DTLS1_HM_HEADER_LENGTH]),n); 1244 if (!EVP_SignFinal(&md_ctx,&(p[2]), 1245 (unsigned int *)&i,pkey)) 1246 { 1247 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,ERR_LIB_DSA); 1248 goto err; 1249 } 1250 s2n(i,p); 1251 n+=i+2; 1252 } 1253 else 1254 #endif 1255 #if !defined(OPENSSL_NO_ECDSA) 1256 if (pkey->type == EVP_PKEY_EC) 1257 { 1258 /* let's do ECDSA */ 1259 EVP_SignInit_ex(&md_ctx,EVP_ecdsa(), NULL); 1260 EVP_SignUpdate(&md_ctx,&(s->s3->client_random[0]),SSL3_RANDOM_SIZE); 1261 EVP_SignUpdate(&md_ctx,&(s->s3->server_random[0]),SSL3_RANDOM_SIZE); 1262 EVP_SignUpdate(&md_ctx,&(d[4]),n); 1263 if (!EVP_SignFinal(&md_ctx,&(p[2]), 1264 (unsigned int *)&i,pkey)) 1265 { 1266 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,ERR_LIB_ECDSA); 1267 goto err; 1268 } 1269 s2n(i,p); 1270 n+=i+2; 1271 } 1272 else 1273 #endif 1274 { 1275 /* Is this error check actually needed? */ 1276 al=SSL_AD_HANDSHAKE_FAILURE; 1277 SSLerr(SSL_F_DTLS1_SEND_SERVER_KEY_EXCHANGE,SSL_R_UNKNOWN_PKEY_TYPE); 1278 goto f_err; 1279 } 1280 } 1281 1282 d = dtls1_set_message_header(s, d, 1283 SSL3_MT_SERVER_KEY_EXCHANGE, n, 0, n); 1284 1285 /* we should now have things packed up, so lets send 1286 * it off */ 1287 s->init_num=n+DTLS1_HM_HEADER_LENGTH; 1288 s->init_off=0; 1289 1290 /* buffer the message to handle re-xmits */ 1291 dtls1_buffer_message(s, 0); 1292 } 1293 1294 s->state = SSL3_ST_SW_KEY_EXCH_B; 1295 EVP_MD_CTX_cleanup(&md_ctx); 1296 return(dtls1_do_write(s,SSL3_RT_HANDSHAKE)); 1297 f_err: 1298 ssl3_send_alert(s,SSL3_AL_FATAL,al); 1299 err: 1300 #ifndef OPENSSL_NO_ECDH 1301 if (encodedPoint != NULL) OPENSSL_free(encodedPoint); 1302 BN_CTX_free(bn_ctx); 1303 #endif 1304 EVP_MD_CTX_cleanup(&md_ctx); 1305 return(-1); 1306 } 1307 1308 int dtls1_send_certificate_request(SSL *s) 1309 { 1310 unsigned char *p,*d; 1311 int i,j,nl,off,n; 1312 STACK_OF(X509_NAME) *sk=NULL; 1313 X509_NAME *name; 1314 BUF_MEM *buf; 1315 unsigned int msg_len; 1316 1317 if (s->state == SSL3_ST_SW_CERT_REQ_A) 1318 { 1319 buf=s->init_buf; 1320 1321 d=p=(unsigned char *)&(buf->data[DTLS1_HM_HEADER_LENGTH]); 1322 1323 /* get the list of acceptable cert types */ 1324 p++; 1325 n=ssl3_get_req_cert_type(s,p); 1326 d[0]=n; 1327 p+=n; 1328 n++; 1329 1330 off=n; 1331 p+=2; 1332 n+=2; 1333 1334 sk=SSL_get_client_CA_list(s); 1335 nl=0; 1336 if (sk != NULL) 1337 { 1338 for (i=0; i<sk_X509_NAME_num(sk); i++) 1339 { 1340 name=sk_X509_NAME_value(sk,i); 1341 j=i2d_X509_NAME(name,NULL); 1342 if (!BUF_MEM_grow_clean(buf,DTLS1_HM_HEADER_LENGTH+n+j+2)) 1343 { 1344 SSLerr(SSL_F_DTLS1_SEND_CERTIFICATE_REQUEST,ERR_R_BUF_LIB); 1345 goto err; 1346 } 1347 p=(unsigned char *)&(buf->data[DTLS1_HM_HEADER_LENGTH+n]); 1348 if (!(s->options & SSL_OP_NETSCAPE_CA_DN_BUG)) 1349 { 1350 s2n(j,p); 1351 i2d_X509_NAME(name,&p); 1352 n+=2+j; 1353 nl+=2+j; 1354 } 1355 else 1356 { 1357 d=p; 1358 i2d_X509_NAME(name,&p); 1359 j-=2; s2n(j,d); j+=2; 1360 n+=j; 1361 nl+=j; 1362 } 1363 } 1364 } 1365 /* else no CA names */ 1366 p=(unsigned char *)&(buf->data[DTLS1_HM_HEADER_LENGTH+off]); 1367 s2n(nl,p); 1368 1369 d=(unsigned char *)buf->data; 1370 *(d++)=SSL3_MT_CERTIFICATE_REQUEST; 1371 l2n3(n,d); 1372 s2n(s->d1->handshake_write_seq,d); 1373 s->d1->handshake_write_seq++; 1374 1375 /* we should now have things packed up, so lets send 1376 * it off */ 1377 1378 s->init_num=n+DTLS1_HM_HEADER_LENGTH; 1379 s->init_off=0; 1380 #ifdef NETSCAPE_HANG_BUG 1381 /* XXX: what to do about this? */ 1382 p=(unsigned char *)s->init_buf->data + s->init_num; 1383 1384 /* do the header */ 1385 *(p++)=SSL3_MT_SERVER_DONE; 1386 *(p++)=0; 1387 *(p++)=0; 1388 *(p++)=0; 1389 s->init_num += 4; 1390 #endif 1391 1392 /* XDTLS: set message header ? */ 1393 msg_len = s->init_num - DTLS1_HM_HEADER_LENGTH; 1394 dtls1_set_message_header(s, (void *)s->init_buf->data, 1395 SSL3_MT_CERTIFICATE_REQUEST, msg_len, 0, msg_len); 1396 1397 /* buffer the message to handle re-xmits */ 1398 dtls1_buffer_message(s, 0); 1399 1400 s->state = SSL3_ST_SW_CERT_REQ_B; 1401 } 1402 1403 /* SSL3_ST_SW_CERT_REQ_B */ 1404 return(dtls1_do_write(s,SSL3_RT_HANDSHAKE)); 1405 err: 1406 return(-1); 1407 } 1408 1409 int dtls1_send_server_certificate(SSL *s) 1410 { 1411 unsigned long l; 1412 X509 *x; 1413 1414 if (s->state == SSL3_ST_SW_CERT_A) 1415 { 1416 x=ssl_get_server_send_cert(s); 1417 if (x == NULL) 1418 { 1419 /* VRS: allow null cert if auth == KRB5 */ 1420 if ((s->s3->tmp.new_cipher->algorithm_mkey != SSL_kKRB5) || 1421 (s->s3->tmp.new_cipher->algorithm_auth != SSL_aKRB5)) 1422 { 1423 SSLerr(SSL_F_DTLS1_SEND_SERVER_CERTIFICATE,ERR_R_INTERNAL_ERROR); 1424 return(0); 1425 } 1426 } 1427 1428 l=dtls1_output_cert_chain(s,x); 1429 s->state=SSL3_ST_SW_CERT_B; 1430 s->init_num=(int)l; 1431 s->init_off=0; 1432 1433 /* buffer the message to handle re-xmits */ 1434 dtls1_buffer_message(s, 0); 1435 } 1436 1437 /* SSL3_ST_SW_CERT_B */ 1438 return(dtls1_do_write(s,SSL3_RT_HANDSHAKE)); 1439 } 1440 1441 #ifndef OPENSSL_NO_TLSEXT 1442 int dtls1_send_newsession_ticket(SSL *s) 1443 { 1444 if (s->state == SSL3_ST_SW_SESSION_TICKET_A) 1445 { 1446 unsigned char *p, *senc, *macstart; 1447 int len, slen; 1448 unsigned int hlen, msg_len; 1449 EVP_CIPHER_CTX ctx; 1450 HMAC_CTX hctx; 1451 SSL_CTX *tctx = s->initial_ctx; 1452 unsigned char iv[EVP_MAX_IV_LENGTH]; 1453 unsigned char key_name[16]; 1454 1455 /* get session encoding length */ 1456 slen = i2d_SSL_SESSION(s->session, NULL); 1457 /* Some length values are 16 bits, so forget it if session is 1458 * too long 1459 */ 1460 if (slen > 0xFF00) 1461 return -1; 1462 /* Grow buffer if need be: the length calculation is as 1463 * follows 12 (DTLS handshake message header) + 1464 * 4 (ticket lifetime hint) + 2 (ticket length) + 1465 * 16 (key name) + max_iv_len (iv length) + 1466 * session_length + max_enc_block_size (max encrypted session 1467 * length) + max_md_size (HMAC). 1468 */ 1469 if (!BUF_MEM_grow(s->init_buf, 1470 DTLS1_HM_HEADER_LENGTH + 22 + EVP_MAX_IV_LENGTH + 1471 EVP_MAX_BLOCK_LENGTH + EVP_MAX_MD_SIZE + slen)) 1472 return -1; 1473 senc = OPENSSL_malloc(slen); 1474 if (!senc) 1475 return -1; 1476 p = senc; 1477 i2d_SSL_SESSION(s->session, &p); 1478 1479 p=(unsigned char *)&(s->init_buf->data[DTLS1_HM_HEADER_LENGTH]); 1480 EVP_CIPHER_CTX_init(&ctx); 1481 HMAC_CTX_init(&hctx); 1482 /* Initialize HMAC and cipher contexts. If callback present 1483 * it does all the work otherwise use generated values 1484 * from parent ctx. 1485 */ 1486 if (tctx->tlsext_ticket_key_cb) 1487 { 1488 if (tctx->tlsext_ticket_key_cb(s, key_name, iv, &ctx, 1489 &hctx, 1) < 0) 1490 { 1491 OPENSSL_free(senc); 1492 return -1; 1493 } 1494 } 1495 else 1496 { 1497 RAND_pseudo_bytes(iv, 16); 1498 EVP_EncryptInit_ex(&ctx, EVP_aes_128_cbc(), NULL, 1499 tctx->tlsext_tick_aes_key, iv); 1500 HMAC_Init_ex(&hctx, tctx->tlsext_tick_hmac_key, 16, 1501 tlsext_tick_md(), NULL); 1502 memcpy(key_name, tctx->tlsext_tick_key_name, 16); 1503 } 1504 l2n(s->session->tlsext_tick_lifetime_hint, p); 1505 /* Skip ticket length for now */ 1506 p += 2; 1507 /* Output key name */ 1508 macstart = p; 1509 memcpy(p, key_name, 16); 1510 p += 16; 1511 /* output IV */ 1512 memcpy(p, iv, EVP_CIPHER_CTX_iv_length(&ctx)); 1513 p += EVP_CIPHER_CTX_iv_length(&ctx); 1514 /* Encrypt session data */ 1515 EVP_EncryptUpdate(&ctx, p, &len, senc, slen); 1516 p += len; 1517 EVP_EncryptFinal(&ctx, p, &len); 1518 p += len; 1519 EVP_CIPHER_CTX_cleanup(&ctx); 1520 1521 HMAC_Update(&hctx, macstart, p - macstart); 1522 HMAC_Final(&hctx, p, &hlen); 1523 HMAC_CTX_cleanup(&hctx); 1524 1525 p += hlen; 1526 /* Now write out lengths: p points to end of data written */ 1527 /* Total length */ 1528 len = p - (unsigned char *)(s->init_buf->data); 1529 /* Ticket length */ 1530 p=(unsigned char *)&(s->init_buf->data[DTLS1_HM_HEADER_LENGTH]) + 4; 1531 s2n(len - DTLS1_HM_HEADER_LENGTH - 6, p); 1532 1533 /* number of bytes to write */ 1534 s->init_num= len; 1535 s->state=SSL3_ST_SW_SESSION_TICKET_B; 1536 s->init_off=0; 1537 OPENSSL_free(senc); 1538 1539 /* XDTLS: set message header ? */ 1540 msg_len = s->init_num - DTLS1_HM_HEADER_LENGTH; 1541 dtls1_set_message_header(s, (void *)s->init_buf->data, 1542 SSL3_MT_NEWSESSION_TICKET, msg_len, 0, msg_len); 1543 1544 /* buffer the message to handle re-xmits */ 1545 dtls1_buffer_message(s, 0); 1546 } 1547 1548 /* SSL3_ST_SW_SESSION_TICKET_B */ 1549 return(dtls1_do_write(s,SSL3_RT_HANDSHAKE)); 1550 } 1551 #endif 1552
