Branch data Line data Source code
1 : : /* ssl/s23_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-2006 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 : : #include <stdio.h>
113 : : #include "ssl_locl.h"
114 : : #include <openssl/buffer.h>
115 : : #include <openssl/rand.h>
116 : : #include <openssl/objects.h>
117 : : #include <openssl/evp.h>
118 : :
119 : : static const SSL_METHOD *ssl23_get_client_method(int ver);
120 : : static int ssl23_client_hello(SSL *s);
121 : : static int ssl23_get_server_hello(SSL *s);
122 : 0 : static const SSL_METHOD *ssl23_get_client_method(int ver)
123 : : {
124 : : #ifndef OPENSSL_NO_SSL2
125 [ # # ]: 0 : if (ver == SSL2_VERSION)
126 : 0 : return(SSLv2_client_method());
127 : : #endif
128 [ # # ]: 0 : if (ver == SSL3_VERSION)
129 : 0 : return(SSLv3_client_method());
130 [ # # ]: 0 : else if (ver == TLS1_VERSION)
131 : 0 : return(TLSv1_client_method());
132 [ # # ]: 0 : else if (ver == TLS1_1_VERSION)
133 : 0 : return(TLSv1_1_client_method());
134 [ # # ]: 0 : else if (ver == TLS1_2_VERSION)
135 : 0 : return(TLSv1_2_client_method());
136 : : else
137 : : return(NULL);
138 : : }
139 : :
140 : 0 : IMPLEMENT_ssl23_meth_func(SSLv23_client_method,
141 : : ssl_undefined_function,
142 : : ssl23_connect,
143 : : ssl23_get_client_method)
144 : :
145 : 1126 : int ssl23_connect(SSL *s)
146 : : {
147 : 1126 : BUF_MEM *buf=NULL;
148 : 1126 : unsigned long Time=(unsigned long)time(NULL);
149 : 1126 : void (*cb)(const SSL *ssl,int type,int val)=NULL;
150 : 1126 : int ret= -1;
151 : : int new_state,state;
152 : :
153 : 1126 : RAND_add(&Time,sizeof(Time),0);
154 : 1126 : ERR_clear_error();
155 : 1126 : clear_sys_error();
156 : :
157 [ + - ]: 1126 : if (s->info_callback != NULL)
158 : : cb=s->info_callback;
159 [ - + ]: 1126 : else if (s->ctx->info_callback != NULL)
160 : 0 : cb=s->ctx->info_callback;
161 : :
162 : 1126 : s->in_handshake++;
163 [ + - ][ + + ]: 1526 : if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s);
164 : :
165 : : for (;;)
166 : : {
167 : 1526 : state=s->state;
168 : :
169 [ + + + - ]: 1526 : switch(s->state)
170 : : {
171 : : case SSL_ST_BEFORE:
172 : : case SSL_ST_CONNECT:
173 : : case SSL_ST_BEFORE|SSL_ST_CONNECT:
174 : : case SSL_ST_OK|SSL_ST_CONNECT:
175 : :
176 [ - + ]: 200 : if (s->session != NULL)
177 : : {
178 : 0 : SSLerr(SSL_F_SSL23_CONNECT,SSL_R_SSL23_DOING_SESSION_ID_REUSE);
179 : 0 : ret= -1;
180 : 0 : goto end;
181 : : }
182 : 200 : s->server=0;
183 [ - + ]: 200 : if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
184 : :
185 : : /* s->version=TLS1_VERSION; */
186 : 200 : s->type=SSL_ST_CONNECT;
187 : :
188 [ + - ]: 200 : if (s->init_buf == NULL)
189 : : {
190 [ + - ]: 200 : if ((buf=BUF_MEM_new()) == NULL)
191 : : {
192 : : ret= -1;
193 : : goto end;
194 : : }
195 [ + - ]: 200 : if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH))
196 : : {
197 : : ret= -1;
198 : : goto end;
199 : : }
200 : 200 : s->init_buf=buf;
201 : 200 : buf=NULL;
202 : : }
203 : :
204 [ + - ]: 200 : if (!ssl3_setup_buffers(s)) { ret= -1; goto end; }
205 : :
206 : 200 : ssl3_init_finished_mac(s);
207 : :
208 : 200 : s->state=SSL23_ST_CW_CLNT_HELLO_A;
209 : 200 : s->ctx->stats.sess_connect++;
210 : 200 : s->init_num=0;
211 : 200 : break;
212 : :
213 : : case SSL23_ST_CW_CLNT_HELLO_A:
214 : : case SSL23_ST_CW_CLNT_HELLO_B:
215 : :
216 : 596 : s->shutdown=0;
217 : 596 : ret=ssl23_client_hello(s);
218 [ + + ]: 596 : if (ret <= 0) goto end;
219 : 200 : s->state=SSL23_ST_CR_SRVR_HELLO_A;
220 : 200 : s->init_num=0;
221 : :
222 : 200 : break;
223 : :
224 : : case SSL23_ST_CR_SRVR_HELLO_A:
225 : : case SSL23_ST_CR_SRVR_HELLO_B:
226 : 730 : ret=ssl23_get_server_hello(s);
227 [ - + ]: 730 : if (ret >= 0) cb=NULL;
228 : : goto end;
229 : : /* break; */
230 : :
231 : : default:
232 : 0 : SSLerr(SSL_F_SSL23_CONNECT,SSL_R_UNKNOWN_STATE);
233 : 0 : ret= -1;
234 : 0 : goto end;
235 : : /* break; */
236 : : }
237 : :
238 [ - + ]: 400 : if (s->debug) { (void)BIO_flush(s->wbio); }
239 : :
240 [ + - ][ # # ]: 400 : if ((cb != NULL) && (s->state != state))
241 : : {
242 : 0 : new_state=s->state;
243 : 0 : s->state=state;
244 : 0 : cb(s,SSL_CB_CONNECT_LOOP,1);
245 : 0 : s->state=new_state;
246 : : }
247 : : }
248 : : end:
249 : 1126 : s->in_handshake--;
250 [ - + ]: 1126 : if (buf != NULL)
251 : 0 : BUF_MEM_free(buf);
252 [ - + ]: 1126 : if (cb != NULL)
253 : 0 : cb(s,SSL_CB_CONNECT_EXIT,ret);
254 : 1126 : return(ret);
255 : : }
256 : :
257 : 596 : static int ssl23_no_ssl2_ciphers(SSL *s)
258 : : {
259 : : SSL_CIPHER *cipher;
260 : : STACK_OF(SSL_CIPHER) *ciphers;
261 : : int i;
262 : 596 : ssl_set_client_disabled(s);
263 : 596 : ciphers = SSL_get_ciphers(s);
264 [ + + ]: 62715 : for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++)
265 : : {
266 : 62119 : cipher = sk_SSL_CIPHER_value(ciphers, i);
267 [ + + ]: 62119 : if (ssl_cipher_disabled(s, cipher, SSL_SECOP_CIPHER_SUPPORTED))
268 : 2068 : continue;
269 [ + - ]: 60051 : if (cipher->algorithm_ssl == SSL_SSLV2)
270 : : return 0;
271 : : }
272 : : return 1;
273 : : }
274 : :
275 : : /* Fill a ClientRandom or ServerRandom field of length len. Returns <= 0
276 : : * on failure, 1 on success. */
277 : 2160 : int ssl_fill_hello_random(SSL *s, int server, unsigned char *result, int len)
278 : : {
279 : 2160 : int send_time = 0;
280 [ + - ]: 2160 : if (len < 4)
281 : : return 0;
282 [ + + ]: 2160 : if (server)
283 : 1080 : send_time = (s->mode & SSL_MODE_SEND_SERVERHELLO_TIME) != 0;
284 : : else
285 : 1080 : send_time = (s->mode & SSL_MODE_SEND_CLIENTHELLO_TIME) != 0;
286 [ - + ]: 2160 : if (send_time)
287 : : {
288 : 0 : unsigned long Time = (unsigned long)time(NULL);
289 : 0 : unsigned char *p = result;
290 : 0 : l2n(Time, p);
291 : 0 : return RAND_pseudo_bytes(p, len-4);
292 : : }
293 : : else
294 : 2160 : return RAND_pseudo_bytes(result, len);
295 : : }
296 : :
297 : 596 : static int ssl23_client_hello(SSL *s)
298 : : {
299 : : unsigned char *buf;
300 : : unsigned char *p,*d;
301 : : int i,ch_len;
302 : : unsigned long l;
303 : : int ssl2_compat;
304 : 596 : int version = 0, version_major, version_minor;
305 : 596 : int al = 0;
306 : : #ifndef OPENSSL_NO_COMP
307 : : int j;
308 : : SSL_COMP *comp;
309 : : #endif
310 : : int ret;
311 : 596 : unsigned long mask, options = s->options;
312 : :
313 : 596 : ssl2_compat = (options & SSL_OP_NO_SSLv2) ? 0 : 1;
314 : :
315 [ + - ][ - + ]: 596 : if (ssl2_compat && !ssl_security(s, SSL_SECOP_SSL2_COMPAT, 0, 0, NULL))
316 : 0 : ssl2_compat = 0;
317 [ + - ][ + - ]: 596 : if (ssl2_compat && ssl23_no_ssl2_ciphers(s))
318 : 596 : ssl2_compat = 0;
319 : :
320 : : /*
321 : : * SSL_OP_NO_X disables all protocols above X *if* there are
322 : : * some protocols below X enabled. This is required in order
323 : : * to maintain "version capability" vector contiguous. So
324 : : * that if application wants to disable TLS1.0 in favour of
325 : : * TLS1>=1, it would be insufficient to pass SSL_NO_TLSv1, the
326 : : * answer is SSL_OP_NO_TLSv1|SSL_OP_NO_SSLv3|SSL_OP_NO_SSLv2.
327 : : */
328 [ + - ]: 596 : mask = SSL_OP_NO_TLSv1_1|SSL_OP_NO_TLSv1
329 : : #if !defined(OPENSSL_NO_SSL3)
330 : : |SSL_OP_NO_SSLv3
331 : : #endif
332 : : #if !defined(OPENSSL_NO_SSL2)
333 : : |(ssl2_compat?SSL_OP_NO_SSLv2:0)
334 : : #endif
335 : : ;
336 : : #if !defined(OPENSSL_NO_TLS1_2_CLIENT)
337 : 596 : version = TLS1_2_VERSION;
338 : :
339 [ - + ][ # # ]: 596 : if ((options & SSL_OP_NO_TLSv1_2) && (options & mask) != mask)
340 : 0 : version = TLS1_1_VERSION;
341 : : #else
342 : : version = TLS1_1_VERSION;
343 : : #endif
344 : 596 : mask &= ~SSL_OP_NO_TLSv1_1;
345 [ - + ][ # # ]: 596 : if ((options & SSL_OP_NO_TLSv1_1) && (options & mask) != mask)
346 : 0 : version = TLS1_VERSION;
347 : 596 : mask &= ~SSL_OP_NO_TLSv1;
348 : : #if !defined(OPENSSL_NO_SSL3)
349 [ - + ][ # # ]: 596 : if ((options & SSL_OP_NO_TLSv1) && (options & mask) != mask)
350 : 0 : version = SSL3_VERSION;
351 : 596 : mask &= ~SSL_OP_NO_SSLv3;
352 : : #endif
353 : : #if !defined(OPENSSL_NO_SSL2)
354 [ - + ][ # # ]: 596 : if ((options & SSL_OP_NO_SSLv3) && (options & mask) != mask)
355 : 0 : version = SSL2_VERSION;
356 : : #endif
357 : :
358 : : #ifndef OPENSSL_NO_TLSEXT
359 [ + - ]: 596 : if (version != SSL2_VERSION)
360 : : {
361 : : /* have to disable SSL 2.0 compatibility if we need TLS extensions */
362 : :
363 [ - + ]: 596 : if (s->tlsext_hostname != NULL)
364 : 0 : ssl2_compat = 0;
365 [ - + ]: 596 : if (s->tlsext_status_type != -1)
366 : 0 : ssl2_compat = 0;
367 : : #ifdef TLSEXT_TYPE_opaque_prf_input
368 : : if (s->ctx->tlsext_opaque_prf_input_callback != 0 || s->tlsext_opaque_prf_input != NULL)
369 : : ssl2_compat = 0;
370 : : #endif
371 [ - + ]: 596 : if (s->ctx->custom_cli_ext_records_count != 0)
372 : 0 : ssl2_compat = 0;
373 : : }
374 : : #endif
375 : :
376 : 596 : buf=(unsigned char *)s->init_buf->data;
377 [ + + ]: 596 : if (s->state == SSL23_ST_CW_CLNT_HELLO_A)
378 : : {
379 : : #if 0
380 : : /* don't reuse session-id's */
381 : : if (!ssl_get_new_session(s,0))
382 : : {
383 : : return(-1);
384 : : }
385 : : #endif
386 : :
387 : 200 : p=s->s3->client_random;
388 [ + - ]: 200 : if (ssl_fill_hello_random(s, 0, p, SSL3_RANDOM_SIZE) <= 0)
389 : : return -1;
390 : :
391 [ - + ]: 200 : if (version == TLS1_2_VERSION)
392 : : {
393 : : version_major = TLS1_2_VERSION_MAJOR;
394 : : version_minor = TLS1_2_VERSION_MINOR;
395 : : }
396 [ # # ]: 0 : else if (tls1_suiteb(s))
397 : : {
398 : 0 : SSLerr(SSL_F_SSL23_CLIENT_HELLO,
399 : : SSL_R_ONLY_TLS_1_2_ALLOWED_IN_SUITEB_MODE);
400 : 0 : return -1;
401 : : }
402 [ # # ]: 0 : else if (version == TLS1_1_VERSION)
403 : : {
404 : : version_major = TLS1_1_VERSION_MAJOR;
405 : : version_minor = TLS1_1_VERSION_MINOR;
406 : : }
407 [ # # ]: 0 : else if (version == TLS1_VERSION)
408 : : {
409 : : version_major = TLS1_VERSION_MAJOR;
410 : : version_minor = TLS1_VERSION_MINOR;
411 : : }
412 : : #ifdef OPENSSL_FIPS
413 : : else if(FIPS_mode())
414 : : {
415 : : SSLerr(SSL_F_SSL23_CLIENT_HELLO,
416 : : SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
417 : : return -1;
418 : : }
419 : : #endif
420 [ # # ]: 0 : else if (version == SSL3_VERSION)
421 : : {
422 : : version_major = SSL3_VERSION_MAJOR;
423 : : version_minor = SSL3_VERSION_MINOR;
424 : : }
425 [ # # ]: 0 : else if (version == SSL2_VERSION)
426 : : {
427 : : version_major = SSL2_VERSION_MAJOR;
428 : : version_minor = SSL2_VERSION_MINOR;
429 : : }
430 : : else
431 : : {
432 : 0 : SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_PROTOCOLS_AVAILABLE);
433 : 0 : return(-1);
434 : : }
435 : :
436 : 200 : s->client_version = version;
437 : :
438 [ - + ]: 200 : if (ssl2_compat)
439 : : {
440 : : /* create SSL 2.0 compatible Client Hello */
441 : :
442 : : /* two byte record header will be written last */
443 : 0 : d = &(buf[2]);
444 : 0 : p = d + 9; /* leave space for message type, version, individual length fields */
445 : :
446 : 0 : *(d++) = SSL2_MT_CLIENT_HELLO;
447 : 0 : *(d++) = version_major;
448 : 0 : *(d++) = version_minor;
449 : :
450 : : /* Ciphers supported */
451 : 0 : i=ssl_cipher_list_to_bytes(s,SSL_get_ciphers(s),p,0);
452 [ # # ]: 0 : if (i == 0)
453 : : {
454 : : /* no ciphers */
455 : 0 : SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_CIPHERS_AVAILABLE);
456 : 0 : return -1;
457 : : }
458 : 0 : s2n(i,d);
459 : 0 : p+=i;
460 : :
461 : : /* put in the session-id length (zero since there is no reuse) */
462 : : #if 0
463 : : s->session->session_id_length=0;
464 : : #endif
465 : 0 : s2n(0,d);
466 : :
467 [ # # ]: 0 : if (s->options & SSL_OP_NETSCAPE_CHALLENGE_BUG)
468 : : ch_len=SSL2_CHALLENGE_LENGTH;
469 : : else
470 : 0 : ch_len=SSL2_MAX_CHALLENGE_LENGTH;
471 : :
472 : : /* write out sslv2 challenge */
473 : : /* Note that ch_len must be <= SSL3_RANDOM_SIZE (32),
474 : : because it is one of SSL2_MAX_CHALLENGE_LENGTH (32)
475 : : or SSL2_MAX_CHALLENGE_LENGTH (16), but leave the
476 : : check in for futurproofing */
477 [ # # ]: 0 : if (SSL3_RANDOM_SIZE < ch_len)
478 : : i=SSL3_RANDOM_SIZE;
479 : : else
480 : 0 : i=ch_len;
481 : 0 : s2n(i,d);
482 : 0 : memset(&(s->s3->client_random[0]),0,SSL3_RANDOM_SIZE);
483 [ # # ]: 0 : if (RAND_pseudo_bytes(&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i) <= 0)
484 : : return -1;
485 : :
486 : 0 : memcpy(p,&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i);
487 : 0 : p+=i;
488 : :
489 : 0 : i= p- &(buf[2]);
490 : 0 : buf[0]=((i>>8)&0xff)|0x80;
491 : 0 : buf[1]=(i&0xff);
492 : :
493 : : /* number of bytes to write */
494 : 0 : s->init_num=i+2;
495 : 0 : s->init_off=0;
496 : :
497 : 0 : ssl3_finish_mac(s,&(buf[2]),i);
498 : : }
499 : : else
500 : : {
501 : : /* create Client Hello in SSL 3.0/TLS 1.0 format */
502 : :
503 : : /* do the record header (5 bytes) and handshake message header (4 bytes) last */
504 : 200 : d = p = &(buf[9]);
505 : :
506 : 200 : *(p++) = version_major;
507 : 200 : *(p++) = version_minor;
508 : :
509 : : /* Random stuff */
510 : 200 : memcpy(p, s->s3->client_random, SSL3_RANDOM_SIZE);
511 : 200 : p += SSL3_RANDOM_SIZE;
512 : :
513 : : /* Session ID (zero since there is no reuse) */
514 : 200 : *(p++) = 0;
515 : :
516 : : /* Ciphers supported (using SSL 3.0/TLS 1.0 format) */
517 : 200 : i=ssl_cipher_list_to_bytes(s,SSL_get_ciphers(s),&(p[2]),ssl3_put_cipher_by_char);
518 [ - + ]: 200 : if (i == 0)
519 : : {
520 : 0 : SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_CIPHERS_AVAILABLE);
521 : 0 : return -1;
522 : : }
523 : : #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH
524 : : /* Some servers hang if client hello > 256 bytes
525 : : * as hack workaround chop number of supported ciphers
526 : : * to keep it well below this if we use TLS v1.2
527 : : */
528 : : if (TLS1_get_version(s) >= TLS1_2_VERSION
529 : : && i > OPENSSL_MAX_TLS1_2_CIPHER_LENGTH)
530 : : i = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1;
531 : : #endif
532 : 200 : s2n(i,p);
533 : 200 : p+=i;
534 : :
535 : : /* COMPRESSION */
536 : : #ifdef OPENSSL_NO_COMP
537 : : *(p++)=1;
538 : : #else
539 [ + - ][ + - ]: 200 : if (!ssl_allow_compression(s) || !s->ctx->comp_methods)
540 : : j=0;
541 : : else
542 : 200 : j=sk_SSL_COMP_num(s->ctx->comp_methods);
543 : 200 : *(p++)=1+j;
544 [ - + ]: 200 : for (i=0; i<j; i++)
545 : : {
546 : 0 : comp=sk_SSL_COMP_value(s->ctx->comp_methods,i);
547 : 0 : *(p++)=comp->id;
548 : : }
549 : : #endif
550 : 200 : *(p++)=0; /* Add the NULL method */
551 : :
552 : : #ifndef OPENSSL_NO_TLSEXT
553 : : /* TLS extensions*/
554 [ - + ]: 200 : if (ssl_prepare_clienthello_tlsext(s) <= 0)
555 : : {
556 : 0 : SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_CLIENTHELLO_TLSEXT);
557 : 0 : return -1;
558 : : }
559 [ - + ]: 200 : if ((p = ssl_add_clienthello_tlsext(s, p, buf+SSL3_RT_MAX_PLAIN_LENGTH, &al)) == NULL)
560 : : {
561 : 0 : ssl3_send_alert(s,SSL3_AL_FATAL,al);
562 : 0 : SSLerr(SSL_F_SSL23_CLIENT_HELLO,ERR_R_INTERNAL_ERROR);
563 : 0 : return -1;
564 : : }
565 : : #endif
566 : :
567 : 200 : l = p-d;
568 : :
569 : : /* fill in 4-byte handshake header */
570 : 200 : d=&(buf[5]);
571 : 200 : *(d++)=SSL3_MT_CLIENT_HELLO;
572 : 200 : l2n3(l,d);
573 : :
574 : 200 : l += 4;
575 : :
576 [ - + ]: 200 : if (l > SSL3_RT_MAX_PLAIN_LENGTH)
577 : : {
578 : 0 : SSLerr(SSL_F_SSL23_CLIENT_HELLO,ERR_R_INTERNAL_ERROR);
579 : 0 : return -1;
580 : : }
581 : :
582 : : /* fill in 5-byte record header */
583 : 200 : d=buf;
584 : 200 : *(d++) = SSL3_RT_HANDSHAKE;
585 : 200 : *(d++) = version_major;
586 : : /* Some servers hang if we use long client hellos
587 : : * and a record number > TLS 1.0.
588 : : */
589 [ + - ][ + - ]: 200 : if (TLS1_get_client_version(s) > TLS1_VERSION)
590 : 200 : *(d++) = 1;
591 : : else
592 : 0 : *(d++) = version_minor;
593 : 200 : s2n((int)l,d);
594 : :
595 : : /* number of bytes to write */
596 : 200 : s->init_num=p-buf;
597 : 200 : s->init_off=0;
598 : :
599 : 200 : ssl3_finish_mac(s,&(buf[5]), s->init_num - 5);
600 : : }
601 : :
602 : 200 : s->state=SSL23_ST_CW_CLNT_HELLO_B;
603 : 200 : s->init_off=0;
604 : : }
605 : :
606 : : /* SSL3_ST_CW_CLNT_HELLO_B */
607 : 596 : ret = ssl23_write_bytes(s);
608 : :
609 [ + + ][ - + ]: 596 : if ((ret >= 2) && s->msg_callback)
610 : : {
611 : : /* Client Hello has been sent; tell msg_callback */
612 : :
613 [ # # ]: 0 : if (ssl2_compat)
614 : 0 : s->msg_callback(1, SSL2_VERSION, 0, s->init_buf->data+2, ret-2, s, s->msg_callback_arg);
615 : : else
616 : : {
617 : 0 : s->msg_callback(1, version, SSL3_RT_HEADER, s->init_buf->data, 5, s, s->msg_callback_arg);
618 : 0 : s->msg_callback(1, version, SSL3_RT_HANDSHAKE, s->init_buf->data+5, ret-5, s, s->msg_callback_arg);
619 : : }
620 : : }
621 : :
622 : 596 : return ret;
623 : : }
624 : :
625 : 730 : static int ssl23_get_server_hello(SSL *s)
626 : : {
627 : : char buf[8];
628 : : unsigned char *p;
629 : : int i;
630 : : int n;
631 : :
632 : 730 : n=ssl23_read_bytes(s,7);
633 : :
634 [ + + ]: 730 : if (n != 7) return(n);
635 : 200 : p=s->packet;
636 : :
637 : 200 : memcpy(buf,p,n);
638 : :
639 [ - + ][ # # ]: 200 : if ((p[0] & 0x80) && (p[2] == SSL2_MT_SERVER_HELLO) &&
[ # # ]
640 [ # # ]: 0 : (p[5] == 0x00) && (p[6] == 0x02))
641 : 0 : {
642 : : #ifdef OPENSSL_NO_SSL2
643 : : SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
644 : : goto err;
645 : : #else
646 : : /* we are talking sslv2 */
647 : : /* we need to clean up the SSLv3 setup and put in the
648 : : * sslv2 stuff. */
649 : : int ch_len;
650 : :
651 [ # # ]: 0 : if (s->options & SSL_OP_NO_SSLv2)
652 : : {
653 : 0 : SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
654 : 0 : goto err;
655 : : }
656 [ # # ]: 0 : if (s->s2 == NULL)
657 : : {
658 [ # # ]: 0 : if (!ssl2_new(s))
659 : : goto err;
660 : : }
661 : : else
662 : 0 : ssl2_clear(s);
663 : :
664 [ # # ]: 0 : if (s->options & SSL_OP_NETSCAPE_CHALLENGE_BUG)
665 : : ch_len=SSL2_CHALLENGE_LENGTH;
666 : : else
667 : 0 : ch_len=SSL2_MAX_CHALLENGE_LENGTH;
668 : :
669 : : /* write out sslv2 challenge */
670 : : /* Note that ch_len must be <= SSL3_RANDOM_SIZE (32), because
671 : : it is one of SSL2_MAX_CHALLENGE_LENGTH (32) or
672 : : SSL2_MAX_CHALLENGE_LENGTH (16), but leave the check in for
673 : : futurproofing */
674 : 0 : i=(SSL3_RANDOM_SIZE < ch_len)
675 : : ?SSL3_RANDOM_SIZE:ch_len;
676 : 0 : s->s2->challenge_length=i;
677 : 0 : memcpy(s->s2->challenge,
678 : 0 : &(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i);
679 : :
680 [ # # ]: 0 : if (s->s3 != NULL) ssl3_free(s);
681 : :
682 [ # # ]: 0 : if (!BUF_MEM_grow_clean(s->init_buf,
683 : : SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER))
684 : : {
685 : 0 : SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,ERR_R_BUF_LIB);
686 : 0 : goto err;
687 : : }
688 : :
689 : 0 : s->state=SSL2_ST_GET_SERVER_HELLO_A;
690 [ # # ]: 0 : if (!(s->client_version == SSL2_VERSION))
691 : : /* use special padding (SSL 3.0 draft/RFC 2246, App. E.2) */
692 : 0 : s->s2->ssl2_rollback=1;
693 : :
694 : : /* setup the 7 bytes we have read so we get them from
695 : : * the sslv2 buffer */
696 : 0 : s->rstate=SSL_ST_READ_HEADER;
697 : 0 : s->packet_length=n;
698 : 0 : s->packet= &(s->s2->rbuf[0]);
699 : 0 : memcpy(s->packet,buf,n);
700 : 0 : s->s2->rbuf_left=n;
701 : 0 : s->s2->rbuf_offs=0;
702 : :
703 : : /* we have already written one */
704 : 0 : s->s2->write_sequence=1;
705 : :
706 : 0 : s->method=SSLv2_client_method();
707 : 0 : s->handshake_func=s->method->ssl_connect;
708 : : #endif
709 : : }
710 [ + - ][ + - ]: 200 : else if (p[1] == SSL3_VERSION_MAJOR &&
711 [ + - ]: 200 : p[2] <= TLS1_2_VERSION_MINOR &&
712 [ - + ][ # # ]: 200 : ((p[0] == SSL3_RT_HANDSHAKE && p[5] == SSL3_MT_SERVER_HELLO) ||
713 [ # # ][ # # ]: 0 : (p[0] == SSL3_RT_ALERT && p[3] == 0 && p[4] == 2)))
714 : : {
715 : : /* we have sslv3 or tls1 (server hello or alert) */
716 : :
717 [ - + ][ # # ]: 200 : if ((p[2] == SSL3_VERSION_MINOR) &&
718 : 0 : !(s->options & SSL_OP_NO_SSLv3))
719 : : {
720 : : #ifdef OPENSSL_FIPS
721 : : if(FIPS_mode())
722 : : {
723 : : SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,
724 : : SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
725 : : goto err;
726 : : }
727 : : #endif
728 : 0 : s->version=SSL3_VERSION;
729 : 0 : s->method=SSLv3_client_method();
730 : : }
731 [ - + ][ # # ]: 200 : else if ((p[2] == TLS1_VERSION_MINOR) &&
732 : 0 : !(s->options & SSL_OP_NO_TLSv1))
733 : : {
734 : 0 : s->version=TLS1_VERSION;
735 : 0 : s->method=TLSv1_client_method();
736 : : }
737 [ - + ][ # # ]: 200 : else if ((p[2] == TLS1_1_VERSION_MINOR) &&
738 : 0 : !(s->options & SSL_OP_NO_TLSv1_1))
739 : : {
740 : 0 : s->version=TLS1_1_VERSION;
741 : 0 : s->method=TLSv1_1_client_method();
742 : : }
743 [ + - ][ + - ]: 200 : else if ((p[2] == TLS1_2_VERSION_MINOR) &&
744 : 200 : !(s->options & SSL_OP_NO_TLSv1_2))
745 : : {
746 : 200 : s->version=TLS1_2_VERSION;
747 : 200 : s->method=TLSv1_2_client_method();
748 : : }
749 : : else
750 : : {
751 : 0 : SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
752 : 0 : goto err;
753 : : }
754 : :
755 [ - + ]: 200 : if (!ssl_security(s, SSL_SECOP_VERSION, 0, s->version, NULL))
756 : : {
757 : 0 : SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_VERSION_TOO_LOW);
758 : 0 : goto err;
759 : : }
760 : :
761 [ - + ][ # # ]: 200 : if (p[0] == SSL3_RT_ALERT && p[5] != SSL3_AL_WARNING)
762 : : {
763 : : /* fatal alert */
764 : :
765 : 0 : void (*cb)(const SSL *ssl,int type,int val)=NULL;
766 : : int j;
767 : :
768 [ # # ]: 0 : if (s->info_callback != NULL)
769 : : cb=s->info_callback;
770 [ # # ]: 0 : else if (s->ctx->info_callback != NULL)
771 : 0 : cb=s->ctx->info_callback;
772 : :
773 : 0 : i=p[5];
774 [ # # ]: 0 : if (cb != NULL)
775 : : {
776 : 0 : j=(i<<8)|p[6];
777 : 0 : cb(s,SSL_CB_READ_ALERT,j);
778 : : }
779 : :
780 [ # # ]: 0 : if (s->msg_callback)
781 : : {
782 : 0 : s->msg_callback(0, s->version, SSL3_RT_HEADER, p, 5, s, s->msg_callback_arg);
783 : 0 : s->msg_callback(0, s->version, SSL3_RT_ALERT, p+5, 2, s, s->msg_callback_arg);
784 : : }
785 : :
786 : 0 : s->rwstate=SSL_NOTHING;
787 : 0 : SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_AD_REASON_OFFSET+p[6]);
788 : 0 : goto err;
789 : : }
790 : :
791 [ + - ]: 200 : if (!ssl_init_wbio_buffer(s,1)) goto err;
792 : :
793 : : /* we are in this state */
794 : 200 : s->state=SSL3_ST_CR_SRVR_HELLO_A;
795 : :
796 : : /* put the 7 bytes we have read into the input buffer
797 : : * for SSLv3 */
798 : 200 : s->rstate=SSL_ST_READ_HEADER;
799 : 200 : s->packet_length=n;
800 [ - + ]: 200 : if (s->s3->rbuf.buf == NULL)
801 [ # # ]: 0 : if (!ssl3_setup_read_buffer(s))
802 : : goto err;
803 : 200 : s->packet= &(s->s3->rbuf.buf[0]);
804 : 200 : memcpy(s->packet,buf,n);
805 : 200 : s->s3->rbuf.left=n;
806 : 200 : s->s3->rbuf.offset=0;
807 : :
808 : 200 : s->handshake_func=s->method->ssl_connect;
809 : : }
810 : : else
811 : : {
812 : 0 : SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNKNOWN_PROTOCOL);
813 : 0 : goto err;
814 : : }
815 : 200 : s->init_num=0;
816 : :
817 : : /* Since, if we are sending a ssl23 client hello, we are not
818 : : * reusing a session-id */
819 [ + - ]: 200 : if (!ssl_get_new_session(s,0))
820 : : goto err;
821 : :
822 : 200 : return(SSL_connect(s));
823 : : err:
824 : : return(-1);
825 : : }
|
