Branch data Line data Source code
1 : : /* ssl/s3_srvr.c -*- mode:C; c-file-style: "eay" -*- */
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 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
113 : : *
114 : : * Portions of the attached software ("Contribution") are developed by
115 : : * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
116 : : *
117 : : * The Contribution is licensed pursuant to the OpenSSL open source
118 : : * license provided above.
119 : : *
120 : : * ECC cipher suite support in OpenSSL originally written by
121 : : * Vipul Gupta and Sumit Gupta of Sun Microsystems Laboratories.
122 : : *
123 : : */
124 : : /* ====================================================================
125 : : * Copyright 2005 Nokia. All rights reserved.
126 : : *
127 : : * The portions of the attached software ("Contribution") is developed by
128 : : * Nokia Corporation and is licensed pursuant to the OpenSSL open source
129 : : * license.
130 : : *
131 : : * The Contribution, originally written by Mika Kousa and Pasi Eronen of
132 : : * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
133 : : * support (see RFC 4279) to OpenSSL.
134 : : *
135 : : * No patent licenses or other rights except those expressly stated in
136 : : * the OpenSSL open source license shall be deemed granted or received
137 : : * expressly, by implication, estoppel, or otherwise.
138 : : *
139 : : * No assurances are provided by Nokia that the Contribution does not
140 : : * infringe the patent or other intellectual property rights of any third
141 : : * party or that the license provides you with all the necessary rights
142 : : * to make use of the Contribution.
143 : : *
144 : : * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
145 : : * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
146 : : * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
147 : : * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
148 : : * OTHERWISE.
149 : : */
150 : :
151 : : #define REUSE_CIPHER_BUG
152 : : #define NETSCAPE_HANG_BUG
153 : :
154 : : #include <stdio.h>
155 : : #include "ssl_locl.h"
156 : : #include "kssl_lcl.h"
157 : : #include <openssl/buffer.h>
158 : : #include <openssl/rand.h>
159 : : #include <openssl/objects.h>
160 : : #include <openssl/evp.h>
161 : : #include <openssl/hmac.h>
162 : : #include <openssl/x509.h>
163 : : #ifndef OPENSSL_NO_DH
164 : : #include <openssl/dh.h>
165 : : #endif
166 : : #include <openssl/bn.h>
167 : : #ifndef OPENSSL_NO_KRB5
168 : : #include <openssl/krb5_asn.h>
169 : : #endif
170 : : #include <openssl/md5.h>
171 : :
172 : : static const SSL_METHOD *ssl3_get_server_method(int ver);
173 : :
174 : 0 : static const SSL_METHOD *ssl3_get_server_method(int ver)
175 : : {
176 [ # # ]: 0 : if (ver == SSL3_VERSION)
177 : 0 : return(SSLv3_server_method());
178 : : else
179 : : return(NULL);
180 : : }
181 : :
182 : : #ifndef OPENSSL_NO_SRP
183 : 1080 : static int ssl_check_srp_ext_ClientHello(SSL *s, int *al)
184 : : {
185 : 1080 : int ret = SSL_ERROR_NONE;
186 : :
187 : 1080 : *al = SSL_AD_UNRECOGNIZED_NAME;
188 : :
189 [ + + ][ + - ]: 1080 : if ((s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) &&
190 : 22 : (s->srp_ctx.TLS_ext_srp_username_callback != NULL))
191 : : {
192 [ - + ]: 22 : if(s->srp_ctx.login == NULL)
193 : : {
194 : : /* RFC 5054 says SHOULD reject,
195 : : we do so if There is no srp login name */
196 : 0 : ret = SSL3_AL_FATAL;
197 : 0 : *al = SSL_AD_UNKNOWN_PSK_IDENTITY;
198 : : }
199 : : else
200 : : {
201 : 22 : ret = SSL_srp_server_param_with_username(s,al);
202 : : }
203 : : }
204 : 1080 : return ret;
205 : : }
206 : : #endif
207 : :
208 : 0 : IMPLEMENT_ssl3_meth_func(SSLv3_server_method,
209 : : ssl3_accept,
210 : : ssl_undefined_function,
211 : : ssl3_get_server_method)
212 : :
213 : 33851 : int ssl3_accept(SSL *s)
214 : : {
215 : : BUF_MEM *buf;
216 : 33851 : unsigned long alg_k,Time=(unsigned long)time(NULL);
217 : 33851 : void (*cb)(const SSL *ssl,int type,int val)=NULL;
218 : 33851 : int ret= -1;
219 : 33851 : int new_state,state,skip=0;
220 : :
221 : 33851 : RAND_add(&Time,sizeof(Time),0);
222 : 33851 : ERR_clear_error();
223 : 33851 : clear_sys_error();
224 : :
225 [ + - ]: 33851 : if (s->info_callback != NULL)
226 : : cb=s->info_callback;
227 [ - + ]: 33851 : else if (s->ctx->info_callback != NULL)
228 : 0 : cb=s->ctx->info_callback;
229 : :
230 : : /* init things to blank */
231 : 33851 : s->in_handshake++;
232 [ + - ][ + + ]: 33851 : if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s);
233 : :
234 [ - + ]: 33851 : if (s->cert == NULL)
235 : : {
236 : 0 : SSLerr(SSL_F_SSL3_ACCEPT,SSL_R_NO_CERTIFICATE_SET);
237 : 0 : return(-1);
238 : : }
239 : :
240 : : #ifndef OPENSSL_NO_HEARTBEATS
241 : : /* If we're awaiting a HeartbeatResponse, pretend we
242 : : * already got and don't await it anymore, because
243 : : * Heartbeats don't make sense during handshakes anyway.
244 : : */
245 [ - + ]: 33851 : if (s->tlsext_hb_pending)
246 : : {
247 : 0 : s->tlsext_hb_pending = 0;
248 : 47161 : s->tlsext_hb_seq++;
249 : : }
250 : : #endif
251 : :
252 : : for (;;)
253 : : {
254 : 50535 : state=s->state;
255 : :
256 [ - + - - : 50535 : switch (s->state)
+ - + + +
+ + + + +
+ + + + -
+ + + - ]
257 : : {
258 : : case SSL_ST_RENEGOTIATE:
259 : 0 : s->renegotiate=1;
260 : : /* s->state=SSL_ST_ACCEPT; */
261 : :
262 : : case SSL_ST_BEFORE:
263 : : case SSL_ST_ACCEPT:
264 : : case SSL_ST_BEFORE|SSL_ST_ACCEPT:
265 : : case SSL_ST_OK|SSL_ST_ACCEPT:
266 : :
267 : 880 : s->server=1;
268 [ - + ]: 880 : if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
269 : :
270 [ - + ]: 880 : if ((s->version>>8) != 3)
271 : : {
272 : 0 : SSLerr(SSL_F_SSL3_ACCEPT, ERR_R_INTERNAL_ERROR);
273 : 0 : return -1;
274 : : }
275 : :
276 [ - + ]: 880 : if (!ssl_security(s, SSL_SECOP_VERSION, 0,
277 : : s->version, NULL))
278 : : {
279 : 0 : SSLerr(SSL_F_SSL3_ACCEPT, SSL_R_VERSION_TOO_LOW);
280 : 0 : return -1;
281 : : }
282 : :
283 : 880 : s->type=SSL_ST_ACCEPT;
284 : :
285 [ + - ]: 880 : if (s->init_buf == NULL)
286 : : {
287 [ + - ]: 880 : if ((buf=BUF_MEM_new()) == NULL)
288 : : {
289 : : ret= -1;
290 : : goto end;
291 : : }
292 [ + - ]: 880 : if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH))
293 : : {
294 : : ret= -1;
295 : : goto end;
296 : : }
297 : 880 : s->init_buf=buf;
298 : : }
299 : :
300 [ + - ]: 880 : if (!ssl3_setup_buffers(s))
301 : : {
302 : : ret= -1;
303 : : goto end;
304 : : }
305 : :
306 : 880 : s->init_num=0;
307 : 880 : s->s3->flags &= ~SSL3_FLAGS_SGC_RESTART_DONE;
308 : 880 : s->s3->flags &= ~TLS1_FLAGS_SKIP_CERT_VERIFY;
309 : :
310 [ + - ]: 880 : if (s->state != SSL_ST_RENEGOTIATE)
311 : : {
312 : : /* Ok, we now need to push on a buffering BIO so that
313 : : * the output is sent in a way that TCP likes :-)
314 : : */
315 [ + - ]: 880 : if (!ssl_init_wbio_buffer(s,1)) { ret= -1; goto end; }
316 : :
317 : 880 : ssl3_init_finished_mac(s);
318 : 880 : s->state=SSL3_ST_SR_CLNT_HELLO_A;
319 : 880 : s->ctx->stats.sess_accept++;
320 : : }
321 [ # # ][ # # ]: 0 : else if (!s->s3->send_connection_binding &&
322 : 0 : !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION))
323 : : {
324 : : /* Server attempting to renegotiate with
325 : : * client that doesn't support secure
326 : : * renegotiation.
327 : : */
328 : 0 : SSLerr(SSL_F_SSL3_ACCEPT, SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
329 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_HANDSHAKE_FAILURE);
330 : 0 : ret = -1;
331 : 0 : goto end;
332 : : }
333 : : else
334 : : {
335 : : /* s->state == SSL_ST_RENEGOTIATE,
336 : : * we will just send a HelloRequest */
337 : 0 : s->ctx->stats.sess_accept_renegotiate++;
338 : 0 : s->state=SSL3_ST_SW_HELLO_REQ_A;
339 : : }
340 : : break;
341 : :
342 : : case SSL3_ST_SW_HELLO_REQ_A:
343 : : case SSL3_ST_SW_HELLO_REQ_B:
344 : :
345 : 0 : s->shutdown=0;
346 : 0 : ret=ssl3_send_hello_request(s);
347 [ # # ]: 0 : if (ret <= 0) goto end;
348 : 0 : s->s3->tmp.next_state=SSL3_ST_SW_HELLO_REQ_C;
349 : 0 : s->state=SSL3_ST_SW_FLUSH;
350 : 0 : s->init_num=0;
351 : :
352 : 0 : ssl3_init_finished_mac(s);
353 : 0 : break;
354 : :
355 : : case SSL3_ST_SW_HELLO_REQ_C:
356 : 0 : s->state=SSL_ST_OK;
357 : 0 : break;
358 : :
359 : : case SSL3_ST_SR_CLNT_HELLO_A:
360 : : case SSL3_ST_SR_CLNT_HELLO_B:
361 : : case SSL3_ST_SR_CLNT_HELLO_C:
362 : :
363 : 7614 : ret=ssl3_get_client_hello(s);
364 [ + + ]: 7614 : if (ret <= 0) goto end;
365 : : #ifndef OPENSSL_NO_SRP
366 : 1080 : s->state = SSL3_ST_SR_CLNT_HELLO_D;
367 : : case SSL3_ST_SR_CLNT_HELLO_D:
368 : : {
369 : : int al;
370 [ - + ]: 1080 : if ((ret = ssl_check_srp_ext_ClientHello(s,&al)) < 0)
371 : : {
372 : : /* callback indicates firther work to be done */
373 : 0 : s->rwstate=SSL_X509_LOOKUP;
374 : 0 : goto end;
375 : : }
376 [ - + ]: 1080 : if (ret != SSL_ERROR_NONE)
377 : : {
378 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,al);
379 : : /* This is not really an error but the only means to
380 : : for a client to detect whether srp is supported. */
381 [ # # ]: 0 : if (al != TLS1_AD_UNKNOWN_PSK_IDENTITY)
382 : 0 : SSLerr(SSL_F_SSL3_ACCEPT,SSL_R_CLIENTHELLO_TLSEXT);
383 : : ret = SSL_TLSEXT_ERR_ALERT_FATAL;
384 : : ret= -1;
385 : : goto end;
386 : : }
387 : : }
388 : : #endif
389 : :
390 : 1080 : s->renegotiate = 2;
391 : 1080 : s->state=SSL3_ST_SW_SRVR_HELLO_A;
392 : 1080 : s->init_num=0;
393 : 1080 : break;
394 : :
395 : : case SSL3_ST_SW_SRVR_HELLO_A:
396 : : case SSL3_ST_SW_SRVR_HELLO_B:
397 : 1080 : ret=ssl3_send_server_hello(s);
398 [ + - ]: 1080 : if (ret <= 0) goto end;
399 : : #ifndef OPENSSL_NO_TLSEXT
400 [ + + ]: 1080 : if (s->hit)
401 : : {
402 [ - + ]: 11 : if (s->tlsext_ticket_expected)
403 : 0 : s->state=SSL3_ST_SW_SESSION_TICKET_A;
404 : : else
405 : 11 : s->state=SSL3_ST_SW_CHANGE_A;
406 : : }
407 : : #else
408 : : if (s->hit)
409 : : s->state=SSL3_ST_SW_CHANGE_A;
410 : : #endif
411 : : else
412 : 1069 : s->state = SSL3_ST_SW_CERT_A;
413 : 1080 : s->init_num = 0;
414 : 1080 : break;
415 : :
416 : : case SSL3_ST_SW_CERT_A:
417 : : case SSL3_ST_SW_CERT_B:
418 : : /* Check if it is anon DH or anon ECDH, */
419 : : /* normal PSK or KRB5 or SRP */
420 [ + + ]: 1069 : if (!(s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL)
421 [ + + ]: 959 : && !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK)
422 [ + - ]: 937 : && !(s->s3->tmp.new_cipher->algorithm_auth & SSL_aKRB5))
423 : : {
424 : 937 : ret=ssl3_send_server_certificate(s);
425 [ + - ]: 937 : if (ret <= 0) goto end;
426 : : #ifndef OPENSSL_NO_TLSEXT
427 [ - + ]: 937 : if (s->tlsext_status_expected)
428 : 0 : s->state=SSL3_ST_SW_CERT_STATUS_A;
429 : : else
430 : 937 : s->state=SSL3_ST_SW_KEY_EXCH_A;
431 : : }
432 : : else
433 : : {
434 : 132 : skip = 1;
435 : 132 : s->state=SSL3_ST_SW_KEY_EXCH_A;
436 : : }
437 : : #else
438 : : }
439 : : else
440 : : skip=1;
441 : :
442 : : s->state=SSL3_ST_SW_KEY_EXCH_A;
443 : : #endif
444 : 1069 : s->init_num=0;
445 : 1069 : break;
446 : :
447 : : case SSL3_ST_SW_KEY_EXCH_A:
448 : : case SSL3_ST_SW_KEY_EXCH_B:
449 : 1069 : alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
450 : :
451 : : /* clear this, it may get reset by
452 : : * send_server_key_exchange */
453 [ - + ]: 1069 : if ((s->options & SSL_OP_EPHEMERAL_RSA)
454 : : #ifndef OPENSSL_NO_KRB5
455 : : && !(alg_k & SSL_kKRB5)
456 : : #endif /* OPENSSL_NO_KRB5 */
457 : : )
458 : : /* option SSL_OP_EPHEMERAL_RSA sends temporary RSA key
459 : : * even when forbidden by protocol specs
460 : : * (handshake may fail as clients are not required to
461 : : * be able to handle this) */
462 : 0 : s->s3->tmp.use_rsa_tmp=1;
463 : : else
464 : 1069 : s->s3->tmp.use_rsa_tmp=0;
465 : :
466 : :
467 : : /* only send if a DH key exchange, fortezza or
468 : : * RSA but we have a sign only certificate
469 : : *
470 : : * PSK: may send PSK identity hints
471 : : *
472 : : * For ECC ciphersuites, we send a serverKeyExchange
473 : : * message only if the cipher suite is either
474 : : * ECDH-anon or ECDHE. In other cases, the
475 : : * server certificate contains the server's
476 : : * public key for key exchange.
477 : : */
478 [ + - ]: 1069 : if (s->s3->tmp.use_rsa_tmp
479 : : /* PSK: send ServerKeyExchange if PSK identity
480 : : * hint if provided */
481 : : #ifndef OPENSSL_NO_PSK
482 [ + + ][ - + ]: 1069 : || ((alg_k & SSL_kPSK) && s->ctx->psk_identity_hint)
483 : : #endif
484 : : #ifndef OPENSSL_NO_SRP
485 : : /* SRP: send ServerKeyExchange */
486 : : || (alg_k & SSL_kSRP)
487 : : #endif
488 : : || (alg_k & SSL_kDHE)
489 [ + + ]: 1047 : || (alg_k & SSL_kECDHE)
490 [ + - ]: 365 : || ((alg_k & SSL_kRSA)
491 [ + - ]: 365 : && (s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey == NULL
492 [ + + ]: 365 : || (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher)
493 [ - + ][ + - ]: 33 : && EVP_PKEY_size(s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey)*8 > SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)
494 : : )
495 : : )
496 : : )
497 : : )
498 : : {
499 : 737 : ret=ssl3_send_server_key_exchange(s);
500 [ + - ]: 737 : if (ret <= 0) goto end;
501 : : }
502 : : else
503 : : skip=1;
504 : :
505 : 1069 : s->state=SSL3_ST_SW_CERT_REQ_A;
506 : 1069 : s->init_num=0;
507 : 1069 : break;
508 : :
509 : : case SSL3_ST_SW_CERT_REQ_A:
510 : : case SSL3_ST_SW_CERT_REQ_B:
511 [ + + ]: 1069 : if (/* don't request cert unless asked for it: */
512 [ - + ]: 99 : !(s->verify_mode & SSL_VERIFY_PEER) ||
513 : : /* if SSL_VERIFY_CLIENT_ONCE is set,
514 : : * don't request cert during re-negotiation: */
515 [ # # ]: 0 : ((s->session->peer != NULL) &&
516 [ - + ]: 99 : (s->verify_mode & SSL_VERIFY_CLIENT_ONCE)) ||
517 : : /* never request cert in anonymous ciphersuites
518 : : * (see section "Certificate request" in SSL 3 drafts
519 : : * and in RFC 2246): */
520 [ # # ]: 0 : ((s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL) &&
521 : : /* ... except when the application insists on verification
522 : : * (against the specs, but s3_clnt.c accepts this for SSL 3) */
523 [ + - ]: 99 : !(s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) ||
524 : : /* never request cert in Kerberos ciphersuites */
525 : 99 : (s->s3->tmp.new_cipher->algorithm_auth & SSL_aKRB5)
526 : : /* With normal PSK Certificates and
527 : : * Certificate Requests are omitted */
528 [ - + ]: 99 : || (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK))
529 : : {
530 : : /* no cert request */
531 : 970 : skip=1;
532 : 970 : s->s3->tmp.cert_request=0;
533 : 970 : s->state=SSL3_ST_SW_SRVR_DONE_A;
534 [ - + ]: 970 : if (s->s3->handshake_buffer)
535 [ # # ]: 0 : if (!ssl3_digest_cached_records(s))
536 : : return -1;
537 : : }
538 : : else
539 : : {
540 : 99 : s->s3->tmp.cert_request=1;
541 : 99 : ret=ssl3_send_certificate_request(s);
542 [ + - ]: 99 : if (ret <= 0) goto end;
543 : : #ifndef NETSCAPE_HANG_BUG
544 : : s->state=SSL3_ST_SW_SRVR_DONE_A;
545 : : #else
546 : 99 : s->state=SSL3_ST_SW_FLUSH;
547 : 99 : s->s3->tmp.next_state=SSL3_ST_SR_CERT_A;
548 : : #endif
549 : 99 : s->init_num=0;
550 : : }
551 : : break;
552 : :
553 : : case SSL3_ST_SW_SRVR_DONE_A:
554 : : case SSL3_ST_SW_SRVR_DONE_B:
555 : 970 : ret=ssl3_send_server_done(s);
556 [ + - ]: 970 : if (ret <= 0) goto end;
557 : 970 : s->s3->tmp.next_state=SSL3_ST_SR_CERT_A;
558 : 970 : s->state=SSL3_ST_SW_FLUSH;
559 : 970 : s->init_num=0;
560 : 970 : break;
561 : :
562 : : case SSL3_ST_SW_FLUSH:
563 : :
564 : : /* This code originally checked to see if
565 : : * any data was pending using BIO_CTRL_INFO
566 : : * and then flushed. This caused problems
567 : : * as documented in PR#1939. The proposed
568 : : * fix doesn't completely resolve this issue
569 : : * as buggy implementations of BIO_CTRL_PENDING
570 : : * still exist. So instead we just flush
571 : : * unconditionally.
572 : : */
573 : :
574 : 8439 : s->rwstate=SSL_WRITING;
575 [ + + ]: 8439 : if (BIO_flush(s->wbio) <= 0)
576 : : {
577 : : ret= -1;
578 : : goto end;
579 : : }
580 : 2149 : s->rwstate=SSL_NOTHING;
581 : :
582 : 2149 : s->state=s->s3->tmp.next_state;
583 : 2149 : break;
584 : :
585 : : case SSL3_ST_SR_CERT_A:
586 : : case SSL3_ST_SR_CERT_B:
587 : : /* Check for second client hello (MS SGC) */
588 : 9664 : ret = ssl3_check_client_hello(s);
589 [ + + ]: 9664 : if (ret <= 0)
590 : : goto end;
591 [ - + ]: 1069 : if (ret == 2)
592 : 0 : s->state = SSL3_ST_SR_CLNT_HELLO_C;
593 : : else {
594 [ + + ]: 1069 : if (s->s3->tmp.cert_request)
595 : : {
596 : 99 : ret=ssl3_get_client_certificate(s);
597 [ + - ]: 99 : if (ret <= 0) goto end;
598 : : }
599 : 1069 : s->init_num=0;
600 : 1069 : s->state=SSL3_ST_SR_KEY_EXCH_A;
601 : : }
602 : : break;
603 : :
604 : : case SSL3_ST_SR_KEY_EXCH_A:
605 : : case SSL3_ST_SR_KEY_EXCH_B:
606 : 1509 : ret=ssl3_get_client_key_exchange(s);
607 [ + + ]: 1509 : if (ret <= 0)
608 : : goto end;
609 [ - + ]: 1069 : if (ret == 2)
610 : : {
611 : : /* For the ECDH ciphersuites when
612 : : * the client sends its ECDH pub key in
613 : : * a certificate, the CertificateVerify
614 : : * message is not sent.
615 : : * Also for GOST ciphersuites when
616 : : * the client uses its key from the certificate
617 : : * for key exchange.
618 : : */
619 : : #if defined(OPENSSL_NO_TLSEXT) || defined(OPENSSL_NO_NEXTPROTONEG)
620 : : s->state=SSL3_ST_SR_FINISHED_A;
621 : : #else
622 [ # # ]: 0 : if (s->s3->next_proto_neg_seen)
623 : 0 : s->state=SSL3_ST_SR_NEXT_PROTO_A;
624 : : else
625 : 0 : s->state=SSL3_ST_SR_FINISHED_A;
626 : : #endif
627 : 0 : s->init_num = 0;
628 : : }
629 [ + + ]: 1069 : else if (SSL_USE_SIGALGS(s))
630 : : {
631 : 200 : s->state=SSL3_ST_SR_CERT_VRFY_A;
632 : 200 : s->init_num=0;
633 [ + + ]: 200 : if (!s->session->peer)
634 : : break;
635 : : /* For sigalgs freeze the handshake buffer
636 : : * at this point and digest cached records.
637 : : */
638 [ - + ]: 55 : if (!s->s3->handshake_buffer)
639 : : {
640 : 0 : SSLerr(SSL_F_SSL3_ACCEPT,ERR_R_INTERNAL_ERROR);
641 : 0 : return -1;
642 : : }
643 : 55 : s->s3->flags |= TLS1_FLAGS_KEEP_HANDSHAKE;
644 [ + - ]: 55 : if (!ssl3_digest_cached_records(s))
645 : : return -1;
646 : : }
647 : : else
648 : : {
649 : 869 : int offset=0;
650 : : int dgst_num;
651 : :
652 : 869 : s->state=SSL3_ST_SR_CERT_VRFY_A;
653 : 869 : s->init_num=0;
654 : :
655 : : /* We need to get hashes here so if there is
656 : : * a client cert, it can be verified
657 : : * FIXME - digest processing for CertificateVerify
658 : : * should be generalized. But it is next step
659 : : */
660 [ - + ]: 869 : if (s->s3->handshake_buffer)
661 [ # # ]: 869 : if (!ssl3_digest_cached_records(s))
662 : : return -1;
663 [ + + ]: 6083 : for (dgst_num=0; dgst_num<SSL_MAX_DIGEST;dgst_num++)
664 [ + + ]: 5214 : if (s->s3->handshake_dgst[dgst_num])
665 : : {
666 : : int dgst_size;
667 : :
668 : 1738 : s->method->ssl3_enc->cert_verify_mac(s,EVP_MD_CTX_type(s->s3->handshake_dgst[dgst_num]),&(s->s3->tmp.cert_verify_md[offset]));
669 : 1738 : dgst_size=EVP_MD_CTX_size(s->s3->handshake_dgst[dgst_num]);
670 [ + - ]: 1738 : if (dgst_size < 0)
671 : : {
672 : : ret = -1;
673 : : goto end;
674 : : }
675 : 1738 : offset+=dgst_size;
676 : : }
677 : : }
678 : : break;
679 : :
680 : : case SSL3_ST_SR_CERT_VRFY_A:
681 : : case SSL3_ST_SR_CERT_VRFY_B:
682 : :
683 : 10595 : s->s3->flags |= SSL3_FLAGS_CCS_OK;
684 : : /* we should decide if we expected this one */
685 : 10595 : ret=ssl3_get_cert_verify(s);
686 [ + + ]: 10595 : if (ret <= 0) goto end;
687 : :
688 : : #if defined(OPENSSL_NO_TLSEXT) || defined(OPENSSL_NO_NEXTPROTONEG)
689 : : s->state=SSL3_ST_SR_FINISHED_A;
690 : : #else
691 [ + + ]: 1069 : if (s->s3->next_proto_neg_seen)
692 : 44 : s->state=SSL3_ST_SR_NEXT_PROTO_A;
693 : : else
694 : 1025 : s->state=SSL3_ST_SR_FINISHED_A;
695 : : #endif
696 : 1069 : s->init_num=0;
697 : 1069 : break;
698 : :
699 : : #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
700 : : case SSL3_ST_SR_NEXT_PROTO_A:
701 : : case SSL3_ST_SR_NEXT_PROTO_B:
702 : 231 : ret=ssl3_get_next_proto(s);
703 [ + + ]: 231 : if (ret <= 0) goto end;
704 : 55 : s->init_num = 0;
705 : 55 : s->state=SSL3_ST_SR_FINISHED_A;
706 : 55 : break;
707 : : #endif
708 : :
709 : : case SSL3_ST_SR_FINISHED_A:
710 : : case SSL3_ST_SR_FINISHED_B:
711 : 2290 : s->s3->flags |= SSL3_FLAGS_CCS_OK;
712 : 2290 : ret=ssl3_get_finished(s,SSL3_ST_SR_FINISHED_A,
713 : : SSL3_ST_SR_FINISHED_B);
714 [ + + ]: 2290 : if (ret <= 0) goto end;
715 [ + + ]: 1080 : if (s->hit)
716 : 11 : s->state=SSL_ST_OK;
717 : : #ifndef OPENSSL_NO_TLSEXT
718 [ + + ]: 1069 : else if (s->tlsext_ticket_expected)
719 : 816 : s->state=SSL3_ST_SW_SESSION_TICKET_A;
720 : : #endif
721 : : else
722 : 253 : s->state=SSL3_ST_SW_CHANGE_A;
723 : 1080 : s->init_num=0;
724 : 1080 : break;
725 : :
726 : : #ifndef OPENSSL_NO_TLSEXT
727 : : case SSL3_ST_SW_SESSION_TICKET_A:
728 : : case SSL3_ST_SW_SESSION_TICKET_B:
729 : 816 : ret=ssl3_send_newsession_ticket(s);
730 [ + - ]: 816 : if (ret <= 0) goto end;
731 : 816 : s->state=SSL3_ST_SW_CHANGE_A;
732 : 816 : s->init_num=0;
733 : 816 : break;
734 : :
735 : : case SSL3_ST_SW_CERT_STATUS_A:
736 : : case SSL3_ST_SW_CERT_STATUS_B:
737 : 0 : ret=ssl3_send_cert_status(s);
738 [ # # ]: 0 : if (ret <= 0) goto end;
739 : 0 : s->state=SSL3_ST_SW_KEY_EXCH_A;
740 : 0 : s->init_num=0;
741 : 0 : break;
742 : :
743 : : #endif
744 : :
745 : : case SSL3_ST_SW_CHANGE_A:
746 : : case SSL3_ST_SW_CHANGE_B:
747 : :
748 : 1080 : s->session->cipher=s->s3->tmp.new_cipher;
749 [ + - ]: 1080 : if (!s->method->ssl3_enc->setup_key_block(s))
750 : : { ret= -1; goto end; }
751 : :
752 : 1080 : ret=ssl3_send_change_cipher_spec(s,
753 : : SSL3_ST_SW_CHANGE_A,SSL3_ST_SW_CHANGE_B);
754 : :
755 [ + - ]: 1080 : if (ret <= 0) goto end;
756 : 1080 : s->state=SSL3_ST_SW_FINISHED_A;
757 : 1080 : s->init_num=0;
758 : :
759 [ + - ]: 1080 : if (!s->method->ssl3_enc->change_cipher_state(s,
760 : : SSL3_CHANGE_CIPHER_SERVER_WRITE))
761 : : {
762 : : ret= -1;
763 : : goto end;
764 : : }
765 : :
766 : : break;
767 : :
768 : : case SSL3_ST_SW_FINISHED_A:
769 : : case SSL3_ST_SW_FINISHED_B:
770 : 1080 : ret=ssl3_send_finished(s,
771 : : SSL3_ST_SW_FINISHED_A,SSL3_ST_SW_FINISHED_B,
772 : : s->method->ssl3_enc->server_finished_label,
773 : 1080 : s->method->ssl3_enc->server_finished_label_len);
774 [ + - ]: 1080 : if (ret <= 0) goto end;
775 : 1080 : s->state=SSL3_ST_SW_FLUSH;
776 [ + + ]: 1080 : if (s->hit)
777 : : {
778 : : #if defined(OPENSSL_NO_TLSEXT) || defined(OPENSSL_NO_NEXTPROTONEG)
779 : : s->s3->tmp.next_state=SSL3_ST_SR_FINISHED_A;
780 : : #else
781 [ + - ]: 11 : if (s->s3->next_proto_neg_seen)
782 : : {
783 : 11 : s->s3->flags |= SSL3_FLAGS_CCS_OK;
784 : 11 : s->s3->tmp.next_state=SSL3_ST_SR_NEXT_PROTO_A;
785 : : }
786 : : else
787 : 0 : s->s3->tmp.next_state=SSL3_ST_SR_FINISHED_A;
788 : : #endif
789 : : }
790 : : else
791 : 1069 : s->s3->tmp.next_state=SSL_ST_OK;
792 : 1080 : s->init_num=0;
793 : 1080 : break;
794 : :
795 : : case SSL_ST_OK:
796 : : /* clean a few things up */
797 : 1080 : ssl3_cleanup_key_block(s);
798 : :
799 : 1080 : BUF_MEM_free(s->init_buf);
800 : 1080 : s->init_buf=NULL;
801 : :
802 : : /* remove buffering on output */
803 : 1080 : ssl_free_wbio_buffer(s);
804 : :
805 : 1080 : s->init_num=0;
806 : :
807 [ + - ]: 1080 : if (s->renegotiate == 2) /* skipped if we just sent a HelloRequest */
808 : : {
809 : 1080 : s->renegotiate=0;
810 : 1080 : s->new_session=0;
811 : :
812 : 1080 : ssl_update_cache(s,SSL_SESS_CACHE_SERVER);
813 : :
814 : 1080 : s->ctx->stats.sess_accept_good++;
815 : : /* s->server=1; */
816 : 1080 : s->handshake_func=ssl3_accept;
817 : :
818 [ - + ]: 1080 : if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_DONE,1);
819 : : }
820 : :
821 : : ret = 1;
822 : : goto end;
823 : : /* break; */
824 : :
825 : : default:
826 : 0 : SSLerr(SSL_F_SSL3_ACCEPT,SSL_R_UNKNOWN_STATE);
827 : 0 : ret= -1;
828 : 0 : goto end;
829 : : /* break; */
830 : : }
831 : :
832 [ + + ]: 16684 : if (!s->s3->tmp.reuse_message && !skip)
833 : : {
834 [ - + ]: 13310 : if (s->debug)
835 : : {
836 [ # # ]: 0 : if ((ret=BIO_flush(s->wbio)) <= 0)
837 : : goto end;
838 : : }
839 : :
840 : :
841 [ + - ][ # # ]: 13310 : if ((cb != NULL) && (s->state != state))
842 : : {
843 : 0 : new_state=s->state;
844 : 0 : s->state=state;
845 : 0 : cb(s,SSL_CB_ACCEPT_LOOP,1);
846 : 0 : s->state=new_state;
847 : : }
848 : : }
849 : : skip=0;
850 : : }
851 : : end:
852 : : /* BIO_flush(s->wbio); */
853 : :
854 : 33851 : s->in_handshake--;
855 [ - + ]: 33851 : if (cb != NULL)
856 : 0 : cb(s,SSL_CB_ACCEPT_EXIT,ret);
857 : 33851 : return(ret);
858 : : }
859 : :
860 : 0 : int ssl3_send_hello_request(SSL *s)
861 : : {
862 : :
863 [ # # ]: 0 : if (s->state == SSL3_ST_SW_HELLO_REQ_A)
864 : : {
865 : 0 : ssl_set_handshake_header(s, SSL3_MT_HELLO_REQUEST, 0);
866 : 0 : s->state=SSL3_ST_SW_HELLO_REQ_B;
867 : : }
868 : :
869 : : /* SSL3_ST_SW_HELLO_REQ_B */
870 : 0 : return ssl_do_write(s);
871 : : }
872 : :
873 : 9664 : int ssl3_check_client_hello(SSL *s)
874 : : {
875 : : int ok;
876 : : long n;
877 : :
878 : : /* this function is called when we really expect a Certificate message,
879 : : * so permit appropriate message length */
880 : 9664 : n=s->method->ssl_get_message(s,
881 : : SSL3_ST_SR_CERT_A,
882 : : SSL3_ST_SR_CERT_B,
883 : : -1,
884 : : s->max_cert_list,
885 : : &ok);
886 [ + + ]: 9664 : if (!ok) return((int)n);
887 : 1069 : s->s3->tmp.reuse_message = 1;
888 [ - + ]: 1069 : if (s->s3->tmp.message_type == SSL3_MT_CLIENT_HELLO)
889 : : {
890 : : /* We only allow the client to restart the handshake once per
891 : : * negotiation. */
892 [ # # ]: 0 : if (s->s3->flags & SSL3_FLAGS_SGC_RESTART_DONE)
893 : : {
894 : 0 : SSLerr(SSL_F_SSL3_CHECK_CLIENT_HELLO, SSL_R_MULTIPLE_SGC_RESTARTS);
895 : 0 : return -1;
896 : : }
897 : : /* Throw away what we have done so far in the current handshake,
898 : : * which will now be aborted. (A full SSL_clear would be too much.) */
899 : : #ifndef OPENSSL_NO_DH
900 [ # # ]: 0 : if (s->s3->tmp.dh != NULL)
901 : : {
902 : 0 : DH_free(s->s3->tmp.dh);
903 : 0 : s->s3->tmp.dh = NULL;
904 : : }
905 : : #endif
906 : : #ifndef OPENSSL_NO_ECDH
907 [ # # ]: 0 : if (s->s3->tmp.ecdh != NULL)
908 : : {
909 : 0 : EC_KEY_free(s->s3->tmp.ecdh);
910 : 0 : s->s3->tmp.ecdh = NULL;
911 : : }
912 : : #endif
913 : 0 : s->s3->flags |= SSL3_FLAGS_SGC_RESTART_DONE;
914 : 0 : return 2;
915 : : }
916 : : return 1;
917 : : }
918 : :
919 : 7614 : int ssl3_get_client_hello(SSL *s)
920 : : {
921 : 7614 : int i,j,ok,al=SSL_AD_INTERNAL_ERROR,ret= -1;
922 : : unsigned int cookie_len;
923 : : long n;
924 : : unsigned long id;
925 : : unsigned char *p,*d;
926 : : SSL_CIPHER *c;
927 : : #ifndef OPENSSL_NO_COMP
928 : : unsigned char *q;
929 : 7614 : SSL_COMP *comp=NULL;
930 : : #endif
931 : 7614 : STACK_OF(SSL_CIPHER) *ciphers=NULL;
932 : :
933 [ - + ][ # # ]: 7614 : if (s->state == SSL3_ST_SR_CLNT_HELLO_C && !s->first_packet)
934 : : goto retry_cert;
935 : :
936 : : /* We do this so that we will respond with our native type.
937 : : * If we are TLSv1 and we get SSLv3, we will respond with TLSv1,
938 : : * This down switching should be handled by a different method.
939 : : * If we are SSLv3, we will respond with SSLv3, even if prompted with
940 : : * TLSv1.
941 : : */
942 [ + + ]: 7614 : if (s->state == SSL3_ST_SR_CLNT_HELLO_A
943 : : )
944 : : {
945 : 1080 : s->state=SSL3_ST_SR_CLNT_HELLO_B;
946 : : }
947 : 7614 : s->first_packet=1;
948 : 7614 : n=s->method->ssl_get_message(s,
949 : : SSL3_ST_SR_CLNT_HELLO_B,
950 : : SSL3_ST_SR_CLNT_HELLO_C,
951 : : SSL3_MT_CLIENT_HELLO,
952 : : SSL3_RT_MAX_PLAIN_LENGTH,
953 : : &ok);
954 : :
955 [ + + ]: 7614 : if (!ok) return((int)n);
956 : 1080 : s->first_packet=0;
957 : 1080 : d=p=(unsigned char *)s->init_msg;
958 : :
959 : : /* use version from inside client hello, not from record header
960 : : * (may differ: see RFC 2246, Appendix E, second paragraph) */
961 : 1080 : s->client_version=(((int)p[0])<<8)|(int)p[1];
962 : 1080 : p+=2;
963 : :
964 [ - + ][ # # ]: 1080 : if (SSL_IS_DTLS(s) ? (s->client_version > s->version &&
[ # # ][ - + ]
965 : 0 : s->method->version != DTLS_ANY_VERSION)
966 : 1080 : : (s->client_version < s->version))
967 : : {
968 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_WRONG_VERSION_NUMBER);
969 [ # # ][ # # ]: 0 : if ((s->client_version>>8) == SSL3_VERSION_MAJOR &&
970 [ # # ]: 0 : !s->enc_write_ctx && !s->write_hash)
971 : : {
972 : : /* similar to ssl3_get_record, send alert using remote version number */
973 : 0 : s->version = s->client_version;
974 : : }
975 : : al = SSL_AD_PROTOCOL_VERSION;
976 : : goto f_err;
977 : : }
978 : :
979 : : /* If we require cookies and this ClientHello doesn't
980 : : * contain one, just return since we do not want to
981 : : * allocate any memory yet. So check cookie length...
982 : : */
983 [ - + ]: 1080 : if (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE)
984 : : {
985 : : unsigned int session_length, cookie_length;
986 : :
987 : 0 : session_length = *(p + SSL3_RANDOM_SIZE);
988 : 0 : cookie_length = *(p + SSL3_RANDOM_SIZE + session_length + 1);
989 : :
990 [ # # ]: 0 : if (cookie_length == 0)
991 : : return 1;
992 : : }
993 : :
994 : : /* load the client random */
995 : 1080 : memcpy(s->s3->client_random,p,SSL3_RANDOM_SIZE);
996 : 1080 : p+=SSL3_RANDOM_SIZE;
997 : :
998 : : /* get the session-id */
999 : 1080 : j= *(p++);
1000 : :
1001 : 1080 : s->hit=0;
1002 : : /* Versions before 0.9.7 always allow clients to resume sessions in renegotiation.
1003 : : * 0.9.7 and later allow this by default, but optionally ignore resumption requests
1004 : : * with flag SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION (it's a new flag rather
1005 : : * than a change to default behavior so that applications relying on this for security
1006 : : * won't even compile against older library versions).
1007 : : *
1008 : : * 1.0.1 and later also have a function SSL_renegotiate_abbreviated() to request
1009 : : * renegotiation but not a new session (s->new_session remains unset): for servers,
1010 : : * this essentially just means that the SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
1011 : : * setting will be ignored.
1012 : : */
1013 [ - + ][ # # ]: 1080 : if ((s->new_session && (s->options & SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION)))
1014 : : {
1015 [ # # ]: 0 : if (!ssl_get_new_session(s,1))
1016 : : goto err;
1017 : : }
1018 : : else
1019 : : {
1020 : 1080 : i=ssl_get_prev_session(s, p, j, d + n);
1021 [ + + ]: 1080 : if (i == 1)
1022 : : { /* previous session */
1023 : 11 : s->hit=1;
1024 : : }
1025 [ + - ]: 1069 : else if (i == -1)
1026 : : goto err;
1027 : : else /* i == 0 */
1028 : : {
1029 [ + - ]: 1069 : if (!ssl_get_new_session(s,1))
1030 : : goto err;
1031 : : }
1032 : : }
1033 : :
1034 : 1080 : p+=j;
1035 : :
1036 [ - + ]: 1080 : if (SSL_IS_DTLS(s))
1037 : : {
1038 : : /* cookie stuff */
1039 : 0 : cookie_len = *(p++);
1040 : :
1041 : : /*
1042 : : * The ClientHello may contain a cookie even if the
1043 : : * HelloVerify message has not been sent--make sure that it
1044 : : * does not cause an overflow.
1045 : : */
1046 [ # # ]: 0 : if ( cookie_len > sizeof(s->d1->rcvd_cookie))
1047 : : {
1048 : : /* too much data */
1049 : 0 : al = SSL_AD_DECODE_ERROR;
1050 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_COOKIE_MISMATCH);
1051 : 0 : goto f_err;
1052 : : }
1053 : :
1054 : : /* verify the cookie if appropriate option is set. */
1055 [ # # ][ # # ]: 0 : if ((SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) &&
1056 : : cookie_len > 0)
1057 : : {
1058 : 0 : memcpy(s->d1->rcvd_cookie, p, cookie_len);
1059 : :
1060 [ # # ]: 0 : if ( s->ctx->app_verify_cookie_cb != NULL)
1061 : : {
1062 [ # # ]: 0 : if ( s->ctx->app_verify_cookie_cb(s, s->d1->rcvd_cookie,
1063 : : cookie_len) == 0)
1064 : : {
1065 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
1066 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
1067 : : SSL_R_COOKIE_MISMATCH);
1068 : 0 : goto f_err;
1069 : : }
1070 : : /* else cookie verification succeeded */
1071 : : }
1072 [ # # ]: 0 : else if ( memcmp(s->d1->rcvd_cookie, s->d1->cookie,
1073 : 0 : s->d1->cookie_len) != 0) /* default verification */
1074 : : {
1075 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
1076 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
1077 : : SSL_R_COOKIE_MISMATCH);
1078 : 0 : goto f_err;
1079 : : }
1080 : : /* Set to -2 so if successful we return 2 */
1081 : : ret = -2;
1082 : : }
1083 : :
1084 : 0 : p += cookie_len;
1085 [ # # ]: 0 : if (s->method->version == DTLS_ANY_VERSION)
1086 : : {
1087 : : /* Select version to use */
1088 [ # # ][ # # ]: 0 : if (s->client_version <= DTLS1_2_VERSION &&
1089 : 0 : !(s->options & SSL_OP_NO_DTLSv1_2))
1090 : : {
1091 : 0 : s->version = DTLS1_2_VERSION;
1092 : 0 : s->method = DTLSv1_2_server_method();
1093 : : }
1094 [ # # ]: 0 : else if (tls1_suiteb(s))
1095 : : {
1096 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_ONLY_DTLS_1_2_ALLOWED_IN_SUITEB_MODE);
1097 : 0 : s->version = s->client_version;
1098 : 0 : al = SSL_AD_PROTOCOL_VERSION;
1099 : 0 : goto f_err;
1100 : : }
1101 [ # # ][ # # ]: 0 : else if (s->client_version <= DTLS1_VERSION &&
1102 : 0 : !(s->options & SSL_OP_NO_DTLSv1))
1103 : : {
1104 : 0 : s->version = DTLS1_VERSION;
1105 : 0 : s->method = DTLSv1_server_method();
1106 : : }
1107 : : else
1108 : : {
1109 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_WRONG_VERSION_NUMBER);
1110 : 0 : s->version = s->client_version;
1111 : 0 : al = SSL_AD_PROTOCOL_VERSION;
1112 : 0 : goto f_err;
1113 : : }
1114 : 0 : s->session->ssl_version = s->version;
1115 : : }
1116 : : }
1117 : :
1118 : 1080 : n2s(p,i);
1119 [ - + ]: 1080 : if ((i == 0) && (j != 0))
1120 : : {
1121 : : /* we need a cipher if we are not resuming a session */
1122 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
1123 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_NO_CIPHERS_SPECIFIED);
1124 : 0 : goto f_err;
1125 : : }
1126 [ - + ]: 1080 : if ((p+i) >= (d+n))
1127 : : {
1128 : : /* not enough data */
1129 : 0 : al=SSL_AD_DECODE_ERROR;
1130 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_LENGTH_MISMATCH);
1131 : 0 : goto f_err;
1132 : : }
1133 [ + - ][ + - ]: 1080 : if ((i > 0) && (ssl_bytes_to_cipher_list(s,p,i,&(ciphers))
1134 : : == NULL))
1135 : : {
1136 : : goto err;
1137 : : }
1138 : 1080 : p+=i;
1139 : :
1140 : : /* If it is a hit, check that the cipher is in the list */
1141 [ + + ][ + - ]: 1080 : if ((s->hit) && (i > 0))
1142 : : {
1143 : 11 : j=0;
1144 : 11 : id=s->session->cipher->id;
1145 : :
1146 : : #ifdef CIPHER_DEBUG
1147 : : printf("client sent %d ciphers\n",sk_num(ciphers));
1148 : : #endif
1149 [ + - ]: 11 : for (i=0; i<sk_SSL_CIPHER_num(ciphers); i++)
1150 : : {
1151 : 11 : c=sk_SSL_CIPHER_value(ciphers,i);
1152 : : #ifdef CIPHER_DEBUG
1153 : : printf("client [%2d of %2d]:%s\n",
1154 : : i,sk_num(ciphers),SSL_CIPHER_get_name(c));
1155 : : #endif
1156 [ - + ]: 11 : if (c->id == id)
1157 : : {
1158 : : j=1;
1159 : : break;
1160 : : }
1161 : : }
1162 : : /* Disabled because it can be used in a ciphersuite downgrade
1163 : : * attack: CVE-2010-4180.
1164 : : */
1165 : : #if 0
1166 : : if (j == 0 && (s->options & SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG) && (sk_SSL_CIPHER_num(ciphers) == 1))
1167 : : {
1168 : : /* Special case as client bug workaround: the previously used cipher may
1169 : : * not be in the current list, the client instead might be trying to
1170 : : * continue using a cipher that before wasn't chosen due to server
1171 : : * preferences. We'll have to reject the connection if the cipher is not
1172 : : * enabled, though. */
1173 : : c = sk_SSL_CIPHER_value(ciphers, 0);
1174 : : if (sk_SSL_CIPHER_find(SSL_get_ciphers(s), c) >= 0)
1175 : : {
1176 : : s->session->cipher = c;
1177 : : j = 1;
1178 : : }
1179 : : }
1180 : : #endif
1181 [ - + ]: 11 : if (j == 0)
1182 : : {
1183 : : /* we need to have the cipher in the cipher
1184 : : * list if we are asked to reuse it */
1185 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
1186 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_REQUIRED_CIPHER_MISSING);
1187 : 0 : goto f_err;
1188 : : }
1189 : : }
1190 : :
1191 : : /* compression */
1192 : 1080 : i= *(p++);
1193 [ + - ]: 1080 : if ((p+i) > (d+n))
1194 : : {
1195 : : /* not enough data */
1196 : 0 : al=SSL_AD_DECODE_ERROR;
1197 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_LENGTH_MISMATCH);
1198 : 0 : goto f_err;
1199 : : }
1200 : : #ifndef OPENSSL_NO_COMP
1201 : : q=p;
1202 : : #endif
1203 [ + - ]: 1080 : for (j=0; j<i; j++)
1204 : : {
1205 [ - + ]: 1080 : if (p[j] == 0) break;
1206 : : }
1207 : :
1208 : 1080 : p+=i;
1209 [ - + ]: 1080 : if (j >= i)
1210 : : {
1211 : : /* no compress */
1212 : 0 : al=SSL_AD_DECODE_ERROR;
1213 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_NO_COMPRESSION_SPECIFIED);
1214 : 0 : goto f_err;
1215 : : }
1216 : :
1217 : : #ifndef OPENSSL_NO_TLSEXT
1218 : : /* TLS extensions*/
1219 [ + - ]: 1080 : if (s->version >= SSL3_VERSION)
1220 : : {
1221 [ - + ]: 1080 : if (!ssl_parse_clienthello_tlsext(s,&p,d,n))
1222 : : {
1223 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_PARSE_TLSEXT);
1224 : 0 : goto err;
1225 : : }
1226 : : }
1227 : :
1228 : : /* Check if we want to use external pre-shared secret for this
1229 : : * handshake for not reused session only. We need to generate
1230 : : * server_random before calling tls_session_secret_cb in order to allow
1231 : : * SessionTicket processing to use it in key derivation. */
1232 : : {
1233 : : unsigned char *pos;
1234 : 1080 : pos=s->s3->server_random;
1235 [ + - ]: 1080 : if (ssl_fill_hello_random(s, 1, pos, SSL3_RANDOM_SIZE) <= 0)
1236 : : {
1237 : : goto f_err;
1238 : : }
1239 : : }
1240 : :
1241 [ + + ][ + + ]: 1080 : if (!s->hit && s->version >= TLS1_VERSION && s->tls_session_secret_cb)
[ - + ]
1242 : : {
1243 : 0 : SSL_CIPHER *pref_cipher=NULL;
1244 : :
1245 : 0 : s->session->master_key_length=sizeof(s->session->master_key);
1246 [ # # ]: 0 : if(s->tls_session_secret_cb(s, s->session->master_key, &s->session->master_key_length,
1247 : : ciphers, &pref_cipher, s->tls_session_secret_cb_arg))
1248 : : {
1249 : 0 : s->hit=1;
1250 : 0 : s->session->ciphers=ciphers;
1251 : 0 : s->session->verify_result=X509_V_OK;
1252 : :
1253 : 0 : ciphers=NULL;
1254 : :
1255 : : /* check if some cipher was preferred by call back */
1256 [ # # ]: 0 : pref_cipher=pref_cipher ? pref_cipher : ssl3_choose_cipher(s, s->session->ciphers, SSL_get_ciphers(s));
1257 [ # # ]: 0 : if (pref_cipher == NULL)
1258 : : {
1259 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
1260 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_NO_SHARED_CIPHER);
1261 : 0 : goto f_err;
1262 : : }
1263 : :
1264 : 0 : s->session->cipher=pref_cipher;
1265 : :
1266 [ # # ]: 0 : if (s->cipher_list)
1267 : 0 : sk_SSL_CIPHER_free(s->cipher_list);
1268 : :
1269 [ # # ]: 0 : if (s->cipher_list_by_id)
1270 : 0 : sk_SSL_CIPHER_free(s->cipher_list_by_id);
1271 : :
1272 : 0 : s->cipher_list = sk_SSL_CIPHER_dup(s->session->ciphers);
1273 : 0 : s->cipher_list_by_id = sk_SSL_CIPHER_dup(s->session->ciphers);
1274 : : }
1275 : : }
1276 : : #endif
1277 : :
1278 : : /* Worst case, we will use the NULL compression, but if we have other
1279 : : * options, we will now look for them. We have i-1 compression
1280 : : * algorithms from the client, starting at q. */
1281 : 1080 : s->s3->tmp.new_compression=NULL;
1282 : : #ifndef OPENSSL_NO_COMP
1283 : : /* This only happens if we have a cache hit */
1284 [ - + ]: 1080 : if (s->session->compress_meth != 0)
1285 : : {
1286 : 0 : int m, comp_id = s->session->compress_meth;
1287 : : /* Perform sanity checks on resumed compression algorithm */
1288 : : /* Can't disable compression */
1289 [ # # ]: 0 : if (!ssl_allow_compression(s))
1290 : : {
1291 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_INCONSISTENT_COMPRESSION);
1292 : 0 : goto f_err;
1293 : : }
1294 : : /* Look for resumed compression method */
1295 [ # # ]: 0 : for (m = 0; m < sk_SSL_COMP_num(s->ctx->comp_methods); m++)
1296 : : {
1297 : 0 : comp=sk_SSL_COMP_value(s->ctx->comp_methods,m);
1298 [ # # ]: 0 : if (comp_id == comp->id)
1299 : : {
1300 : 0 : s->s3->tmp.new_compression=comp;
1301 : 0 : break;
1302 : : }
1303 : : }
1304 [ # # ]: 0 : if (s->s3->tmp.new_compression == NULL)
1305 : : {
1306 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_INVALID_COMPRESSION_ALGORITHM);
1307 : 0 : goto f_err;
1308 : : }
1309 : : /* Look for resumed method in compression list */
1310 [ # # ]: 0 : for (m = 0; m < i; m++)
1311 : : {
1312 [ # # ]: 0 : if (q[m] == comp_id)
1313 : : break;
1314 : : }
1315 [ # # ]: 0 : if (m >= i)
1316 : : {
1317 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
1318 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_REQUIRED_COMPRESSSION_ALGORITHM_MISSING);
1319 : 0 : goto f_err;
1320 : : }
1321 : : }
1322 [ + + ]: 1080 : else if (s->hit)
1323 : : comp = NULL;
1324 [ + - ][ + - ]: 1069 : else if (ssl_allow_compression(s) && s->ctx->comp_methods)
1325 : : { /* See if we have a match */
1326 : 1069 : int m,nn,o,v,done=0;
1327 : :
1328 : 1069 : nn=sk_SSL_COMP_num(s->ctx->comp_methods);
1329 [ - + ]: 1069 : for (m=0; m<nn; m++)
1330 : : {
1331 : 0 : comp=sk_SSL_COMP_value(s->ctx->comp_methods,m);
1332 : 0 : v=comp->id;
1333 [ # # ]: 0 : for (o=0; o<i; o++)
1334 : : {
1335 [ # # ]: 0 : if (v == q[o])
1336 : : {
1337 : : done=1;
1338 : : break;
1339 : : }
1340 : : }
1341 [ # # ]: 0 : if (done) break;
1342 : : }
1343 [ - + ]: 1069 : if (done)
1344 : 0 : s->s3->tmp.new_compression=comp;
1345 : : else
1346 : : comp=NULL;
1347 : : }
1348 : : #else
1349 : : /* If compression is disabled we'd better not try to resume a session
1350 : : * using compression.
1351 : : */
1352 : : if (s->session->compress_meth != 0)
1353 : : {
1354 : : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_INCONSISTENT_COMPRESSION);
1355 : : goto f_err;
1356 : : }
1357 : : #endif
1358 : :
1359 : : /* Given s->session->ciphers and SSL_get_ciphers, we must
1360 : : * pick a cipher */
1361 : :
1362 [ + + ]: 1080 : if (!s->hit)
1363 : : {
1364 : : #ifdef OPENSSL_NO_COMP
1365 : : s->session->compress_meth=0;
1366 : : #else
1367 [ - + ]: 1069 : s->session->compress_meth=(comp == NULL)?0:comp->id;
1368 : : #endif
1369 [ - + ]: 1069 : if (s->session->ciphers != NULL)
1370 : 0 : sk_SSL_CIPHER_free(s->session->ciphers);
1371 : 1069 : s->session->ciphers=ciphers;
1372 [ - + ]: 1069 : if (ciphers == NULL)
1373 : : {
1374 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
1375 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_NO_CIPHERS_PASSED);
1376 : 0 : goto f_err;
1377 : : }
1378 : 1069 : ciphers=NULL;
1379 : : /* Let cert callback update server certificates if required */
1380 : : retry_cert:
1381 [ - + ]: 1069 : if (s->cert->cert_cb)
1382 : : {
1383 : 0 : int rv = s->cert->cert_cb(s, s->cert->cert_cb_arg);
1384 [ # # ]: 0 : if (rv == 0)
1385 : : {
1386 : 0 : al=SSL_AD_INTERNAL_ERROR;
1387 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_CERT_CB_ERROR);
1388 : 0 : goto f_err;
1389 : : }
1390 [ # # ]: 0 : if (rv < 0)
1391 : : {
1392 : 0 : s->rwstate=SSL_X509_LOOKUP;
1393 : 0 : return -1;
1394 : : }
1395 : 0 : s->rwstate = SSL_NOTHING;
1396 : : }
1397 : 1069 : c=ssl3_choose_cipher(s,s->session->ciphers,
1398 : : SSL_get_ciphers(s));
1399 : :
1400 [ - + ]: 1069 : if (c == NULL)
1401 : : {
1402 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
1403 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_NO_SHARED_CIPHER);
1404 : 0 : goto f_err;
1405 : : }
1406 : 1069 : s->s3->tmp.new_cipher=c;
1407 : : /* check whether we should disable session resumption */
1408 [ - + ]: 1069 : if (s->not_resumable_session_cb != NULL)
1409 : 0 : s->session->not_resumable=s->not_resumable_session_cb(s,
1410 : 0 : ((c->algorithm_mkey & (SSL_kDHE | SSL_kECDHE)) != 0));
1411 [ - + ]: 1069 : if (s->session->not_resumable)
1412 : : /* do not send a session ticket */
1413 : 0 : s->tlsext_ticket_expected = 0;
1414 : : }
1415 : : else
1416 : : {
1417 : : /* Session-id reuse */
1418 : : #ifdef REUSE_CIPHER_BUG
1419 : : STACK_OF(SSL_CIPHER) *sk;
1420 : 11 : SSL_CIPHER *nc=NULL;
1421 : 11 : SSL_CIPHER *ec=NULL;
1422 : :
1423 [ - + ]: 11 : if (s->options & SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG)
1424 : : {
1425 : 0 : sk=s->session->ciphers;
1426 [ # # ]: 0 : for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
1427 : : {
1428 : 0 : c=sk_SSL_CIPHER_value(sk,i);
1429 [ # # ]: 0 : if (c->algorithm_enc & SSL_eNULL)
1430 : 0 : nc=c;
1431 [ # # ]: 0 : if (SSL_C_IS_EXPORT(c))
1432 : 0 : ec=c;
1433 : : }
1434 [ # # ]: 0 : if (nc != NULL)
1435 : 0 : s->s3->tmp.new_cipher=nc;
1436 [ # # ]: 0 : else if (ec != NULL)
1437 : 0 : s->s3->tmp.new_cipher=ec;
1438 : : else
1439 : 0 : s->s3->tmp.new_cipher=s->session->cipher;
1440 : : }
1441 : : else
1442 : : #endif
1443 : 11 : s->s3->tmp.new_cipher=s->session->cipher;
1444 : : }
1445 : :
1446 [ + + ][ + + ]: 1080 : if (!SSL_USE_SIGALGS(s) || !(s->verify_mode & SSL_VERIFY_PEER))
1447 : : {
1448 [ + - ]: 1025 : if (!ssl3_digest_cached_records(s))
1449 : : goto f_err;
1450 : : }
1451 : :
1452 : : /* we now have the following setup.
1453 : : * client_random
1454 : : * cipher_list - our prefered list of ciphers
1455 : : * ciphers - the clients prefered list of ciphers
1456 : : * compression - basically ignored right now
1457 : : * ssl version is set - sslv3
1458 : : * s->session - The ssl session has been setup.
1459 : : * s->hit - session reuse flag
1460 : : * s->s3->tmp.new_cipher- the new cipher to use.
1461 : : */
1462 : :
1463 : : /* Handles TLS extensions that we couldn't check earlier */
1464 [ + - ]: 1080 : if (s->version >= SSL3_VERSION)
1465 : : {
1466 [ - + ]: 1080 : if (ssl_check_clienthello_tlsext_late(s) <= 0)
1467 : : {
1468 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
1469 : 0 : goto err;
1470 : : }
1471 : : }
1472 : :
1473 : 1080 : if (ret < 0) ret=-ret;
1474 : : if (0)
1475 : : {
1476 : : f_err:
1477 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,al);
1478 : : }
1479 : : err:
1480 [ + + ]: 1080 : if (ciphers != NULL) sk_SSL_CIPHER_free(ciphers);
1481 : 1080 : return ret < 0 ? -1 : ret;
1482 : : }
1483 : :
1484 : 1080 : int ssl3_send_server_hello(SSL *s)
1485 : : {
1486 : : unsigned char *buf;
1487 : : unsigned char *p,*d;
1488 : : int i,sl;
1489 : 1080 : int al = 0;
1490 : : unsigned long l;
1491 : :
1492 [ + - ]: 1080 : if (s->state == SSL3_ST_SW_SRVR_HELLO_A)
1493 : : {
1494 : 1080 : buf=(unsigned char *)s->init_buf->data;
1495 : : #ifdef OPENSSL_NO_TLSEXT
1496 : : p=s->s3->server_random;
1497 : : if (ssl_fill_hello_random(s, 1, p, SSL3_RANDOM_SIZE) <= 0)
1498 : : return -1;
1499 : : #endif
1500 : : /* Do the message type and length last */
1501 : 1080 : d=p= ssl_handshake_start(s);
1502 : :
1503 : 1080 : *(p++)=s->version>>8;
1504 : 1080 : *(p++)=s->version&0xff;
1505 : :
1506 : : /* Random stuff */
1507 : 1080 : memcpy(p,s->s3->server_random,SSL3_RANDOM_SIZE);
1508 : 1080 : p+=SSL3_RANDOM_SIZE;
1509 : :
1510 : : /* There are several cases for the session ID to send
1511 : : * back in the server hello:
1512 : : * - For session reuse from the session cache,
1513 : : * we send back the old session ID.
1514 : : * - If stateless session reuse (using a session ticket)
1515 : : * is successful, we send back the client's "session ID"
1516 : : * (which doesn't actually identify the session).
1517 : : * - If it is a new session, we send back the new
1518 : : * session ID.
1519 : : * - However, if we want the new session to be single-use,
1520 : : * we send back a 0-length session ID.
1521 : : * s->hit is non-zero in either case of session reuse,
1522 : : * so the following won't overwrite an ID that we're supposed
1523 : : * to send back.
1524 : : */
1525 [ + - ][ - + ]: 1080 : if (s->session->not_resumable ||
1526 : 1080 : (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_SERVER)
1527 [ # # ]: 0 : && !s->hit))
1528 : 0 : s->session->session_id_length=0;
1529 : :
1530 : 1080 : sl=s->session->session_id_length;
1531 [ - + ]: 1080 : if (sl > (int)sizeof(s->session->session_id))
1532 : : {
1533 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
1534 : 0 : return -1;
1535 : : }
1536 : 1080 : *(p++)=sl;
1537 : 1080 : memcpy(p,s->session->session_id,sl);
1538 : 1080 : p+=sl;
1539 : :
1540 : : /* put the cipher */
1541 : 1080 : i=ssl3_put_cipher_by_char(s->s3->tmp.new_cipher,p);
1542 : 1080 : p+=i;
1543 : :
1544 : : /* put the compression method */
1545 : : #ifdef OPENSSL_NO_COMP
1546 : : *(p++)=0;
1547 : : #else
1548 [ + - ]: 1080 : if (s->s3->tmp.new_compression == NULL)
1549 : 1080 : *(p++)=0;
1550 : : else
1551 : 0 : *(p++)=s->s3->tmp.new_compression->id;
1552 : : #endif
1553 : : #ifndef OPENSSL_NO_TLSEXT
1554 [ - + ]: 1080 : if (ssl_prepare_serverhello_tlsext(s) <= 0)
1555 : : {
1556 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_HELLO,SSL_R_SERVERHELLO_TLSEXT);
1557 : 0 : return -1;
1558 : : }
1559 [ - + ]: 1080 : if ((p = ssl_add_serverhello_tlsext(s, p, buf+SSL3_RT_MAX_PLAIN_LENGTH, &al)) == NULL)
1560 : : {
1561 : 0 : ssl3_send_alert(s, SSL3_AL_FATAL, al);
1562 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_HELLO,ERR_R_INTERNAL_ERROR);
1563 : 0 : return -1;
1564 : : }
1565 : : #endif
1566 : : /* do the header */
1567 : 1080 : l=(p-d);
1568 : 1080 : ssl_set_handshake_header(s, SSL3_MT_SERVER_HELLO, l);
1569 : 1080 : s->state=SSL3_ST_SW_SRVR_HELLO_B;
1570 : : }
1571 : :
1572 : : /* SSL3_ST_SW_SRVR_HELLO_B */
1573 : 1080 : return ssl_do_write(s);
1574 : : }
1575 : :
1576 : 970 : int ssl3_send_server_done(SSL *s)
1577 : : {
1578 : :
1579 [ + - ]: 970 : if (s->state == SSL3_ST_SW_SRVR_DONE_A)
1580 : : {
1581 : 970 : ssl_set_handshake_header(s, SSL3_MT_SERVER_DONE, 0);
1582 : 970 : s->state = SSL3_ST_SW_SRVR_DONE_B;
1583 : : }
1584 : :
1585 : : /* SSL3_ST_SW_SRVR_DONE_B */
1586 : 970 : return ssl_do_write(s);
1587 : : }
1588 : :
1589 : 737 : int ssl3_send_server_key_exchange(SSL *s)
1590 : : {
1591 : : #ifndef OPENSSL_NO_RSA
1592 : : unsigned char *q;
1593 : : int j,num;
1594 : : RSA *rsa;
1595 : : unsigned char md_buf[MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH];
1596 : : unsigned int u;
1597 : : #endif
1598 : : #ifndef OPENSSL_NO_DH
1599 : 737 : DH *dh=NULL,*dhp;
1600 : : #endif
1601 : : #ifndef OPENSSL_NO_ECDH
1602 : 737 : EC_KEY *ecdh=NULL, *ecdhp;
1603 : 737 : unsigned char *encodedPoint = NULL;
1604 : 737 : int encodedlen = 0;
1605 : 737 : int curve_id = 0;
1606 : 737 : BN_CTX *bn_ctx = NULL;
1607 : : #endif
1608 : : EVP_PKEY *pkey;
1609 : 737 : const EVP_MD *md = NULL;
1610 : : unsigned char *p,*d;
1611 : : int al,i;
1612 : : unsigned long type;
1613 : : int n;
1614 : : CERT *cert;
1615 : : BIGNUM *r[4];
1616 : : int nr[4],kn;
1617 : : BUF_MEM *buf;
1618 : : EVP_MD_CTX md_ctx;
1619 : :
1620 : 737 : EVP_MD_CTX_init(&md_ctx);
1621 [ + - ]: 737 : if (s->state == SSL3_ST_SW_KEY_EXCH_A)
1622 : : {
1623 : 737 : type=s->s3->tmp.new_cipher->algorithm_mkey;
1624 : 737 : cert=s->cert;
1625 : :
1626 : 737 : buf=s->init_buf;
1627 : :
1628 : 737 : r[0]=r[1]=r[2]=r[3]=NULL;
1629 : 737 : n=0;
1630 : : #ifndef OPENSSL_NO_RSA
1631 [ + + ]: 737 : if (type & SSL_kRSA)
1632 : : {
1633 : 33 : rsa=cert->rsa_tmp;
1634 [ + - ][ + - ]: 33 : if ((rsa == NULL) && (s->cert->rsa_tmp_cb != NULL))
1635 : : {
1636 [ - + ]: 33 : rsa=s->cert->rsa_tmp_cb(s,
1637 : : SSL_C_IS_EXPORT(s->s3->tmp.new_cipher),
1638 : 33 : SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher));
1639 [ - + ]: 33 : if(rsa == NULL)
1640 : : {
1641 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
1642 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_ERROR_GENERATING_TMP_RSA_KEY);
1643 : 0 : goto f_err;
1644 : : }
1645 : 33 : RSA_up_ref(rsa);
1646 : 33 : cert->rsa_tmp=rsa;
1647 : : }
1648 [ - + ]: 33 : if (rsa == NULL)
1649 : : {
1650 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
1651 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_MISSING_TMP_RSA_KEY);
1652 : 0 : goto f_err;
1653 : : }
1654 : 33 : r[0]=rsa->n;
1655 : 33 : r[1]=rsa->e;
1656 : 33 : s->s3->tmp.use_rsa_tmp=1;
1657 : : }
1658 : : else
1659 : : #endif
1660 : : #ifndef OPENSSL_NO_DH
1661 [ + + ]: 704 : if (type & SSL_kDHE)
1662 : : {
1663 [ - + ]: 198 : if (s->cert->dh_tmp_auto)
1664 : : {
1665 : 0 : dhp = ssl_get_auto_dh(s);
1666 [ # # ]: 0 : if (dhp == NULL)
1667 : : {
1668 : 0 : al=SSL_AD_INTERNAL_ERROR;
1669 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
1670 : 0 : goto f_err;
1671 : : }
1672 : : }
1673 : : else
1674 : 198 : dhp=cert->dh_tmp;
1675 [ - + ][ # # ]: 198 : if ((dhp == NULL) && (s->cert->dh_tmp_cb != NULL))
1676 [ # # ]: 0 : dhp=s->cert->dh_tmp_cb(s,
1677 : : SSL_C_IS_EXPORT(s->s3->tmp.new_cipher),
1678 : 0 : SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher));
1679 [ - + ]: 198 : if (dhp == NULL)
1680 : : {
1681 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
1682 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_MISSING_TMP_DH_KEY);
1683 : 0 : goto f_err;
1684 : : }
1685 [ - + ]: 198 : if (!ssl_security(s, SSL_SECOP_TMP_DH,
1686 : : DH_security_bits(dhp), 0, dhp))
1687 : : {
1688 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
1689 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_DH_KEY_TOO_SMALL);
1690 : 0 : goto f_err;
1691 : : }
1692 [ - + ]: 198 : if (s->s3->tmp.dh != NULL)
1693 : : {
1694 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
1695 : 0 : goto err;
1696 : : }
1697 : :
1698 [ + - ]: 198 : if (s->cert->dh_tmp_auto)
1699 : : dh = dhp;
1700 [ - + ]: 198 : else if ((dh=DHparams_dup(dhp)) == NULL)
1701 : : {
1702 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_DH_LIB);
1703 : 0 : goto err;
1704 : : }
1705 : :
1706 : 198 : s->s3->tmp.dh=dh;
1707 [ + + ][ + - ]: 198 : if ((dhp->pub_key == NULL ||
1708 [ - + ]: 88 : dhp->priv_key == NULL ||
1709 : 88 : (s->options & SSL_OP_SINGLE_DH_USE)))
1710 : : {
1711 [ - + ]: 110 : if(!DH_generate_key(dh))
1712 : : {
1713 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,
1714 : : ERR_R_DH_LIB);
1715 : 0 : goto err;
1716 : : }
1717 : : }
1718 : : else
1719 : : {
1720 : 88 : dh->pub_key=BN_dup(dhp->pub_key);
1721 : 88 : dh->priv_key=BN_dup(dhp->priv_key);
1722 [ + - ][ - + ]: 88 : if ((dh->pub_key == NULL) ||
1723 : : (dh->priv_key == NULL))
1724 : : {
1725 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_DH_LIB);
1726 : 0 : goto err;
1727 : : }
1728 : : }
1729 : 198 : r[0]=dh->p;
1730 : 198 : r[1]=dh->g;
1731 : 198 : r[2]=dh->pub_key;
1732 : : }
1733 : : else
1734 : : #endif
1735 : : #ifndef OPENSSL_NO_ECDH
1736 [ + + ]: 506 : if (type & SSL_kECDHE)
1737 : : {
1738 : : const EC_GROUP *group;
1739 : :
1740 : 462 : ecdhp=cert->ecdh_tmp;
1741 [ - + ]: 462 : if (s->cert->ecdh_tmp_auto)
1742 : : {
1743 : : /* Get NID of appropriate shared curve */
1744 : 0 : int nid = tls1_shared_curve(s, -2);
1745 [ # # ]: 0 : if (nid != NID_undef)
1746 : 0 : ecdhp = EC_KEY_new_by_curve_name(nid);
1747 : : }
1748 [ - + ][ # # ]: 462 : else if ((ecdhp == NULL) && s->cert->ecdh_tmp_cb)
1749 : : {
1750 [ # # ]: 0 : ecdhp=s->cert->ecdh_tmp_cb(s,
1751 : : SSL_C_IS_EXPORT(s->s3->tmp.new_cipher),
1752 : 0 : SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher));
1753 : : }
1754 [ - + ]: 462 : if (ecdhp == NULL)
1755 : : {
1756 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
1757 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_MISSING_TMP_ECDH_KEY);
1758 : 0 : goto f_err;
1759 : : }
1760 : :
1761 [ - + ]: 462 : if (s->s3->tmp.ecdh != NULL)
1762 : : {
1763 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
1764 : 0 : goto err;
1765 : : }
1766 : :
1767 : : /* Duplicate the ECDH structure. */
1768 [ - + ]: 462 : if (ecdhp == NULL)
1769 : : {
1770 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB);
1771 : 0 : goto err;
1772 : : }
1773 [ + - ]: 462 : if (s->cert->ecdh_tmp_auto)
1774 : : ecdh = ecdhp;
1775 [ - + ]: 462 : else if ((ecdh = EC_KEY_dup(ecdhp)) == NULL)
1776 : : {
1777 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB);
1778 : 0 : goto err;
1779 : : }
1780 : :
1781 : 462 : s->s3->tmp.ecdh=ecdh;
1782 [ + - + - ]: 924 : if ((EC_KEY_get0_public_key(ecdh) == NULL) ||
1783 [ + - ]: 924 : (EC_KEY_get0_private_key(ecdh) == NULL) ||
1784 : 462 : (s->options & SSL_OP_SINGLE_ECDH_USE))
1785 : : {
1786 [ - + ]: 462 : if(!EC_KEY_generate_key(ecdh))
1787 : : {
1788 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB);
1789 : 0 : goto err;
1790 : : }
1791 : : }
1792 : :
1793 [ + - + - ]: 924 : if (((group = EC_KEY_get0_group(ecdh)) == NULL) ||
1794 [ - + ]: 924 : (EC_KEY_get0_public_key(ecdh) == NULL) ||
1795 : 462 : (EC_KEY_get0_private_key(ecdh) == NULL))
1796 : : {
1797 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB);
1798 : 0 : goto err;
1799 : : }
1800 : :
1801 [ - + # # ]: 462 : if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) &&
1802 : 0 : (EC_GROUP_get_degree(group) > 163))
1803 : : {
1804 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_ECGROUP_TOO_LARGE_FOR_CIPHER);
1805 : 0 : goto err;
1806 : : }
1807 : :
1808 : : /* XXX: For now, we only support ephemeral ECDH
1809 : : * keys over named (not generic) curves. For
1810 : : * supported named curves, curve_id is non-zero.
1811 : : */
1812 [ - + ]: 462 : if ((curve_id =
1813 : 462 : tls1_ec_nid2curve_id(EC_GROUP_get_curve_name(group)))
1814 : : == 0)
1815 : : {
1816 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_UNSUPPORTED_ELLIPTIC_CURVE);
1817 : 0 : goto err;
1818 : : }
1819 : :
1820 : : /* Encode the public key.
1821 : : * First check the size of encoding and
1822 : : * allocate memory accordingly.
1823 : : */
1824 : 462 : encodedlen = EC_POINT_point2oct(group,
1825 : : EC_KEY_get0_public_key(ecdh),
1826 : : POINT_CONVERSION_UNCOMPRESSED,
1827 : : NULL, 0, NULL);
1828 : :
1829 : 462 : encodedPoint = (unsigned char *)
1830 : : OPENSSL_malloc(encodedlen*sizeof(unsigned char));
1831 : 462 : bn_ctx = BN_CTX_new();
1832 [ - + ]: 462 : if ((encodedPoint == NULL) || (bn_ctx == NULL))
1833 : : {
1834 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_MALLOC_FAILURE);
1835 : 0 : goto err;
1836 : : }
1837 : :
1838 : :
1839 : 462 : encodedlen = EC_POINT_point2oct(group,
1840 : : EC_KEY_get0_public_key(ecdh),
1841 : : POINT_CONVERSION_UNCOMPRESSED,
1842 : : encodedPoint, encodedlen, bn_ctx);
1843 : :
1844 [ - + ]: 462 : if (encodedlen == 0)
1845 : : {
1846 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_ECDH_LIB);
1847 : 0 : goto err;
1848 : : }
1849 : :
1850 : 462 : BN_CTX_free(bn_ctx); bn_ctx=NULL;
1851 : :
1852 : : /* XXX: For now, we only support named (not
1853 : : * generic) curves in ECDH ephemeral key exchanges.
1854 : : * In this situation, we need four additional bytes
1855 : : * to encode the entire ServerECDHParams
1856 : : * structure.
1857 : : */
1858 : 462 : n = 4 + encodedlen;
1859 : :
1860 : : /* We'll generate the serverKeyExchange message
1861 : : * explicitly so we can set these to NULLs
1862 : : */
1863 : 462 : r[0]=NULL;
1864 : 462 : r[1]=NULL;
1865 : 462 : r[2]=NULL;
1866 : 462 : r[3]=NULL;
1867 : : }
1868 : : else
1869 : : #endif /* !OPENSSL_NO_ECDH */
1870 : : #ifndef OPENSSL_NO_PSK
1871 [ + + ]: 44 : if (type & SSL_kPSK)
1872 : : {
1873 : : /* reserve size for record length and PSK identity hint*/
1874 : 22 : n+=2+strlen(s->ctx->psk_identity_hint);
1875 : : }
1876 : : else
1877 : : #endif /* !OPENSSL_NO_PSK */
1878 : : #ifndef OPENSSL_NO_SRP
1879 [ + - ]: 22 : if (type & SSL_kSRP)
1880 : : {
1881 [ + - ][ + - ]: 22 : if ((s->srp_ctx.N == NULL) ||
1882 [ + - ]: 22 : (s->srp_ctx.g == NULL) ||
1883 [ - + ]: 22 : (s->srp_ctx.s == NULL) ||
1884 : 22 : (s->srp_ctx.B == NULL))
1885 : : {
1886 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_MISSING_SRP_PARAM);
1887 : 0 : goto err;
1888 : : }
1889 : 22 : r[0]=s->srp_ctx.N;
1890 : 22 : r[1]=s->srp_ctx.g;
1891 : 22 : r[2]=s->srp_ctx.s;
1892 : 22 : r[3]=s->srp_ctx.B;
1893 : : }
1894 : : else
1895 : : #endif
1896 : : {
1897 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
1898 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE);
1899 : 0 : goto f_err;
1900 : : }
1901 [ + + ][ + + ]: 1485 : for (i=0; i < 4 && r[i] != NULL; i++)
1902 : : {
1903 : 748 : nr[i]=BN_num_bytes(r[i]);
1904 : : #ifndef OPENSSL_NO_SRP
1905 [ + + ][ + + ]: 748 : if ((i == 2) && (type & SSL_kSRP))
1906 : 22 : n+=1+nr[i];
1907 : : else
1908 : : #endif
1909 : 726 : n+=2+nr[i];
1910 : : }
1911 : :
1912 [ + + ]: 737 : if (!(s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL)
1913 [ + + ]: 627 : && !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK))
1914 : : {
1915 [ + - ]: 605 : if ((pkey=ssl_get_sign_pkey(s,s->s3->tmp.new_cipher,&md))
1916 : : == NULL)
1917 : : {
1918 : : al=SSL_AD_DECODE_ERROR;
1919 : : goto f_err;
1920 : : }
1921 : 605 : kn=EVP_PKEY_size(pkey);
1922 : : }
1923 : : else
1924 : : {
1925 : : pkey=NULL;
1926 : : kn=0;
1927 : : }
1928 : :
1929 [ - + ]: 737 : if (!BUF_MEM_grow_clean(buf,n+SSL_HM_HEADER_LENGTH(s)+kn))
1930 : : {
1931 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_LIB_BUF);
1932 : 0 : goto err;
1933 : : }
1934 : 737 : d = p = ssl_handshake_start(s);
1935 : :
1936 [ + + ][ + + ]: 1485 : for (i=0; i < 4 && r[i] != NULL; i++)
1937 : : {
1938 : : #ifndef OPENSSL_NO_SRP
1939 [ + + ][ + + ]: 748 : if ((i == 2) && (type & SSL_kSRP))
1940 : : {
1941 : 22 : *p = nr[i];
1942 : 22 : p++;
1943 : : }
1944 : : else
1945 : : #endif
1946 : 726 : s2n(nr[i],p);
1947 : 748 : BN_bn2bin(r[i],p);
1948 : 748 : p+=nr[i];
1949 : : }
1950 : :
1951 : : #ifndef OPENSSL_NO_ECDH
1952 [ + + ]: 737 : if (type & SSL_kECDHE)
1953 : : {
1954 : : /* XXX: For now, we only support named (not generic) curves.
1955 : : * In this situation, the serverKeyExchange message has:
1956 : : * [1 byte CurveType], [2 byte CurveName]
1957 : : * [1 byte length of encoded point], followed by
1958 : : * the actual encoded point itself
1959 : : */
1960 : 462 : *p = NAMED_CURVE_TYPE;
1961 : 462 : p += 1;
1962 : 462 : *p = 0;
1963 : 462 : p += 1;
1964 : 462 : *p = curve_id;
1965 : 462 : p += 1;
1966 : 462 : *p = encodedlen;
1967 : 462 : p += 1;
1968 : 462 : memcpy((unsigned char*)p,
1969 : : (unsigned char *)encodedPoint,
1970 : : encodedlen);
1971 : 462 : OPENSSL_free(encodedPoint);
1972 : 462 : encodedPoint = NULL;
1973 : 462 : p += encodedlen;
1974 : : }
1975 : : #endif
1976 : :
1977 : : #ifndef OPENSSL_NO_PSK
1978 [ + + ]: 737 : if (type & SSL_kPSK)
1979 : : {
1980 : : /* copy PSK identity hint */
1981 : 22 : s2n(strlen(s->ctx->psk_identity_hint), p);
1982 : 22 : strncpy((char *)p, s->ctx->psk_identity_hint, strlen(s->ctx->psk_identity_hint));
1983 : 22 : p+=strlen(s->ctx->psk_identity_hint);
1984 : : }
1985 : : #endif
1986 : :
1987 : : /* not anonymous */
1988 [ + + ]: 737 : if (pkey != NULL)
1989 : : {
1990 : : /* n is the length of the params, they start at &(d[4])
1991 : : * and p points to the space at the end. */
1992 : : #ifndef OPENSSL_NO_RSA
1993 [ + - ][ + + ]: 605 : if (pkey->type == EVP_PKEY_RSA && !SSL_USE_SIGALGS(s))
1994 : : {
1995 : : q=md_buf;
1996 : : j=0;
1997 [ + + ]: 1485 : for (num=2; num > 0; num--)
1998 : : {
1999 : 990 : EVP_MD_CTX_set_flags(&md_ctx,
2000 : : EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
2001 [ + + ]: 990 : EVP_DigestInit_ex(&md_ctx,(num == 2)
2002 : 990 : ?s->ctx->md5:s->ctx->sha1, NULL);
2003 : 990 : EVP_DigestUpdate(&md_ctx,&(s->s3->client_random[0]),SSL3_RANDOM_SIZE);
2004 : 990 : EVP_DigestUpdate(&md_ctx,&(s->s3->server_random[0]),SSL3_RANDOM_SIZE);
2005 : 990 : EVP_DigestUpdate(&md_ctx,d,n);
2006 : 990 : EVP_DigestFinal_ex(&md_ctx,q,
2007 : : (unsigned int *)&i);
2008 : 990 : q+=i;
2009 : 990 : j+=i;
2010 : : }
2011 [ - + ]: 495 : if (RSA_sign(NID_md5_sha1, md_buf, j,
2012 : 495 : &(p[2]), &u, pkey->pkey.rsa) <= 0)
2013 : : {
2014 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_LIB_RSA);
2015 : 0 : goto err;
2016 : : }
2017 : 495 : s2n(u,p);
2018 : 495 : n+=u+2;
2019 : : }
2020 : : else
2021 : : #endif
2022 [ + - ]: 110 : if (md)
2023 : : {
2024 : : /* send signature algorithm */
2025 [ + - ]: 110 : if (SSL_USE_SIGALGS(s))
2026 : : {
2027 [ - + ]: 110 : if (!tls12_get_sigandhash(p, pkey, md))
2028 : : {
2029 : : /* Should never happen */
2030 : 0 : al=SSL_AD_INTERNAL_ERROR;
2031 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
2032 : 0 : goto f_err;
2033 : : }
2034 : 110 : p+=2;
2035 : : }
2036 : : #ifdef SSL_DEBUG
2037 : : fprintf(stderr, "Using hash %s\n",
2038 : : EVP_MD_name(md));
2039 : : #endif
2040 : 110 : EVP_SignInit_ex(&md_ctx, md, NULL);
2041 : 110 : EVP_SignUpdate(&md_ctx,&(s->s3->client_random[0]),SSL3_RANDOM_SIZE);
2042 : 110 : EVP_SignUpdate(&md_ctx,&(s->s3->server_random[0]),SSL3_RANDOM_SIZE);
2043 : 110 : EVP_SignUpdate(&md_ctx,d,n);
2044 [ - + ]: 110 : if (!EVP_SignFinal(&md_ctx,&(p[2]),
2045 : : (unsigned int *)&i,pkey))
2046 : : {
2047 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,ERR_LIB_EVP);
2048 : 0 : goto err;
2049 : : }
2050 : 110 : s2n(i,p);
2051 : 110 : n+=i+2;
2052 [ + - ]: 110 : if (SSL_USE_SIGALGS(s))
2053 : 110 : n+= 2;
2054 : : }
2055 : : else
2056 : : {
2057 : : /* Is this error check actually needed? */
2058 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
2059 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_KEY_EXCHANGE,SSL_R_UNKNOWN_PKEY_TYPE);
2060 : 0 : goto f_err;
2061 : : }
2062 : : }
2063 : :
2064 : 737 : ssl_set_handshake_header(s, SSL3_MT_SERVER_KEY_EXCHANGE, n);
2065 : : }
2066 : :
2067 : 737 : s->state = SSL3_ST_SW_KEY_EXCH_B;
2068 : 737 : EVP_MD_CTX_cleanup(&md_ctx);
2069 : 737 : return ssl_do_write(s);
2070 : : f_err:
2071 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,al);
2072 : : err:
2073 : : #ifndef OPENSSL_NO_ECDH
2074 [ # # ]: 0 : if (encodedPoint != NULL) OPENSSL_free(encodedPoint);
2075 : 0 : BN_CTX_free(bn_ctx);
2076 : : #endif
2077 : 0 : EVP_MD_CTX_cleanup(&md_ctx);
2078 : 0 : return(-1);
2079 : : }
2080 : :
2081 : 99 : int ssl3_send_certificate_request(SSL *s)
2082 : : {
2083 : : unsigned char *p,*d;
2084 : : int i,j,nl,off,n;
2085 : 99 : STACK_OF(X509_NAME) *sk=NULL;
2086 : : X509_NAME *name;
2087 : : BUF_MEM *buf;
2088 : :
2089 [ + - ]: 99 : if (s->state == SSL3_ST_SW_CERT_REQ_A)
2090 : : {
2091 : 99 : buf=s->init_buf;
2092 : :
2093 : 99 : d=p=ssl_handshake_start(s);
2094 : :
2095 : : /* get the list of acceptable cert types */
2096 : 99 : p++;
2097 : 99 : n=ssl3_get_req_cert_type(s,p);
2098 : 99 : d[0]=n;
2099 : 99 : p+=n;
2100 : 99 : n++;
2101 : :
2102 [ + + ]: 99 : if (SSL_USE_SIGALGS(s))
2103 : : {
2104 : : const unsigned char *psigs;
2105 : 55 : unsigned char *etmp = p;
2106 : 55 : nl = tls12_get_psigalgs(s, &psigs);
2107 : : /* Skip over length for now */
2108 : 55 : p += 2;
2109 : 55 : nl = tls12_copy_sigalgs(s, p, psigs, nl);
2110 : : /* Now fill in length */
2111 : 55 : s2n(nl, etmp);
2112 : 55 : p += nl;
2113 : 55 : n += nl + 2;
2114 : : }
2115 : :
2116 : 99 : off=n;
2117 : 99 : p+=2;
2118 : 99 : n+=2;
2119 : :
2120 : 99 : sk=SSL_get_client_CA_list(s);
2121 : 99 : nl=0;
2122 [ + - ]: 99 : if (sk != NULL)
2123 : : {
2124 [ - + ]: 99 : for (i=0; i<sk_X509_NAME_num(sk); i++)
2125 : : {
2126 : 0 : name=sk_X509_NAME_value(sk,i);
2127 : 0 : j=i2d_X509_NAME(name,NULL);
2128 [ # # ]: 0 : if (!BUF_MEM_grow_clean(buf,SSL_HM_HEADER_LENGTH(s)+n+j+2))
2129 : : {
2130 : 0 : SSLerr(SSL_F_SSL3_SEND_CERTIFICATE_REQUEST,ERR_R_BUF_LIB);
2131 : 0 : goto err;
2132 : : }
2133 : 0 : p = ssl_handshake_start(s) + n;
2134 [ # # ]: 0 : if (!(s->options & SSL_OP_NETSCAPE_CA_DN_BUG))
2135 : : {
2136 : 0 : s2n(j,p);
2137 : 0 : i2d_X509_NAME(name,&p);
2138 : 0 : n+=2+j;
2139 : 0 : nl+=2+j;
2140 : : }
2141 : : else
2142 : : {
2143 : 0 : d=p;
2144 : 0 : i2d_X509_NAME(name,&p);
2145 : 0 : j-=2; s2n(j,d); j+=2;
2146 : 0 : n+=j;
2147 : 0 : nl+=j;
2148 : : }
2149 : : }
2150 : : }
2151 : : /* else no CA names */
2152 : 99 : p = ssl_handshake_start(s) + off;
2153 : 99 : s2n(nl,p);
2154 : :
2155 : 99 : ssl_set_handshake_header(s, SSL3_MT_CERTIFICATE_REQUEST, n);
2156 : :
2157 : : #ifdef NETSCAPE_HANG_BUG
2158 [ + - ]: 99 : if (!SSL_IS_DTLS(s))
2159 : : {
2160 [ - + ]: 99 : if (!BUF_MEM_grow_clean(buf, s->init_num + 4))
2161 : : {
2162 : 0 : SSLerr(SSL_F_SSL3_SEND_CERTIFICATE_REQUEST,ERR_R_BUF_LIB);
2163 : 0 : goto err;
2164 : : }
2165 : 99 : p=(unsigned char *)s->init_buf->data + s->init_num;
2166 : : /* do the header */
2167 : 99 : *(p++)=SSL3_MT_SERVER_DONE;
2168 : 99 : *(p++)=0;
2169 : 99 : *(p++)=0;
2170 : 99 : *(p++)=0;
2171 : 99 : s->init_num += 4;
2172 : : }
2173 : : #endif
2174 : :
2175 : 99 : s->state = SSL3_ST_SW_CERT_REQ_B;
2176 : : }
2177 : :
2178 : : /* SSL3_ST_SW_CERT_REQ_B */
2179 : 99 : return ssl_do_write(s);
2180 : : err:
2181 : : return(-1);
2182 : : }
2183 : :
2184 : 1509 : int ssl3_get_client_key_exchange(SSL *s)
2185 : : {
2186 : : int i,al,ok;
2187 : : long n;
2188 : : unsigned long alg_k;
2189 : : unsigned char *p;
2190 : : #ifndef OPENSSL_NO_RSA
2191 : 1509 : RSA *rsa=NULL;
2192 : 1509 : EVP_PKEY *pkey=NULL;
2193 : : #endif
2194 : : #ifndef OPENSSL_NO_DH
2195 : 1509 : BIGNUM *pub=NULL;
2196 : 1509 : DH *dh_srvr, *dh_clnt = NULL;
2197 : : #endif
2198 : : #ifndef OPENSSL_NO_KRB5
2199 : : KSSL_ERR kssl_err;
2200 : : #endif /* OPENSSL_NO_KRB5 */
2201 : :
2202 : : #ifndef OPENSSL_NO_ECDH
2203 : 1509 : EC_KEY *srvr_ecdh = NULL;
2204 : 1509 : EVP_PKEY *clnt_pub_pkey = NULL;
2205 : 1509 : EC_POINT *clnt_ecpoint = NULL;
2206 : 1509 : BN_CTX *bn_ctx = NULL;
2207 : : #endif
2208 : :
2209 : 1509 : n=s->method->ssl_get_message(s,
2210 : : SSL3_ST_SR_KEY_EXCH_A,
2211 : : SSL3_ST_SR_KEY_EXCH_B,
2212 : : SSL3_MT_CLIENT_KEY_EXCHANGE,
2213 : : 2048, /* ??? */
2214 : : &ok);
2215 : :
2216 [ + + ]: 1509 : if (!ok) return((int)n);
2217 : 1069 : p=(unsigned char *)s->init_msg;
2218 : :
2219 : 1069 : alg_k=s->s3->tmp.new_cipher->algorithm_mkey;
2220 : :
2221 : : #ifndef OPENSSL_NO_RSA
2222 [ + + ]: 1069 : if (alg_k & SSL_kRSA)
2223 : : {
2224 : : unsigned char rand_premaster_secret[SSL_MAX_MASTER_KEY_LENGTH];
2225 : : int decrypt_len, decrypt_good_mask;
2226 : : unsigned char version_good;
2227 : :
2228 : : /* FIX THIS UP EAY EAY EAY EAY */
2229 [ + + ]: 365 : if (s->s3->tmp.use_rsa_tmp)
2230 : : {
2231 [ + - ][ + - ]: 33 : if ((s->cert != NULL) && (s->cert->rsa_tmp != NULL))
2232 : 33 : rsa=s->cert->rsa_tmp;
2233 : : /* Don't do a callback because rsa_tmp should
2234 : : * be sent already */
2235 [ - + ]: 33 : if (rsa == NULL)
2236 : : {
2237 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
2238 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_TMP_RSA_PKEY);
2239 : 0 : goto f_err;
2240 : :
2241 : : }
2242 : : }
2243 : : else
2244 : : {
2245 : 332 : pkey=s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey;
2246 [ + - ][ + - ]: 332 : if ( (pkey == NULL) ||
2247 [ - + ]: 332 : (pkey->type != EVP_PKEY_RSA) ||
2248 : 332 : (pkey->pkey.rsa == NULL))
2249 : : {
2250 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
2251 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_RSA_CERTIFICATE);
2252 : 0 : goto f_err;
2253 : : }
2254 : : rsa=pkey->pkey.rsa;
2255 : : }
2256 : :
2257 : : /* TLS and [incidentally] DTLS{0xFEFF} */
2258 [ + + ]: 365 : if (s->version > SSL3_VERSION && s->version != DTLS1_BAD_VER)
2259 : : {
2260 : 200 : n2s(p,i);
2261 [ - + ]: 200 : if (n != i+2)
2262 : : {
2263 [ # # ]: 0 : if (!(s->options & SSL_OP_TLS_D5_BUG))
2264 : : {
2265 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG);
2266 : 0 : goto err;
2267 : : }
2268 : : else
2269 : 0 : p-=2;
2270 : : }
2271 : : else
2272 : 200 : n=i;
2273 : : }
2274 : :
2275 : : /* We must not leak whether a decryption failure occurs because
2276 : : * of Bleichenbacher's attack on PKCS #1 v1.5 RSA padding (see
2277 : : * RFC 2246, section 7.4.7.1). The code follows that advice of
2278 : : * the TLS RFC and generates a random premaster secret for the
2279 : : * case that the decrypt fails. See
2280 : : * https://tools.ietf.org/html/rfc5246#section-7.4.7.1 */
2281 : :
2282 : : /* should be RAND_bytes, but we cannot work around a failure. */
2283 [ + - ]: 365 : if (RAND_pseudo_bytes(rand_premaster_secret,
2284 : : sizeof(rand_premaster_secret)) <= 0)
2285 : : goto err;
2286 : 365 : decrypt_len = RSA_private_decrypt((int)n,p,p,rsa,RSA_PKCS1_PADDING);
2287 : 365 : ERR_clear_error();
2288 : :
2289 : : /* decrypt_len should be SSL_MAX_MASTER_KEY_LENGTH.
2290 : : * decrypt_good_mask will be zero if so and non-zero otherwise. */
2291 : 365 : decrypt_good_mask = decrypt_len ^ SSL_MAX_MASTER_KEY_LENGTH;
2292 : :
2293 : : /* If the version in the decrypted pre-master secret is correct
2294 : : * then version_good will be zero. The Klima-Pokorny-Rosa
2295 : : * extension of Bleichenbacher's attack
2296 : : * (http://eprint.iacr.org/2003/052/) exploits the version
2297 : : * number check as a "bad version oracle". Thus version checks
2298 : : * are done in constant time and are treated like any other
2299 : : * decryption error. */
2300 : 365 : version_good = p[0] ^ (s->client_version>>8);
2301 : 365 : version_good |= p[1] ^ (s->client_version&0xff);
2302 : :
2303 : : /* The premaster secret must contain the same version number as
2304 : : * the ClientHello to detect version rollback attacks
2305 : : * (strangely, the protocol does not offer such protection for
2306 : : * DH ciphersuites). However, buggy clients exist that send the
2307 : : * negotiated protocol version instead if the server does not
2308 : : * support the requested protocol version. If
2309 : : * SSL_OP_TLS_ROLLBACK_BUG is set, tolerate such clients. */
2310 [ - + ]: 365 : if (s->options & SSL_OP_TLS_ROLLBACK_BUG)
2311 : : {
2312 : 0 : unsigned char workaround_mask = version_good;
2313 : : unsigned char workaround;
2314 : :
2315 : : /* workaround_mask will be 0xff if version_good is
2316 : : * non-zero (i.e. the version match failed). Otherwise
2317 : : * it'll be 0x00. */
2318 : 0 : workaround_mask |= workaround_mask >> 4;
2319 : 0 : workaround_mask |= workaround_mask >> 2;
2320 : 0 : workaround_mask |= workaround_mask >> 1;
2321 : 0 : workaround_mask = ~((workaround_mask & 1) - 1);
2322 : :
2323 : 0 : workaround = p[0] ^ (s->version>>8);
2324 : 0 : workaround |= p[1] ^ (s->version&0xff);
2325 : :
2326 : : /* If workaround_mask is 0xff (i.e. there was a version
2327 : : * mismatch) then we copy the value of workaround over
2328 : : * version_good. */
2329 : 0 : version_good = (workaround & workaround_mask) |
2330 : : (version_good & ~workaround_mask);
2331 : : }
2332 : :
2333 : : /* If any bits in version_good are set then they'll poision
2334 : : * decrypt_good_mask and cause rand_premaster_secret to be
2335 : : * used. */
2336 : 365 : decrypt_good_mask |= version_good;
2337 : :
2338 : : /* decrypt_good_mask will be zero iff decrypt_len ==
2339 : : * SSL_MAX_MASTER_KEY_LENGTH and the version check passed. We
2340 : : * fold the bottom 32 bits of it with an OR so that the LSB
2341 : : * will be zero iff everything is good. This assumes that we'll
2342 : : * never decrypt a value > 2**31 bytes, which seems safe. */
2343 : 365 : decrypt_good_mask |= decrypt_good_mask >> 16;
2344 : 365 : decrypt_good_mask |= decrypt_good_mask >> 8;
2345 : 365 : decrypt_good_mask |= decrypt_good_mask >> 4;
2346 : 365 : decrypt_good_mask |= decrypt_good_mask >> 2;
2347 : 365 : decrypt_good_mask |= decrypt_good_mask >> 1;
2348 : : /* Now select only the LSB and subtract one. If decrypt_len ==
2349 : : * SSL_MAX_MASTER_KEY_LENGTH and the version check passed then
2350 : : * decrypt_good_mask will be all ones. Otherwise it'll be all
2351 : : * zeros. */
2352 : 365 : decrypt_good_mask &= 1;
2353 : 365 : decrypt_good_mask--;
2354 : :
2355 : : /* Now copy rand_premaster_secret over p using
2356 : : * decrypt_good_mask. */
2357 [ + + ]: 17885 : for (i = 0; i < (int) sizeof(rand_premaster_secret); i++)
2358 : : {
2359 : 35040 : p[i] = (p[i] & decrypt_good_mask) |
2360 : 17520 : (rand_premaster_secret[i] & ~decrypt_good_mask);
2361 : : }
2362 : :
2363 : 365 : s->session->master_key_length=
2364 : 365 : s->method->ssl3_enc->generate_master_secret(s,
2365 : 365 : s->session->master_key,
2366 : : p,i);
2367 : 365 : OPENSSL_cleanse(p,i);
2368 : : }
2369 : : else
2370 : : #endif
2371 : : #ifndef OPENSSL_NO_DH
2372 [ + + ]: 704 : if (alg_k & (SSL_kDHE|SSL_kDHr|SSL_kDHd))
2373 : : {
2374 : 198 : int idx = -1;
2375 : 198 : EVP_PKEY *skey = NULL;
2376 [ + - ]: 198 : if (n)
2377 : 198 : n2s(p,i);
2378 : : else
2379 : : i = 0;
2380 [ + - ][ - + ]: 198 : if (n && n != i+2)
2381 : : {
2382 [ # # ]: 0 : if (!(s->options & SSL_OP_SSLEAY_080_CLIENT_DH_BUG))
2383 : : {
2384 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG);
2385 : 0 : goto err;
2386 : : }
2387 : : else
2388 : : {
2389 : 0 : p-=2;
2390 : 0 : i=(int)n;
2391 : : }
2392 : : }
2393 [ + - ]: 198 : if (alg_k & SSL_kDHr)
2394 : : idx = SSL_PKEY_DH_RSA;
2395 [ - + ]: 198 : else if (alg_k & SSL_kDHd)
2396 : 0 : idx = SSL_PKEY_DH_DSA;
2397 [ - + ]: 198 : if (idx >= 0)
2398 : : {
2399 : 0 : skey = s->cert->pkeys[idx].privatekey;
2400 [ # # ][ # # ]: 0 : if ((skey == NULL) ||
2401 [ # # ]: 0 : (skey->type != EVP_PKEY_DH) ||
2402 : 0 : (skey->pkey.dh == NULL))
2403 : : {
2404 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
2405 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_RSA_CERTIFICATE);
2406 : 0 : goto f_err;
2407 : : }
2408 : : dh_srvr = skey->pkey.dh;
2409 : : }
2410 [ - + ]: 198 : else if (s->s3->tmp.dh == NULL)
2411 : : {
2412 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
2413 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_TMP_DH_KEY);
2414 : 0 : goto f_err;
2415 : : }
2416 : : else
2417 : : dh_srvr=s->s3->tmp.dh;
2418 : :
2419 [ - + ]: 198 : if (n == 0L)
2420 : : {
2421 : : /* Get pubkey from cert */
2422 : 0 : EVP_PKEY *clkey=X509_get_pubkey(s->session->peer);
2423 [ # # ]: 0 : if (clkey)
2424 : : {
2425 [ # # ]: 0 : if (EVP_PKEY_cmp_parameters(clkey, skey) == 1)
2426 : 0 : dh_clnt = EVP_PKEY_get1_DH(clkey);
2427 : : }
2428 [ # # ]: 0 : if (dh_clnt == NULL)
2429 : : {
2430 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
2431 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_TMP_DH_KEY);
2432 : 0 : goto f_err;
2433 : : }
2434 : 0 : EVP_PKEY_free(clkey);
2435 : 0 : pub = dh_clnt->pub_key;
2436 : : }
2437 : : else
2438 : 198 : pub=BN_bin2bn(p,i,NULL);
2439 [ - + ]: 198 : if (pub == NULL)
2440 : : {
2441 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_BN_LIB);
2442 : 0 : goto err;
2443 : : }
2444 : :
2445 : 198 : i=DH_compute_key(p,pub,dh_srvr);
2446 : :
2447 [ - + ]: 198 : if (i <= 0)
2448 : : {
2449 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,ERR_R_DH_LIB);
2450 : 0 : BN_clear_free(pub);
2451 : 0 : goto err;
2452 : : }
2453 : :
2454 : 198 : DH_free(s->s3->tmp.dh);
2455 : 198 : s->s3->tmp.dh=NULL;
2456 [ - + ]: 198 : if (dh_clnt)
2457 : 0 : DH_free(dh_clnt);
2458 : : else
2459 : 198 : BN_clear_free(pub);
2460 : 198 : pub=NULL;
2461 : 198 : s->session->master_key_length=
2462 : 198 : s->method->ssl3_enc->generate_master_secret(s,
2463 : 198 : s->session->master_key,p,i);
2464 : 198 : OPENSSL_cleanse(p,i);
2465 [ + - ]: 198 : if (dh_clnt)
2466 : : return 2;
2467 : : }
2468 : : else
2469 : : #endif
2470 : : #ifndef OPENSSL_NO_KRB5
2471 : : if (alg_k & SSL_kKRB5)
2472 : : {
2473 : : krb5_error_code krb5rc;
2474 : : krb5_data enc_ticket;
2475 : : krb5_data authenticator;
2476 : : krb5_data enc_pms;
2477 : : KSSL_CTX *kssl_ctx = s->kssl_ctx;
2478 : : EVP_CIPHER_CTX ciph_ctx;
2479 : : const EVP_CIPHER *enc = NULL;
2480 : : unsigned char iv[EVP_MAX_IV_LENGTH];
2481 : : unsigned char pms[SSL_MAX_MASTER_KEY_LENGTH
2482 : : + EVP_MAX_BLOCK_LENGTH];
2483 : : int padl, outl;
2484 : : krb5_timestamp authtime = 0;
2485 : : krb5_ticket_times ttimes;
2486 : :
2487 : : EVP_CIPHER_CTX_init(&ciph_ctx);
2488 : :
2489 : : if (!kssl_ctx) kssl_ctx = kssl_ctx_new();
2490 : :
2491 : : n2s(p,i);
2492 : : enc_ticket.length = i;
2493 : :
2494 : : if (n < (long)(enc_ticket.length + 6))
2495 : : {
2496 : : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2497 : : SSL_R_DATA_LENGTH_TOO_LONG);
2498 : : goto err;
2499 : : }
2500 : :
2501 : : enc_ticket.data = (char *)p;
2502 : : p+=enc_ticket.length;
2503 : :
2504 : : n2s(p,i);
2505 : : authenticator.length = i;
2506 : :
2507 : : if (n < (long)(enc_ticket.length + authenticator.length + 6))
2508 : : {
2509 : : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2510 : : SSL_R_DATA_LENGTH_TOO_LONG);
2511 : : goto err;
2512 : : }
2513 : :
2514 : : authenticator.data = (char *)p;
2515 : : p+=authenticator.length;
2516 : :
2517 : : n2s(p,i);
2518 : : enc_pms.length = i;
2519 : : enc_pms.data = (char *)p;
2520 : : p+=enc_pms.length;
2521 : :
2522 : : /* Note that the length is checked again below,
2523 : : ** after decryption
2524 : : */
2525 : : if(enc_pms.length > sizeof pms)
2526 : : {
2527 : : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2528 : : SSL_R_DATA_LENGTH_TOO_LONG);
2529 : : goto err;
2530 : : }
2531 : :
2532 : : if (n != (long)(enc_ticket.length + authenticator.length +
2533 : : enc_pms.length + 6))
2534 : : {
2535 : : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2536 : : SSL_R_DATA_LENGTH_TOO_LONG);
2537 : : goto err;
2538 : : }
2539 : :
2540 : : if ((krb5rc = kssl_sget_tkt(kssl_ctx, &enc_ticket, &ttimes,
2541 : : &kssl_err)) != 0)
2542 : : {
2543 : : #ifdef KSSL_DEBUG
2544 : : printf("kssl_sget_tkt rtn %d [%d]\n",
2545 : : krb5rc, kssl_err.reason);
2546 : : if (kssl_err.text)
2547 : : printf("kssl_err text= %s\n", kssl_err.text);
2548 : : #endif /* KSSL_DEBUG */
2549 : : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2550 : : kssl_err.reason);
2551 : : goto err;
2552 : : }
2553 : :
2554 : : /* Note: no authenticator is not considered an error,
2555 : : ** but will return authtime == 0.
2556 : : */
2557 : : if ((krb5rc = kssl_check_authent(kssl_ctx, &authenticator,
2558 : : &authtime, &kssl_err)) != 0)
2559 : : {
2560 : : #ifdef KSSL_DEBUG
2561 : : printf("kssl_check_authent rtn %d [%d]\n",
2562 : : krb5rc, kssl_err.reason);
2563 : : if (kssl_err.text)
2564 : : printf("kssl_err text= %s\n", kssl_err.text);
2565 : : #endif /* KSSL_DEBUG */
2566 : : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2567 : : kssl_err.reason);
2568 : : goto err;
2569 : : }
2570 : :
2571 : : if ((krb5rc = kssl_validate_times(authtime, &ttimes)) != 0)
2572 : : {
2573 : : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, krb5rc);
2574 : : goto err;
2575 : : }
2576 : :
2577 : : #ifdef KSSL_DEBUG
2578 : : kssl_ctx_show(kssl_ctx);
2579 : : #endif /* KSSL_DEBUG */
2580 : :
2581 : : enc = kssl_map_enc(kssl_ctx->enctype);
2582 : : if (enc == NULL)
2583 : : goto err;
2584 : :
2585 : : memset(iv, 0, sizeof iv); /* per RFC 1510 */
2586 : :
2587 : : if (!EVP_DecryptInit_ex(&ciph_ctx,enc,NULL,kssl_ctx->key,iv))
2588 : : {
2589 : : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2590 : : SSL_R_DECRYPTION_FAILED);
2591 : : goto err;
2592 : : }
2593 : : if (!EVP_DecryptUpdate(&ciph_ctx, pms,&outl,
2594 : : (unsigned char *)enc_pms.data, enc_pms.length))
2595 : : {
2596 : : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2597 : : SSL_R_DECRYPTION_FAILED);
2598 : : goto err;
2599 : : }
2600 : : if (outl > SSL_MAX_MASTER_KEY_LENGTH)
2601 : : {
2602 : : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2603 : : SSL_R_DATA_LENGTH_TOO_LONG);
2604 : : goto err;
2605 : : }
2606 : : if (!EVP_DecryptFinal_ex(&ciph_ctx,&(pms[outl]),&padl))
2607 : : {
2608 : : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2609 : : SSL_R_DECRYPTION_FAILED);
2610 : : goto err;
2611 : : }
2612 : : outl += padl;
2613 : : if (outl > SSL_MAX_MASTER_KEY_LENGTH)
2614 : : {
2615 : : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2616 : : SSL_R_DATA_LENGTH_TOO_LONG);
2617 : : goto err;
2618 : : }
2619 : : if (!((pms[0] == (s->client_version>>8)) && (pms[1] == (s->client_version & 0xff))))
2620 : : {
2621 : : /* The premaster secret must contain the same version number as the
2622 : : * ClientHello to detect version rollback attacks (strangely, the
2623 : : * protocol does not offer such protection for DH ciphersuites).
2624 : : * However, buggy clients exist that send random bytes instead of
2625 : : * the protocol version.
2626 : : * If SSL_OP_TLS_ROLLBACK_BUG is set, tolerate such clients.
2627 : : * (Perhaps we should have a separate BUG value for the Kerberos cipher)
2628 : : */
2629 : : if (!(s->options & SSL_OP_TLS_ROLLBACK_BUG))
2630 : : {
2631 : : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2632 : : SSL_AD_DECODE_ERROR);
2633 : : goto err;
2634 : : }
2635 : : }
2636 : :
2637 : : EVP_CIPHER_CTX_cleanup(&ciph_ctx);
2638 : :
2639 : : s->session->master_key_length=
2640 : : s->method->ssl3_enc->generate_master_secret(s,
2641 : : s->session->master_key, pms, outl);
2642 : :
2643 : : if (kssl_ctx->client_princ)
2644 : : {
2645 : : size_t len = strlen(kssl_ctx->client_princ);
2646 : : if ( len < SSL_MAX_KRB5_PRINCIPAL_LENGTH )
2647 : : {
2648 : : s->session->krb5_client_princ_len = len;
2649 : : memcpy(s->session->krb5_client_princ,kssl_ctx->client_princ,len);
2650 : : }
2651 : : }
2652 : :
2653 : :
2654 : : /* Was doing kssl_ctx_free() here,
2655 : : ** but it caused problems for apache.
2656 : : ** kssl_ctx = kssl_ctx_free(kssl_ctx);
2657 : : ** if (s->kssl_ctx) s->kssl_ctx = NULL;
2658 : : */
2659 : : }
2660 : : else
2661 : : #endif /* OPENSSL_NO_KRB5 */
2662 : :
2663 : : #ifndef OPENSSL_NO_ECDH
2664 [ + + ]: 506 : if (alg_k & (SSL_kECDHE|SSL_kECDHr|SSL_kECDHe))
2665 : : {
2666 : 462 : int ret = 1;
2667 : 462 : int field_size = 0;
2668 : : const EC_KEY *tkey;
2669 : : const EC_GROUP *group;
2670 : : const BIGNUM *priv_key;
2671 : :
2672 : : /* initialize structures for server's ECDH key pair */
2673 [ - + ]: 462 : if ((srvr_ecdh = EC_KEY_new()) == NULL)
2674 : : {
2675 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2676 : : ERR_R_MALLOC_FAILURE);
2677 : 0 : goto err;
2678 : : }
2679 : :
2680 : : /* Let's get server private key and group information */
2681 [ - + ]: 462 : if (alg_k & (SSL_kECDHr|SSL_kECDHe))
2682 : : {
2683 : : /* use the certificate */
2684 : 0 : tkey = s->cert->pkeys[SSL_PKEY_ECC].privatekey->pkey.ec;
2685 : : }
2686 : : else
2687 : : {
2688 : : /* use the ephermeral values we saved when
2689 : : * generating the ServerKeyExchange msg.
2690 : : */
2691 : 462 : tkey = s->s3->tmp.ecdh;
2692 : : }
2693 : :
2694 : 462 : group = EC_KEY_get0_group(tkey);
2695 : 462 : priv_key = EC_KEY_get0_private_key(tkey);
2696 : :
2697 [ + - - + ]: 924 : if (!EC_KEY_set_group(srvr_ecdh, group) ||
2698 : 462 : !EC_KEY_set_private_key(srvr_ecdh, priv_key))
2699 : : {
2700 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2701 : : ERR_R_EC_LIB);
2702 : 0 : goto err;
2703 : : }
2704 : :
2705 : : /* Let's get client's public key */
2706 [ - + ]: 462 : if ((clnt_ecpoint = EC_POINT_new(group)) == NULL)
2707 : : {
2708 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2709 : : ERR_R_MALLOC_FAILURE);
2710 : 0 : goto err;
2711 : : }
2712 : :
2713 [ - + ]: 462 : if (n == 0L)
2714 : : {
2715 : : /* Client Publickey was in Client Certificate */
2716 : :
2717 [ # # ]: 0 : if (alg_k & SSL_kECDHE)
2718 : : {
2719 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
2720 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_MISSING_TMP_ECDH_KEY);
2721 : 0 : goto f_err;
2722 : : }
2723 [ # # ]: 0 : if (((clnt_pub_pkey=X509_get_pubkey(s->session->peer))
2724 [ # # ]: 0 : == NULL) ||
2725 : 0 : (clnt_pub_pkey->type != EVP_PKEY_EC))
2726 : : {
2727 : : /* XXX: For now, we do not support client
2728 : : * authentication using ECDH certificates
2729 : : * so this branch (n == 0L) of the code is
2730 : : * never executed. When that support is
2731 : : * added, we ought to ensure the key
2732 : : * received in the certificate is
2733 : : * authorized for key agreement.
2734 : : * ECDH_compute_key implicitly checks that
2735 : : * the two ECDH shares are for the same
2736 : : * group.
2737 : : */
2738 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
2739 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2740 : : SSL_R_UNABLE_TO_DECODE_ECDH_CERTS);
2741 : 0 : goto f_err;
2742 : : }
2743 : :
2744 [ # # ]: 0 : if (EC_POINT_copy(clnt_ecpoint,
2745 : 0 : EC_KEY_get0_public_key(clnt_pub_pkey->pkey.ec)) == 0)
2746 : : {
2747 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2748 : : ERR_R_EC_LIB);
2749 : 0 : goto err;
2750 : : }
2751 : : ret = 2; /* Skip certificate verify processing */
2752 : : }
2753 : : else
2754 : : {
2755 : : /* Get client's public key from encoded point
2756 : : * in the ClientKeyExchange message.
2757 : : */
2758 [ - + ]: 462 : if ((bn_ctx = BN_CTX_new()) == NULL)
2759 : : {
2760 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2761 : : ERR_R_MALLOC_FAILURE);
2762 : 0 : goto err;
2763 : : }
2764 : :
2765 : : /* Get encoded point length */
2766 : 462 : i = *p;
2767 : 462 : p += 1;
2768 [ - + ]: 462 : if (n != 1 + i)
2769 : : {
2770 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2771 : : ERR_R_EC_LIB);
2772 : 0 : goto err;
2773 : : }
2774 [ - + ]: 462 : if (EC_POINT_oct2point(group,
2775 : : clnt_ecpoint, p, i, bn_ctx) == 0)
2776 : : {
2777 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2778 : : ERR_R_EC_LIB);
2779 : 0 : goto err;
2780 : : }
2781 : : /* p is pointing to somewhere in the buffer
2782 : : * currently, so set it to the start
2783 : : */
2784 : 462 : p=(unsigned char *)s->init_buf->data;
2785 : : }
2786 : :
2787 : : /* Compute the shared pre-master secret */
2788 : 462 : field_size = EC_GROUP_get_degree(group);
2789 [ - + ]: 462 : if (field_size <= 0)
2790 : : {
2791 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2792 : : ERR_R_ECDH_LIB);
2793 : 0 : goto err;
2794 : : }
2795 : 462 : i = ECDH_compute_key(p, (field_size+7)/8, clnt_ecpoint, srvr_ecdh, NULL);
2796 [ - + ]: 462 : if (i <= 0)
2797 : : {
2798 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2799 : : ERR_R_ECDH_LIB);
2800 : 0 : goto err;
2801 : : }
2802 : :
2803 : 462 : EVP_PKEY_free(clnt_pub_pkey);
2804 : 462 : EC_POINT_free(clnt_ecpoint);
2805 : 462 : EC_KEY_free(srvr_ecdh);
2806 : 462 : BN_CTX_free(bn_ctx);
2807 : 462 : EC_KEY_free(s->s3->tmp.ecdh);
2808 : 462 : s->s3->tmp.ecdh = NULL;
2809 : :
2810 : : /* Compute the master secret */
2811 : 924 : s->session->master_key_length = s->method->ssl3_enc-> \
2812 : 462 : generate_master_secret(s, s->session->master_key, p, i);
2813 : :
2814 : 462 : OPENSSL_cleanse(p, i);
2815 : 462 : return (ret);
2816 : : }
2817 : : else
2818 : : #endif
2819 : : #ifndef OPENSSL_NO_PSK
2820 [ + + ]: 44 : if (alg_k & SSL_kPSK)
2821 : : {
2822 : 22 : unsigned char *t = NULL;
2823 : : unsigned char psk_or_pre_ms[PSK_MAX_PSK_LEN*2+4];
2824 : 22 : unsigned int pre_ms_len = 0, psk_len = 0;
2825 : 22 : int psk_err = 1;
2826 : : char tmp_id[PSK_MAX_IDENTITY_LEN+1];
2827 : :
2828 : 22 : al=SSL_AD_HANDSHAKE_FAILURE;
2829 : :
2830 : 22 : n2s(p,i);
2831 [ - + ]: 22 : if (n != i+2)
2832 : : {
2833 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2834 : : SSL_R_LENGTH_MISMATCH);
2835 : 0 : goto psk_err;
2836 : : }
2837 [ - + ]: 22 : if (i > PSK_MAX_IDENTITY_LEN)
2838 : : {
2839 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2840 : : SSL_R_DATA_LENGTH_TOO_LONG);
2841 : 0 : goto psk_err;
2842 : : }
2843 [ - + ]: 22 : if (s->psk_server_callback == NULL)
2844 : : {
2845 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2846 : : SSL_R_PSK_NO_SERVER_CB);
2847 : 0 : goto psk_err;
2848 : : }
2849 : :
2850 : : /* Create guaranteed NULL-terminated identity
2851 : : * string for the callback */
2852 : 22 : memcpy(tmp_id, p, i);
2853 : 22 : memset(tmp_id+i, 0, PSK_MAX_IDENTITY_LEN+1-i);
2854 : 22 : psk_len = s->psk_server_callback(s, tmp_id,
2855 : : psk_or_pre_ms, sizeof(psk_or_pre_ms));
2856 : 22 : OPENSSL_cleanse(tmp_id, PSK_MAX_IDENTITY_LEN+1);
2857 : :
2858 [ - + ]: 22 : if (psk_len > PSK_MAX_PSK_LEN)
2859 : : {
2860 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2861 : : ERR_R_INTERNAL_ERROR);
2862 : 0 : goto psk_err;
2863 : : }
2864 [ - + ]: 22 : else if (psk_len == 0)
2865 : : {
2866 : : /* PSK related to the given identity not found */
2867 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2868 : : SSL_R_PSK_IDENTITY_NOT_FOUND);
2869 : 0 : al=SSL_AD_UNKNOWN_PSK_IDENTITY;
2870 : 0 : goto psk_err;
2871 : : }
2872 : :
2873 : : /* create PSK pre_master_secret */
2874 : 22 : pre_ms_len=2+psk_len+2+psk_len;
2875 : 22 : t = psk_or_pre_ms;
2876 : 22 : memmove(psk_or_pre_ms+psk_len+4, psk_or_pre_ms, psk_len);
2877 : 22 : s2n(psk_len, t);
2878 : 22 : memset(t, 0, psk_len);
2879 : 22 : t+=psk_len;
2880 : 22 : s2n(psk_len, t);
2881 : :
2882 [ - + ]: 22 : if (s->session->psk_identity != NULL)
2883 : 0 : OPENSSL_free(s->session->psk_identity);
2884 : 22 : s->session->psk_identity = BUF_strdup((char *)p);
2885 [ - + ]: 22 : if (s->session->psk_identity == NULL)
2886 : : {
2887 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2888 : : ERR_R_MALLOC_FAILURE);
2889 : 0 : goto psk_err;
2890 : : }
2891 : :
2892 [ - + ]: 22 : if (s->session->psk_identity_hint != NULL)
2893 : 0 : OPENSSL_free(s->session->psk_identity_hint);
2894 : 22 : s->session->psk_identity_hint = BUF_strdup(s->ctx->psk_identity_hint);
2895 [ + - ][ - + ]: 22 : if (s->ctx->psk_identity_hint != NULL &&
2896 : 22 : s->session->psk_identity_hint == NULL)
2897 : : {
2898 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2899 : : ERR_R_MALLOC_FAILURE);
2900 : 0 : goto psk_err;
2901 : : }
2902 : :
2903 : 22 : s->session->master_key_length=
2904 : 22 : s->method->ssl3_enc->generate_master_secret(s,
2905 : 22 : s->session->master_key, psk_or_pre_ms, pre_ms_len);
2906 : 22 : psk_err = 0;
2907 : : psk_err:
2908 : 22 : OPENSSL_cleanse(psk_or_pre_ms, sizeof(psk_or_pre_ms));
2909 [ + - ]: 22 : if (psk_err != 0)
2910 : : goto f_err;
2911 : : }
2912 : : else
2913 : : #endif
2914 : : #ifndef OPENSSL_NO_SRP
2915 [ + - ]: 22 : if (alg_k & SSL_kSRP)
2916 : : {
2917 : : int param_len;
2918 : :
2919 : 22 : n2s(p,i);
2920 : 22 : param_len=i+2;
2921 [ - + ]: 22 : if (param_len > n)
2922 : : {
2923 : 0 : al=SSL_AD_DECODE_ERROR;
2924 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_BAD_SRP_A_LENGTH);
2925 : 0 : goto f_err;
2926 : : }
2927 [ - + ]: 22 : if (!(s->srp_ctx.A=BN_bin2bn(p,i,NULL)))
2928 : : {
2929 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,ERR_R_BN_LIB);
2930 : 0 : goto err;
2931 : : }
2932 [ - + ]: 22 : if (s->session->srp_username != NULL)
2933 : 0 : OPENSSL_free(s->session->srp_username);
2934 : 22 : s->session->srp_username = BUF_strdup(s->srp_ctx.login);
2935 [ - + ]: 22 : if (s->session->srp_username == NULL)
2936 : : {
2937 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2938 : : ERR_R_MALLOC_FAILURE);
2939 : 0 : goto err;
2940 : : }
2941 : :
2942 [ - + ]: 22 : if ((s->session->master_key_length = SRP_generate_server_master_secret(s,s->session->master_key))<0)
2943 : : {
2944 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
2945 : 0 : goto err;
2946 : : }
2947 : :
2948 : : p+=i;
2949 : : }
2950 : : else
2951 : : #endif /* OPENSSL_NO_SRP */
2952 [ # # ]: 0 : if (alg_k & SSL_kGOST)
2953 : : {
2954 : 0 : int ret = 0;
2955 : : EVP_PKEY_CTX *pkey_ctx;
2956 : 0 : EVP_PKEY *client_pub_pkey = NULL, *pk = NULL;
2957 : : unsigned char premaster_secret[32], *start;
2958 : 0 : size_t outlen=32, inlen;
2959 : : unsigned long alg_a;
2960 : : int Ttag, Tclass;
2961 : : long Tlen;
2962 : :
2963 : : /* Get our certificate private key*/
2964 : 0 : alg_a = s->s3->tmp.new_cipher->algorithm_auth;
2965 [ # # ]: 0 : if (alg_a & SSL_aGOST94)
2966 : 0 : pk = s->cert->pkeys[SSL_PKEY_GOST94].privatekey;
2967 [ # # ]: 0 : else if (alg_a & SSL_aGOST01)
2968 : 0 : pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey;
2969 : :
2970 : 0 : pkey_ctx = EVP_PKEY_CTX_new(pk,NULL);
2971 : 0 : EVP_PKEY_decrypt_init(pkey_ctx);
2972 : : /* If client certificate is present and is of the same type, maybe
2973 : : * use it for key exchange. Don't mind errors from
2974 : : * EVP_PKEY_derive_set_peer, because it is completely valid to use
2975 : : * a client certificate for authorization only. */
2976 : 0 : client_pub_pkey = X509_get_pubkey(s->session->peer);
2977 [ # # ]: 0 : if (client_pub_pkey)
2978 : : {
2979 [ # # ]: 0 : if (EVP_PKEY_derive_set_peer(pkey_ctx, client_pub_pkey) <= 0)
2980 : 0 : ERR_clear_error();
2981 : : }
2982 : : /* Decrypt session key */
2983 [ # # ][ # # ]: 0 : if (ASN1_get_object((const unsigned char **)&p, &Tlen, &Ttag, &Tclass, n) != V_ASN1_CONSTRUCTED ||
2984 [ # # ]: 0 : Ttag != V_ASN1_SEQUENCE ||
2985 : 0 : Tclass != V_ASN1_UNIVERSAL)
2986 : : {
2987 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_DECRYPTION_FAILED);
2988 : 0 : goto gerr;
2989 : : }
2990 : 0 : start = p;
2991 : 0 : inlen = Tlen;
2992 [ # # ]: 0 : if (EVP_PKEY_decrypt(pkey_ctx,premaster_secret,&outlen,start,inlen) <=0)
2993 : :
2994 : : {
2995 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,SSL_R_DECRYPTION_FAILED);
2996 : 0 : goto gerr;
2997 : : }
2998 : : /* Generate master secret */
2999 : 0 : s->session->master_key_length=
3000 : 0 : s->method->ssl3_enc->generate_master_secret(s,
3001 : 0 : s->session->master_key,premaster_secret,32);
3002 : : /* Check if pubkey from client certificate was used */
3003 [ # # ]: 0 : if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 2, NULL) > 0)
3004 : : ret = 2;
3005 : : else
3006 : 0 : ret = 1;
3007 : : gerr:
3008 : 0 : EVP_PKEY_free(client_pub_pkey);
3009 : 0 : EVP_PKEY_CTX_free(pkey_ctx);
3010 [ # # ]: 0 : if (ret)
3011 : 0 : return ret;
3012 : : else
3013 : : goto err;
3014 : : }
3015 : : else
3016 : : {
3017 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
3018 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
3019 : : SSL_R_UNKNOWN_CIPHER_TYPE);
3020 : 198 : goto f_err;
3021 : : }
3022 : :
3023 : : return(1);
3024 : : f_err:
3025 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,al);
3026 : : #if !defined(OPENSSL_NO_DH) || !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_ECDH) || defined(OPENSSL_NO_SRP)
3027 : : err:
3028 : : #endif
3029 : : #ifndef OPENSSL_NO_ECDH
3030 : 0 : EVP_PKEY_free(clnt_pub_pkey);
3031 : 0 : EC_POINT_free(clnt_ecpoint);
3032 [ # # ]: 0 : if (srvr_ecdh != NULL)
3033 : 0 : EC_KEY_free(srvr_ecdh);
3034 : 0 : BN_CTX_free(bn_ctx);
3035 : : #endif
3036 : 0 : return(-1);
3037 : : }
3038 : :
3039 : 10595 : int ssl3_get_cert_verify(SSL *s)
3040 : : {
3041 : 10595 : EVP_PKEY *pkey=NULL;
3042 : : unsigned char *p;
3043 : 10595 : int al,ok,ret=0;
3044 : : long n;
3045 : 10595 : int type=0,i,j;
3046 : : X509 *peer;
3047 : 10595 : const EVP_MD *md = NULL;
3048 : : EVP_MD_CTX mctx;
3049 : 10595 : EVP_MD_CTX_init(&mctx);
3050 : :
3051 : 10595 : n=s->method->ssl_get_message(s,
3052 : : SSL3_ST_SR_CERT_VRFY_A,
3053 : : SSL3_ST_SR_CERT_VRFY_B,
3054 : : -1,
3055 : : SSL3_RT_MAX_PLAIN_LENGTH,
3056 : : &ok);
3057 : :
3058 [ + + ]: 10595 : if (!ok) return((int)n);
3059 : :
3060 [ + + ]: 1069 : if (s->session->peer != NULL)
3061 : : {
3062 : 99 : peer=s->session->peer;
3063 : 99 : pkey=X509_get_pubkey(peer);
3064 : 99 : type=X509_certificate_type(peer,pkey);
3065 : : }
3066 : : else
3067 : : {
3068 : : peer=NULL;
3069 : : pkey=NULL;
3070 : : }
3071 : :
3072 [ + + ]: 1069 : if (s->s3->tmp.message_type != SSL3_MT_CERTIFICATE_VERIFY)
3073 : : {
3074 : 970 : s->s3->tmp.reuse_message=1;
3075 [ - + ][ # # ]: 970 : if ((peer != NULL) && (type & EVP_PKT_SIGN))
3076 : : {
3077 : 0 : al=SSL_AD_UNEXPECTED_MESSAGE;
3078 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_MISSING_VERIFY_MESSAGE);
3079 : 0 : goto f_err;
3080 : : }
3081 : : ret=1;
3082 : : goto end;
3083 : : }
3084 : :
3085 [ - + ]: 99 : if (peer == NULL)
3086 : : {
3087 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_NO_CLIENT_CERT_RECEIVED);
3088 : 0 : al=SSL_AD_UNEXPECTED_MESSAGE;
3089 : 0 : goto f_err;
3090 : : }
3091 : :
3092 [ - + ]: 99 : if (!(type & EVP_PKT_SIGN))
3093 : : {
3094 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE);
3095 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
3096 : 0 : goto f_err;
3097 : : }
3098 : :
3099 [ - + ]: 99 : if (s->s3->change_cipher_spec)
3100 : : {
3101 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_CCS_RECEIVED_EARLY);
3102 : 0 : al=SSL_AD_UNEXPECTED_MESSAGE;
3103 : 0 : goto f_err;
3104 : : }
3105 : :
3106 : : /* we now have a signature that we need to verify */
3107 : 99 : p=(unsigned char *)s->init_msg;
3108 : : /* Check for broken implementations of GOST ciphersuites */
3109 : : /* If key is GOST and n is exactly 64, it is bare
3110 : : * signature without length field */
3111 [ - + ][ # # ]: 99 : if (n==64 && (pkey->type==NID_id_GostR3410_94 ||
3112 : : pkey->type == NID_id_GostR3410_2001) )
3113 : : {
3114 : : i=64;
3115 : : }
3116 : : else
3117 : : {
3118 [ + + ]: 99 : if (SSL_USE_SIGALGS(s))
3119 : : {
3120 : 55 : int rv = tls12_check_peer_sigalg(&md, s, p, pkey);
3121 [ + - ]: 55 : if (rv == -1)
3122 : : {
3123 : : al = SSL_AD_INTERNAL_ERROR;
3124 : : goto f_err;
3125 : : }
3126 [ + - ]: 55 : else if (rv == 0)
3127 : : {
3128 : : al = SSL_AD_DECODE_ERROR;
3129 : : goto f_err;
3130 : : }
3131 : : #ifdef SSL_DEBUG
3132 : : fprintf(stderr, "USING TLSv1.2 HASH %s\n", EVP_MD_name(md));
3133 : : #endif
3134 : 55 : p += 2;
3135 : 55 : n -= 2;
3136 : : }
3137 : 99 : n2s(p,i);
3138 : 99 : n-=2;
3139 [ - + ]: 99 : if (i > n)
3140 : : {
3141 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_LENGTH_MISMATCH);
3142 : 0 : al=SSL_AD_DECODE_ERROR;
3143 : 0 : goto f_err;
3144 : : }
3145 : : }
3146 : 99 : j=EVP_PKEY_size(pkey);
3147 [ + - ][ + - ]: 99 : if ((i > j) || (n > j) || (n <= 0))
[ - + ]
3148 : : {
3149 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_WRONG_SIGNATURE_SIZE);
3150 : 0 : al=SSL_AD_DECODE_ERROR;
3151 : 0 : goto f_err;
3152 : : }
3153 : :
3154 [ + + ]: 99 : if (SSL_USE_SIGALGS(s))
3155 : : {
3156 : 55 : long hdatalen = 0;
3157 : : void *hdata;
3158 : 55 : hdatalen = BIO_get_mem_data(s->s3->handshake_buffer, &hdata);
3159 [ - + ]: 55 : if (hdatalen <= 0)
3160 : : {
3161 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
3162 : 0 : al=SSL_AD_INTERNAL_ERROR;
3163 : 0 : goto f_err;
3164 : : }
3165 : : #ifdef SSL_DEBUG
3166 : : fprintf(stderr, "Using TLS 1.2 with client verify alg %s\n",
3167 : : EVP_MD_name(md));
3168 : : #endif
3169 [ + - ]: 55 : if (!EVP_VerifyInit_ex(&mctx, md, NULL)
3170 [ - + ]: 55 : || !EVP_VerifyUpdate(&mctx, hdata, hdatalen))
3171 : : {
3172 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY, ERR_R_EVP_LIB);
3173 : 0 : al=SSL_AD_INTERNAL_ERROR;
3174 : 0 : goto f_err;
3175 : : }
3176 : :
3177 [ - + ]: 55 : if (EVP_VerifyFinal(&mctx, p , i, pkey) <= 0)
3178 : : {
3179 : 0 : al=SSL_AD_DECRYPT_ERROR;
3180 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_BAD_SIGNATURE);
3181 : 55 : goto f_err;
3182 : : }
3183 : : }
3184 : : else
3185 : : #ifndef OPENSSL_NO_RSA
3186 [ + - ]: 44 : if (pkey->type == EVP_PKEY_RSA)
3187 : : {
3188 : 44 : i=RSA_verify(NID_md5_sha1, s->s3->tmp.cert_verify_md,
3189 : : MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH, p, i,
3190 : 44 : pkey->pkey.rsa);
3191 [ - + ]: 44 : if (i < 0)
3192 : : {
3193 : 0 : al=SSL_AD_DECRYPT_ERROR;
3194 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_BAD_RSA_DECRYPT);
3195 : 0 : goto f_err;
3196 : : }
3197 [ - + ]: 44 : if (i == 0)
3198 : : {
3199 : 0 : al=SSL_AD_DECRYPT_ERROR;
3200 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_BAD_RSA_SIGNATURE);
3201 : 0 : goto f_err;
3202 : : }
3203 : : }
3204 : : else
3205 : : #endif
3206 : : #ifndef OPENSSL_NO_DSA
3207 [ # # ]: 0 : if (pkey->type == EVP_PKEY_DSA)
3208 : : {
3209 : 0 : j=DSA_verify(pkey->save_type,
3210 : 0 : &(s->s3->tmp.cert_verify_md[MD5_DIGEST_LENGTH]),
3211 : 0 : SHA_DIGEST_LENGTH,p,i,pkey->pkey.dsa);
3212 [ # # ]: 0 : if (j <= 0)
3213 : : {
3214 : : /* bad signature */
3215 : 0 : al=SSL_AD_DECRYPT_ERROR;
3216 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,SSL_R_BAD_DSA_SIGNATURE);
3217 : 0 : goto f_err;
3218 : : }
3219 : : }
3220 : : else
3221 : : #endif
3222 : : #ifndef OPENSSL_NO_ECDSA
3223 [ # # ]: 0 : if (pkey->type == EVP_PKEY_EC)
3224 : : {
3225 : 0 : j=ECDSA_verify(pkey->save_type,
3226 : 0 : &(s->s3->tmp.cert_verify_md[MD5_DIGEST_LENGTH]),
3227 : 0 : SHA_DIGEST_LENGTH,p,i,pkey->pkey.ec);
3228 [ # # ]: 0 : if (j <= 0)
3229 : : {
3230 : : /* bad signature */
3231 : 0 : al=SSL_AD_DECRYPT_ERROR;
3232 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,
3233 : : SSL_R_BAD_ECDSA_SIGNATURE);
3234 : 0 : goto f_err;
3235 : : }
3236 : : }
3237 : : else
3238 : : #endif
3239 [ # # ]: 0 : if (pkey->type == NID_id_GostR3410_94 || pkey->type == NID_id_GostR3410_2001)
3240 : : { unsigned char signature[64];
3241 : : int idx;
3242 : 0 : EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new(pkey,NULL);
3243 : 0 : EVP_PKEY_verify_init(pctx);
3244 [ # # ]: 0 : if (i!=64) {
3245 : 0 : fprintf(stderr,"GOST signature length is %d",i);
3246 : : }
3247 [ # # ]: 0 : for (idx=0;idx<64;idx++) {
3248 : 0 : signature[63-idx]=p[idx];
3249 : : }
3250 : 0 : j=EVP_PKEY_verify(pctx,signature,64,s->s3->tmp.cert_verify_md,32);
3251 : 0 : EVP_PKEY_CTX_free(pctx);
3252 [ # # ]: 0 : if (j<=0)
3253 : : {
3254 : 0 : al=SSL_AD_DECRYPT_ERROR;
3255 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,
3256 : : SSL_R_BAD_ECDSA_SIGNATURE);
3257 : 0 : goto f_err;
3258 : : }
3259 : : }
3260 : : else
3261 : : {
3262 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_VERIFY,ERR_R_INTERNAL_ERROR);
3263 : 0 : al=SSL_AD_UNSUPPORTED_CERTIFICATE;
3264 : 0 : goto f_err;
3265 : : }
3266 : :
3267 : :
3268 : : ret=1;
3269 : : if (0)
3270 : : {
3271 : : f_err:
3272 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,al);
3273 : : }
3274 : : end:
3275 [ + + ]: 1069 : if (s->s3->handshake_buffer)
3276 : : {
3277 : 55 : BIO_free(s->s3->handshake_buffer);
3278 : 55 : s->s3->handshake_buffer = NULL;
3279 : 55 : s->s3->flags &= ~TLS1_FLAGS_KEEP_HANDSHAKE;
3280 : : }
3281 : 1069 : EVP_MD_CTX_cleanup(&mctx);
3282 : 1069 : EVP_PKEY_free(pkey);
3283 : 1069 : return(ret);
3284 : : }
3285 : :
3286 : 99 : int ssl3_get_client_certificate(SSL *s)
3287 : : {
3288 : 99 : int i,ok,al,ret= -1;
3289 : 99 : X509 *x=NULL;
3290 : : unsigned long l,nc,llen,n;
3291 : : const unsigned char *p,*q;
3292 : : unsigned char *d;
3293 : 99 : STACK_OF(X509) *sk=NULL;
3294 : :
3295 : 99 : n=s->method->ssl_get_message(s,
3296 : : SSL3_ST_SR_CERT_A,
3297 : : SSL3_ST_SR_CERT_B,
3298 : : -1,
3299 : : s->max_cert_list,
3300 : : &ok);
3301 : :
3302 [ - + ]: 99 : if (!ok) return((int)n);
3303 : :
3304 [ - + ]: 99 : if (s->s3->tmp.message_type == SSL3_MT_CLIENT_KEY_EXCHANGE)
3305 : : {
3306 [ # # ]: 0 : if ( (s->verify_mode & SSL_VERIFY_PEER) &&
3307 : : (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT))
3308 : : {
3309 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
3310 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
3311 : 0 : goto f_err;
3312 : : }
3313 : : /* If tls asked for a client cert, the client must return a 0 list */
3314 [ # # ][ # # ]: 0 : if ((s->version > SSL3_VERSION) && s->s3->tmp.cert_request)
3315 : : {
3316 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST);
3317 : 0 : al=SSL_AD_UNEXPECTED_MESSAGE;
3318 : 0 : goto f_err;
3319 : : }
3320 : 0 : s->s3->tmp.reuse_message=1;
3321 : 0 : return(1);
3322 : : }
3323 : :
3324 [ - + ]: 99 : if (s->s3->tmp.message_type != SSL3_MT_CERTIFICATE)
3325 : : {
3326 : 0 : al=SSL_AD_UNEXPECTED_MESSAGE;
3327 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_WRONG_MESSAGE_TYPE);
3328 : 0 : goto f_err;
3329 : : }
3330 : 99 : p=d=(unsigned char *)s->init_msg;
3331 : :
3332 [ - + ]: 99 : if ((sk=sk_X509_new_null()) == NULL)
3333 : : {
3334 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,ERR_R_MALLOC_FAILURE);
3335 : 0 : goto err;
3336 : : }
3337 : :
3338 : 99 : n2l3(p,llen);
3339 [ + - ]: 99 : if (llen+3 != n)
3340 : : {
3341 : 0 : al=SSL_AD_DECODE_ERROR;
3342 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_LENGTH_MISMATCH);
3343 : 0 : goto f_err;
3344 : : }
3345 [ + + ]: 423 : for (nc=0; nc<llen; )
3346 : : {
3347 : 324 : n2l3(p,l);
3348 [ - + ]: 324 : if ((l+nc+3) > llen)
3349 : : {
3350 : 0 : al=SSL_AD_DECODE_ERROR;
3351 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_CERT_LENGTH_MISMATCH);
3352 : 0 : goto f_err;
3353 : : }
3354 : :
3355 : 324 : q=p;
3356 : 324 : x=d2i_X509(NULL,&p,l);
3357 [ - + ]: 324 : if (x == NULL)
3358 : : {
3359 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,ERR_R_ASN1_LIB);
3360 : 0 : goto err;
3361 : : }
3362 [ - + ]: 324 : if (p != (q+l))
3363 : : {
3364 : 0 : al=SSL_AD_DECODE_ERROR;
3365 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_CERT_LENGTH_MISMATCH);
3366 : 0 : goto f_err;
3367 : : }
3368 [ - + ]: 324 : if (!sk_X509_push(sk,x))
3369 : : {
3370 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,ERR_R_MALLOC_FAILURE);
3371 : 324 : goto err;
3372 : : }
3373 : : x=NULL;
3374 : : nc+=l+3;
3375 : : }
3376 : :
3377 [ - + ]: 99 : if (sk_X509_num(sk) <= 0)
3378 : : {
3379 : : /* TLS does not mind 0 certs returned */
3380 [ # # ]: 0 : if (s->version == SSL3_VERSION)
3381 : : {
3382 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
3383 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_NO_CERTIFICATES_RETURNED);
3384 : 0 : goto f_err;
3385 : : }
3386 : : /* Fail for TLS only if we required a certificate */
3387 [ # # ]: 0 : else if ((s->verify_mode & SSL_VERIFY_PEER) &&
3388 : : (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT))
3389 : : {
3390 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
3391 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
3392 : 0 : goto f_err;
3393 : : }
3394 : : /* No client certificate so digest cached records */
3395 [ # # ][ # # ]: 0 : if (s->s3->handshake_buffer && !ssl3_digest_cached_records(s))
3396 : : {
3397 : : al=SSL_AD_INTERNAL_ERROR;
3398 : : goto f_err;
3399 : : }
3400 : : }
3401 : : else
3402 : : {
3403 : : EVP_PKEY *pkey;
3404 : 99 : i=ssl_verify_cert_chain(s,sk);
3405 [ - + ]: 99 : if (i <= 0)
3406 : : {
3407 : 0 : al=ssl_verify_alarm_type(s->verify_result);
3408 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,SSL_R_CERTIFICATE_VERIFY_FAILED);
3409 : 0 : goto f_err;
3410 : : }
3411 [ - + ]: 99 : if (i > 1)
3412 : : {
3413 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, i);
3414 : 0 : al = SSL_AD_HANDSHAKE_FAILURE;
3415 : 0 : goto f_err;
3416 : : }
3417 : 99 : pkey = X509_get_pubkey(sk_X509_value(sk, 0));
3418 [ - + ]: 99 : if (pkey == NULL)
3419 : : {
3420 : 0 : al=SSL3_AD_HANDSHAKE_FAILURE;
3421 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
3422 : : SSL_R_UNKNOWN_CERTIFICATE_TYPE);
3423 : 0 : goto f_err;
3424 : : }
3425 : 99 : EVP_PKEY_free(pkey);
3426 : : }
3427 : :
3428 [ - + ]: 99 : if (s->session->peer != NULL) /* This should not be needed */
3429 : 0 : X509_free(s->session->peer);
3430 : 99 : s->session->peer=sk_X509_shift(sk);
3431 : 99 : s->session->verify_result = s->verify_result;
3432 : :
3433 : : /* With the current implementation, sess_cert will always be NULL
3434 : : * when we arrive here. */
3435 [ + - ]: 99 : if (s->session->sess_cert == NULL)
3436 : : {
3437 : 99 : s->session->sess_cert = ssl_sess_cert_new();
3438 [ - + ]: 99 : if (s->session->sess_cert == NULL)
3439 : : {
3440 : 0 : SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
3441 : 0 : goto err;
3442 : : }
3443 : : }
3444 [ - + ]: 99 : if (s->session->sess_cert->cert_chain != NULL)
3445 : 0 : sk_X509_pop_free(s->session->sess_cert->cert_chain, X509_free);
3446 : 99 : s->session->sess_cert->cert_chain=sk;
3447 : : /* Inconsistency alert: cert_chain does *not* include the
3448 : : * peer's own certificate, while we do include it in s3_clnt.c */
3449 : :
3450 : 99 : sk=NULL;
3451 : :
3452 : 99 : ret=1;
3453 : : if (0)
3454 : : {
3455 : : f_err:
3456 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,al);
3457 : : }
3458 : : err:
3459 [ - + ]: 99 : if (x != NULL) X509_free(x);
3460 [ - + ]: 99 : if (sk != NULL) sk_X509_pop_free(sk,X509_free);
3461 : 99 : return(ret);
3462 : : }
3463 : :
3464 : 937 : int ssl3_send_server_certificate(SSL *s)
3465 : : {
3466 : : CERT_PKEY *cpk;
3467 : :
3468 [ + - ]: 937 : if (s->state == SSL3_ST_SW_CERT_A)
3469 : : {
3470 : 937 : cpk=ssl_get_server_send_pkey(s);
3471 [ - + ]: 937 : if (cpk == NULL)
3472 : : {
3473 : : /* VRS: allow null cert if auth == KRB5 */
3474 [ # # ][ # # ]: 0 : if ((s->s3->tmp.new_cipher->algorithm_auth != SSL_aKRB5) ||
3475 : 0 : (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kKRB5))
3476 : : {
3477 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_CERTIFICATE,ERR_R_INTERNAL_ERROR);
3478 : 0 : return(0);
3479 : : }
3480 : : }
3481 : :
3482 [ - + ]: 937 : if (!ssl3_output_cert_chain(s,cpk))
3483 : : {
3484 : 0 : SSLerr(SSL_F_SSL3_SEND_SERVER_CERTIFICATE,ERR_R_INTERNAL_ERROR);
3485 : 0 : return(0);
3486 : : }
3487 : 937 : s->state=SSL3_ST_SW_CERT_B;
3488 : : }
3489 : :
3490 : : /* SSL3_ST_SW_CERT_B */
3491 : 937 : return ssl_do_write(s);
3492 : : }
3493 : :
3494 : : #ifndef OPENSSL_NO_TLSEXT
3495 : : /* send a new session ticket (not necessarily for a new session) */
3496 : 816 : int ssl3_send_newsession_ticket(SSL *s)
3497 : : {
3498 [ + - ]: 816 : if (s->state == SSL3_ST_SW_SESSION_TICKET_A)
3499 : : {
3500 : : unsigned char *p, *senc, *macstart;
3501 : : const unsigned char *const_p;
3502 : : int len, slen_full, slen;
3503 : : SSL_SESSION *sess;
3504 : : unsigned int hlen;
3505 : : EVP_CIPHER_CTX ctx;
3506 : : HMAC_CTX hctx;
3507 : 816 : SSL_CTX *tctx = s->initial_ctx;
3508 : : unsigned char iv[EVP_MAX_IV_LENGTH];
3509 : : unsigned char key_name[16];
3510 : :
3511 : : /* get session encoding length */
3512 : 816 : slen_full = i2d_SSL_SESSION(s->session, NULL);
3513 : : /* Some length values are 16 bits, so forget it if session is
3514 : : * too long
3515 : : */
3516 [ + - ]: 816 : if (slen_full > 0xFF00)
3517 : 0 : return -1;
3518 : 816 : senc = OPENSSL_malloc(slen_full);
3519 [ + - ]: 816 : if (!senc)
3520 : : return -1;
3521 : 816 : p = senc;
3522 : 816 : i2d_SSL_SESSION(s->session, &p);
3523 : :
3524 : : /* create a fresh copy (not shared with other threads) to clean up */
3525 : 816 : const_p = senc;
3526 : 816 : sess = d2i_SSL_SESSION(NULL, &const_p, slen_full);
3527 [ - + ]: 816 : if (sess == NULL)
3528 : : {
3529 : 0 : OPENSSL_free(senc);
3530 : 0 : return -1;
3531 : : }
3532 : 816 : sess->session_id_length = 0; /* ID is irrelevant for the ticket */
3533 : :
3534 : 816 : slen = i2d_SSL_SESSION(sess, NULL);
3535 [ - + ]: 816 : if (slen > slen_full) /* shouldn't ever happen */
3536 : : {
3537 : 0 : OPENSSL_free(senc);
3538 : 0 : return -1;
3539 : : }
3540 : 816 : p = senc;
3541 : 816 : i2d_SSL_SESSION(sess, &p);
3542 : 816 : SSL_SESSION_free(sess);
3543 : :
3544 : : /* Grow buffer if need be: the length calculation is as
3545 : : * follows handshake_header_length +
3546 : : * 4 (ticket lifetime hint) + 2 (ticket length) +
3547 : : * 16 (key name) + max_iv_len (iv length) +
3548 : : * session_length + max_enc_block_size (max encrypted session
3549 : : * length) + max_md_size (HMAC).
3550 : : */
3551 [ + - ]: 816 : if (!BUF_MEM_grow(s->init_buf,
3552 : 816 : SSL_HM_HEADER_LENGTH(s) + 22 + EVP_MAX_IV_LENGTH +
3553 : 816 : EVP_MAX_BLOCK_LENGTH + EVP_MAX_MD_SIZE + slen))
3554 : : return -1;
3555 : 816 : p = ssl_handshake_start(s);
3556 : 816 : EVP_CIPHER_CTX_init(&ctx);
3557 : 816 : HMAC_CTX_init(&hctx);
3558 : : /* Initialize HMAC and cipher contexts. If callback present
3559 : : * it does all the work otherwise use generated values
3560 : : * from parent ctx.
3561 : : */
3562 [ - + ]: 816 : if (tctx->tlsext_ticket_key_cb)
3563 : : {
3564 [ # # ]: 0 : if (tctx->tlsext_ticket_key_cb(s, key_name, iv, &ctx,
3565 : : &hctx, 1) < 0)
3566 : : {
3567 : 0 : OPENSSL_free(senc);
3568 : 0 : return -1;
3569 : : }
3570 : : }
3571 : : else
3572 : : {
3573 : 816 : RAND_pseudo_bytes(iv, 16);
3574 : 816 : EVP_EncryptInit_ex(&ctx, EVP_aes_128_cbc(), NULL,
3575 : 816 : tctx->tlsext_tick_aes_key, iv);
3576 : 816 : HMAC_Init_ex(&hctx, tctx->tlsext_tick_hmac_key, 16,
3577 : : tlsext_tick_md(), NULL);
3578 : 816 : memcpy(key_name, tctx->tlsext_tick_key_name, 16);
3579 : : }
3580 : :
3581 : : /* Ticket lifetime hint (advisory only):
3582 : : * We leave this unspecified for resumed session (for simplicity),
3583 : : * and guess that tickets for new sessions will live as long
3584 : : * as their sessions. */
3585 [ + - ][ + - ]: 816 : l2n(s->hit ? 0 : s->session->timeout, p);
[ + - ][ + - ]
3586 : :
3587 : : /* Skip ticket length for now */
3588 : 816 : p += 2;
3589 : : /* Output key name */
3590 : 816 : macstart = p;
3591 : 816 : memcpy(p, key_name, 16);
3592 : 816 : p += 16;
3593 : : /* output IV */
3594 : 816 : memcpy(p, iv, EVP_CIPHER_CTX_iv_length(&ctx));
3595 : 816 : p += EVP_CIPHER_CTX_iv_length(&ctx);
3596 : : /* Encrypt session data */
3597 : 816 : EVP_EncryptUpdate(&ctx, p, &len, senc, slen);
3598 : 816 : p += len;
3599 : 816 : EVP_EncryptFinal(&ctx, p, &len);
3600 : 816 : p += len;
3601 : 816 : EVP_CIPHER_CTX_cleanup(&ctx);
3602 : :
3603 : 816 : HMAC_Update(&hctx, macstart, p - macstart);
3604 : 816 : HMAC_Final(&hctx, p, &hlen);
3605 : 816 : HMAC_CTX_cleanup(&hctx);
3606 : :
3607 : 816 : p += hlen;
3608 : : /* Now write out lengths: p points to end of data written */
3609 : : /* Total length */
3610 : 816 : len = p - ssl_handshake_start(s);
3611 : 816 : ssl_set_handshake_header(s, SSL3_MT_NEWSESSION_TICKET, len);
3612 : : /* Skip ticket lifetime hint */
3613 : 816 : p = ssl_handshake_start(s) + 4;
3614 : 816 : s2n(len - 6, p);
3615 : 816 : s->state=SSL3_ST_SW_SESSION_TICKET_B;
3616 : 816 : OPENSSL_free(senc);
3617 : : }
3618 : :
3619 : : /* SSL3_ST_SW_SESSION_TICKET_B */
3620 : 816 : return ssl_do_write(s);
3621 : : }
3622 : :
3623 : 0 : int ssl3_send_cert_status(SSL *s)
3624 : : {
3625 [ # # ]: 0 : if (s->state == SSL3_ST_SW_CERT_STATUS_A)
3626 : : {
3627 : : unsigned char *p;
3628 : : /* Grow buffer if need be: the length calculation is as
3629 : : * follows 1 (message type) + 3 (message length) +
3630 : : * 1 (ocsp response type) + 3 (ocsp response length)
3631 : : * + (ocsp response)
3632 : : */
3633 [ # # ]: 0 : if (!BUF_MEM_grow(s->init_buf, 8 + s->tlsext_ocsp_resplen))
3634 : : return -1;
3635 : :
3636 : 0 : p=(unsigned char *)s->init_buf->data;
3637 : :
3638 : : /* do the header */
3639 : 0 : *(p++)=SSL3_MT_CERTIFICATE_STATUS;
3640 : : /* message length */
3641 : 0 : l2n3(s->tlsext_ocsp_resplen + 4, p);
3642 : : /* status type */
3643 : 0 : *(p++)= s->tlsext_status_type;
3644 : : /* length of OCSP response */
3645 : 0 : l2n3(s->tlsext_ocsp_resplen, p);
3646 : : /* actual response */
3647 : 0 : memcpy(p, s->tlsext_ocsp_resp, s->tlsext_ocsp_resplen);
3648 : : /* number of bytes to write */
3649 : 0 : s->init_num = 8 + s->tlsext_ocsp_resplen;
3650 : 0 : s->state=SSL3_ST_SW_CERT_STATUS_B;
3651 : 0 : s->init_off = 0;
3652 : : }
3653 : :
3654 : : /* SSL3_ST_SW_CERT_STATUS_B */
3655 : 0 : return(ssl3_do_write(s,SSL3_RT_HANDSHAKE));
3656 : : }
3657 : :
3658 : : # ifndef OPENSSL_NO_NEXTPROTONEG
3659 : : /* ssl3_get_next_proto reads a Next Protocol Negotiation handshake message. It
3660 : : * sets the next_proto member in s if found */
3661 : 231 : int ssl3_get_next_proto(SSL *s)
3662 : : {
3663 : : int ok;
3664 : : int proto_len, padding_len;
3665 : : long n;
3666 : : const unsigned char *p;
3667 : :
3668 : : /* Clients cannot send a NextProtocol message if we didn't see the
3669 : : * extension in their ClientHello */
3670 [ - + ]: 231 : if (!s->s3->next_proto_neg_seen)
3671 : : {
3672 : 0 : SSLerr(SSL_F_SSL3_GET_NEXT_PROTO,SSL_R_GOT_NEXT_PROTO_WITHOUT_EXTENSION);
3673 : 0 : return -1;
3674 : : }
3675 : :
3676 : 231 : n=s->method->ssl_get_message(s,
3677 : : SSL3_ST_SR_NEXT_PROTO_A,
3678 : : SSL3_ST_SR_NEXT_PROTO_B,
3679 : : SSL3_MT_NEXT_PROTO,
3680 : : 514, /* See the payload format below */
3681 : : &ok);
3682 : :
3683 [ + + ]: 231 : if (!ok)
3684 : 176 : return((int)n);
3685 : :
3686 : : /* s->state doesn't reflect whether ChangeCipherSpec has been received
3687 : : * in this handshake, but s->s3->change_cipher_spec does (will be reset
3688 : : * by ssl3_get_finished). */
3689 [ - + ]: 55 : if (!s->s3->change_cipher_spec)
3690 : : {
3691 : 0 : SSLerr(SSL_F_SSL3_GET_NEXT_PROTO,SSL_R_GOT_NEXT_PROTO_BEFORE_A_CCS);
3692 : 0 : return -1;
3693 : : }
3694 : :
3695 [ + - ]: 55 : if (n < 2)
3696 : : return 0; /* The body must be > 1 bytes long */
3697 : :
3698 : 55 : p=(unsigned char *)s->init_msg;
3699 : :
3700 : : /* The payload looks like:
3701 : : * uint8 proto_len;
3702 : : * uint8 proto[proto_len];
3703 : : * uint8 padding_len;
3704 : : * uint8 padding[padding_len];
3705 : : */
3706 : 55 : proto_len = p[0];
3707 [ + - ]: 55 : if (proto_len + 2 > s->init_num)
3708 : : return 0;
3709 : 55 : padding_len = p[proto_len + 1];
3710 [ + - ]: 55 : if (proto_len + padding_len + 2 != s->init_num)
3711 : : return 0;
3712 : :
3713 : 55 : s->next_proto_negotiated = OPENSSL_malloc(proto_len);
3714 [ - + ]: 55 : if (!s->next_proto_negotiated)
3715 : : {
3716 : 0 : SSLerr(SSL_F_SSL3_GET_NEXT_PROTO,ERR_R_MALLOC_FAILURE);
3717 : 0 : return 0;
3718 : : }
3719 : 55 : memcpy(s->next_proto_negotiated, p + 1, proto_len);
3720 : 55 : s->next_proto_negotiated_len = proto_len;
3721 : :
3722 : 55 : return 1;
3723 : : }
3724 : : # endif
3725 : :
3726 : : #endif
|
