Branch data Line data Source code
1 : : /* ssl/s3_clnt.c */
2 : : /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 : : * All rights reserved.
4 : : *
5 : : * This package is an SSL implementation written
6 : : * by Eric Young (eay@cryptsoft.com).
7 : : * The implementation was written so as to conform with Netscapes SSL.
8 : : *
9 : : * This library is free for commercial and non-commercial use as long as
10 : : * the following conditions are aheared to. The following conditions
11 : : * apply to all code found in this distribution, be it the RC4, RSA,
12 : : * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13 : : * included with this distribution is covered by the same copyright terms
14 : : * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 : : *
16 : : * Copyright remains Eric Young's, and as such any Copyright notices in
17 : : * the code are not to be removed.
18 : : * If this package is used in a product, Eric Young should be given attribution
19 : : * as the author of the parts of the library used.
20 : : * This can be in the form of a textual message at program startup or
21 : : * in documentation (online or textual) provided with the package.
22 : : *
23 : : * Redistribution and use in source and binary forms, with or without
24 : : * modification, are permitted provided that the following conditions
25 : : * are met:
26 : : * 1. Redistributions of source code must retain the copyright
27 : : * notice, this list of conditions and the following disclaimer.
28 : : * 2. Redistributions in binary form must reproduce the above copyright
29 : : * notice, this list of conditions and the following disclaimer in the
30 : : * documentation and/or other materials provided with the distribution.
31 : : * 3. All advertising materials mentioning features or use of this software
32 : : * must display the following acknowledgement:
33 : : * "This product includes cryptographic software written by
34 : : * Eric Young (eay@cryptsoft.com)"
35 : : * The word 'cryptographic' can be left out if the rouines from the library
36 : : * being used are not cryptographic related :-).
37 : : * 4. If you include any Windows specific code (or a derivative thereof) from
38 : : * the apps directory (application code) you must include an acknowledgement:
39 : : * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 : : *
41 : : * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 : : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 : : * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 : : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 : : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 : : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 : : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 : : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 : : * SUCH DAMAGE.
52 : : *
53 : : * The licence and distribution terms for any publically available version or
54 : : * derivative of this code cannot be changed. i.e. this code cannot simply be
55 : : * copied and put under another distribution licence
56 : : * [including the GNU Public Licence.]
57 : : */
58 : : /* ====================================================================
59 : : * Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved.
60 : : *
61 : : * Redistribution and use in source and binary forms, with or without
62 : : * modification, are permitted provided that the following conditions
63 : : * are met:
64 : : *
65 : : * 1. Redistributions of source code must retain the above copyright
66 : : * notice, this list of conditions and the following disclaimer.
67 : : *
68 : : * 2. Redistributions in binary form must reproduce the above copyright
69 : : * notice, this list of conditions and the following disclaimer in
70 : : * the documentation and/or other materials provided with the
71 : : * distribution.
72 : : *
73 : : * 3. All advertising materials mentioning features or use of this
74 : : * software must display the following acknowledgment:
75 : : * "This product includes software developed by the OpenSSL Project
76 : : * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
77 : : *
78 : : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79 : : * endorse or promote products derived from this software without
80 : : * prior written permission. For written permission, please contact
81 : : * openssl-core@openssl.org.
82 : : *
83 : : * 5. Products derived from this software may not be called "OpenSSL"
84 : : * nor may "OpenSSL" appear in their names without prior written
85 : : * permission of the OpenSSL Project.
86 : : *
87 : : * 6. Redistributions of any form whatsoever must retain the following
88 : : * acknowledgment:
89 : : * "This product includes software developed by the OpenSSL Project
90 : : * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
91 : : *
92 : : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93 : : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95 : : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
96 : : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97 : : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99 : : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101 : : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102 : : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103 : : * OF THE POSSIBILITY OF SUCH DAMAGE.
104 : : * ====================================================================
105 : : *
106 : : * This product includes cryptographic software written by Eric Young
107 : : * (eay@cryptsoft.com). This product includes software written by Tim
108 : : * Hudson (tjh@cryptsoft.com).
109 : : *
110 : : */
111 : : /* ====================================================================
112 : : * Copyright 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 : : #include <stdio.h>
152 : : #include "ssl_locl.h"
153 : : #include "kssl_lcl.h"
154 : : #include <openssl/buffer.h>
155 : : #include <openssl/rand.h>
156 : : #include <openssl/objects.h>
157 : : #include <openssl/evp.h>
158 : : #include <openssl/md5.h>
159 : : #ifdef OPENSSL_FIPS
160 : : #include <openssl/fips.h>
161 : : #endif
162 : : #ifndef OPENSSL_NO_DH
163 : : #include <openssl/dh.h>
164 : : #endif
165 : : #include <openssl/bn.h>
166 : : #ifndef OPENSSL_NO_ENGINE
167 : : #include <openssl/engine.h>
168 : : #endif
169 : :
170 : : static const SSL_METHOD *ssl3_get_client_method(int ver);
171 : : static int ca_dn_cmp(const X509_NAME * const *a,const X509_NAME * const *b);
172 : :
173 : 0 : static const SSL_METHOD *ssl3_get_client_method(int ver)
174 : : {
175 [ # # ]: 0 : if (ver == SSL3_VERSION)
176 : 0 : return(SSLv3_client_method());
177 : : else
178 : : return(NULL);
179 : : }
180 : :
181 : 0 : IMPLEMENT_ssl3_meth_func(SSLv3_client_method,
182 : : ssl_undefined_function,
183 : : ssl3_connect,
184 : : ssl3_get_client_method)
185 : :
186 : 34720 : int ssl3_connect(SSL *s)
187 : : {
188 : 34720 : BUF_MEM *buf=NULL;
189 : 34720 : unsigned long Time=(unsigned long)time(NULL);
190 : 34720 : void (*cb)(const SSL *ssl,int type,int val)=NULL;
191 : 34720 : int ret= -1;
192 : 34720 : int new_state,state,skip=0;
193 : :
194 : 34720 : RAND_add(&Time,sizeof(Time),0);
195 : 34720 : ERR_clear_error();
196 : 34720 : clear_sys_error();
197 : :
198 [ + - ]: 34720 : if (s->info_callback != NULL)
199 : : cb=s->info_callback;
200 [ - + ]: 34720 : else if (s->ctx->info_callback != NULL)
201 : 0 : cb=s->ctx->info_callback;
202 : :
203 : 34720 : s->in_handshake++;
204 [ + - ][ + + ]: 34720 : if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s);
205 : :
206 : : #ifndef OPENSSL_NO_HEARTBEATS
207 : : /* If we're awaiting a HeartbeatResponse, pretend we
208 : : * already got and don't await it anymore, because
209 : : * Heartbeats don't make sense during handshakes anyway.
210 : : */
211 [ - + ]: 34720 : if (s->tlsext_hb_pending)
212 : : {
213 : 0 : s->tlsext_hb_pending = 0;
214 : 46860 : s->tlsext_hb_seq++;
215 : : }
216 : : #endif
217 : :
218 : : for (;;)
219 : : {
220 : 48305 : state=s->state;
221 : :
222 [ - + + + : 48305 : switch(s->state)
+ + + + +
+ + + + +
+ - + + +
- ]
223 : : {
224 : : case SSL_ST_RENEGOTIATE:
225 : 0 : s->renegotiate=1;
226 : 0 : s->state=SSL_ST_CONNECT;
227 : 0 : s->ctx->stats.sess_connect_renegotiate++;
228 : : /* break */
229 : : case SSL_ST_BEFORE:
230 : : case SSL_ST_CONNECT:
231 : : case SSL_ST_BEFORE|SSL_ST_CONNECT:
232 : : case SSL_ST_OK|SSL_ST_CONNECT:
233 : :
234 : 880 : s->server=0;
235 [ - + ]: 880 : if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
236 : :
237 [ - + ]: 880 : if ((s->version & 0xff00 ) != 0x0300)
238 : : {
239 : 0 : SSLerr(SSL_F_SSL3_CONNECT, ERR_R_INTERNAL_ERROR);
240 : 0 : ret = -1;
241 : 0 : goto end;
242 : : }
243 : :
244 [ - + ]: 880 : if (!ssl_security(s, SSL_SECOP_VERSION, 0,
245 : : s->version, NULL))
246 : : {
247 : 0 : SSLerr(SSL_F_SSL3_CONNECT, SSL_R_VERSION_TOO_LOW);
248 : 0 : return -1;
249 : : }
250 : :
251 : : /* s->version=SSL3_VERSION; */
252 : 880 : s->type=SSL_ST_CONNECT;
253 : :
254 [ + - ]: 880 : if (s->init_buf == NULL)
255 : : {
256 [ + - ]: 880 : if ((buf=BUF_MEM_new()) == NULL)
257 : : {
258 : : ret= -1;
259 : : goto end;
260 : : }
261 [ + - ]: 880 : if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH))
262 : : {
263 : : ret= -1;
264 : : goto end;
265 : : }
266 : 880 : s->init_buf=buf;
267 : 880 : buf=NULL;
268 : : }
269 : :
270 [ + - ]: 880 : if (!ssl3_setup_buffers(s)) { ret= -1; goto end; }
271 : :
272 : : /* setup buffing BIO */
273 [ + - ]: 880 : if (!ssl_init_wbio_buffer(s,0)) { ret= -1; goto end; }
274 : :
275 : : /* don't push the buffering BIO quite yet */
276 : :
277 : 880 : ssl3_init_finished_mac(s);
278 : :
279 : 880 : s->state=SSL3_ST_CW_CLNT_HELLO_A;
280 : 880 : s->ctx->stats.sess_connect++;
281 : 880 : s->init_num=0;
282 : 880 : break;
283 : :
284 : : case SSL3_ST_CW_CLNT_HELLO_A:
285 : : case SSL3_ST_CW_CLNT_HELLO_B:
286 : :
287 : 3718 : s->shutdown=0;
288 : 3718 : ret=ssl3_client_hello(s);
289 [ + + ]: 3718 : if (ret <= 0) goto end;
290 : 880 : s->state=SSL3_ST_CR_SRVR_HELLO_A;
291 : 880 : s->init_num=0;
292 : :
293 : : /* turn on buffering for the next lot of output */
294 [ + - ]: 880 : if (s->bbio != s->wbio)
295 : 880 : s->wbio=BIO_push(s->bbio,s->wbio);
296 : :
297 : : break;
298 : :
299 : : case SSL3_ST_CR_SRVR_HELLO_A:
300 : : case SSL3_ST_CR_SRVR_HELLO_B:
301 : 6019 : ret=ssl3_get_server_hello(s);
302 [ + + ]: 6019 : if (ret <= 0) goto end;
303 : :
304 [ + + ]: 1080 : if (s->hit)
305 : : {
306 : 11 : s->state=SSL3_ST_CR_FINISHED_A;
307 : : #ifndef OPENSSL_NO_TLSEXT
308 [ + - ]: 11 : if (s->tlsext_ticket_expected)
309 : : {
310 : : /* receive renewed session ticket */
311 : 11 : s->state=SSL3_ST_CR_SESSION_TICKET_A;
312 : : }
313 : : #endif
314 : : }
315 : : else
316 : : {
317 : 1069 : s->state=SSL3_ST_CR_CERT_A;
318 : : }
319 : 1080 : s->init_num=0;
320 : 1080 : break;
321 : : case SSL3_ST_CR_CERT_A:
322 : : case SSL3_ST_CR_CERT_B:
323 : : #ifndef OPENSSL_NO_TLSEXT
324 : 5887 : ret=ssl3_check_finished(s);
325 [ + - ]: 5887 : if (ret <= 0) goto end;
326 [ - + ]: 5887 : if (ret == 2)
327 : : {
328 : 0 : s->hit = 1;
329 [ # # ]: 0 : if (s->tlsext_ticket_expected)
330 : 0 : s->state=SSL3_ST_CR_SESSION_TICKET_A;
331 : : else
332 : 0 : s->state=SSL3_ST_CR_FINISHED_A;
333 : 0 : s->init_num=0;
334 : 0 : break;
335 : : }
336 : : #endif
337 : : /* Check if it is anon DH/ECDH */
338 : : /* or PSK */
339 [ + + ][ + + ]: 5887 : if (!(s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL) &&
340 : 5777 : !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK))
341 : : {
342 : 5755 : ret=ssl3_get_server_certificate(s);
343 [ + + ]: 5755 : if (ret <= 0) goto end;
344 : : #ifndef OPENSSL_NO_TLSEXT
345 [ - + ]: 937 : if (s->tlsext_status_expected)
346 : 0 : s->state=SSL3_ST_CR_CERT_STATUS_A;
347 : : else
348 : 937 : s->state=SSL3_ST_CR_KEY_EXCH_A;
349 : : }
350 : : else
351 : : {
352 : 132 : skip = 1;
353 : 132 : s->state=SSL3_ST_CR_KEY_EXCH_A;
354 : : }
355 : : #else
356 : : }
357 : : else
358 : : skip=1;
359 : :
360 : : s->state=SSL3_ST_CR_KEY_EXCH_A;
361 : : #endif
362 : 1069 : s->init_num=0;
363 : 1069 : break;
364 : :
365 : : case SSL3_ST_CR_KEY_EXCH_A:
366 : : case SSL3_ST_CR_KEY_EXCH_B:
367 : 2143 : ret=ssl3_get_key_exchange(s);
368 [ + + ]: 2143 : if (ret <= 0) goto end;
369 : 1069 : s->state=SSL3_ST_CR_CERT_REQ_A;
370 : 1069 : s->init_num=0;
371 : :
372 : : /* at this point we check that we have the
373 : : * required stuff from the server */
374 [ + - ]: 1069 : if (!ssl3_check_cert_and_algorithm(s))
375 : : {
376 : : ret= -1;
377 : : goto end;
378 : : }
379 : : break;
380 : :
381 : : case SSL3_ST_CR_CERT_REQ_A:
382 : : case SSL3_ST_CR_CERT_REQ_B:
383 : 1113 : ret=ssl3_get_certificate_request(s);
384 [ + + ]: 1113 : if (ret <= 0) goto end;
385 : 1069 : s->state=SSL3_ST_CR_SRVR_DONE_A;
386 : 1069 : s->init_num=0;
387 : 1069 : break;
388 : :
389 : : case SSL3_ST_CR_SRVR_DONE_A:
390 : : case SSL3_ST_CR_SRVR_DONE_B:
391 : 1069 : ret=ssl3_get_server_done(s);
392 [ + - ]: 1069 : if (ret <= 0) goto end;
393 : : #ifndef OPENSSL_NO_SRP
394 [ + + ]: 1069 : if (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP)
395 : : {
396 [ - + ]: 22 : if ((ret = SRP_Calc_A_param(s))<=0)
397 : : {
398 : 0 : SSLerr(SSL_F_SSL3_CONNECT,SSL_R_SRP_A_CALC);
399 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_INTERNAL_ERROR);
400 : 0 : goto end;
401 : : }
402 : : }
403 : : #endif
404 [ + + ]: 1069 : if (s->s3->tmp.cert_req)
405 : 99 : s->state=SSL3_ST_CW_CERT_A;
406 : : else
407 : 970 : s->state=SSL3_ST_CW_KEY_EXCH_A;
408 : 1069 : s->init_num=0;
409 : :
410 : 1069 : break;
411 : :
412 : : case SSL3_ST_CW_CERT_A:
413 : : case SSL3_ST_CW_CERT_B:
414 : : case SSL3_ST_CW_CERT_C:
415 : : case SSL3_ST_CW_CERT_D:
416 : 99 : ret=ssl3_send_client_certificate(s);
417 [ + - ]: 99 : if (ret <= 0) goto end;
418 : 99 : s->state=SSL3_ST_CW_KEY_EXCH_A;
419 : 99 : s->init_num=0;
420 : 99 : break;
421 : :
422 : : case SSL3_ST_CW_KEY_EXCH_A:
423 : : case SSL3_ST_CW_KEY_EXCH_B:
424 : 1069 : ret=ssl3_send_client_key_exchange(s);
425 [ + - ]: 1069 : if (ret <= 0) goto end;
426 : : /* EAY EAY EAY need to check for DH fix cert
427 : : * sent back */
428 : : /* For TLS, cert_req is set to 2, so a cert chain
429 : : * of nothing is sent, but no verify packet is sent */
430 : : /* XXX: For now, we do not support client
431 : : * authentication in ECDH cipher suites with
432 : : * ECDH (rather than ECDSA) certificates.
433 : : * We need to skip the certificate verify
434 : : * message when client's ECDH public key is sent
435 : : * inside the client certificate.
436 : : */
437 [ + + ]: 1069 : if (s->s3->tmp.cert_req == 1)
438 : : {
439 : 99 : s->state=SSL3_ST_CW_CERT_VRFY_A;
440 : : }
441 : : else
442 : : {
443 : 970 : s->state=SSL3_ST_CW_CHANGE_A;
444 : 970 : s->s3->change_cipher_spec=0;
445 : : }
446 [ - + ]: 1069 : if (s->s3->flags & TLS1_FLAGS_SKIP_CERT_VERIFY)
447 : : {
448 : 0 : s->state=SSL3_ST_CW_CHANGE_A;
449 : 0 : s->s3->change_cipher_spec=0;
450 : : }
451 : :
452 : 1069 : s->init_num=0;
453 : 1069 : break;
454 : :
455 : : case SSL3_ST_CW_CERT_VRFY_A:
456 : : case SSL3_ST_CW_CERT_VRFY_B:
457 : 99 : ret=ssl3_send_client_verify(s);
458 [ + - ]: 99 : if (ret <= 0) goto end;
459 : 99 : s->state=SSL3_ST_CW_CHANGE_A;
460 : 99 : s->init_num=0;
461 : 99 : s->s3->change_cipher_spec=0;
462 : 99 : break;
463 : :
464 : : case SSL3_ST_CW_CHANGE_A:
465 : : case SSL3_ST_CW_CHANGE_B:
466 : 1080 : ret=ssl3_send_change_cipher_spec(s,
467 : : SSL3_ST_CW_CHANGE_A,SSL3_ST_CW_CHANGE_B);
468 [ + - ]: 1080 : if (ret <= 0) goto end;
469 : :
470 : : #if defined(OPENSSL_NO_TLSEXT) || defined(OPENSSL_NO_NEXTPROTONEG)
471 : : s->state=SSL3_ST_CW_FINISHED_A;
472 : : #else
473 [ + + ]: 1080 : if (s->s3->next_proto_neg_seen)
474 : 55 : s->state=SSL3_ST_CW_NEXT_PROTO_A;
475 : : else
476 : 1025 : s->state=SSL3_ST_CW_FINISHED_A;
477 : : #endif
478 : 1080 : s->init_num=0;
479 : :
480 : 1080 : s->session->cipher=s->s3->tmp.new_cipher;
481 : : #ifdef OPENSSL_NO_COMP
482 : : s->session->compress_meth=0;
483 : : #else
484 [ + - ]: 1080 : if (s->s3->tmp.new_compression == NULL)
485 : 1080 : s->session->compress_meth=0;
486 : : else
487 : 0 : s->session->compress_meth=
488 : 0 : s->s3->tmp.new_compression->id;
489 : : #endif
490 [ + - ]: 1080 : if (!s->method->ssl3_enc->setup_key_block(s))
491 : : {
492 : : ret= -1;
493 : : goto end;
494 : : }
495 : :
496 [ + - ]: 1080 : if (!s->method->ssl3_enc->change_cipher_state(s,
497 : : SSL3_CHANGE_CIPHER_CLIENT_WRITE))
498 : : {
499 : : ret= -1;
500 : : goto end;
501 : : }
502 : :
503 : : break;
504 : :
505 : : #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
506 : : case SSL3_ST_CW_NEXT_PROTO_A:
507 : : case SSL3_ST_CW_NEXT_PROTO_B:
508 : 55 : ret=ssl3_send_next_proto(s);
509 [ + - ]: 55 : if (ret <= 0) goto end;
510 : 55 : s->state=SSL3_ST_CW_FINISHED_A;
511 : 55 : break;
512 : : #endif
513 : :
514 : : case SSL3_ST_CW_FINISHED_A:
515 : : case SSL3_ST_CW_FINISHED_B:
516 : 1080 : ret=ssl3_send_finished(s,
517 : : SSL3_ST_CW_FINISHED_A,SSL3_ST_CW_FINISHED_B,
518 : : s->method->ssl3_enc->client_finished_label,
519 : 1080 : s->method->ssl3_enc->client_finished_label_len);
520 [ + - ]: 1080 : if (ret <= 0) goto end;
521 : 1080 : s->s3->flags |= SSL3_FLAGS_CCS_OK;
522 : 1080 : s->state=SSL3_ST_CW_FLUSH;
523 : :
524 : : /* clear flags */
525 : 1080 : s->s3->flags&= ~SSL3_FLAGS_POP_BUFFER;
526 [ + + ]: 1080 : if (s->hit)
527 : : {
528 : 11 : s->s3->tmp.next_state=SSL_ST_OK;
529 [ - + ]: 11 : if (s->s3->flags & SSL3_FLAGS_DELAY_CLIENT_FINISHED)
530 : : {
531 : 0 : s->state=SSL_ST_OK;
532 : 0 : s->s3->flags|=SSL3_FLAGS_POP_BUFFER;
533 : 0 : s->s3->delay_buf_pop_ret=0;
534 : : }
535 : : }
536 : : else
537 : : {
538 : : #ifndef OPENSSL_NO_TLSEXT
539 : : /* Allow NewSessionTicket if ticket expected */
540 [ + + ]: 1069 : if (s->tlsext_ticket_expected)
541 : 816 : s->s3->tmp.next_state=SSL3_ST_CR_SESSION_TICKET_A;
542 : : else
543 : : #endif
544 : :
545 : 253 : s->s3->tmp.next_state=SSL3_ST_CR_FINISHED_A;
546 : : }
547 : 1080 : s->init_num=0;
548 : 1080 : break;
549 : :
550 : : #ifndef OPENSSL_NO_TLSEXT
551 : : case SSL3_ST_CR_SESSION_TICKET_A:
552 : : case SSL3_ST_CR_SESSION_TICKET_B:
553 : 17263 : ret=ssl3_get_new_session_ticket(s);
554 [ + + ]: 17263 : if (ret <= 0) goto end;
555 : 827 : s->state=SSL3_ST_CR_FINISHED_A;
556 : 827 : s->init_num=0;
557 : 827 : break;
558 : :
559 : : case SSL3_ST_CR_CERT_STATUS_A:
560 : : case SSL3_ST_CR_CERT_STATUS_B:
561 : 0 : ret=ssl3_get_cert_status(s);
562 [ # # ]: 0 : if (ret <= 0) goto end;
563 : 0 : s->state=SSL3_ST_CR_KEY_EXCH_A;
564 : 0 : s->init_num=0;
565 : 0 : break;
566 : : #endif
567 : :
568 : : case SSL3_ST_CR_FINISHED_A:
569 : : case SSL3_ST_CR_FINISHED_B:
570 : :
571 : 2435 : s->s3->flags |= SSL3_FLAGS_CCS_OK;
572 : 2435 : ret=ssl3_get_finished(s,SSL3_ST_CR_FINISHED_A,
573 : : SSL3_ST_CR_FINISHED_B);
574 [ + + ]: 2435 : if (ret <= 0) goto end;
575 : :
576 [ + + ]: 1080 : if (s->hit)
577 : 11 : s->state=SSL3_ST_CW_CHANGE_A;
578 : : else
579 : 1069 : s->state=SSL_ST_OK;
580 : 1080 : s->init_num=0;
581 : 1080 : break;
582 : :
583 : : case SSL3_ST_CW_FLUSH:
584 : 3216 : s->rwstate=SSL_WRITING;
585 [ + + ]: 3216 : if (BIO_flush(s->wbio) <= 0)
586 : : {
587 : : ret= -1;
588 : : goto end;
589 : : }
590 : 1080 : s->rwstate=SSL_NOTHING;
591 : 1080 : s->state=s->s3->tmp.next_state;
592 : 1080 : break;
593 : :
594 : : case SSL_ST_OK:
595 : : /* clean a few things up */
596 : 1080 : ssl3_cleanup_key_block(s);
597 : :
598 [ + - ]: 1080 : if (s->init_buf != NULL)
599 : : {
600 : 1080 : BUF_MEM_free(s->init_buf);
601 : 1080 : s->init_buf=NULL;
602 : : }
603 : :
604 : : /* If we are not 'joining' the last two packets,
605 : : * remove the buffering now */
606 [ + - ]: 1080 : if (!(s->s3->flags & SSL3_FLAGS_POP_BUFFER))
607 : 1080 : ssl_free_wbio_buffer(s);
608 : : /* else do it later in ssl3_write */
609 : :
610 : 1080 : s->init_num=0;
611 : 1080 : s->renegotiate=0;
612 : 1080 : s->new_session=0;
613 : :
614 : 1080 : ssl_update_cache(s,SSL_SESS_CACHE_CLIENT);
615 [ + + ]: 1080 : if (s->hit) s->ctx->stats.sess_hit++;
616 : :
617 : 1080 : ret=1;
618 : : /* s->server=0; */
619 : 1080 : s->handshake_func=ssl3_connect;
620 : 1080 : s->ctx->stats.sess_connect_good++;
621 : :
622 [ - + ]: 1080 : if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_DONE,1);
623 : :
624 : : goto end;
625 : : /* break; */
626 : :
627 : : default:
628 : 0 : SSLerr(SSL_F_SSL3_CONNECT,SSL_R_UNKNOWN_STATE);
629 : 0 : ret= -1;
630 : 0 : goto end;
631 : : /* break; */
632 : : }
633 : :
634 : : /* did we do anything */
635 [ + + ]: 13585 : if (!s->s3->tmp.reuse_message && !skip)
636 : : {
637 [ - + ]: 12140 : if (s->debug)
638 : : {
639 [ # # ]: 0 : if ((ret=BIO_flush(s->wbio)) <= 0)
640 : : goto end;
641 : : }
642 : :
643 [ + - ][ # # ]: 12140 : if ((cb != NULL) && (s->state != state))
644 : : {
645 : 0 : new_state=s->state;
646 : 0 : s->state=state;
647 : 0 : cb(s,SSL_CB_CONNECT_LOOP,1);
648 : 0 : s->state=new_state;
649 : : }
650 : : }
651 : : skip=0;
652 : : }
653 : : end:
654 : 34720 : s->in_handshake--;
655 [ - + ]: 34720 : if (buf != NULL)
656 : 0 : BUF_MEM_free(buf);
657 [ - + ]: 34720 : if (cb != NULL)
658 : 0 : cb(s,SSL_CB_CONNECT_EXIT,ret);
659 : 34720 : return(ret);
660 : : }
661 : :
662 : :
663 : 3718 : int ssl3_client_hello(SSL *s)
664 : : {
665 : : unsigned char *buf;
666 : : unsigned char *p,*d;
667 : : int i;
668 : : unsigned long l;
669 : 3718 : int al = 0;
670 : : #ifndef OPENSSL_NO_COMP
671 : : int j;
672 : : SSL_COMP *comp;
673 : : #endif
674 : :
675 : 3718 : buf=(unsigned char *)s->init_buf->data;
676 [ + + ]: 3718 : if (s->state == SSL3_ST_CW_CLNT_HELLO_A)
677 : : {
678 : 880 : SSL_SESSION *sess = s->session;
679 [ + + ][ + - ]: 880 : if ((sess == NULL) ||
680 [ - + ]: 11 : (sess->ssl_version != s->version) ||
681 : : #ifdef OPENSSL_NO_TLSEXT
682 : : !sess->session_id_length ||
683 : : #else
684 [ # # ][ - + ]: 11 : (!sess->session_id_length && !sess->tlsext_tick) ||
685 : : #endif
686 : 11 : (sess->not_resumable))
687 : : {
688 [ + - ]: 869 : if (!ssl_get_new_session(s,0))
689 : : goto err;
690 : : }
691 [ - + ]: 880 : if (s->method->version == DTLS_ANY_VERSION)
692 : : {
693 : : /* Determine which DTLS version to use */
694 : 0 : int options = s->options;
695 : : /* If DTLS 1.2 disabled correct the version number */
696 [ # # ]: 0 : if (options & SSL_OP_NO_DTLSv1_2)
697 : : {
698 [ # # ]: 0 : if (tls1_suiteb(s))
699 : : {
700 : 0 : SSLerr(SSL_F_SSL3_CLIENT_HELLO, SSL_R_ONLY_DTLS_1_2_ALLOWED_IN_SUITEB_MODE);
701 : 0 : goto err;
702 : : }
703 : : /* Disabling all versions is silly: return an
704 : : * error.
705 : : */
706 [ # # ]: 0 : if (options & SSL_OP_NO_DTLSv1)
707 : : {
708 : 0 : SSLerr(SSL_F_SSL3_CLIENT_HELLO,SSL_R_WRONG_SSL_VERSION);
709 : 0 : goto err;
710 : : }
711 : : /* Update method so we don't use any DTLS 1.2
712 : : * features.
713 : : */
714 : 0 : s->method = DTLSv1_client_method();
715 : 0 : s->version = DTLS1_VERSION;
716 : : }
717 : : else
718 : : {
719 : : /* We only support one version: update method */
720 [ # # ]: 0 : if (options & SSL_OP_NO_DTLSv1)
721 : 0 : s->method = DTLSv1_2_client_method();
722 : 0 : s->version = DTLS1_2_VERSION;
723 : : }
724 : 0 : s->client_version = s->version;
725 : : }
726 : : /* else use the pre-loaded session */
727 : :
728 : 880 : p=s->s3->client_random;
729 : :
730 : : /* for DTLS if client_random is initialized, reuse it, we are
731 : : * required to use same upon reply to HelloVerify */
732 [ - + ]: 880 : if (SSL_IS_DTLS(s))
733 : : {
734 : : size_t idx;
735 : : i = 1;
736 [ # # ]: 0 : for (idx=0; idx < sizeof(s->s3->client_random); idx++)
737 : : {
738 [ # # ]: 0 : if (p[idx])
739 : : {
740 : : i = 0;
741 : : break;
742 : : }
743 : : }
744 : : }
745 : : else
746 : : i = 1;
747 : :
748 [ + - ]: 880 : if (i)
749 : 880 : ssl_fill_hello_random(s, 0, p,
750 : : sizeof(s->s3->client_random));
751 : :
752 : : /* Do the message type and length last */
753 : 880 : d=p= ssl_handshake_start(s);
754 : :
755 : : /* version indicates the negotiated version: for example from
756 : : * an SSLv2/v3 compatible client hello). The client_version
757 : : * field is the maximum version we permit and it is also
758 : : * used in RSA encrypted premaster secrets. Some servers can
759 : : * choke if we initially report a higher version then
760 : : * renegotiate to a lower one in the premaster secret. This
761 : : * didn't happen with TLS 1.0 as most servers supported it
762 : : * but it can with TLS 1.1 or later if the server only supports
763 : : * 1.0.
764 : : *
765 : : * Possible scenario with previous logic:
766 : : * 1. Client hello indicates TLS 1.2
767 : : * 2. Server hello says TLS 1.0
768 : : * 3. RSA encrypted premaster secret uses 1.2.
769 : : * 4. Handhaked proceeds using TLS 1.0.
770 : : * 5. Server sends hello request to renegotiate.
771 : : * 6. Client hello indicates TLS v1.0 as we now
772 : : * know that is maximum server supports.
773 : : * 7. Server chokes on RSA encrypted premaster secret
774 : : * containing version 1.0.
775 : : *
776 : : * For interoperability it should be OK to always use the
777 : : * maximum version we support in client hello and then rely
778 : : * on the checking of version to ensure the servers isn't
779 : : * being inconsistent: for example initially negotiating with
780 : : * TLS 1.0 and renegotiating with TLS 1.2. We do this by using
781 : : * client_version in client hello and not resetting it to
782 : : * the negotiated version.
783 : : */
784 : : #if 0
785 : : *(p++)=s->version>>8;
786 : : *(p++)=s->version&0xff;
787 : : s->client_version=s->version;
788 : : #else
789 : 880 : *(p++)=s->client_version>>8;
790 : 880 : *(p++)=s->client_version&0xff;
791 : : #endif
792 : :
793 : : /* Random stuff */
794 : 880 : memcpy(p,s->s3->client_random,SSL3_RANDOM_SIZE);
795 : 880 : p+=SSL3_RANDOM_SIZE;
796 : :
797 : : /* Session ID */
798 [ + - ]: 880 : if (s->new_session)
799 : : i=0;
800 : : else
801 : 880 : i=s->session->session_id_length;
802 : 880 : *(p++)=i;
803 [ + + ]: 880 : if (i != 0)
804 : : {
805 [ - + ]: 11 : if (i > (int)sizeof(s->session->session_id))
806 : : {
807 : 0 : SSLerr(SSL_F_SSL3_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
808 : 0 : goto err;
809 : : }
810 : 11 : memcpy(p,s->session->session_id,i);
811 : 11 : p+=i;
812 : : }
813 : :
814 : : /* cookie stuff for DTLS */
815 [ - + ]: 880 : if (SSL_IS_DTLS(s))
816 : : {
817 [ # # ]: 0 : if ( s->d1->cookie_len > sizeof(s->d1->cookie))
818 : : {
819 : 0 : SSLerr(SSL_F_SSL3_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
820 : 0 : goto err;
821 : : }
822 : 0 : *(p++) = s->d1->cookie_len;
823 : 0 : memcpy(p, s->d1->cookie, s->d1->cookie_len);
824 : 0 : p += s->d1->cookie_len;
825 : : }
826 : :
827 : : /* Ciphers supported */
828 : 880 : i=ssl_cipher_list_to_bytes(s,SSL_get_ciphers(s),&(p[2]),0);
829 [ - + ]: 880 : if (i == 0)
830 : : {
831 : 0 : SSLerr(SSL_F_SSL3_CLIENT_HELLO,SSL_R_NO_CIPHERS_AVAILABLE);
832 : 0 : goto err;
833 : : }
834 : : #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH
835 : : /* Some servers hang if client hello > 256 bytes
836 : : * as hack workaround chop number of supported ciphers
837 : : * to keep it well below this if we use TLS v1.2
838 : : */
839 : : if (TLS1_get_version(s) >= TLS1_2_VERSION
840 : : && i > OPENSSL_MAX_TLS1_2_CIPHER_LENGTH)
841 : : i = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1;
842 : : #endif
843 : 880 : s2n(i,p);
844 : 880 : p+=i;
845 : :
846 : : /* COMPRESSION */
847 : : #ifdef OPENSSL_NO_COMP
848 : : *(p++)=1;
849 : : #else
850 : :
851 [ + - ][ + - ]: 880 : if (!ssl_allow_compression(s) || !s->ctx->comp_methods)
852 : : j=0;
853 : : else
854 : 880 : j=sk_SSL_COMP_num(s->ctx->comp_methods);
855 : 880 : *(p++)=1+j;
856 [ - + ]: 880 : for (i=0; i<j; i++)
857 : : {
858 : 0 : comp=sk_SSL_COMP_value(s->ctx->comp_methods,i);
859 : 0 : *(p++)=comp->id;
860 : : }
861 : : #endif
862 : 880 : *(p++)=0; /* Add the NULL method */
863 : :
864 : : #ifndef OPENSSL_NO_TLSEXT
865 : : /* TLS extensions*/
866 [ - + ]: 880 : if (ssl_prepare_clienthello_tlsext(s) <= 0)
867 : : {
868 : 0 : SSLerr(SSL_F_SSL3_CLIENT_HELLO,SSL_R_CLIENTHELLO_TLSEXT);
869 : 0 : goto err;
870 : : }
871 [ - + ]: 880 : if ((p = ssl_add_clienthello_tlsext(s, p, buf+SSL3_RT_MAX_PLAIN_LENGTH, &al)) == NULL)
872 : : {
873 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,al);
874 : 0 : SSLerr(SSL_F_SSL3_CLIENT_HELLO,ERR_R_INTERNAL_ERROR);
875 : 0 : goto err;
876 : : }
877 : : #endif
878 : :
879 : 880 : l= p-d;
880 : 880 : ssl_set_handshake_header(s, SSL3_MT_CLIENT_HELLO, l);
881 : 880 : s->state=SSL3_ST_CW_CLNT_HELLO_B;
882 : : }
883 : :
884 : : /* SSL3_ST_CW_CLNT_HELLO_B */
885 : 3718 : return ssl_do_write(s);
886 : : err:
887 : : return(-1);
888 : : }
889 : :
890 : 6019 : int ssl3_get_server_hello(SSL *s)
891 : : {
892 : : STACK_OF(SSL_CIPHER) *sk;
893 : : const SSL_CIPHER *c;
894 : 6019 : CERT *ct = s->cert;
895 : : unsigned char *p,*d;
896 : 6019 : int i,al=SSL_AD_INTERNAL_ERROR,ok;
897 : : unsigned int j;
898 : : long n;
899 : : #ifndef OPENSSL_NO_COMP
900 : : SSL_COMP *comp;
901 : : #endif
902 : : /* Hello verify request and/or server hello version may not
903 : : * match so set first packet if we're negotiating version.
904 : : */
905 [ - + ]: 6019 : if (SSL_IS_DTLS(s))
906 : 0 : s->first_packet = 1;
907 : :
908 : 6019 : n=s->method->ssl_get_message(s,
909 : : SSL3_ST_CR_SRVR_HELLO_A,
910 : : SSL3_ST_CR_SRVR_HELLO_B,
911 : : -1,
912 : : 20000, /* ?? */
913 : : &ok);
914 : :
915 [ + + ]: 6019 : if (!ok) return((int)n);
916 : :
917 [ - + ]: 1080 : if (SSL_IS_DTLS(s))
918 : : {
919 : 0 : s->first_packet = 0;
920 [ # # ]: 0 : if ( s->s3->tmp.message_type == DTLS1_MT_HELLO_VERIFY_REQUEST)
921 : : {
922 [ # # ]: 0 : if ( s->d1->send_cookie == 0)
923 : : {
924 : 0 : s->s3->tmp.reuse_message = 1;
925 : 0 : return 1;
926 : : }
927 : : else /* already sent a cookie */
928 : : {
929 : 0 : al=SSL_AD_UNEXPECTED_MESSAGE;
930 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_BAD_MESSAGE_TYPE);
931 : 0 : goto f_err;
932 : : }
933 : : }
934 : : }
935 : :
936 [ - + ]: 1080 : if ( s->s3->tmp.message_type != SSL3_MT_SERVER_HELLO)
937 : : {
938 : 0 : al=SSL_AD_UNEXPECTED_MESSAGE;
939 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_BAD_MESSAGE_TYPE);
940 : 0 : goto f_err;
941 : : }
942 : :
943 : 1080 : d=p=(unsigned char *)s->init_msg;
944 [ - + ]: 1080 : if (s->method->version == DTLS_ANY_VERSION)
945 : : {
946 : : /* Work out correct protocol version to use */
947 : 0 : int hversion = (p[0] << 8)|p[1];
948 : 0 : int options = s->options;
949 [ # # ]: 0 : if (hversion == DTLS1_2_VERSION
950 [ # # ]: 0 : && !(options & SSL_OP_NO_DTLSv1_2))
951 : 0 : s->method = DTLSv1_2_client_method();
952 [ # # ]: 0 : else if (tls1_suiteb(s))
953 : : {
954 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO, SSL_R_ONLY_DTLS_1_2_ALLOWED_IN_SUITEB_MODE);
955 : 0 : s->version = hversion;
956 : 0 : al = SSL_AD_PROTOCOL_VERSION;
957 : 0 : goto f_err;
958 : : }
959 [ # # ]: 0 : else if (hversion == DTLS1_VERSION
960 [ # # ]: 0 : && !(options & SSL_OP_NO_DTLSv1))
961 : 0 : s->method = DTLSv1_client_method();
962 : : else
963 : : {
964 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_WRONG_SSL_VERSION);
965 : 0 : s->version = hversion;
966 : 0 : al = SSL_AD_PROTOCOL_VERSION;
967 : 0 : goto f_err;
968 : : }
969 : 0 : s->version = s->client_version = s->method->version;
970 : : }
971 : :
972 [ + - ][ - + ]: 1080 : if ((p[0] != (s->version>>8)) || (p[1] != (s->version&0xff)))
973 : : {
974 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_WRONG_SSL_VERSION);
975 : 0 : s->version=(s->version&0xff00)|p[1];
976 : 0 : al=SSL_AD_PROTOCOL_VERSION;
977 : 0 : goto f_err;
978 : : }
979 : 1080 : p+=2;
980 : :
981 : : /* load the server hello data */
982 : : /* load the server random */
983 : 1080 : memcpy(s->s3->server_random,p,SSL3_RANDOM_SIZE);
984 : 1080 : p+=SSL3_RANDOM_SIZE;
985 : :
986 : : /* get the session-id */
987 : 1080 : j= *(p++);
988 : :
989 [ - + ]: 1080 : if ((j > sizeof s->session->session_id) || (j > SSL3_SESSION_ID_SIZE))
990 : : {
991 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
992 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_SSL3_SESSION_ID_TOO_LONG);
993 : 0 : goto f_err;
994 : : }
995 : :
996 : : #ifndef OPENSSL_NO_TLSEXT
997 : : /* check if we want to resume the session based on external pre-shared secret */
998 [ + + ][ - + ]: 1080 : if (s->version >= TLS1_VERSION && s->tls_session_secret_cb)
999 : : {
1000 : 0 : SSL_CIPHER *pref_cipher=NULL;
1001 : 0 : s->session->master_key_length=sizeof(s->session->master_key);
1002 [ # # ]: 0 : if (s->tls_session_secret_cb(s, s->session->master_key,
1003 : : &s->session->master_key_length,
1004 : : NULL, &pref_cipher,
1005 : : s->tls_session_secret_cb_arg))
1006 : : {
1007 : 0 : s->session->cipher = pref_cipher ?
1008 [ # # ]: 0 : pref_cipher : ssl_get_cipher_by_char(s, p+j);
1009 : 0 : s->s3->flags |= SSL3_FLAGS_CCS_OK;
1010 : : }
1011 : : }
1012 : : #endif /* OPENSSL_NO_TLSEXT */
1013 : :
1014 [ + + ][ + + ]: 1080 : if (j != 0 && j == s->session->session_id_length
1015 [ + - ]: 11 : && memcmp(p,s->session->session_id,j) == 0)
1016 : : {
1017 [ + - ]: 11 : if(s->sid_ctx_length != s->session->sid_ctx_length
1018 [ - + ]: 11 : || memcmp(s->session->sid_ctx,s->sid_ctx,s->sid_ctx_length))
1019 : : {
1020 : : /* actually a client application bug */
1021 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
1022 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT);
1023 : 0 : goto f_err;
1024 : : }
1025 : 11 : s->s3->flags |= SSL3_FLAGS_CCS_OK;
1026 : 11 : s->hit=1;
1027 : : }
1028 : : else /* a miss or crap from the other end */
1029 : : {
1030 : : /* If we were trying for session-id reuse, make a new
1031 : : * SSL_SESSION so we don't stuff up other people */
1032 : 1069 : s->hit=0;
1033 [ - + ]: 1069 : if (s->session->session_id_length > 0)
1034 : : {
1035 [ # # ]: 0 : if (!ssl_get_new_session(s,0))
1036 : : {
1037 : : goto f_err;
1038 : : }
1039 : : }
1040 : 1069 : s->session->session_id_length=j;
1041 : 1069 : memcpy(s->session->session_id,p,j); /* j could be 0 */
1042 : : }
1043 : 1080 : p+=j;
1044 : 1080 : c=ssl_get_cipher_by_char(s,p);
1045 [ - + ]: 1080 : if (c == NULL)
1046 : : {
1047 : : /* unknown cipher */
1048 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
1049 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_UNKNOWN_CIPHER_RETURNED);
1050 : 0 : goto f_err;
1051 : : }
1052 : : /* Set version disabled mask now we know version */
1053 [ + + ]: 1080 : if (!SSL_USE_TLS1_2_CIPHERS(s))
1054 : 880 : ct->mask_ssl = SSL_TLSV1_2;
1055 : : else
1056 : 200 : ct->mask_ssl = 0;
1057 : : /* If it is a disabled cipher we didn't send it in client hello,
1058 : : * so return an error.
1059 : : */
1060 [ - + ]: 1080 : if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_CHECK))
1061 : : {
1062 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
1063 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_WRONG_CIPHER_RETURNED);
1064 : 0 : goto f_err;
1065 : : }
1066 : 1080 : p+=ssl_put_cipher_by_char(s,NULL,NULL);
1067 : :
1068 : 1080 : sk=ssl_get_ciphers_by_id(s);
1069 : 1080 : i=sk_SSL_CIPHER_find(sk,c);
1070 [ - + ]: 1080 : if (i < 0)
1071 : : {
1072 : : /* we did not say we would use this cipher */
1073 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
1074 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_WRONG_CIPHER_RETURNED);
1075 : 0 : goto f_err;
1076 : : }
1077 : :
1078 : : /* Depending on the session caching (internal/external), the cipher
1079 : : and/or cipher_id values may not be set. Make sure that
1080 : : cipher_id is set and use it for comparison. */
1081 [ + + ]: 1080 : if (s->session->cipher)
1082 : 11 : s->session->cipher_id = s->session->cipher->id;
1083 [ + + ][ - + ]: 1080 : if (s->hit && (s->session->cipher_id != c->id))
1084 : : {
1085 : : /* Workaround is now obsolete */
1086 : : #if 0
1087 : : if (!(s->options &
1088 : : SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG))
1089 : : #endif
1090 : : {
1091 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
1092 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED);
1093 : 0 : goto f_err;
1094 : : }
1095 : : }
1096 : 1080 : s->s3->tmp.new_cipher=c;
1097 : : /* Don't digest cached records if no sigalgs: we may need them for
1098 : : * client authentication.
1099 : : */
1100 [ + + ][ + - ]: 1080 : if (!SSL_USE_SIGALGS(s) && !ssl3_digest_cached_records(s))
1101 : : goto f_err;
1102 : : /* lets get the compression algorithm */
1103 : : /* COMPRESSION */
1104 : : #ifdef OPENSSL_NO_COMP
1105 : : if (*(p++) != 0)
1106 : : {
1107 : : al=SSL_AD_ILLEGAL_PARAMETER;
1108 : : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
1109 : : goto f_err;
1110 : : }
1111 : : /* If compression is disabled we'd better not try to resume a session
1112 : : * using compression.
1113 : : */
1114 : : if (s->session->compress_meth != 0)
1115 : : {
1116 : : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_INCONSISTENT_COMPRESSION);
1117 : : goto f_err;
1118 : : }
1119 : : #else
1120 : 1080 : j= *(p++);
1121 [ + + ][ - + ]: 1080 : if (s->hit && j != s->session->compress_meth)
1122 : : {
1123 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
1124 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED);
1125 : 0 : goto f_err;
1126 : : }
1127 [ - + ]: 1080 : if (j == 0)
1128 : : comp=NULL;
1129 [ # # ]: 0 : else if (!ssl_allow_compression(s))
1130 : : {
1131 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
1132 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_COMPRESSION_DISABLED);
1133 : 0 : goto f_err;
1134 : : }
1135 : : else
1136 : 0 : comp=ssl3_comp_find(s->ctx->comp_methods,j);
1137 : :
1138 [ - + ]: 1080 : if ((j != 0) && (comp == NULL))
1139 : : {
1140 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
1141 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
1142 : 0 : goto f_err;
1143 : : }
1144 : : else
1145 : : {
1146 : 1080 : s->s3->tmp.new_compression=comp;
1147 : : }
1148 : : #endif
1149 : :
1150 : : #ifndef OPENSSL_NO_TLSEXT
1151 : : /* TLS extensions*/
1152 [ - + ]: 1080 : if (!ssl_parse_serverhello_tlsext(s,&p,d,n))
1153 : : {
1154 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_PARSE_TLSEXT);
1155 : 0 : goto err;
1156 : : }
1157 : : #endif
1158 : :
1159 [ - + ]: 1080 : if (p != (d+n))
1160 : : {
1161 : : /* wrong packet length */
1162 : 0 : al=SSL_AD_DECODE_ERROR;
1163 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_BAD_PACKET_LENGTH);
1164 : 0 : goto f_err;
1165 : : }
1166 : :
1167 : : return(1);
1168 : : f_err:
1169 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,al);
1170 : : err:
1171 : : return(-1);
1172 : : }
1173 : :
1174 : 5755 : int ssl3_get_server_certificate(SSL *s)
1175 : : {
1176 : 5755 : int al,i,ok,ret= -1;
1177 : : unsigned long n,nc,llen,l;
1178 : 5755 : X509 *x=NULL;
1179 : : const unsigned char *q,*p;
1180 : : unsigned char *d;
1181 : 5755 : STACK_OF(X509) *sk=NULL;
1182 : : SESS_CERT *sc;
1183 : 5755 : EVP_PKEY *pkey=NULL;
1184 : 5755 : int need_cert = 1; /* VRS: 0=> will allow null cert if auth == KRB5 */
1185 : :
1186 : 5755 : n=s->method->ssl_get_message(s,
1187 : : SSL3_ST_CR_CERT_A,
1188 : : SSL3_ST_CR_CERT_B,
1189 : : -1,
1190 : : s->max_cert_list,
1191 : : &ok);
1192 : :
1193 [ + + ]: 5755 : if (!ok) return((int)n);
1194 : :
1195 [ + - ][ - + ]: 937 : if ((s->s3->tmp.message_type == SSL3_MT_SERVER_KEY_EXCHANGE) ||
1196 [ # # ]: 0 : ((s->s3->tmp.new_cipher->algorithm_auth & SSL_aKRB5) &&
1197 : : (s->s3->tmp.message_type == SSL3_MT_SERVER_DONE)))
1198 : : {
1199 : 0 : s->s3->tmp.reuse_message=1;
1200 : 0 : return(1);
1201 : : }
1202 : :
1203 [ - + ]: 937 : if (s->s3->tmp.message_type != SSL3_MT_CERTIFICATE)
1204 : : {
1205 : 0 : al=SSL_AD_UNEXPECTED_MESSAGE;
1206 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,SSL_R_BAD_MESSAGE_TYPE);
1207 : 0 : goto f_err;
1208 : : }
1209 : 937 : p=d=(unsigned char *)s->init_msg;
1210 : :
1211 [ - + ]: 937 : if ((sk=sk_X509_new_null()) == NULL)
1212 : : {
1213 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,ERR_R_MALLOC_FAILURE);
1214 : 0 : goto err;
1215 : : }
1216 : :
1217 : 937 : n2l3(p,llen);
1218 [ + - ]: 937 : if (llen+3 != n)
1219 : : {
1220 : 0 : al=SSL_AD_DECODE_ERROR;
1221 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,SSL_R_LENGTH_MISMATCH);
1222 : 0 : goto f_err;
1223 : : }
1224 [ + + ]: 2199 : for (nc=0; nc<llen; )
1225 : : {
1226 : 1262 : n2l3(p,l);
1227 [ - + ]: 1262 : if ((l+nc+3) > llen)
1228 : : {
1229 : 0 : al=SSL_AD_DECODE_ERROR;
1230 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,SSL_R_CERT_LENGTH_MISMATCH);
1231 : 0 : goto f_err;
1232 : : }
1233 : :
1234 : 1262 : q=p;
1235 : 1262 : x=d2i_X509(NULL,&q,l);
1236 [ - + ]: 1262 : if (x == NULL)
1237 : : {
1238 : 0 : al=SSL_AD_BAD_CERTIFICATE;
1239 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,ERR_R_ASN1_LIB);
1240 : 0 : goto f_err;
1241 : : }
1242 [ - + ]: 1262 : if (q != (p+l))
1243 : : {
1244 : 0 : al=SSL_AD_DECODE_ERROR;
1245 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,SSL_R_CERT_LENGTH_MISMATCH);
1246 : 0 : goto f_err;
1247 : : }
1248 [ - + ]: 1262 : if (!sk_X509_push(sk,x))
1249 : : {
1250 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,ERR_R_MALLOC_FAILURE);
1251 : 0 : goto err;
1252 : : }
1253 : 1262 : x=NULL;
1254 : 1262 : nc+=l+3;
1255 : 1262 : p=q;
1256 : : }
1257 : :
1258 : 937 : i=ssl_verify_cert_chain(s,sk);
1259 [ + + ][ - + ]: 937 : if ((s->verify_mode != SSL_VERIFY_NONE) && (i <= 0)
1260 : : #ifndef OPENSSL_NO_KRB5
1261 : : && !((s->s3->tmp.new_cipher->algorithm_mkey & SSL_kKRB5) &&
1262 : : (s->s3->tmp.new_cipher->algorithm_auth & SSL_aKRB5))
1263 : : #endif /* OPENSSL_NO_KRB5 */
1264 : : )
1265 : : {
1266 : 0 : al=ssl_verify_alarm_type(s->verify_result);
1267 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,SSL_R_CERTIFICATE_VERIFY_FAILED);
1268 : 0 : goto f_err;
1269 : : }
1270 : 937 : ERR_clear_error(); /* but we keep s->verify_result */
1271 [ - + ]: 937 : if (i > 1)
1272 : : {
1273 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE, i);
1274 : 0 : al = SSL_AD_HANDSHAKE_FAILURE;
1275 : 0 : goto f_err;
1276 : : }
1277 : :
1278 : 937 : sc=ssl_sess_cert_new();
1279 [ + - ]: 937 : if (sc == NULL) goto err;
1280 : :
1281 [ - + ]: 937 : if (s->session->sess_cert) ssl_sess_cert_free(s->session->sess_cert);
1282 : 937 : s->session->sess_cert=sc;
1283 : :
1284 : 937 : sc->cert_chain=sk;
1285 : : /* Inconsistency alert: cert_chain does include the peer's
1286 : : * certificate, which we don't include in s3_srvr.c */
1287 : 937 : x=sk_X509_value(sk,0);
1288 : 937 : sk=NULL;
1289 : : /* VRS 19990621: possible memory leak; sk=null ==> !sk_pop_free() @end*/
1290 : :
1291 : 937 : pkey=X509_get_pubkey(x);
1292 : :
1293 : : /* VRS: allow null cert if auth == KRB5 */
1294 : 1874 : need_cert = ((s->s3->tmp.new_cipher->algorithm_mkey & SSL_kKRB5) &&
1295 : 0 : (s->s3->tmp.new_cipher->algorithm_auth & SSL_aKRB5))
1296 [ - + ][ # # ]: 937 : ? 0 : 1;
1297 : :
1298 : : #ifdef KSSL_DEBUG
1299 : : printf("pkey,x = %p, %p\n", pkey,x);
1300 : : printf("ssl_cert_type(x,pkey) = %d\n", ssl_cert_type(x,pkey));
1301 : : printf("cipher, alg, nc = %s, %lx, %lx, %d\n", s->s3->tmp.new_cipher->name,
1302 : : s->s3->tmp.new_cipher->algorithm_mkey, s->s3->tmp.new_cipher->algorithm_auth, need_cert);
1303 : : #endif /* KSSL_DEBUG */
1304 : :
1305 [ + - ][ + - ]: 937 : if (need_cert && ((pkey == NULL) || EVP_PKEY_missing_parameters(pkey)))
[ - + ]
1306 : : {
1307 : 0 : x=NULL;
1308 : 0 : al=SSL3_AL_FATAL;
1309 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,
1310 : : SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS);
1311 : 0 : goto f_err;
1312 : : }
1313 : :
1314 : 937 : i=ssl_cert_type(x,pkey);
1315 [ - + ]: 937 : if (need_cert && i < 0)
1316 : : {
1317 : 0 : x=NULL;
1318 : 0 : al=SSL3_AL_FATAL;
1319 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,
1320 : : SSL_R_UNKNOWN_CERTIFICATE_TYPE);
1321 : 0 : goto f_err;
1322 : : }
1323 : :
1324 [ + - ]: 937 : if (need_cert)
1325 : : {
1326 : 937 : int exp_idx = ssl_cipher_get_cert_index(s->s3->tmp.new_cipher);
1327 [ - + ]: 937 : if (exp_idx >= 0 && i != exp_idx)
1328 : : {
1329 : 0 : x=NULL;
1330 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
1331 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE,
1332 : : SSL_R_WRONG_CERTIFICATE_TYPE);
1333 : 0 : goto f_err;
1334 : : }
1335 : 937 : sc->peer_cert_type=i;
1336 : 937 : CRYPTO_add(&x->references,1,CRYPTO_LOCK_X509);
1337 : : /* Why would the following ever happen?
1338 : : * We just created sc a couple of lines ago. */
1339 [ - + ]: 937 : if (sc->peer_pkeys[i].x509 != NULL)
1340 : 0 : X509_free(sc->peer_pkeys[i].x509);
1341 : 937 : sc->peer_pkeys[i].x509=x;
1342 : 937 : sc->peer_key= &(sc->peer_pkeys[i]);
1343 : :
1344 [ - + ]: 937 : if (s->session->peer != NULL)
1345 : 0 : X509_free(s->session->peer);
1346 : 937 : CRYPTO_add(&x->references,1,CRYPTO_LOCK_X509);
1347 : 937 : s->session->peer=x;
1348 : : }
1349 : : else
1350 : : {
1351 : 0 : sc->peer_cert_type=i;
1352 : 0 : sc->peer_key= NULL;
1353 : :
1354 [ # # ]: 0 : if (s->session->peer != NULL)
1355 : 0 : X509_free(s->session->peer);
1356 : 0 : s->session->peer=NULL;
1357 : : }
1358 : 937 : s->session->verify_result = s->verify_result;
1359 : :
1360 : 937 : x=NULL;
1361 : 937 : ret=1;
1362 : : if (0)
1363 : : {
1364 : : f_err:
1365 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,al);
1366 : : }
1367 : : err:
1368 : 937 : EVP_PKEY_free(pkey);
1369 : 937 : X509_free(x);
1370 : 937 : sk_X509_pop_free(sk,X509_free);
1371 : 937 : return(ret);
1372 : : }
1373 : :
1374 : 2143 : int ssl3_get_key_exchange(SSL *s)
1375 : : {
1376 : : #ifndef OPENSSL_NO_RSA
1377 : : unsigned char *q,md_buf[EVP_MAX_MD_SIZE*2];
1378 : : #endif
1379 : : EVP_MD_CTX md_ctx;
1380 : : unsigned char *param,*p;
1381 : : int al,i,j,param_len,ok;
1382 : : long n,alg_k,alg_a;
1383 : 2143 : EVP_PKEY *pkey=NULL;
1384 : 2143 : const EVP_MD *md = NULL;
1385 : : #ifndef OPENSSL_NO_RSA
1386 : 2143 : RSA *rsa=NULL;
1387 : : #endif
1388 : : #ifndef OPENSSL_NO_DH
1389 : 2143 : DH *dh=NULL;
1390 : : #endif
1391 : : #ifndef OPENSSL_NO_ECDH
1392 : 2143 : EC_KEY *ecdh = NULL;
1393 : 2143 : BN_CTX *bn_ctx = NULL;
1394 : 2143 : EC_POINT *srvr_ecpoint = NULL;
1395 : 2143 : int curve_nid = 0;
1396 : 2143 : int encoded_pt_len = 0;
1397 : : #endif
1398 : :
1399 : : /* use same message size as in ssl3_get_certificate_request()
1400 : : * as ServerKeyExchange message may be skipped */
1401 : 2143 : n=s->method->ssl_get_message(s,
1402 : : SSL3_ST_CR_KEY_EXCH_A,
1403 : : SSL3_ST_CR_KEY_EXCH_B,
1404 : : -1,
1405 : : s->max_cert_list,
1406 : : &ok);
1407 [ + + ]: 2143 : if (!ok) return((int)n);
1408 : :
1409 [ + + ]: 1069 : if (s->s3->tmp.message_type != SSL3_MT_SERVER_KEY_EXCHANGE)
1410 : : {
1411 : : #ifndef OPENSSL_NO_PSK
1412 : : /* In plain PSK ciphersuite, ServerKeyExchange can be
1413 : : omitted if no identity hint is sent. Set
1414 : : session->sess_cert anyway to avoid problems
1415 : : later.*/
1416 [ - + ]: 332 : if (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK)
1417 : : {
1418 : 0 : s->session->sess_cert=ssl_sess_cert_new();
1419 [ # # ]: 0 : if (s->ctx->psk_identity_hint)
1420 : 0 : OPENSSL_free(s->ctx->psk_identity_hint);
1421 : 0 : s->ctx->psk_identity_hint = NULL;
1422 : : }
1423 : : #endif
1424 : 332 : s->s3->tmp.reuse_message=1;
1425 : 332 : return(1);
1426 : : }
1427 : :
1428 : 737 : param=p=(unsigned char *)s->init_msg;
1429 [ + + ]: 737 : if (s->session->sess_cert != NULL)
1430 : : {
1431 : : #ifndef OPENSSL_NO_RSA
1432 [ - + ]: 605 : if (s->session->sess_cert->peer_rsa_tmp != NULL)
1433 : : {
1434 : 0 : RSA_free(s->session->sess_cert->peer_rsa_tmp);
1435 : 0 : s->session->sess_cert->peer_rsa_tmp=NULL;
1436 : : }
1437 : : #endif
1438 : : #ifndef OPENSSL_NO_DH
1439 [ - + ]: 605 : if (s->session->sess_cert->peer_dh_tmp)
1440 : : {
1441 : 0 : DH_free(s->session->sess_cert->peer_dh_tmp);
1442 : 0 : s->session->sess_cert->peer_dh_tmp=NULL;
1443 : : }
1444 : : #endif
1445 : : #ifndef OPENSSL_NO_ECDH
1446 [ - + ]: 605 : if (s->session->sess_cert->peer_ecdh_tmp)
1447 : : {
1448 : 0 : EC_KEY_free(s->session->sess_cert->peer_ecdh_tmp);
1449 : 0 : s->session->sess_cert->peer_ecdh_tmp=NULL;
1450 : : }
1451 : : #endif
1452 : : }
1453 : : else
1454 : : {
1455 : 132 : s->session->sess_cert=ssl_sess_cert_new();
1456 : : }
1457 : :
1458 : 737 : param_len=0;
1459 : 737 : alg_k=s->s3->tmp.new_cipher->algorithm_mkey;
1460 : 737 : alg_a=s->s3->tmp.new_cipher->algorithm_auth;
1461 : 737 : EVP_MD_CTX_init(&md_ctx);
1462 : :
1463 : : #ifndef OPENSSL_NO_PSK
1464 [ + + ]: 737 : if (alg_k & SSL_kPSK)
1465 : : {
1466 : : char tmp_id_hint[PSK_MAX_IDENTITY_LEN+1];
1467 : :
1468 : 22 : al=SSL_AD_HANDSHAKE_FAILURE;
1469 : 22 : n2s(p,i);
1470 : 22 : param_len=i+2;
1471 : : /* Store PSK identity hint for later use, hint is used
1472 : : * in ssl3_send_client_key_exchange. Assume that the
1473 : : * maximum length of a PSK identity hint can be as
1474 : : * long as the maximum length of a PSK identity. */
1475 [ - + ]: 22 : if (i > PSK_MAX_IDENTITY_LEN)
1476 : : {
1477 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,
1478 : : SSL_R_DATA_LENGTH_TOO_LONG);
1479 : 0 : goto f_err;
1480 : : }
1481 [ - + ]: 22 : if (param_len > n)
1482 : : {
1483 : 0 : al=SSL_AD_DECODE_ERROR;
1484 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,
1485 : : SSL_R_BAD_PSK_IDENTITY_HINT_LENGTH);
1486 : 0 : goto f_err;
1487 : : }
1488 : : /* If received PSK identity hint contains NULL
1489 : : * characters, the hint is truncated from the first
1490 : : * NULL. p may not be ending with NULL, so create a
1491 : : * NULL-terminated string. */
1492 : 22 : memcpy(tmp_id_hint, p, i);
1493 : 22 : memset(tmp_id_hint+i, 0, PSK_MAX_IDENTITY_LEN+1-i);
1494 [ - + ]: 22 : if (s->ctx->psk_identity_hint != NULL)
1495 : 0 : OPENSSL_free(s->ctx->psk_identity_hint);
1496 : 22 : s->ctx->psk_identity_hint = BUF_strdup(tmp_id_hint);
1497 [ - + ]: 22 : if (s->ctx->psk_identity_hint == NULL)
1498 : : {
1499 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
1500 : 0 : goto f_err;
1501 : : }
1502 : :
1503 : 22 : p+=i;
1504 : 22 : n-=param_len;
1505 : : }
1506 : : else
1507 : : #endif /* !OPENSSL_NO_PSK */
1508 : : #ifndef OPENSSL_NO_SRP
1509 [ + + ]: 715 : if (alg_k & SSL_kSRP)
1510 : : {
1511 : 22 : n2s(p,i);
1512 : 22 : param_len=i+2;
1513 [ - + ]: 22 : if (param_len > n)
1514 : : {
1515 : 0 : al=SSL_AD_DECODE_ERROR;
1516 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_BAD_SRP_N_LENGTH);
1517 : 0 : goto f_err;
1518 : : }
1519 [ - + ]: 22 : if (!(s->srp_ctx.N=BN_bin2bn(p,i,NULL)))
1520 : : {
1521 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_BN_LIB);
1522 : 0 : goto err;
1523 : : }
1524 : 22 : p+=i;
1525 : :
1526 : 22 : n2s(p,i);
1527 : 22 : param_len+=i+2;
1528 [ - + ]: 22 : if (param_len > n)
1529 : : {
1530 : 0 : al=SSL_AD_DECODE_ERROR;
1531 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_BAD_SRP_G_LENGTH);
1532 : 0 : goto f_err;
1533 : : }
1534 [ - + ]: 22 : if (!(s->srp_ctx.g=BN_bin2bn(p,i,NULL)))
1535 : : {
1536 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_BN_LIB);
1537 : 0 : goto err;
1538 : : }
1539 : 22 : p+=i;
1540 : :
1541 : 22 : i = (unsigned int)(p[0]);
1542 : 22 : p++;
1543 : 22 : param_len+=i+1;
1544 [ - + ]: 22 : if (param_len > n)
1545 : : {
1546 : 0 : al=SSL_AD_DECODE_ERROR;
1547 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_BAD_SRP_S_LENGTH);
1548 : 0 : goto f_err;
1549 : : }
1550 [ - + ]: 22 : if (!(s->srp_ctx.s=BN_bin2bn(p,i,NULL)))
1551 : : {
1552 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_BN_LIB);
1553 : 0 : goto err;
1554 : : }
1555 : 22 : p+=i;
1556 : :
1557 : 22 : n2s(p,i);
1558 : 22 : param_len+=i+2;
1559 [ - + ]: 22 : if (param_len > n)
1560 : : {
1561 : 0 : al=SSL_AD_DECODE_ERROR;
1562 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_BAD_SRP_B_LENGTH);
1563 : 0 : goto f_err;
1564 : : }
1565 [ - + ]: 22 : if (!(s->srp_ctx.B=BN_bin2bn(p,i,NULL)))
1566 : : {
1567 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_BN_LIB);
1568 : 0 : goto err;
1569 : : }
1570 : 22 : p+=i;
1571 : 22 : n-=param_len;
1572 : :
1573 : : /* We must check if there is a certificate */
1574 : : #ifndef OPENSSL_NO_RSA
1575 [ + - ]: 22 : if (alg_a & SSL_aRSA)
1576 : 22 : pkey=X509_get_pubkey(s->session->sess_cert->peer_pkeys[SSL_PKEY_RSA_ENC].x509);
1577 : : #else
1578 : : if (0)
1579 : : ;
1580 : : #endif
1581 : : #ifndef OPENSSL_NO_DSA
1582 [ # # ]: 0 : else if (alg_a & SSL_aDSS)
1583 : 0 : pkey=X509_get_pubkey(s->session->sess_cert->peer_pkeys[SSL_PKEY_DSA_SIGN].x509);
1584 : : #endif
1585 : : }
1586 : : else
1587 : : #endif /* !OPENSSL_NO_SRP */
1588 : : #ifndef OPENSSL_NO_RSA
1589 [ + + ]: 693 : if (alg_k & SSL_kRSA)
1590 : : {
1591 [ - + ]: 33 : if ((rsa=RSA_new()) == NULL)
1592 : : {
1593 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_MALLOC_FAILURE);
1594 : 0 : goto err;
1595 : : }
1596 : 33 : n2s(p,i);
1597 : 33 : param_len=i+2;
1598 [ - + ]: 33 : if (param_len > n)
1599 : : {
1600 : 0 : al=SSL_AD_DECODE_ERROR;
1601 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_BAD_RSA_MODULUS_LENGTH);
1602 : 0 : goto f_err;
1603 : : }
1604 [ - + ]: 33 : if (!(rsa->n=BN_bin2bn(p,i,rsa->n)))
1605 : : {
1606 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_BN_LIB);
1607 : 0 : goto err;
1608 : : }
1609 : 33 : p+=i;
1610 : :
1611 : 33 : n2s(p,i);
1612 : 33 : param_len+=i+2;
1613 [ - + ]: 33 : if (param_len > n)
1614 : : {
1615 : 0 : al=SSL_AD_DECODE_ERROR;
1616 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_BAD_RSA_E_LENGTH);
1617 : 0 : goto f_err;
1618 : : }
1619 [ - + ]: 33 : if (!(rsa->e=BN_bin2bn(p,i,rsa->e)))
1620 : : {
1621 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_BN_LIB);
1622 : 0 : goto err;
1623 : : }
1624 : 33 : p+=i;
1625 : 33 : n-=param_len;
1626 : :
1627 : : /* this should be because we are using an export cipher */
1628 [ + - ]: 33 : if (alg_a & SSL_aRSA)
1629 : 33 : pkey=X509_get_pubkey(s->session->sess_cert->peer_pkeys[SSL_PKEY_RSA_ENC].x509);
1630 : : else
1631 : : {
1632 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
1633 : 0 : goto err;
1634 : : }
1635 : 33 : s->session->sess_cert->peer_rsa_tmp=rsa;
1636 : 33 : rsa=NULL;
1637 : : }
1638 : : #else /* OPENSSL_NO_RSA */
1639 : : if (0)
1640 : : ;
1641 : : #endif
1642 : : #ifndef OPENSSL_NO_DH
1643 [ + + ]: 660 : else if (alg_k & SSL_kDHE)
1644 : : {
1645 [ - + ]: 198 : if ((dh=DH_new()) == NULL)
1646 : : {
1647 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_DH_LIB);
1648 : 0 : goto err;
1649 : : }
1650 : 198 : n2s(p,i);
1651 : 198 : param_len=i+2;
1652 [ - + ]: 198 : if (param_len > n)
1653 : : {
1654 : 0 : al=SSL_AD_DECODE_ERROR;
1655 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_BAD_DH_P_LENGTH);
1656 : 0 : goto f_err;
1657 : : }
1658 [ - + ]: 198 : if (!(dh->p=BN_bin2bn(p,i,NULL)))
1659 : : {
1660 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_BN_LIB);
1661 : 0 : goto err;
1662 : : }
1663 : 198 : p+=i;
1664 : :
1665 : 198 : n2s(p,i);
1666 : 198 : param_len+=i+2;
1667 [ - + ]: 198 : if (param_len > n)
1668 : : {
1669 : 0 : al=SSL_AD_DECODE_ERROR;
1670 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_BAD_DH_G_LENGTH);
1671 : 0 : goto f_err;
1672 : : }
1673 [ - + ]: 198 : if (!(dh->g=BN_bin2bn(p,i,NULL)))
1674 : : {
1675 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_BN_LIB);
1676 : 0 : goto err;
1677 : : }
1678 : 198 : p+=i;
1679 : :
1680 : 198 : n2s(p,i);
1681 : 198 : param_len+=i+2;
1682 [ - + ]: 198 : if (param_len > n)
1683 : : {
1684 : 0 : al=SSL_AD_DECODE_ERROR;
1685 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_BAD_DH_PUB_KEY_LENGTH);
1686 : 0 : goto f_err;
1687 : : }
1688 [ - + ]: 198 : if (!(dh->pub_key=BN_bin2bn(p,i,NULL)))
1689 : : {
1690 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_BN_LIB);
1691 : 0 : goto err;
1692 : : }
1693 : 198 : p+=i;
1694 : 198 : n-=param_len;
1695 : :
1696 [ - + ]: 198 : if (!ssl_security(s, SSL_SECOP_TMP_DH,
1697 : : DH_security_bits(dh), 0, dh))
1698 : : {
1699 : 0 : al=SSL_AD_HANDSHAKE_FAILURE;
1700 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_DH_KEY_TOO_SMALL);
1701 : 0 : goto f_err;
1702 : : }
1703 : :
1704 : : #ifndef OPENSSL_NO_RSA
1705 [ + + ]: 198 : if (alg_a & SSL_aRSA)
1706 : 88 : pkey=X509_get_pubkey(s->session->sess_cert->peer_pkeys[SSL_PKEY_RSA_ENC].x509);
1707 : : #else
1708 : : if (0)
1709 : : ;
1710 : : #endif
1711 : : #ifndef OPENSSL_NO_DSA
1712 [ - + ]: 110 : else if (alg_a & SSL_aDSS)
1713 : 0 : pkey=X509_get_pubkey(s->session->sess_cert->peer_pkeys[SSL_PKEY_DSA_SIGN].x509);
1714 : : #endif
1715 : : /* else anonymous DH, so no certificate or pkey. */
1716 : :
1717 : 198 : s->session->sess_cert->peer_dh_tmp=dh;
1718 : 198 : dh=NULL;
1719 : : }
1720 [ - + ]: 462 : else if ((alg_k & SSL_kDHr) || (alg_k & SSL_kDHd))
1721 : : {
1722 : 0 : al=SSL_AD_ILLEGAL_PARAMETER;
1723 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_TRIED_TO_USE_UNSUPPORTED_CIPHER);
1724 : 0 : goto f_err;
1725 : : }
1726 : : #endif /* !OPENSSL_NO_DH */
1727 : :
1728 : : #ifndef OPENSSL_NO_ECDH
1729 [ + - ]: 462 : else if (alg_k & SSL_kECDHE)
1730 : : {
1731 : : EC_GROUP *ngroup;
1732 : : const EC_GROUP *group;
1733 : :
1734 [ - + ]: 462 : if ((ecdh=EC_KEY_new()) == NULL)
1735 : : {
1736 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_MALLOC_FAILURE);
1737 : 0 : goto err;
1738 : : }
1739 : :
1740 : : /* Extract elliptic curve parameters and the
1741 : : * server's ephemeral ECDH public key.
1742 : : * Keep accumulating lengths of various components in
1743 : : * param_len and make sure it never exceeds n.
1744 : : */
1745 : :
1746 : : /* XXX: For now we only support named (not generic) curves
1747 : : * and the ECParameters in this case is just three bytes.
1748 : : */
1749 : 462 : param_len=3;
1750 : : /* Check curve is one of our preferences, if not server has
1751 : : * sent an invalid curve.
1752 : : */
1753 [ - + ]: 462 : if (!tls1_check_curve(s, p, param_len))
1754 : : {
1755 : 0 : al=SSL_AD_DECODE_ERROR;
1756 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_WRONG_CURVE);
1757 : 0 : goto f_err;
1758 : : }
1759 : :
1760 [ - + ]: 462 : if ((curve_nid = tls1_ec_curve_id2nid(*(p + 2))) == 0)
1761 : : {
1762 : 0 : al=SSL_AD_INTERNAL_ERROR;
1763 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
1764 : 0 : goto f_err;
1765 : : }
1766 : :
1767 : 462 : ngroup = EC_GROUP_new_by_curve_name(curve_nid);
1768 [ - + ]: 462 : if (ngroup == NULL)
1769 : : {
1770 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_EC_LIB);
1771 : 0 : goto err;
1772 : : }
1773 [ - + ]: 462 : if (EC_KEY_set_group(ecdh, ngroup) == 0)
1774 : : {
1775 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_EC_LIB);
1776 : 0 : goto err;
1777 : : }
1778 : 462 : EC_GROUP_free(ngroup);
1779 : :
1780 : 462 : group = EC_KEY_get0_group(ecdh);
1781 : :
1782 [ - + # # ]: 462 : if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) &&
1783 : 0 : (EC_GROUP_get_degree(group) > 163))
1784 : : {
1785 : 0 : al=SSL_AD_EXPORT_RESTRICTION;
1786 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_ECGROUP_TOO_LARGE_FOR_CIPHER);
1787 : 0 : goto f_err;
1788 : : }
1789 : :
1790 : 462 : p+=3;
1791 : :
1792 : : /* Next, get the encoded ECPoint */
1793 [ + - ][ - + ]: 462 : if (((srvr_ecpoint = EC_POINT_new(group)) == NULL) ||
1794 : : ((bn_ctx = BN_CTX_new()) == NULL))
1795 : : {
1796 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_MALLOC_FAILURE);
1797 : 0 : goto err;
1798 : : }
1799 : :
1800 : 462 : encoded_pt_len = *p; /* length of encoded point */
1801 : 462 : p+=1;
1802 : 462 : param_len += (1 + encoded_pt_len);
1803 [ + - - + ]: 924 : if ((param_len > n) ||
1804 : 462 : (EC_POINT_oct2point(group, srvr_ecpoint,
1805 : : p, encoded_pt_len, bn_ctx) == 0))
1806 : : {
1807 : 0 : al=SSL_AD_DECODE_ERROR;
1808 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_BAD_ECPOINT);
1809 : 0 : goto f_err;
1810 : : }
1811 : :
1812 : 462 : n-=param_len;
1813 : 462 : p+=encoded_pt_len;
1814 : :
1815 : : /* The ECC/TLS specification does not mention
1816 : : * the use of DSA to sign ECParameters in the server
1817 : : * key exchange message. We do support RSA and ECDSA.
1818 : : */
1819 : : if (0) ;
1820 : : #ifndef OPENSSL_NO_RSA
1821 [ + - ]: 462 : else if (alg_a & SSL_aRSA)
1822 : 462 : pkey=X509_get_pubkey(s->session->sess_cert->peer_pkeys[SSL_PKEY_RSA_ENC].x509);
1823 : : #endif
1824 : : #ifndef OPENSSL_NO_ECDSA
1825 [ # # ]: 0 : else if (alg_a & SSL_aECDSA)
1826 : 0 : pkey=X509_get_pubkey(s->session->sess_cert->peer_pkeys[SSL_PKEY_ECC].x509);
1827 : : #endif
1828 : : /* else anonymous ECDH, so no certificate or pkey. */
1829 : 462 : EC_KEY_set_public_key(ecdh, srvr_ecpoint);
1830 : 462 : s->session->sess_cert->peer_ecdh_tmp=ecdh;
1831 : 462 : ecdh=NULL;
1832 : 462 : BN_CTX_free(bn_ctx);
1833 : 462 : bn_ctx = NULL;
1834 : 462 : EC_POINT_free(srvr_ecpoint);
1835 : 462 : srvr_ecpoint = NULL;
1836 : : }
1837 [ # # ]: 0 : else if (alg_k)
1838 : : {
1839 : 0 : al=SSL_AD_UNEXPECTED_MESSAGE;
1840 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_UNEXPECTED_MESSAGE);
1841 : 0 : goto f_err;
1842 : : }
1843 : : #endif /* !OPENSSL_NO_ECDH */
1844 : :
1845 : :
1846 : : /* p points to the next byte, there are 'n' bytes left */
1847 : :
1848 : : /* if it was signed, check the signature */
1849 [ + + ]: 737 : if (pkey != NULL)
1850 : : {
1851 [ + + ]: 605 : if (SSL_USE_SIGALGS(s))
1852 : : {
1853 : 110 : int rv = tls12_check_peer_sigalg(&md, s, p, pkey);
1854 [ + - ]: 110 : if (rv == -1)
1855 : : goto err;
1856 [ + - ]: 110 : else if (rv == 0)
1857 : : {
1858 : : al = SSL_AD_DECODE_ERROR;
1859 : : goto f_err;
1860 : : }
1861 : : #ifdef SSL_DEBUG
1862 : : fprintf(stderr, "USING TLSv1.2 HASH %s\n", EVP_MD_name(md));
1863 : : #endif
1864 : 110 : p += 2;
1865 : 110 : n -= 2;
1866 : : }
1867 : : else
1868 : 495 : md = EVP_sha1();
1869 : :
1870 : 605 : n2s(p,i);
1871 : 605 : n-=2;
1872 : 605 : j=EVP_PKEY_size(pkey);
1873 : :
1874 [ + - ][ + - ]: 605 : if ((i != n) || (n > j) || (n <= 0))
[ - + ]
1875 : : {
1876 : : /* wrong packet length */
1877 : 0 : al=SSL_AD_DECODE_ERROR;
1878 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_WRONG_SIGNATURE_LENGTH);
1879 : 0 : goto f_err;
1880 : : }
1881 : :
1882 : : #ifndef OPENSSL_NO_RSA
1883 [ + - ][ + + ]: 605 : if (pkey->type == EVP_PKEY_RSA && !SSL_USE_SIGALGS(s))
1884 : : {
1885 : : int num;
1886 : :
1887 : : j=0;
1888 : : q=md_buf;
1889 [ + + ]: 1485 : for (num=2; num > 0; num--)
1890 : : {
1891 : 990 : EVP_MD_CTX_set_flags(&md_ctx,
1892 : : EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
1893 [ + + ]: 990 : EVP_DigestInit_ex(&md_ctx,(num == 2)
1894 : 990 : ?s->ctx->md5:s->ctx->sha1, NULL);
1895 : 990 : EVP_DigestUpdate(&md_ctx,&(s->s3->client_random[0]),SSL3_RANDOM_SIZE);
1896 : 990 : EVP_DigestUpdate(&md_ctx,&(s->s3->server_random[0]),SSL3_RANDOM_SIZE);
1897 : 990 : EVP_DigestUpdate(&md_ctx,param,param_len);
1898 : 990 : EVP_DigestFinal_ex(&md_ctx,q,(unsigned int *)&i);
1899 : 990 : q+=i;
1900 : 990 : j+=i;
1901 : : }
1902 : 495 : i=RSA_verify(NID_md5_sha1, md_buf, j, p, n,
1903 : 495 : pkey->pkey.rsa);
1904 [ - + ]: 495 : if (i < 0)
1905 : : {
1906 : 0 : al=SSL_AD_DECRYPT_ERROR;
1907 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_BAD_RSA_DECRYPT);
1908 : 0 : goto f_err;
1909 : : }
1910 [ - + ]: 495 : if (i == 0)
1911 : : {
1912 : : /* bad signature */
1913 : 0 : al=SSL_AD_DECRYPT_ERROR;
1914 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_BAD_SIGNATURE);
1915 : 0 : goto f_err;
1916 : : }
1917 : : }
1918 : : else
1919 : : #endif
1920 : : {
1921 : 110 : EVP_VerifyInit_ex(&md_ctx, md, NULL);
1922 : 110 : EVP_VerifyUpdate(&md_ctx,&(s->s3->client_random[0]),SSL3_RANDOM_SIZE);
1923 : 110 : EVP_VerifyUpdate(&md_ctx,&(s->s3->server_random[0]),SSL3_RANDOM_SIZE);
1924 : 110 : EVP_VerifyUpdate(&md_ctx,param,param_len);
1925 [ - + ]: 110 : if (EVP_VerifyFinal(&md_ctx,p,(int)n,pkey) <= 0)
1926 : : {
1927 : : /* bad signature */
1928 : 0 : al=SSL_AD_DECRYPT_ERROR;
1929 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_BAD_SIGNATURE);
1930 : 0 : goto f_err;
1931 : : }
1932 : : }
1933 : : }
1934 : : else
1935 : : {
1936 : : /* aNULL or kPSK do not need public keys */
1937 [ + + ][ - + ]: 132 : if (!(alg_a & SSL_aNULL) && !(alg_k & SSL_kPSK))
1938 : : {
1939 : : /* Might be wrong key type, check it */
1940 [ # # ]: 0 : if (ssl3_check_cert_and_algorithm(s))
1941 : : /* Otherwise this shouldn't happen */
1942 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
1943 : : goto err;
1944 : : }
1945 : : /* still data left over */
1946 [ - + ]: 132 : if (n != 0)
1947 : : {
1948 : 0 : al=SSL_AD_DECODE_ERROR;
1949 : 0 : SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE,SSL_R_EXTRA_DATA_IN_MESSAGE);
1950 : 0 : goto f_err;
1951 : : }
1952 : : }
1953 : 737 : EVP_PKEY_free(pkey);
1954 : 737 : EVP_MD_CTX_cleanup(&md_ctx);
1955 : 737 : return(1);
1956 : : f_err:
1957 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,al);
1958 : : err:
1959 : 0 : EVP_PKEY_free(pkey);
1960 : : #ifndef OPENSSL_NO_RSA
1961 [ # # ]: 0 : if (rsa != NULL)
1962 : 0 : RSA_free(rsa);
1963 : : #endif
1964 : : #ifndef OPENSSL_NO_DH
1965 [ # # ]: 0 : if (dh != NULL)
1966 : 0 : DH_free(dh);
1967 : : #endif
1968 : : #ifndef OPENSSL_NO_ECDH
1969 : 0 : BN_CTX_free(bn_ctx);
1970 : 0 : EC_POINT_free(srvr_ecpoint);
1971 [ # # ]: 0 : if (ecdh != NULL)
1972 : 0 : EC_KEY_free(ecdh);
1973 : : #endif
1974 : 0 : EVP_MD_CTX_cleanup(&md_ctx);
1975 : 0 : return(-1);
1976 : : }
1977 : :
1978 : 1113 : int ssl3_get_certificate_request(SSL *s)
1979 : : {
1980 : 1113 : int ok,ret=0;
1981 : : unsigned long n,nc,l;
1982 : : unsigned int llen, ctype_num,i;
1983 : 1113 : X509_NAME *xn=NULL;
1984 : : const unsigned char *p,*q;
1985 : : unsigned char *d;
1986 : 1113 : STACK_OF(X509_NAME) *ca_sk=NULL;
1987 : :
1988 : 1113 : n=s->method->ssl_get_message(s,
1989 : : SSL3_ST_CR_CERT_REQ_A,
1990 : : SSL3_ST_CR_CERT_REQ_B,
1991 : : -1,
1992 : : s->max_cert_list,
1993 : : &ok);
1994 : :
1995 [ + + ]: 1113 : if (!ok) return((int)n);
1996 : :
1997 : 1069 : s->s3->tmp.cert_req=0;
1998 : :
1999 [ + + ]: 1069 : if (s->s3->tmp.message_type == SSL3_MT_SERVER_DONE)
2000 : : {
2001 : 970 : s->s3->tmp.reuse_message=1;
2002 : : /* If we get here we don't need any cached handshake records
2003 : : * as we wont be doing client auth.
2004 : : */
2005 [ + + ]: 970 : if (s->s3->handshake_buffer)
2006 : : {
2007 [ - + ]: 145 : if (!ssl3_digest_cached_records(s))
2008 : : goto err;
2009 : : }
2010 : : return(1);
2011 : : }
2012 : :
2013 [ - + ]: 99 : if (s->s3->tmp.message_type != SSL3_MT_CERTIFICATE_REQUEST)
2014 : : {
2015 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_UNEXPECTED_MESSAGE);
2016 : 0 : SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,SSL_R_WRONG_MESSAGE_TYPE);
2017 : 0 : goto err;
2018 : : }
2019 : :
2020 : : /* TLS does not like anon-DH with client cert */
2021 [ + + ]: 99 : if (s->version > SSL3_VERSION)
2022 : : {
2023 [ - + ]: 55 : if (s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL)
2024 : : {
2025 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_UNEXPECTED_MESSAGE);
2026 : 0 : SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,SSL_R_TLS_CLIENT_CERT_REQ_WITH_ANON_CIPHER);
2027 : 0 : goto err;
2028 : : }
2029 : : }
2030 : :
2031 : 99 : p=d=(unsigned char *)s->init_msg;
2032 : :
2033 [ - + ]: 99 : if ((ca_sk=sk_X509_NAME_new(ca_dn_cmp)) == NULL)
2034 : : {
2035 : 0 : SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,ERR_R_MALLOC_FAILURE);
2036 : 0 : goto err;
2037 : : }
2038 : :
2039 : : /* get the certificate types */
2040 : 99 : ctype_num= *(p++);
2041 [ - + ]: 99 : if (s->cert->ctypes)
2042 : : {
2043 : 0 : OPENSSL_free(s->cert->ctypes);
2044 : 0 : s->cert->ctypes = NULL;
2045 : : }
2046 [ - + ]: 99 : if (ctype_num > SSL3_CT_NUMBER)
2047 : : {
2048 : : /* If we exceed static buffer copy all to cert structure */
2049 : 0 : s->cert->ctypes = OPENSSL_malloc(ctype_num);
2050 : 0 : memcpy(s->cert->ctypes, p, ctype_num);
2051 : 0 : s->cert->ctype_num = (size_t)ctype_num;
2052 : 0 : ctype_num=SSL3_CT_NUMBER;
2053 : : }
2054 [ + + ]: 528 : for (i=0; i<ctype_num; i++)
2055 : 429 : s->s3->tmp.ctype[i]= p[i];
2056 : 99 : p+=p[-1];
2057 [ + + ]: 99 : if (SSL_USE_SIGALGS(s))
2058 : : {
2059 : 55 : n2s(p, llen);
2060 : : /* Check we have enough room for signature algorithms and
2061 : : * following length value.
2062 : : */
2063 [ + - ]: 55 : if ((unsigned long)(p - d + llen + 2) > n)
2064 : : {
2065 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECODE_ERROR);
2066 : 0 : SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,SSL_R_DATA_LENGTH_TOO_LONG);
2067 : 0 : goto err;
2068 : : }
2069 : : /* Clear certificate digests and validity flags */
2070 [ + + ]: 495 : for (i = 0; i < SSL_PKEY_NUM; i++)
2071 : : {
2072 : 440 : s->cert->pkeys[i].digest = NULL;
2073 : 440 : s->cert->pkeys[i].valid_flags = 0;
2074 : : }
2075 [ + - ][ - + ]: 55 : if ((llen & 1) || !tls1_process_sigalgs(s, p, llen))
2076 : : {
2077 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECODE_ERROR);
2078 : 0 : SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,SSL_R_SIGNATURE_ALGORITHMS_ERROR);
2079 : 0 : goto err;
2080 : : }
2081 : 55 : p += llen;
2082 : : }
2083 : :
2084 : : /* get the CA RDNs */
2085 : 99 : n2s(p,llen);
2086 : : #if 0
2087 : : {
2088 : : FILE *out;
2089 : : out=fopen("/tmp/vsign.der","w");
2090 : : fwrite(p,1,llen,out);
2091 : : fclose(out);
2092 : : }
2093 : : #endif
2094 : :
2095 [ + - ]: 99 : if ((unsigned long)(p - d + llen) != n)
2096 : : {
2097 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECODE_ERROR);
2098 : 0 : SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,SSL_R_LENGTH_MISMATCH);
2099 : 0 : goto err;
2100 : : }
2101 : :
2102 [ - + ]: 99 : for (nc=0; nc<llen; )
2103 : : {
2104 : 0 : n2s(p,l);
2105 [ # # ]: 0 : if ((l+nc+2) > llen)
2106 : : {
2107 [ # # ]: 0 : if ((s->options & SSL_OP_NETSCAPE_CA_DN_BUG))
2108 : : goto cont; /* netscape bugs */
2109 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECODE_ERROR);
2110 : 0 : SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,SSL_R_CA_DN_TOO_LONG);
2111 : 0 : goto err;
2112 : : }
2113 : :
2114 : 0 : q=p;
2115 : :
2116 [ # # ]: 0 : if ((xn=d2i_X509_NAME(NULL,&q,l)) == NULL)
2117 : : {
2118 : : /* If netscape tolerance is on, ignore errors */
2119 [ # # ]: 0 : if (s->options & SSL_OP_NETSCAPE_CA_DN_BUG)
2120 : : goto cont;
2121 : : else
2122 : : {
2123 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECODE_ERROR);
2124 : 0 : SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,ERR_R_ASN1_LIB);
2125 : 0 : goto err;
2126 : : }
2127 : : }
2128 : :
2129 [ # # ]: 0 : if (q != (p+l))
2130 : : {
2131 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECODE_ERROR);
2132 : 0 : SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,SSL_R_CA_DN_LENGTH_MISMATCH);
2133 : 0 : goto err;
2134 : : }
2135 [ # # ]: 0 : if (!sk_X509_NAME_push(ca_sk,xn))
2136 : : {
2137 : 0 : SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,ERR_R_MALLOC_FAILURE);
2138 : 0 : goto err;
2139 : : }
2140 : :
2141 : : p+=l;
2142 : : nc+=l+2;
2143 : : }
2144 : :
2145 : : if (0)
2146 : : {
2147 : : cont:
2148 : 0 : ERR_clear_error();
2149 : : }
2150 : :
2151 : : /* we should setup a certificate to return.... */
2152 : 99 : s->s3->tmp.cert_req=1;
2153 : 99 : s->s3->tmp.ctype_num=ctype_num;
2154 [ - + ]: 99 : if (s->s3->tmp.ca_names != NULL)
2155 : 0 : sk_X509_NAME_pop_free(s->s3->tmp.ca_names,X509_NAME_free);
2156 : 99 : s->s3->tmp.ca_names=ca_sk;
2157 : 99 : ca_sk=NULL;
2158 : :
2159 : 99 : ret=1;
2160 : : err:
2161 [ - + ]: 99 : if (ca_sk != NULL) sk_X509_NAME_pop_free(ca_sk,X509_NAME_free);
2162 : 99 : return(ret);
2163 : : }
2164 : :
2165 : 0 : static int ca_dn_cmp(const X509_NAME * const *a, const X509_NAME * const *b)
2166 : : {
2167 : 0 : return(X509_NAME_cmp(*a,*b));
2168 : : }
2169 : : #ifndef OPENSSL_NO_TLSEXT
2170 : 17263 : int ssl3_get_new_session_ticket(SSL *s)
2171 : : {
2172 : 17263 : int ok,al,ret=0, ticklen;
2173 : : long n;
2174 : : const unsigned char *p;
2175 : : unsigned char *d;
2176 : :
2177 : 17263 : n=s->method->ssl_get_message(s,
2178 : : SSL3_ST_CR_SESSION_TICKET_A,
2179 : : SSL3_ST_CR_SESSION_TICKET_B,
2180 : : -1,
2181 : : 16384,
2182 : : &ok);
2183 : :
2184 [ + + ]: 17263 : if (!ok)
2185 : 16436 : return((int)n);
2186 : :
2187 [ + + ]: 827 : if (s->s3->tmp.message_type == SSL3_MT_FINISHED)
2188 : : {
2189 : 11 : s->s3->tmp.reuse_message=1;
2190 : 11 : return(1);
2191 : : }
2192 [ - + ]: 816 : if (s->s3->tmp.message_type != SSL3_MT_NEWSESSION_TICKET)
2193 : : {
2194 : 0 : al=SSL_AD_UNEXPECTED_MESSAGE;
2195 : 0 : SSLerr(SSL_F_SSL3_GET_NEW_SESSION_TICKET,SSL_R_BAD_MESSAGE_TYPE);
2196 : 0 : goto f_err;
2197 : : }
2198 [ - + ]: 816 : if (n < 6)
2199 : : {
2200 : : /* need at least ticket_lifetime_hint + ticket length */
2201 : 0 : al = SSL_AD_DECODE_ERROR;
2202 : 0 : SSLerr(SSL_F_SSL3_GET_NEW_SESSION_TICKET,SSL_R_LENGTH_MISMATCH);
2203 : 0 : goto f_err;
2204 : : }
2205 : :
2206 : 816 : p=d=(unsigned char *)s->init_msg;
2207 : 816 : n2l(p, s->session->tlsext_tick_lifetime_hint);
2208 : 816 : n2s(p, ticklen);
2209 : : /* ticket_lifetime_hint + ticket_length + ticket */
2210 [ - + ]: 816 : if (ticklen + 6 != n)
2211 : : {
2212 : 0 : al = SSL_AD_DECODE_ERROR;
2213 : 0 : SSLerr(SSL_F_SSL3_GET_NEW_SESSION_TICKET,SSL_R_LENGTH_MISMATCH);
2214 : 0 : goto f_err;
2215 : : }
2216 [ - + ]: 816 : if (s->session->tlsext_tick)
2217 : : {
2218 : 0 : OPENSSL_free(s->session->tlsext_tick);
2219 : 0 : s->session->tlsext_ticklen = 0;
2220 : : }
2221 : 816 : s->session->tlsext_tick = OPENSSL_malloc(ticklen);
2222 [ - + ]: 816 : if (!s->session->tlsext_tick)
2223 : : {
2224 : 0 : SSLerr(SSL_F_SSL3_GET_NEW_SESSION_TICKET,ERR_R_MALLOC_FAILURE);
2225 : 0 : goto err;
2226 : : }
2227 : 816 : memcpy(s->session->tlsext_tick, p, ticklen);
2228 : 816 : s->session->tlsext_ticklen = ticklen;
2229 : : /* There are two ways to detect a resumed ticket sesion.
2230 : : * One is to set an appropriate session ID and then the server
2231 : : * must return a match in ServerHello. This allows the normal
2232 : : * client session ID matching to work and we know much
2233 : : * earlier that the ticket has been accepted.
2234 : : *
2235 : : * The other way is to set zero length session ID when the
2236 : : * ticket is presented and rely on the handshake to determine
2237 : : * session resumption.
2238 : : *
2239 : : * We choose the former approach because this fits in with
2240 : : * assumptions elsewhere in OpenSSL. The session ID is set
2241 : : * to the SHA256 (or SHA1 is SHA256 is disabled) hash of the
2242 : : * ticket.
2243 : : */
2244 : 816 : EVP_Digest(p, ticklen,
2245 : 1632 : s->session->session_id, &s->session->session_id_length,
2246 : : #ifndef OPENSSL_NO_SHA256
2247 : : EVP_sha256(), NULL);
2248 : : #else
2249 : : EVP_sha1(), NULL);
2250 : : #endif
2251 : 816 : ret=1;
2252 : 816 : return(ret);
2253 : : f_err:
2254 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,al);
2255 : : err:
2256 : : return(-1);
2257 : : }
2258 : :
2259 : 0 : int ssl3_get_cert_status(SSL *s)
2260 : : {
2261 : : int ok, al;
2262 : : unsigned long resplen,n;
2263 : : const unsigned char *p;
2264 : :
2265 : 0 : n=s->method->ssl_get_message(s,
2266 : : SSL3_ST_CR_CERT_STATUS_A,
2267 : : SSL3_ST_CR_CERT_STATUS_B,
2268 : : SSL3_MT_CERTIFICATE_STATUS,
2269 : : 16384,
2270 : : &ok);
2271 : :
2272 [ # # ]: 0 : if (!ok) return((int)n);
2273 [ # # ]: 0 : if (n < 4)
2274 : : {
2275 : : /* need at least status type + length */
2276 : 0 : al = SSL_AD_DECODE_ERROR;
2277 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_STATUS,SSL_R_LENGTH_MISMATCH);
2278 : 0 : goto f_err;
2279 : : }
2280 : 0 : p = (unsigned char *)s->init_msg;
2281 [ # # ]: 0 : if (*p++ != TLSEXT_STATUSTYPE_ocsp)
2282 : : {
2283 : 0 : al = SSL_AD_DECODE_ERROR;
2284 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_STATUS,SSL_R_UNSUPPORTED_STATUS_TYPE);
2285 : 0 : goto f_err;
2286 : : }
2287 : 0 : n2l3(p, resplen);
2288 [ # # ]: 0 : if (resplen + 4 != n)
2289 : : {
2290 : 0 : al = SSL_AD_DECODE_ERROR;
2291 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_STATUS,SSL_R_LENGTH_MISMATCH);
2292 : 0 : goto f_err;
2293 : : }
2294 [ # # ]: 0 : if (s->tlsext_ocsp_resp)
2295 : 0 : OPENSSL_free(s->tlsext_ocsp_resp);
2296 : 0 : s->tlsext_ocsp_resp = BUF_memdup(p, resplen);
2297 [ # # ]: 0 : if (!s->tlsext_ocsp_resp)
2298 : : {
2299 : 0 : al = SSL_AD_INTERNAL_ERROR;
2300 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_STATUS,ERR_R_MALLOC_FAILURE);
2301 : 0 : goto f_err;
2302 : : }
2303 : 0 : s->tlsext_ocsp_resplen = resplen;
2304 [ # # ]: 0 : if (s->ctx->tlsext_status_cb)
2305 : : {
2306 : : int ret;
2307 : 0 : ret = s->ctx->tlsext_status_cb(s, s->ctx->tlsext_status_arg);
2308 [ # # ]: 0 : if (ret == 0)
2309 : : {
2310 : 0 : al = SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE;
2311 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_STATUS,SSL_R_INVALID_STATUS_RESPONSE);
2312 : 0 : goto f_err;
2313 : : }
2314 [ # # ]: 0 : if (ret < 0)
2315 : : {
2316 : 0 : al = SSL_AD_INTERNAL_ERROR;
2317 : 0 : SSLerr(SSL_F_SSL3_GET_CERT_STATUS,ERR_R_MALLOC_FAILURE);
2318 : 0 : goto f_err;
2319 : : }
2320 : : }
2321 : : return 1;
2322 : : f_err:
2323 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,al);
2324 : 0 : return(-1);
2325 : : }
2326 : : #endif
2327 : :
2328 : 1069 : int ssl3_get_server_done(SSL *s)
2329 : : {
2330 : 1069 : int ok,ret=0;
2331 : : long n;
2332 : :
2333 : 1069 : n=s->method->ssl_get_message(s,
2334 : : SSL3_ST_CR_SRVR_DONE_A,
2335 : : SSL3_ST_CR_SRVR_DONE_B,
2336 : : SSL3_MT_SERVER_DONE,
2337 : : 30, /* should be very small, like 0 :-) */
2338 : : &ok);
2339 : :
2340 [ - + ]: 1069 : if (!ok) return((int)n);
2341 [ - + ]: 1069 : if (n > 0)
2342 : : {
2343 : : /* should contain no data */
2344 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECODE_ERROR);
2345 : 0 : SSLerr(SSL_F_SSL3_GET_SERVER_DONE,SSL_R_LENGTH_MISMATCH);
2346 : 0 : return -1;
2347 : : }
2348 : : ret=1;
2349 : : return(ret);
2350 : : }
2351 : :
2352 : :
2353 : 1069 : int ssl3_send_client_key_exchange(SSL *s)
2354 : : {
2355 : : unsigned char *p;
2356 : : int n;
2357 : : unsigned long alg_k;
2358 : : #ifndef OPENSSL_NO_RSA
2359 : : unsigned char *q;
2360 : 1069 : EVP_PKEY *pkey=NULL;
2361 : : #endif
2362 : : #ifndef OPENSSL_NO_KRB5
2363 : : KSSL_ERR kssl_err;
2364 : : #endif /* OPENSSL_NO_KRB5 */
2365 : : #ifndef OPENSSL_NO_ECDH
2366 : 1069 : EC_KEY *clnt_ecdh = NULL;
2367 : 1069 : const EC_POINT *srvr_ecpoint = NULL;
2368 : 1069 : EVP_PKEY *srvr_pub_pkey = NULL;
2369 : 1069 : unsigned char *encodedPoint = NULL;
2370 : 1069 : int encoded_pt_len = 0;
2371 : 1069 : BN_CTX * bn_ctx = NULL;
2372 : : #endif
2373 : :
2374 [ + - ]: 1069 : if (s->state == SSL3_ST_CW_KEY_EXCH_A)
2375 : : {
2376 : 1069 : p = ssl_handshake_start(s);
2377 : :
2378 : 1069 : alg_k=s->s3->tmp.new_cipher->algorithm_mkey;
2379 : :
2380 : : /* Fool emacs indentation */
2381 : : if (0) {}
2382 : : #ifndef OPENSSL_NO_RSA
2383 [ + + ]: 1069 : else if (alg_k & SSL_kRSA)
2384 : : {
2385 : : RSA *rsa;
2386 : : unsigned char tmp_buf[SSL_MAX_MASTER_KEY_LENGTH];
2387 : :
2388 [ + + ]: 365 : if (s->session->sess_cert->peer_rsa_tmp != NULL)
2389 : : rsa=s->session->sess_cert->peer_rsa_tmp;
2390 : : else
2391 : : {
2392 : 332 : pkey=X509_get_pubkey(s->session->sess_cert->peer_pkeys[SSL_PKEY_RSA_ENC].x509);
2393 [ + - ][ + - ]: 332 : if ((pkey == NULL) ||
2394 [ - + ]: 332 : (pkey->type != EVP_PKEY_RSA) ||
2395 : 332 : (pkey->pkey.rsa == NULL))
2396 : : {
2397 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
2398 : 0 : goto err;
2399 : : }
2400 : 332 : rsa=pkey->pkey.rsa;
2401 : 332 : EVP_PKEY_free(pkey);
2402 : : }
2403 : :
2404 : 365 : tmp_buf[0]=s->client_version>>8;
2405 : 365 : tmp_buf[1]=s->client_version&0xff;
2406 [ + - ]: 365 : if (RAND_bytes(&(tmp_buf[2]),sizeof tmp_buf-2) <= 0)
2407 : : goto err;
2408 : :
2409 : 365 : s->session->master_key_length=sizeof tmp_buf;
2410 : :
2411 : 365 : q=p;
2412 : : /* Fix buf for TLS and beyond */
2413 [ + + ]: 365 : if (s->version > SSL3_VERSION)
2414 : 200 : p+=2;
2415 : 365 : n=RSA_public_encrypt(sizeof tmp_buf,
2416 : : tmp_buf,p,rsa,RSA_PKCS1_PADDING);
2417 : : #ifdef PKCS1_CHECK
2418 : : if (s->options & SSL_OP_PKCS1_CHECK_1) p[1]++;
2419 : : if (s->options & SSL_OP_PKCS1_CHECK_2) tmp_buf[0]=0x70;
2420 : : #endif
2421 [ - + ]: 365 : if (n <= 0)
2422 : : {
2423 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,SSL_R_BAD_RSA_ENCRYPT);
2424 : 0 : goto err;
2425 : : }
2426 : :
2427 : : /* Fix buf for TLS and beyond */
2428 [ + + ]: 365 : if (s->version > SSL3_VERSION)
2429 : : {
2430 : 200 : s2n(n,q);
2431 : 200 : n+=2;
2432 : : }
2433 : :
2434 : 365 : s->session->master_key_length=
2435 : 365 : s->method->ssl3_enc->generate_master_secret(s,
2436 : 365 : s->session->master_key,
2437 : : tmp_buf,sizeof tmp_buf);
2438 : 365 : OPENSSL_cleanse(tmp_buf,sizeof tmp_buf);
2439 : : }
2440 : : #endif
2441 : : #ifndef OPENSSL_NO_KRB5
2442 : : else if (alg_k & SSL_kKRB5)
2443 : : {
2444 : : krb5_error_code krb5rc;
2445 : : KSSL_CTX *kssl_ctx = s->kssl_ctx;
2446 : : /* krb5_data krb5_ap_req; */
2447 : : krb5_data *enc_ticket;
2448 : : krb5_data authenticator, *authp = NULL;
2449 : : EVP_CIPHER_CTX ciph_ctx;
2450 : : const EVP_CIPHER *enc = NULL;
2451 : : unsigned char iv[EVP_MAX_IV_LENGTH];
2452 : : unsigned char tmp_buf[SSL_MAX_MASTER_KEY_LENGTH];
2453 : : unsigned char epms[SSL_MAX_MASTER_KEY_LENGTH
2454 : : + EVP_MAX_IV_LENGTH];
2455 : : int padl, outl = sizeof(epms);
2456 : :
2457 : : EVP_CIPHER_CTX_init(&ciph_ctx);
2458 : :
2459 : : #ifdef KSSL_DEBUG
2460 : : printf("ssl3_send_client_key_exchange(%lx & %lx)\n",
2461 : : alg_k, SSL_kKRB5);
2462 : : #endif /* KSSL_DEBUG */
2463 : :
2464 : : authp = NULL;
2465 : : #ifdef KRB5SENDAUTH
2466 : : if (KRB5SENDAUTH) authp = &authenticator;
2467 : : #endif /* KRB5SENDAUTH */
2468 : :
2469 : : krb5rc = kssl_cget_tkt(kssl_ctx, &enc_ticket, authp,
2470 : : &kssl_err);
2471 : : enc = kssl_map_enc(kssl_ctx->enctype);
2472 : : if (enc == NULL)
2473 : : goto err;
2474 : : #ifdef KSSL_DEBUG
2475 : : {
2476 : : printf("kssl_cget_tkt rtn %d\n", krb5rc);
2477 : : if (krb5rc && kssl_err.text)
2478 : : printf("kssl_cget_tkt kssl_err=%s\n", kssl_err.text);
2479 : : }
2480 : : #endif /* KSSL_DEBUG */
2481 : :
2482 : : if (krb5rc)
2483 : : {
2484 : : ssl3_send_alert(s,SSL3_AL_FATAL,
2485 : : SSL_AD_HANDSHAKE_FAILURE);
2486 : : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
2487 : : kssl_err.reason);
2488 : : goto err;
2489 : : }
2490 : :
2491 : : /* 20010406 VRS - Earlier versions used KRB5 AP_REQ
2492 : : ** in place of RFC 2712 KerberosWrapper, as in:
2493 : : **
2494 : : ** Send ticket (copy to *p, set n = length)
2495 : : ** n = krb5_ap_req.length;
2496 : : ** memcpy(p, krb5_ap_req.data, krb5_ap_req.length);
2497 : : ** if (krb5_ap_req.data)
2498 : : ** kssl_krb5_free_data_contents(NULL,&krb5_ap_req);
2499 : : **
2500 : : ** Now using real RFC 2712 KerberosWrapper
2501 : : ** (Thanks to Simon Wilkinson <sxw@sxw.org.uk>)
2502 : : ** Note: 2712 "opaque" types are here replaced
2503 : : ** with a 2-byte length followed by the value.
2504 : : ** Example:
2505 : : ** KerberosWrapper= xx xx asn1ticket 0 0 xx xx encpms
2506 : : ** Where "xx xx" = length bytes. Shown here with
2507 : : ** optional authenticator omitted.
2508 : : */
2509 : :
2510 : : /* KerberosWrapper.Ticket */
2511 : : s2n(enc_ticket->length,p);
2512 : : memcpy(p, enc_ticket->data, enc_ticket->length);
2513 : : p+= enc_ticket->length;
2514 : : n = enc_ticket->length + 2;
2515 : :
2516 : : /* KerberosWrapper.Authenticator */
2517 : : if (authp && authp->length)
2518 : : {
2519 : : s2n(authp->length,p);
2520 : : memcpy(p, authp->data, authp->length);
2521 : : p+= authp->length;
2522 : : n+= authp->length + 2;
2523 : :
2524 : : free(authp->data);
2525 : : authp->data = NULL;
2526 : : authp->length = 0;
2527 : : }
2528 : : else
2529 : : {
2530 : : s2n(0,p);/* null authenticator length */
2531 : : n+=2;
2532 : : }
2533 : :
2534 : : tmp_buf[0]=s->client_version>>8;
2535 : : tmp_buf[1]=s->client_version&0xff;
2536 : : if (RAND_bytes(&(tmp_buf[2]),sizeof tmp_buf-2) <= 0)
2537 : : goto err;
2538 : :
2539 : : /* 20010420 VRS. Tried it this way; failed.
2540 : : ** EVP_EncryptInit_ex(&ciph_ctx,enc, NULL,NULL);
2541 : : ** EVP_CIPHER_CTX_set_key_length(&ciph_ctx,
2542 : : ** kssl_ctx->length);
2543 : : ** EVP_EncryptInit_ex(&ciph_ctx,NULL, key,iv);
2544 : : */
2545 : :
2546 : : memset(iv, 0, sizeof iv); /* per RFC 1510 */
2547 : : EVP_EncryptInit_ex(&ciph_ctx,enc, NULL,
2548 : : kssl_ctx->key,iv);
2549 : : EVP_EncryptUpdate(&ciph_ctx,epms,&outl,tmp_buf,
2550 : : sizeof tmp_buf);
2551 : : EVP_EncryptFinal_ex(&ciph_ctx,&(epms[outl]),&padl);
2552 : : outl += padl;
2553 : : if (outl > (int)sizeof epms)
2554 : : {
2555 : : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2556 : : goto err;
2557 : : }
2558 : : EVP_CIPHER_CTX_cleanup(&ciph_ctx);
2559 : :
2560 : : /* KerberosWrapper.EncryptedPreMasterSecret */
2561 : : s2n(outl,p);
2562 : : memcpy(p, epms, outl);
2563 : : p+=outl;
2564 : : n+=outl + 2;
2565 : :
2566 : : s->session->master_key_length=
2567 : : s->method->ssl3_enc->generate_master_secret(s,
2568 : : s->session->master_key,
2569 : : tmp_buf, sizeof tmp_buf);
2570 : :
2571 : : OPENSSL_cleanse(tmp_buf, sizeof tmp_buf);
2572 : : OPENSSL_cleanse(epms, outl);
2573 : : }
2574 : : #endif
2575 : : #ifndef OPENSSL_NO_DH
2576 [ + + ]: 704 : else if (alg_k & (SSL_kDHE|SSL_kDHr|SSL_kDHd))
2577 : : {
2578 : : DH *dh_srvr,*dh_clnt;
2579 : 198 : SESS_CERT *scert = s->session->sess_cert;
2580 : :
2581 [ - + ]: 198 : if (scert == NULL)
2582 : : {
2583 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_UNEXPECTED_MESSAGE);
2584 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,SSL_R_UNEXPECTED_MESSAGE);
2585 : 0 : goto err;
2586 : : }
2587 : :
2588 [ - + ]: 198 : if (scert->peer_dh_tmp != NULL)
2589 : : dh_srvr=scert->peer_dh_tmp;
2590 : : else
2591 : : {
2592 : : /* we get them from the cert */
2593 : 0 : int idx = scert->peer_cert_type;
2594 : 0 : EVP_PKEY *spkey = NULL;
2595 : 0 : dh_srvr = NULL;
2596 [ # # ]: 0 : if (idx >= 0)
2597 : 0 : spkey = X509_get_pubkey(
2598 : : scert->peer_pkeys[idx].x509);
2599 [ # # ]: 0 : if (spkey)
2600 : : {
2601 : 0 : dh_srvr = EVP_PKEY_get1_DH(spkey);
2602 : 0 : EVP_PKEY_free(spkey);
2603 : : }
2604 [ # # ]: 0 : if (dh_srvr == NULL)
2605 : : {
2606 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
2607 : : ERR_R_INTERNAL_ERROR);
2608 : 0 : goto err;
2609 : : }
2610 : : }
2611 [ - + ]: 198 : if (s->s3->flags & TLS1_FLAGS_SKIP_CERT_VERIFY)
2612 : : {
2613 : : /* Use client certificate key */
2614 : 0 : EVP_PKEY *clkey = s->cert->key->privatekey;
2615 : 0 : dh_clnt = NULL;
2616 [ # # ]: 0 : if (clkey)
2617 : 0 : dh_clnt = EVP_PKEY_get1_DH(clkey);
2618 [ # # ]: 0 : if (dh_clnt == NULL)
2619 : : {
2620 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
2621 : : ERR_R_INTERNAL_ERROR);
2622 : 0 : goto err;
2623 : : }
2624 : : }
2625 : : else
2626 : : {
2627 : : /* generate a new random key */
2628 [ - + ]: 198 : if ((dh_clnt=DHparams_dup(dh_srvr)) == NULL)
2629 : : {
2630 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,ERR_R_DH_LIB);
2631 : 0 : goto err;
2632 : : }
2633 [ - + ]: 198 : if (!DH_generate_key(dh_clnt))
2634 : : {
2635 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,ERR_R_DH_LIB);
2636 : 0 : DH_free(dh_clnt);
2637 : 0 : goto err;
2638 : : }
2639 : : }
2640 : :
2641 : : /* use the 'p' output buffer for the DH key, but
2642 : : * make sure to clear it out afterwards */
2643 : :
2644 : 198 : n=DH_compute_key(p,dh_srvr->pub_key,dh_clnt);
2645 [ - + ]: 198 : if (scert->peer_dh_tmp == NULL)
2646 : 0 : DH_free(dh_srvr);
2647 : :
2648 [ - + ]: 198 : if (n <= 0)
2649 : : {
2650 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,ERR_R_DH_LIB);
2651 : 0 : DH_free(dh_clnt);
2652 : 0 : goto err;
2653 : : }
2654 : :
2655 : : /* generate master key from the result */
2656 : 198 : s->session->master_key_length=
2657 : 198 : s->method->ssl3_enc->generate_master_secret(s,
2658 : 198 : s->session->master_key,p,n);
2659 : : /* clean up */
2660 : 198 : memset(p,0,n);
2661 : :
2662 [ + - ]: 198 : if (s->s3->flags & TLS1_FLAGS_SKIP_CERT_VERIFY)
2663 : : n = 0;
2664 : : else
2665 : : {
2666 : : /* send off the data */
2667 : 198 : n=BN_num_bytes(dh_clnt->pub_key);
2668 : 198 : s2n(n,p);
2669 : 198 : BN_bn2bin(dh_clnt->pub_key,p);
2670 : 198 : n+=2;
2671 : : }
2672 : :
2673 : 198 : DH_free(dh_clnt);
2674 : :
2675 : : /* perhaps clean things up a bit EAY EAY EAY EAY*/
2676 : : }
2677 : : #endif
2678 : :
2679 : : #ifndef OPENSSL_NO_ECDH
2680 [ + + ]: 506 : else if (alg_k & (SSL_kECDHE|SSL_kECDHr|SSL_kECDHe))
2681 : : {
2682 : 462 : const EC_GROUP *srvr_group = NULL;
2683 : : EC_KEY *tkey;
2684 : 462 : int ecdh_clnt_cert = 0;
2685 : 462 : int field_size = 0;
2686 : :
2687 [ - + ]: 462 : if (s->session->sess_cert == NULL)
2688 : : {
2689 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_UNEXPECTED_MESSAGE);
2690 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,SSL_R_UNEXPECTED_MESSAGE);
2691 : 0 : goto err;
2692 : : }
2693 : :
2694 : : /* Did we send out the client's
2695 : : * ECDH share for use in premaster
2696 : : * computation as part of client certificate?
2697 : : * If so, set ecdh_clnt_cert to 1.
2698 : : */
2699 : : if ((alg_k & (SSL_kECDHr|SSL_kECDHe)) && (s->cert != NULL))
2700 : : {
2701 : : /* XXX: For now, we do not support client
2702 : : * authentication using ECDH certificates.
2703 : : * To add such support, one needs to add
2704 : : * code that checks for appropriate
2705 : : * conditions and sets ecdh_clnt_cert to 1.
2706 : : * For example, the cert have an ECC
2707 : : * key on the same curve as the server's
2708 : : * and the key should be authorized for
2709 : : * key agreement.
2710 : : *
2711 : : * One also needs to add code in ssl3_connect
2712 : : * to skip sending the certificate verify
2713 : : * message.
2714 : : *
2715 : : * if ((s->cert->key->privatekey != NULL) &&
2716 : : * (s->cert->key->privatekey->type ==
2717 : : * EVP_PKEY_EC) && ...)
2718 : : * ecdh_clnt_cert = 1;
2719 : : */
2720 : : }
2721 : :
2722 [ - + ]: 462 : if (s->session->sess_cert->peer_ecdh_tmp != NULL)
2723 : : {
2724 : : tkey = s->session->sess_cert->peer_ecdh_tmp;
2725 : : }
2726 : : else
2727 : : {
2728 : : /* Get the Server Public Key from Cert */
2729 : 0 : srvr_pub_pkey = X509_get_pubkey(s->session-> \
2730 : : sess_cert->peer_pkeys[SSL_PKEY_ECC].x509);
2731 [ # # ][ # # ]: 0 : if ((srvr_pub_pkey == NULL) ||
2732 [ # # ]: 0 : (srvr_pub_pkey->type != EVP_PKEY_EC) ||
2733 : 0 : (srvr_pub_pkey->pkey.ec == NULL))
2734 : : {
2735 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
2736 : : ERR_R_INTERNAL_ERROR);
2737 : 0 : goto err;
2738 : : }
2739 : :
2740 : : tkey = srvr_pub_pkey->pkey.ec;
2741 : : }
2742 : :
2743 : 462 : srvr_group = EC_KEY_get0_group(tkey);
2744 : 462 : srvr_ecpoint = EC_KEY_get0_public_key(tkey);
2745 : :
2746 [ - + ]: 462 : if ((srvr_group == NULL) || (srvr_ecpoint == NULL))
2747 : : {
2748 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
2749 : : ERR_R_INTERNAL_ERROR);
2750 : 0 : goto err;
2751 : : }
2752 : :
2753 [ - + ]: 462 : if ((clnt_ecdh=EC_KEY_new()) == NULL)
2754 : : {
2755 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,ERR_R_MALLOC_FAILURE);
2756 : 0 : goto err;
2757 : : }
2758 : :
2759 [ - + ]: 462 : if (!EC_KEY_set_group(clnt_ecdh, srvr_group))
2760 : : {
2761 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,ERR_R_EC_LIB);
2762 : 0 : goto err;
2763 : : }
2764 : : if (ecdh_clnt_cert)
2765 : : {
2766 : : /* Reuse key info from our certificate
2767 : : * We only need our private key to perform
2768 : : * the ECDH computation.
2769 : : */
2770 : : const BIGNUM *priv_key;
2771 : : tkey = s->cert->key->privatekey->pkey.ec;
2772 : : priv_key = EC_KEY_get0_private_key(tkey);
2773 : : if (priv_key == NULL)
2774 : : {
2775 : : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,ERR_R_MALLOC_FAILURE);
2776 : : goto err;
2777 : : }
2778 : : if (!EC_KEY_set_private_key(clnt_ecdh, priv_key))
2779 : : {
2780 : : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,ERR_R_EC_LIB);
2781 : : goto err;
2782 : : }
2783 : : }
2784 : : else
2785 : : {
2786 : : /* Generate a new ECDH key pair */
2787 [ - + ]: 462 : if (!(EC_KEY_generate_key(clnt_ecdh)))
2788 : : {
2789 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE, ERR_R_ECDH_LIB);
2790 : 0 : goto err;
2791 : : }
2792 : : }
2793 : :
2794 : : /* use the 'p' output buffer for the ECDH key, but
2795 : : * make sure to clear it out afterwards
2796 : : */
2797 : :
2798 : 462 : field_size = EC_GROUP_get_degree(srvr_group);
2799 [ - + ]: 462 : if (field_size <= 0)
2800 : : {
2801 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
2802 : : ERR_R_ECDH_LIB);
2803 : 0 : goto err;
2804 : : }
2805 : 462 : n=ECDH_compute_key(p, (field_size+7)/8, srvr_ecpoint, clnt_ecdh, NULL);
2806 [ - + ]: 462 : if (n <= 0)
2807 : : {
2808 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
2809 : : ERR_R_ECDH_LIB);
2810 : 0 : goto err;
2811 : : }
2812 : :
2813 : : /* generate master key from the result */
2814 : 924 : s->session->master_key_length = s->method->ssl3_enc \
2815 : 462 : -> generate_master_secret(s,
2816 : 462 : s->session->master_key,
2817 : : p, n);
2818 : :
2819 : 462 : memset(p, 0, n); /* clean up */
2820 : :
2821 : : if (ecdh_clnt_cert)
2822 : : {
2823 : : /* Send empty client key exch message */
2824 : : n = 0;
2825 : : }
2826 : : else
2827 : : {
2828 : : /* First check the size of encoding and
2829 : : * allocate memory accordingly.
2830 : : */
2831 : 462 : encoded_pt_len =
2832 : 462 : EC_POINT_point2oct(srvr_group,
2833 : : EC_KEY_get0_public_key(clnt_ecdh),
2834 : : POINT_CONVERSION_UNCOMPRESSED,
2835 : : NULL, 0, NULL);
2836 : :
2837 : 462 : encodedPoint = (unsigned char *)
2838 : : OPENSSL_malloc(encoded_pt_len *
2839 : : sizeof(unsigned char));
2840 : 462 : bn_ctx = BN_CTX_new();
2841 [ - + ]: 462 : if ((encodedPoint == NULL) ||
2842 : 462 : (bn_ctx == NULL))
2843 : : {
2844 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,ERR_R_MALLOC_FAILURE);
2845 : 0 : goto err;
2846 : : }
2847 : :
2848 : : /* Encode the public key */
2849 : 462 : n = EC_POINT_point2oct(srvr_group,
2850 : : EC_KEY_get0_public_key(clnt_ecdh),
2851 : : POINT_CONVERSION_UNCOMPRESSED,
2852 : : encodedPoint, encoded_pt_len, bn_ctx);
2853 : :
2854 : 462 : *p = n; /* length of encoded point */
2855 : : /* Encoded point will be copied here */
2856 : 462 : p += 1;
2857 : : /* copy the point */
2858 : 462 : memcpy((unsigned char *)p, encodedPoint, n);
2859 : : /* increment n to account for length field */
2860 : 462 : n += 1;
2861 : : }
2862 : :
2863 : : /* Free allocated memory */
2864 : 462 : BN_CTX_free(bn_ctx);
2865 [ + - ]: 462 : if (encodedPoint != NULL) OPENSSL_free(encodedPoint);
2866 [ + - ]: 462 : if (clnt_ecdh != NULL)
2867 : 462 : EC_KEY_free(clnt_ecdh);
2868 : 462 : EVP_PKEY_free(srvr_pub_pkey);
2869 : : }
2870 : : #endif /* !OPENSSL_NO_ECDH */
2871 [ - + ]: 44 : else if (alg_k & SSL_kGOST)
2872 : : {
2873 : : /* GOST key exchange message creation */
2874 : : EVP_PKEY_CTX *pkey_ctx;
2875 : : X509 *peer_cert;
2876 : : size_t msglen;
2877 : : unsigned int md_len;
2878 : : int keytype;
2879 : : unsigned char premaster_secret[32],shared_ukm[32], tmp[256];
2880 : : EVP_MD_CTX *ukm_hash;
2881 : : EVP_PKEY *pub_key;
2882 : :
2883 : : /* Get server sertificate PKEY and create ctx from it */
2884 : 0 : peer_cert=s->session->sess_cert->peer_pkeys[(keytype=SSL_PKEY_GOST01)].x509;
2885 [ # # ]: 0 : if (!peer_cert)
2886 : 0 : peer_cert=s->session->sess_cert->peer_pkeys[(keytype=SSL_PKEY_GOST94)].x509;
2887 [ # # ]: 0 : if (!peer_cert) {
2888 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER);
2889 : 0 : goto err;
2890 : : }
2891 : :
2892 : 0 : pkey_ctx=EVP_PKEY_CTX_new(pub_key=X509_get_pubkey(peer_cert),NULL);
2893 : : /* If we have send a certificate, and certificate key
2894 : :
2895 : : * parameters match those of server certificate, use
2896 : : * certificate key for key exchange
2897 : : */
2898 : :
2899 : : /* Otherwise, generate ephemeral key pair */
2900 : :
2901 : 0 : EVP_PKEY_encrypt_init(pkey_ctx);
2902 : : /* Generate session key */
2903 : 0 : RAND_bytes(premaster_secret,32);
2904 : : /* If we have client certificate, use its secret as peer key */
2905 [ # # ][ # # ]: 0 : if (s->s3->tmp.cert_req && s->cert->key->privatekey) {
2906 [ # # ]: 0 : if (EVP_PKEY_derive_set_peer(pkey_ctx,s->cert->key->privatekey) <=0) {
2907 : : /* If there was an error - just ignore it. Ephemeral key
2908 : : * would be used
2909 : : */
2910 : 0 : ERR_clear_error();
2911 : : }
2912 : : }
2913 : : /* Compute shared IV and store it in algorithm-specific
2914 : : * context data */
2915 : 0 : ukm_hash = EVP_MD_CTX_create();
2916 : 0 : EVP_DigestInit(ukm_hash,EVP_get_digestbynid(NID_id_GostR3411_94));
2917 : 0 : EVP_DigestUpdate(ukm_hash,s->s3->client_random,SSL3_RANDOM_SIZE);
2918 : 0 : EVP_DigestUpdate(ukm_hash,s->s3->server_random,SSL3_RANDOM_SIZE);
2919 : 0 : EVP_DigestFinal_ex(ukm_hash, shared_ukm, &md_len);
2920 : 0 : EVP_MD_CTX_destroy(ukm_hash);
2921 [ # # ]: 0 : if (EVP_PKEY_CTX_ctrl(pkey_ctx,-1,EVP_PKEY_OP_ENCRYPT,EVP_PKEY_CTRL_SET_IV,
2922 : : 8,shared_ukm)<0) {
2923 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
2924 : : SSL_R_LIBRARY_BUG);
2925 : 0 : goto err;
2926 : : }
2927 : : /* Make GOST keytransport blob message */
2928 : : /*Encapsulate it into sequence */
2929 : 0 : *(p++)=V_ASN1_SEQUENCE | V_ASN1_CONSTRUCTED;
2930 : 0 : msglen=255;
2931 [ # # ]: 0 : if (EVP_PKEY_encrypt(pkey_ctx,tmp,&msglen,premaster_secret,32)<0) {
2932 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
2933 : : SSL_R_LIBRARY_BUG);
2934 : 0 : goto err;
2935 : : }
2936 [ # # ]: 0 : if (msglen >= 0x80)
2937 : : {
2938 : 0 : *(p++)=0x81;
2939 : 0 : *(p++)= msglen & 0xff;
2940 : 0 : n=msglen+3;
2941 : : }
2942 : : else
2943 : : {
2944 : 0 : *(p++)= msglen & 0xff;
2945 : 0 : n=msglen+2;
2946 : : }
2947 : 0 : memcpy(p, tmp, msglen);
2948 : : /* Check if pubkey from client certificate was used */
2949 [ # # ]: 0 : if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 2, NULL) > 0)
2950 : : {
2951 : : /* Set flag "skip certificate verify" */
2952 : 0 : s->s3->flags |= TLS1_FLAGS_SKIP_CERT_VERIFY;
2953 : : }
2954 : 0 : EVP_PKEY_CTX_free(pkey_ctx);
2955 : 0 : s->session->master_key_length=
2956 : 0 : s->method->ssl3_enc->generate_master_secret(s,
2957 : 0 : s->session->master_key,premaster_secret,32);
2958 : 0 : EVP_PKEY_free(pub_key);
2959 : :
2960 : : }
2961 : : #ifndef OPENSSL_NO_SRP
2962 [ + + ]: 44 : else if (alg_k & SSL_kSRP)
2963 : : {
2964 [ + - ]: 22 : if (s->srp_ctx.A != NULL)
2965 : : {
2966 : : /* send off the data */
2967 : 22 : n=BN_num_bytes(s->srp_ctx.A);
2968 : 22 : s2n(n,p);
2969 : 22 : BN_bn2bin(s->srp_ctx.A,p);
2970 : 22 : n+=2;
2971 : : }
2972 : : else
2973 : : {
2974 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
2975 : 0 : goto err;
2976 : : }
2977 [ - + ]: 22 : if (s->session->srp_username != NULL)
2978 : 0 : OPENSSL_free(s->session->srp_username);
2979 : 22 : s->session->srp_username = BUF_strdup(s->srp_ctx.login);
2980 [ - + ]: 22 : if (s->session->srp_username == NULL)
2981 : : {
2982 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
2983 : : ERR_R_MALLOC_FAILURE);
2984 : 0 : goto err;
2985 : : }
2986 : :
2987 [ - + ]: 22 : if ((s->session->master_key_length = SRP_generate_client_master_secret(s,s->session->master_key))<0)
2988 : : {
2989 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,ERR_R_INTERNAL_ERROR);
2990 : 0 : goto err;
2991 : : }
2992 : : }
2993 : : #endif
2994 : : #ifndef OPENSSL_NO_PSK
2995 [ + - ]: 22 : else if (alg_k & SSL_kPSK)
2996 : : {
2997 : : char identity[PSK_MAX_IDENTITY_LEN];
2998 : 22 : unsigned char *t = NULL;
2999 : : unsigned char psk_or_pre_ms[PSK_MAX_PSK_LEN*2+4];
3000 : 22 : unsigned int pre_ms_len = 0, psk_len = 0;
3001 : 22 : int psk_err = 1;
3002 : :
3003 : 22 : n = 0;
3004 [ - + ]: 22 : if (s->psk_client_callback == NULL)
3005 : : {
3006 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
3007 : : SSL_R_PSK_NO_CLIENT_CB);
3008 : 0 : goto err;
3009 : : }
3010 : :
3011 : 22 : psk_len = s->psk_client_callback(s, s->ctx->psk_identity_hint,
3012 : : identity, PSK_MAX_IDENTITY_LEN,
3013 : : psk_or_pre_ms, sizeof(psk_or_pre_ms));
3014 [ - + ]: 22 : if (psk_len > PSK_MAX_PSK_LEN)
3015 : : {
3016 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
3017 : : ERR_R_INTERNAL_ERROR);
3018 : 0 : goto psk_err;
3019 : : }
3020 [ - + ]: 22 : else if (psk_len == 0)
3021 : : {
3022 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
3023 : : SSL_R_PSK_IDENTITY_NOT_FOUND);
3024 : 0 : goto psk_err;
3025 : : }
3026 : :
3027 : : /* create PSK pre_master_secret */
3028 : 22 : pre_ms_len = 2+psk_len+2+psk_len;
3029 : 22 : t = psk_or_pre_ms;
3030 : 22 : memmove(psk_or_pre_ms+psk_len+4, psk_or_pre_ms, psk_len);
3031 : 22 : s2n(psk_len, t);
3032 : 22 : memset(t, 0, psk_len);
3033 : 22 : t+=psk_len;
3034 : 22 : s2n(psk_len, t);
3035 : :
3036 [ - + ]: 22 : if (s->session->psk_identity_hint != NULL)
3037 : 0 : OPENSSL_free(s->session->psk_identity_hint);
3038 : 22 : s->session->psk_identity_hint = BUF_strdup(s->ctx->psk_identity_hint);
3039 [ + - ][ - + ]: 22 : if (s->ctx->psk_identity_hint != NULL &&
3040 : 22 : s->session->psk_identity_hint == NULL)
3041 : : {
3042 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
3043 : : ERR_R_MALLOC_FAILURE);
3044 : 0 : goto psk_err;
3045 : : }
3046 : :
3047 [ - + ]: 22 : if (s->session->psk_identity != NULL)
3048 : 0 : OPENSSL_free(s->session->psk_identity);
3049 : 22 : s->session->psk_identity = BUF_strdup(identity);
3050 [ - + ]: 22 : if (s->session->psk_identity == NULL)
3051 : : {
3052 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
3053 : : ERR_R_MALLOC_FAILURE);
3054 : 0 : goto psk_err;
3055 : : }
3056 : :
3057 : 22 : s->session->master_key_length =
3058 : 22 : s->method->ssl3_enc->generate_master_secret(s,
3059 : 22 : s->session->master_key,
3060 : : psk_or_pre_ms, pre_ms_len);
3061 : 22 : n = strlen(identity);
3062 : 22 : s2n(n, p);
3063 : 22 : memcpy(p, identity, n);
3064 : 22 : n+=2;
3065 : 22 : psk_err = 0;
3066 : : psk_err:
3067 : 22 : OPENSSL_cleanse(identity, PSK_MAX_IDENTITY_LEN);
3068 : 22 : OPENSSL_cleanse(psk_or_pre_ms, sizeof(psk_or_pre_ms));
3069 [ - + ]: 22 : if (psk_err != 0)
3070 : : {
3071 : 0 : ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_HANDSHAKE_FAILURE);
3072 : 22 : goto err;
3073 : : }
3074 : : }
3075 : : #endif
3076 : : else
3077 : : {
3078 : 0 : ssl3_send_alert(s, SSL3_AL_FATAL,
3079 : : SSL_AD_HANDSHAKE_FAILURE);
3080 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_KEY_EXCHANGE,
3081 : : ERR_R_INTERNAL_ERROR);
3082 : 0 : goto err;
3083 : : }
3084 : :
3085 : 1069 : ssl_set_handshake_header(s, SSL3_MT_CLIENT_KEY_EXCHANGE, n);
3086 : 1069 : s->state=SSL3_ST_CW_KEY_EXCH_B;
3087 : : }
3088 : :
3089 : : /* SSL3_ST_CW_KEY_EXCH_B */
3090 : 1069 : return ssl_do_write(s);
3091 : : err:
3092 : : #ifndef OPENSSL_NO_ECDH
3093 : 0 : BN_CTX_free(bn_ctx);
3094 [ # # ]: 0 : if (encodedPoint != NULL) OPENSSL_free(encodedPoint);
3095 [ # # ]: 0 : if (clnt_ecdh != NULL)
3096 : 0 : EC_KEY_free(clnt_ecdh);
3097 : 0 : EVP_PKEY_free(srvr_pub_pkey);
3098 : : #endif
3099 : 0 : return(-1);
3100 : : }
3101 : :
3102 : 99 : int ssl3_send_client_verify(SSL *s)
3103 : : {
3104 : : unsigned char *p;
3105 : : unsigned char data[MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH];
3106 : : EVP_PKEY *pkey;
3107 : 99 : EVP_PKEY_CTX *pctx=NULL;
3108 : : EVP_MD_CTX mctx;
3109 : 99 : unsigned u=0;
3110 : : unsigned long n;
3111 : : int j;
3112 : :
3113 : 99 : EVP_MD_CTX_init(&mctx);
3114 : :
3115 [ + - ]: 99 : if (s->state == SSL3_ST_CW_CERT_VRFY_A)
3116 : : {
3117 : 99 : p= ssl_handshake_start(s);
3118 : 99 : pkey=s->cert->key->privatekey;
3119 : : /* Create context from key and test if sha1 is allowed as digest */
3120 : 99 : pctx = EVP_PKEY_CTX_new(pkey,NULL);
3121 : 99 : EVP_PKEY_sign_init(pctx);
3122 [ + - ]: 99 : if (EVP_PKEY_CTX_set_signature_md(pctx, EVP_sha1())>0)
3123 : : {
3124 [ + + ]: 99 : if (!SSL_USE_SIGALGS(s))
3125 : 44 : s->method->ssl3_enc->cert_verify_mac(s,
3126 : : NID_sha1,
3127 : : &(data[MD5_DIGEST_LENGTH]));
3128 : : }
3129 : : else
3130 : : {
3131 : 0 : ERR_clear_error();
3132 : : }
3133 : : /* For TLS v1.2 send signature algorithm and signature
3134 : : * using agreed digest and cached handshake records.
3135 : : */
3136 [ + + ]: 99 : if (SSL_USE_SIGALGS(s))
3137 : : {
3138 : 55 : long hdatalen = 0;
3139 : : void *hdata;
3140 : 55 : const EVP_MD *md = s->cert->key->digest;
3141 : 55 : hdatalen = BIO_get_mem_data(s->s3->handshake_buffer,
3142 : : &hdata);
3143 [ + - ][ - + ]: 55 : if (hdatalen <= 0 || !tls12_get_sigandhash(p, pkey, md))
3144 : : {
3145 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,
3146 : : ERR_R_INTERNAL_ERROR);
3147 : 0 : goto err;
3148 : : }
3149 : 55 : p += 2;
3150 : : #ifdef SSL_DEBUG
3151 : : fprintf(stderr, "Using TLS 1.2 with client alg %s\n",
3152 : : EVP_MD_name(md));
3153 : : #endif
3154 [ + - ]: 55 : if (!EVP_SignInit_ex(&mctx, md, NULL)
3155 [ + - ]: 55 : || !EVP_SignUpdate(&mctx, hdata, hdatalen)
3156 [ - + ]: 55 : || !EVP_SignFinal(&mctx, p + 2, &u, pkey))
3157 : : {
3158 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,
3159 : : ERR_R_EVP_LIB);
3160 : 0 : goto err;
3161 : : }
3162 : 55 : s2n(u,p);
3163 : 55 : n = u + 4;
3164 [ + - ]: 55 : if (!ssl3_digest_cached_records(s))
3165 : : goto err;
3166 : : }
3167 : : else
3168 : : #ifndef OPENSSL_NO_RSA
3169 [ + - ]: 44 : if (pkey->type == EVP_PKEY_RSA)
3170 : : {
3171 : 44 : s->method->ssl3_enc->cert_verify_mac(s,
3172 : : NID_md5,
3173 : : &(data[0]));
3174 [ - + ]: 44 : if (RSA_sign(NID_md5_sha1, data,
3175 : : MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH,
3176 : 44 : &(p[2]), &u, pkey->pkey.rsa) <= 0 )
3177 : : {
3178 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,ERR_R_RSA_LIB);
3179 : 0 : goto err;
3180 : : }
3181 : 44 : s2n(u,p);
3182 : 44 : n=u+2;
3183 : : }
3184 : : else
3185 : : #endif
3186 : : #ifndef OPENSSL_NO_DSA
3187 [ # # ]: 0 : if (pkey->type == EVP_PKEY_DSA)
3188 : : {
3189 [ # # ]: 0 : if (!DSA_sign(pkey->save_type,
3190 : : &(data[MD5_DIGEST_LENGTH]),
3191 : : SHA_DIGEST_LENGTH,&(p[2]),
3192 : 0 : (unsigned int *)&j,pkey->pkey.dsa))
3193 : : {
3194 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,ERR_R_DSA_LIB);
3195 : 0 : goto err;
3196 : : }
3197 : 0 : s2n(j,p);
3198 : 0 : n=j+2;
3199 : : }
3200 : : else
3201 : : #endif
3202 : : #ifndef OPENSSL_NO_ECDSA
3203 [ # # ]: 0 : if (pkey->type == EVP_PKEY_EC)
3204 : : {
3205 [ # # ]: 0 : if (!ECDSA_sign(pkey->save_type,
3206 : : &(data[MD5_DIGEST_LENGTH]),
3207 : : SHA_DIGEST_LENGTH,&(p[2]),
3208 : 0 : (unsigned int *)&j,pkey->pkey.ec))
3209 : : {
3210 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,
3211 : : ERR_R_ECDSA_LIB);
3212 : 0 : goto err;
3213 : : }
3214 : 0 : s2n(j,p);
3215 : 0 : n=j+2;
3216 : : }
3217 : : else
3218 : : #endif
3219 [ # # ]: 0 : if (pkey->type == NID_id_GostR3410_94 || pkey->type == NID_id_GostR3410_2001)
3220 : : {
3221 : : unsigned char signbuf[64];
3222 : : int i;
3223 : 0 : size_t sigsize=64;
3224 : 0 : s->method->ssl3_enc->cert_verify_mac(s,
3225 : : NID_id_GostR3411_94,
3226 : : data);
3227 [ # # ]: 0 : if (EVP_PKEY_sign(pctx, signbuf, &sigsize, data, 32) <= 0) {
3228 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,
3229 : : ERR_R_INTERNAL_ERROR);
3230 : 0 : goto err;
3231 : : }
3232 [ # # ]: 0 : for (i=63,j=0; i>=0; j++, i--) {
3233 : 0 : p[2+j]=signbuf[i];
3234 : : }
3235 : 0 : s2n(j,p);
3236 : 0 : n=j+2;
3237 : : }
3238 : : else
3239 : : {
3240 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,ERR_R_INTERNAL_ERROR);
3241 : 0 : goto err;
3242 : : }
3243 : 99 : ssl_set_handshake_header(s, SSL3_MT_CERTIFICATE_VERIFY, n);
3244 : 99 : s->state=SSL3_ST_CW_CERT_VRFY_B;
3245 : : }
3246 : 99 : EVP_MD_CTX_cleanup(&mctx);
3247 : 99 : EVP_PKEY_CTX_free(pctx);
3248 : 99 : return ssl_do_write(s);
3249 : : err:
3250 : 0 : EVP_MD_CTX_cleanup(&mctx);
3251 : 0 : EVP_PKEY_CTX_free(pctx);
3252 : 0 : return(-1);
3253 : : }
3254 : :
3255 : : /* Check a certificate can be used for client authentication. Currently
3256 : : * check cert exists, if we have a suitable digest for TLS 1.2 if
3257 : : * static DH client certificates can be used and optionally checks
3258 : : * suitability for Suite B.
3259 : : */
3260 : 99 : static int ssl3_check_client_certificate(SSL *s)
3261 : : {
3262 : : unsigned long alg_k;
3263 [ + - ][ + - ]: 99 : if (!s->cert || !s->cert->key->x509 || !s->cert->key->privatekey)
[ + - ]
3264 : : return 0;
3265 : : /* If no suitable signature algorithm can't use certificate */
3266 [ + + ][ + - ]: 99 : if (SSL_USE_SIGALGS(s) && !s->cert->key->digest)
3267 : : return 0;
3268 : : /* If strict mode check suitability of chain before using it.
3269 : : * This also adjusts suite B digest if necessary.
3270 : : */
3271 [ - + # # ]: 99 : if (s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT &&
3272 : 0 : !tls1_check_chain(s, NULL, NULL, NULL, -2))
3273 : : return 0;
3274 : 99 : alg_k=s->s3->tmp.new_cipher->algorithm_mkey;
3275 : : /* See if we can use client certificate for fixed DH */
3276 [ - + ]: 99 : if (alg_k & (SSL_kDHr|SSL_kDHd))
3277 : : {
3278 : 0 : SESS_CERT *scert = s->session->sess_cert;
3279 : 0 : int i = scert->peer_cert_type;
3280 : 0 : EVP_PKEY *clkey = NULL, *spkey = NULL;
3281 : 0 : clkey = s->cert->key->privatekey;
3282 : : /* If client key not DH assume it can be used */
3283 [ # # ]: 0 : if (EVP_PKEY_id(clkey) != EVP_PKEY_DH)
3284 : : return 1;
3285 [ # # ]: 0 : if (i >= 0)
3286 : 0 : spkey = X509_get_pubkey(scert->peer_pkeys[i].x509);
3287 [ # # ]: 0 : if (spkey)
3288 : : {
3289 : : /* Compare server and client parameters */
3290 : 0 : i = EVP_PKEY_cmp_parameters(clkey, spkey);
3291 : 0 : EVP_PKEY_free(spkey);
3292 [ # # ]: 0 : if (i != 1)
3293 : : return 0;
3294 : : }
3295 : 0 : s->s3->flags |= TLS1_FLAGS_SKIP_CERT_VERIFY;
3296 : : }
3297 : : return 1;
3298 : : }
3299 : :
3300 : 99 : int ssl3_send_client_certificate(SSL *s)
3301 : : {
3302 : 99 : X509 *x509=NULL;
3303 : 99 : EVP_PKEY *pkey=NULL;
3304 : : int i;
3305 : :
3306 [ + - ]: 99 : if (s->state == SSL3_ST_CW_CERT_A)
3307 : : {
3308 : : /* Let cert callback update client certificates if required */
3309 [ - + ]: 99 : if (s->cert->cert_cb)
3310 : : {
3311 : 0 : i = s->cert->cert_cb(s, s->cert->cert_cb_arg);
3312 [ # # ]: 0 : if (i < 0)
3313 : : {
3314 : 0 : s->rwstate=SSL_X509_LOOKUP;
3315 : 0 : return -1;
3316 : : }
3317 [ # # ]: 0 : if (i == 0)
3318 : : {
3319 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_INTERNAL_ERROR);
3320 : 0 : return 0;
3321 : : }
3322 : 0 : s->rwstate=SSL_NOTHING;
3323 : : }
3324 [ + - ]: 99 : if (ssl3_check_client_certificate(s))
3325 : 99 : s->state=SSL3_ST_CW_CERT_C;
3326 : : else
3327 : 0 : s->state=SSL3_ST_CW_CERT_B;
3328 : : }
3329 : :
3330 : : /* We need to get a client cert */
3331 [ - + ]: 99 : if (s->state == SSL3_ST_CW_CERT_B)
3332 : : {
3333 : : /* If we get an error, we need to
3334 : : * ssl->rwstate=SSL_X509_LOOKUP; return(-1);
3335 : : * We then get retied later */
3336 : 0 : i=0;
3337 : 0 : i = ssl_do_client_cert_cb(s, &x509, &pkey);
3338 [ # # ]: 0 : if (i < 0)
3339 : : {
3340 : 0 : s->rwstate=SSL_X509_LOOKUP;
3341 : 0 : return(-1);
3342 : : }
3343 : 0 : s->rwstate=SSL_NOTHING;
3344 [ # # ][ # # ]: 0 : if ((i == 1) && (pkey != NULL) && (x509 != NULL))
[ # # ]
3345 : : {
3346 : 0 : s->state=SSL3_ST_CW_CERT_B;
3347 [ # # # # ]: 0 : if ( !SSL_use_certificate(s,x509) ||
3348 : 0 : !SSL_use_PrivateKey(s,pkey))
3349 : : i=0;
3350 : : }
3351 [ # # ]: 0 : else if (i == 1)
3352 : : {
3353 : 0 : i=0;
3354 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_CERTIFICATE,SSL_R_BAD_DATA_RETURNED_BY_CALLBACK);
3355 : : }
3356 : :
3357 [ # # ]: 0 : if (x509 != NULL) X509_free(x509);
3358 [ # # ]: 0 : if (pkey != NULL) EVP_PKEY_free(pkey);
3359 [ # # ][ # # ]: 0 : if (i && !ssl3_check_client_certificate(s))
3360 : 0 : i = 0;
3361 [ # # ]: 0 : if (i == 0)
3362 : : {
3363 [ # # ]: 0 : if (s->version == SSL3_VERSION)
3364 : : {
3365 : 0 : s->s3->tmp.cert_req=0;
3366 : 0 : ssl3_send_alert(s,SSL3_AL_WARNING,SSL_AD_NO_CERTIFICATE);
3367 : 0 : return(1);
3368 : : }
3369 : : else
3370 : : {
3371 : 0 : s->s3->tmp.cert_req=2;
3372 : : }
3373 : : }
3374 : :
3375 : : /* Ok, we have a cert */
3376 : 0 : s->state=SSL3_ST_CW_CERT_C;
3377 : : }
3378 : :
3379 [ + - ]: 99 : if (s->state == SSL3_ST_CW_CERT_C)
3380 : : {
3381 : 99 : s->state=SSL3_ST_CW_CERT_D;
3382 [ + - ][ - + ]: 99 : if (!ssl3_output_cert_chain(s,
3383 : 198 : (s->s3->tmp.cert_req == 2)?NULL:s->cert->key))
3384 : : {
3385 : 0 : SSLerr(SSL_F_SSL3_SEND_CLIENT_CERTIFICATE, ERR_R_INTERNAL_ERROR);
3386 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_INTERNAL_ERROR);
3387 : 0 : return 0;
3388 : : }
3389 : : }
3390 : : /* SSL3_ST_CW_CERT_D */
3391 : 99 : return ssl_do_write(s);
3392 : : }
3393 : :
3394 : : #define has_bits(i,m) (((i)&(m)) == (m))
3395 : :
3396 : 1069 : int ssl3_check_cert_and_algorithm(SSL *s)
3397 : : {
3398 : : int i,idx;
3399 : : long alg_k,alg_a;
3400 : 1069 : EVP_PKEY *pkey=NULL;
3401 : : SESS_CERT *sc;
3402 : : #ifndef OPENSSL_NO_RSA
3403 : : RSA *rsa;
3404 : : #endif
3405 : : #ifndef OPENSSL_NO_DH
3406 : : DH *dh;
3407 : : #endif
3408 : :
3409 : 1069 : alg_k=s->s3->tmp.new_cipher->algorithm_mkey;
3410 : 1069 : alg_a=s->s3->tmp.new_cipher->algorithm_auth;
3411 : :
3412 : : /* we don't have a certificate */
3413 [ + + ][ + + ]: 1069 : if ((alg_a & (SSL_aNULL|SSL_aKRB5)) || (alg_k & SSL_kPSK))
3414 : : return(1);
3415 : :
3416 : 937 : sc=s->session->sess_cert;
3417 [ - + ]: 937 : if (sc == NULL)
3418 : : {
3419 : 0 : SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,ERR_R_INTERNAL_ERROR);
3420 : 0 : goto err;
3421 : : }
3422 : :
3423 : : #ifndef OPENSSL_NO_RSA
3424 : 937 : rsa=s->session->sess_cert->peer_rsa_tmp;
3425 : : #endif
3426 : : #ifndef OPENSSL_NO_DH
3427 : 937 : dh=s->session->sess_cert->peer_dh_tmp;
3428 : : #endif
3429 : :
3430 : : /* This is the passed certificate */
3431 : :
3432 : 937 : idx=sc->peer_cert_type;
3433 : : #ifndef OPENSSL_NO_ECDH
3434 [ - + ]: 937 : if (idx == SSL_PKEY_ECC)
3435 : : {
3436 [ # # ]: 0 : if (ssl_check_srvr_ecc_cert_and_alg(sc->peer_pkeys[idx].x509,
3437 : : s) == 0)
3438 : : { /* check failed */
3439 : 0 : SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_BAD_ECC_CERT);
3440 : 0 : goto f_err;
3441 : : }
3442 : : else
3443 : : {
3444 : : return 1;
3445 : : }
3446 : : }
3447 [ - + ]: 937 : else if (alg_a & SSL_aECDSA)
3448 : : {
3449 : 0 : SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_ECDSA_SIGNING_CERT);
3450 : 0 : goto f_err;
3451 : : }
3452 [ - + ]: 937 : else if (alg_k & (SSL_kECDHr|SSL_kECDHe))
3453 : : {
3454 : 0 : SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_ECDH_CERT);
3455 : 0 : goto f_err;
3456 : : }
3457 : : #endif
3458 : 937 : pkey=X509_get_pubkey(sc->peer_pkeys[idx].x509);
3459 : 937 : i=X509_certificate_type(sc->peer_pkeys[idx].x509,pkey);
3460 : 937 : EVP_PKEY_free(pkey);
3461 : :
3462 : :
3463 : : /* Check that we have a certificate if we require one */
3464 [ + - ][ - + ]: 937 : if ((alg_a & SSL_aRSA) && !has_bits(i,EVP_PK_RSA|EVP_PKT_SIGN))
3465 : : {
3466 : 0 : SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_RSA_SIGNING_CERT);
3467 : 0 : goto f_err;
3468 : : }
3469 : : #ifndef OPENSSL_NO_DSA
3470 [ - + ][ # # ]: 937 : else if ((alg_a & SSL_aDSS) && !has_bits(i,EVP_PK_DSA|EVP_PKT_SIGN))
3471 : : {
3472 : 0 : SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_DSA_SIGNING_CERT);
3473 : 0 : goto f_err;
3474 : : }
3475 : : #endif
3476 : : #ifndef OPENSSL_NO_RSA
3477 [ + + ][ - + ]: 937 : if ((alg_k & SSL_kRSA) &&
3478 [ # # ]: 0 : !(has_bits(i,EVP_PK_RSA|EVP_PKT_ENC) || (rsa != NULL)))
3479 : : {
3480 : 0 : SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_RSA_ENCRYPTING_CERT);
3481 : 0 : goto f_err;
3482 : : }
3483 : : #endif
3484 : : #ifndef OPENSSL_NO_DH
3485 [ + + ][ + - ]: 937 : if ((alg_k & SSL_kDHE) &&
3486 [ - + ]: 88 : !(has_bits(i,EVP_PK_DH|EVP_PKT_EXCH) || (dh != NULL)))
3487 : : {
3488 : 0 : SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_DH_KEY);
3489 : 0 : goto f_err;
3490 : : }
3491 [ - + ][ # # ]: 937 : else if ((alg_k & SSL_kDHr) && !SSL_USE_SIGALGS(s) &&
[ # # ]
3492 : 0 : !has_bits(i,EVP_PK_DH|EVP_PKS_RSA))
3493 : : {
3494 : 0 : SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_DH_RSA_CERT);
3495 : 0 : goto f_err;
3496 : : }
3497 : : #ifndef OPENSSL_NO_DSA
3498 [ - + ][ # # ]: 937 : else if ((alg_k & SSL_kDHd) && !SSL_USE_SIGALGS(s) &&
[ # # ]
3499 : 0 : !has_bits(i,EVP_PK_DH|EVP_PKS_DSA))
3500 : : {
3501 : 0 : SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_DH_DSA_CERT);
3502 : 0 : goto f_err;
3503 : : }
3504 : : #endif
3505 : : #endif
3506 : :
3507 [ + + ][ - + ]: 937 : if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) && !has_bits(i,EVP_PKT_EXP))
3508 : : {
3509 : : #ifndef OPENSSL_NO_RSA
3510 [ # # ]: 0 : if (alg_k & SSL_kRSA)
3511 : : {
3512 [ # # ]: 0 : if (rsa == NULL
3513 [ # # ][ # # ]: 0 : || RSA_size(rsa)*8 > SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher))
3514 : : {
3515 : 0 : SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_EXPORT_TMP_RSA_KEY);
3516 : 0 : goto f_err;
3517 : : }
3518 : : }
3519 : : else
3520 : : #endif
3521 : : #ifndef OPENSSL_NO_DH
3522 [ # # ]: 0 : if (alg_k & (SSL_kDHE|SSL_kDHr|SSL_kDHd))
3523 : : {
3524 [ # # ]: 0 : if (dh == NULL
3525 [ # # ][ # # ]: 0 : || DH_size(dh)*8 > SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher))
3526 : : {
3527 : 0 : SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_MISSING_EXPORT_TMP_DH_KEY);
3528 : 0 : goto f_err;
3529 : : }
3530 : : }
3531 : : else
3532 : : #endif
3533 : : {
3534 : 0 : SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE);
3535 : 0 : goto f_err;
3536 : : }
3537 : : }
3538 : : return(1);
3539 : : f_err:
3540 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_HANDSHAKE_FAILURE);
3541 : : err:
3542 : : return(0);
3543 : : }
3544 : :
3545 : : /* Check to see if handshake is full or resumed. Usually this is just a
3546 : : * case of checking to see if a cache hit has occurred. In the case of
3547 : : * session tickets we have to check the next message to be sure.
3548 : : */
3549 : :
3550 : : #ifndef OPENSSL_NO_TLSEXT
3551 : : # ifndef OPENSSL_NO_NEXTPROTONEG
3552 : 55 : int ssl3_send_next_proto(SSL *s)
3553 : : {
3554 : : unsigned int len, padding_len;
3555 : : unsigned char *d;
3556 : :
3557 [ + - ]: 55 : if (s->state == SSL3_ST_CW_NEXT_PROTO_A)
3558 : : {
3559 : 55 : len = s->next_proto_negotiated_len;
3560 : 55 : padding_len = 32 - ((len + 2) % 32);
3561 : 55 : d = (unsigned char *)s->init_buf->data;
3562 : 55 : d[4] = len;
3563 : 55 : memcpy(d + 5, s->next_proto_negotiated, len);
3564 : 55 : d[5 + len] = padding_len;
3565 : 55 : memset(d + 6 + len, 0, padding_len);
3566 : 55 : *(d++)=SSL3_MT_NEXT_PROTO;
3567 : 55 : l2n3(2 + len + padding_len, d);
3568 : 55 : s->state = SSL3_ST_CW_NEXT_PROTO_B;
3569 : 55 : s->init_num = 4 + 2 + len + padding_len;
3570 : 55 : s->init_off = 0;
3571 : : }
3572 : :
3573 : 55 : return ssl3_do_write(s, SSL3_RT_HANDSHAKE);
3574 : : }
3575 : : # endif
3576 : :
3577 : 5887 : int ssl3_check_finished(SSL *s)
3578 : : {
3579 : : int ok;
3580 : : long n;
3581 : :
3582 : : /* If we have no ticket it cannot be a resumed session. */
3583 [ - + ]: 5887 : if (!s->session->tlsext_tick)
3584 : : return 1;
3585 : : /* this function is called when we really expect a Certificate
3586 : : * message, so permit appropriate message length */
3587 : 0 : n=s->method->ssl_get_message(s,
3588 : : SSL3_ST_CR_CERT_A,
3589 : : SSL3_ST_CR_CERT_B,
3590 : : -1,
3591 : : s->max_cert_list,
3592 : : &ok);
3593 [ # # ]: 0 : if (!ok) return((int)n);
3594 : 0 : s->s3->tmp.reuse_message = 1;
3595 : :
3596 [ # # ]: 0 : if ((s->s3->tmp.message_type == SSL3_MT_FINISHED)
3597 : 0 : || (s->s3->tmp.message_type == SSL3_MT_NEWSESSION_TICKET))
3598 : : return 2;
3599 : :
3600 : 0 : return 1;
3601 : : }
3602 : : #endif
3603 : :
3604 : 0 : int ssl_do_client_cert_cb(SSL *s, X509 **px509, EVP_PKEY **ppkey)
3605 : : {
3606 : 0 : int i = 0;
3607 : : #ifndef OPENSSL_NO_ENGINE
3608 [ # # ]: 0 : if (s->ctx->client_cert_engine)
3609 : : {
3610 : 0 : i = ENGINE_load_ssl_client_cert(s->ctx->client_cert_engine, s,
3611 : : SSL_get_client_CA_list(s),
3612 : : px509, ppkey, NULL, NULL, NULL);
3613 [ # # ]: 0 : if (i != 0)
3614 : : return i;
3615 : : }
3616 : : #endif
3617 [ # # ]: 0 : if (s->ctx->client_cert_cb)
3618 : 0 : i = s->ctx->client_cert_cb(s,px509,ppkey);
3619 : 0 : return i;
3620 : : }
|
