Branch data Line data Source code
1 : : /* ssl/s23_srvr.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 : : #ifdef OPENSSL_FIPS
119 : : #include <openssl/fips.h>
120 : : #endif
121 : :
122 : : static const SSL_METHOD *ssl23_get_server_method(int ver);
123 : : int ssl23_get_client_hello(SSL *s);
124 : 0 : static const SSL_METHOD *ssl23_get_server_method(int ver)
125 : : {
126 : : #ifndef OPENSSL_NO_SSL2
127 [ # # ]: 0 : if (ver == SSL2_VERSION)
128 : 0 : return(SSLv2_server_method());
129 : : #endif
130 [ # # ]: 0 : if (ver == SSL3_VERSION)
131 : 0 : return(SSLv3_server_method());
132 [ # # ]: 0 : else if (ver == TLS1_VERSION)
133 : 0 : return(TLSv1_server_method());
134 [ # # ]: 0 : else if (ver == TLS1_1_VERSION)
135 : 0 : return(TLSv1_1_server_method());
136 [ # # ]: 0 : else if (ver == TLS1_2_VERSION)
137 : 0 : return(TLSv1_2_server_method());
138 : : else
139 : : return(NULL);
140 : : }
141 : :
142 : 22 : IMPLEMENT_ssl23_meth_func(SSLv23_server_method,
143 : : ssl23_accept,
144 : : ssl_undefined_function,
145 : : ssl23_get_server_method)
146 : :
147 : 464 : int ssl23_accept(SSL *s)
148 : : {
149 : : BUF_MEM *buf;
150 : 464 : unsigned long Time=(unsigned long)time(NULL);
151 : 464 : void (*cb)(const SSL *ssl,int type,int val)=NULL;
152 : 464 : int ret= -1;
153 : : int new_state,state;
154 : :
155 : 464 : RAND_add(&Time,sizeof(Time),0);
156 : 464 : ERR_clear_error();
157 : 464 : clear_sys_error();
158 : :
159 [ + - ]: 464 : if (s->info_callback != NULL)
160 : : cb=s->info_callback;
161 [ - + ]: 464 : else if (s->ctx->info_callback != NULL)
162 : 0 : cb=s->ctx->info_callback;
163 : :
164 : 464 : s->in_handshake++;
165 [ + - ][ + + ]: 664 : if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s);
166 : :
167 : : for (;;)
168 : : {
169 : 664 : state=s->state;
170 : :
171 [ + + - ]: 664 : switch(s->state)
172 : : {
173 : : case SSL_ST_BEFORE:
174 : : case SSL_ST_ACCEPT:
175 : : case SSL_ST_BEFORE|SSL_ST_ACCEPT:
176 : : case SSL_ST_OK|SSL_ST_ACCEPT:
177 : :
178 : 200 : s->server=1;
179 [ - + ]: 200 : if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
180 : :
181 : : /* s->version=SSL3_VERSION; */
182 : 200 : s->type=SSL_ST_ACCEPT;
183 : :
184 [ + - ]: 200 : if (s->init_buf == NULL)
185 : : {
186 [ + - ]: 200 : if ((buf=BUF_MEM_new()) == NULL)
187 : : {
188 : : ret= -1;
189 : : goto end;
190 : : }
191 [ + - ]: 200 : if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH))
192 : : {
193 : : ret= -1;
194 : : goto end;
195 : : }
196 : 200 : s->init_buf=buf;
197 : : }
198 : :
199 : 200 : ssl3_init_finished_mac(s);
200 : :
201 : 200 : s->state=SSL23_ST_SR_CLNT_HELLO_A;
202 : 200 : s->ctx->stats.sess_accept++;
203 : 200 : s->init_num=0;
204 : : break;
205 : :
206 : : case SSL23_ST_SR_CLNT_HELLO_A:
207 : : case SSL23_ST_SR_CLNT_HELLO_B:
208 : :
209 : 464 : s->shutdown=0;
210 : 464 : ret=ssl23_get_client_hello(s);
211 [ - + ]: 464 : if (ret >= 0) cb=NULL;
212 : : goto end;
213 : : /* break; */
214 : :
215 : : default:
216 : 0 : SSLerr(SSL_F_SSL23_ACCEPT,SSL_R_UNKNOWN_STATE);
217 : 0 : ret= -1;
218 : 0 : goto end;
219 : : /* break; */
220 : : }
221 : :
222 [ + - ][ # # ]: 200 : if ((cb != NULL) && (s->state != state))
223 : : {
224 : 0 : new_state=s->state;
225 : 0 : s->state=state;
226 : 0 : cb(s,SSL_CB_ACCEPT_LOOP,1);
227 : 0 : s->state=new_state;
228 : : }
229 : : }
230 : : end:
231 : 464 : s->in_handshake--;
232 [ - + ]: 464 : if (cb != NULL)
233 : 0 : cb(s,SSL_CB_ACCEPT_EXIT,ret);
234 : 464 : return(ret);
235 : : }
236 : :
237 : :
238 : 464 : int ssl23_get_client_hello(SSL *s)
239 : : {
240 : : char buf_space[11]; /* Request this many bytes in initial read.
241 : : * We can detect SSL 3.0/TLS 1.0 Client Hellos
242 : : * ('type == 3') correctly only when the following
243 : : * is in a single record, which is not guaranteed by
244 : : * the protocol specification:
245 : : * Byte Content
246 : : * 0 type \
247 : : * 1/2 version > record header
248 : : * 3/4 length /
249 : : * 5 msg_type \
250 : : * 6-8 length > Client Hello message
251 : : * 9/10 client_version /
252 : : */
253 : 464 : char *buf= &(buf_space[0]);
254 : : unsigned char *p,*d,*d_len,*dd;
255 : : unsigned int i;
256 : : unsigned int csl,sil,cl;
257 : 464 : int n=0,j;
258 : 464 : int type=0;
259 : : int v[2];
260 : :
261 [ + - ]: 464 : if (s->state == SSL23_ST_SR_CLNT_HELLO_A)
262 : : {
263 : : /* read the initial header */
264 : 464 : v[0]=v[1]=0;
265 : :
266 [ + - ]: 464 : if (!ssl3_setup_buffers(s)) goto err;
267 : :
268 : 464 : n=ssl23_read_bytes(s, sizeof buf_space);
269 [ + + ]: 464 : if (n != sizeof buf_space) return(n); /* n == -1 || n == 0 */
270 : :
271 : 200 : p=s->packet;
272 : :
273 : 200 : memcpy(buf,p,n);
274 : :
275 [ - + ][ # # ]: 200 : if ((p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO))
276 : : {
277 : : /*
278 : : * SSLv2 header
279 : : */
280 [ # # ][ # # ]: 0 : if ((p[3] == 0x00) && (p[4] == 0x02))
281 : : {
282 : 0 : v[0]=p[3]; v[1]=p[4];
283 : : /* SSLv2 */
284 [ # # ]: 0 : if (!(s->options & SSL_OP_NO_SSLv2))
285 : 0 : type=1;
286 : : }
287 [ # # ]: 0 : else if (p[3] == SSL3_VERSION_MAJOR)
288 : : {
289 : 0 : v[0]=p[3]; v[1]=p[4];
290 : : /* SSLv3/TLSv1 */
291 [ # # ]: 0 : if (p[4] >= TLS1_VERSION_MINOR)
292 : : {
293 [ # # ][ # # ]: 0 : if (p[4] >= TLS1_2_VERSION_MINOR &&
294 : 0 : !(s->options & SSL_OP_NO_TLSv1_2))
295 : : {
296 : 0 : s->version=TLS1_2_VERSION;
297 : 0 : s->state=SSL23_ST_SR_CLNT_HELLO_B;
298 : : }
299 [ # # ][ # # ]: 0 : else if (p[4] >= TLS1_1_VERSION_MINOR &&
300 : 0 : !(s->options & SSL_OP_NO_TLSv1_1))
301 : : {
302 : 0 : s->version=TLS1_1_VERSION;
303 : : /* type=2; */ /* done later to survive restarts */
304 : 0 : s->state=SSL23_ST_SR_CLNT_HELLO_B;
305 : : }
306 [ # # ]: 0 : else if (!(s->options & SSL_OP_NO_TLSv1))
307 : : {
308 : 0 : s->version=TLS1_VERSION;
309 : : /* type=2; */ /* done later to survive restarts */
310 : 0 : s->state=SSL23_ST_SR_CLNT_HELLO_B;
311 : : }
312 [ # # ]: 0 : else if (!(s->options & SSL_OP_NO_SSLv3))
313 : : {
314 : 0 : s->version=SSL3_VERSION;
315 : : /* type=2; */
316 : 0 : s->state=SSL23_ST_SR_CLNT_HELLO_B;
317 : : }
318 [ # # ]: 0 : else if (!(s->options & SSL_OP_NO_SSLv2))
319 : : {
320 : 0 : type=1;
321 : : }
322 : : }
323 [ # # ]: 0 : else if (!(s->options & SSL_OP_NO_SSLv3))
324 : : {
325 : 0 : s->version=SSL3_VERSION;
326 : : /* type=2; */
327 : 0 : s->state=SSL23_ST_SR_CLNT_HELLO_B;
328 : : }
329 [ # # ]: 0 : else if (!(s->options & SSL_OP_NO_SSLv2))
330 : 0 : type=1;
331 : :
332 : : }
333 : : }
334 [ + - ][ + - ]: 200 : else if ((p[0] == SSL3_RT_HANDSHAKE) &&
335 [ + - ]: 200 : (p[1] == SSL3_VERSION_MAJOR) &&
336 [ + + ]: 200 : (p[5] == SSL3_MT_CLIENT_HELLO) &&
337 [ + - ]: 79 : ((p[3] == 0 && p[4] < 5 /* silly record length? */)
338 [ + - ]: 200 : || (p[9] >= p[1])))
339 : : {
340 : : /*
341 : : * SSLv3 or tls1 header
342 : : */
343 : :
344 : 200 : v[0]=p[1]; /* major version (= SSL3_VERSION_MAJOR) */
345 : : /* We must look at client_version inside the Client Hello message
346 : : * to get the correct minor version.
347 : : * However if we have only a pathologically small fragment of the
348 : : * Client Hello message, this would be difficult, and we'd have
349 : : * to read more records to find out.
350 : : * No known SSL 3.0 client fragments ClientHello like this,
351 : : * so we simply assume TLS 1.0 to avoid protocol version downgrade
352 : : * attacks. */
353 [ + + ][ + - ]: 200 : if (p[3] == 0 && p[4] < 6)
354 : : {
355 : : #if 0
356 : : SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_SMALL);
357 : : goto err;
358 : : #else
359 : : v[1] = TLS1_VERSION_MINOR;
360 : : #endif
361 : : }
362 : : /* if major version number > 3 set minor to a value
363 : : * which will use the highest version 3 we support.
364 : : * If TLS 2.0 ever appears we will need to revise
365 : : * this....
366 : : */
367 [ + - ]: 200 : else if (p[9] > SSL3_VERSION_MAJOR)
368 : : v[1]=0xff;
369 : : else
370 : 200 : v[1]=p[10]; /* minor version according to client_version */
371 [ + - ]: 200 : if (v[1] >= TLS1_VERSION_MINOR)
372 : : {
373 [ + - ][ + - ]: 200 : if (v[1] >= TLS1_2_VERSION_MINOR &&
374 : 200 : !(s->options & SSL_OP_NO_TLSv1_2))
375 : : {
376 : 200 : s->version=TLS1_2_VERSION;
377 : 200 : type=3;
378 : : }
379 [ # # ][ # # ]: 0 : else if (v[1] >= TLS1_1_VERSION_MINOR &&
380 : 0 : !(s->options & SSL_OP_NO_TLSv1_1))
381 : : {
382 : 0 : s->version=TLS1_1_VERSION;
383 : 0 : type=3;
384 : : }
385 [ # # ]: 0 : else if (!(s->options & SSL_OP_NO_TLSv1))
386 : : {
387 : 0 : s->version=TLS1_VERSION;
388 : 0 : type=3;
389 : : }
390 [ # # ]: 0 : else if (!(s->options & SSL_OP_NO_SSLv3))
391 : : {
392 : 0 : s->version=SSL3_VERSION;
393 : 0 : type=3;
394 : : }
395 : : }
396 : : else
397 : : {
398 : : /* client requests SSL 3.0 */
399 [ # # ]: 0 : if (!(s->options & SSL_OP_NO_SSLv3))
400 : : {
401 : 0 : s->version=SSL3_VERSION;
402 : 0 : type=3;
403 : : }
404 [ # # ]: 0 : else if (!(s->options & SSL_OP_NO_TLSv1))
405 : : {
406 : : /* we won't be able to use TLS of course,
407 : : * but this will send an appropriate alert */
408 : 0 : s->version=TLS1_VERSION;
409 : 0 : type=3;
410 : : }
411 : : }
412 : : }
413 [ # # ][ # # ]: 0 : else if ((strncmp("GET ", (char *)p,4) == 0) ||
414 [ # # ]: 0 : (strncmp("POST ",(char *)p,5) == 0) ||
415 [ # # ]: 0 : (strncmp("HEAD ",(char *)p,5) == 0) ||
416 : 0 : (strncmp("PUT ", (char *)p,4) == 0))
417 : : {
418 : 0 : SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTP_REQUEST);
419 : 0 : goto err;
420 : : }
421 [ # # ]: 0 : else if (strncmp("CONNECT",(char *)p,7) == 0)
422 : : {
423 : 0 : SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTPS_PROXY_REQUEST);
424 : 0 : goto err;
425 : : }
426 : : }
427 : :
428 [ - + ][ # # ]: 200 : if (s->version < TLS1_2_VERSION && tls1_suiteb(s))
429 : : {
430 : 0 : SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,
431 : : SSL_R_ONLY_TLS_1_2_ALLOWED_IN_SUITEB_MODE);
432 : 0 : goto err;
433 : : }
434 : :
435 : : #ifdef OPENSSL_FIPS
436 : : if (FIPS_mode() && (s->version < TLS1_VERSION))
437 : : {
438 : : SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,
439 : : SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
440 : : goto err;
441 : : }
442 : : #endif
443 : :
444 [ - + ]: 200 : if (!ssl_security(s, SSL_SECOP_VERSION, 0, s->version, NULL))
445 : : {
446 : 0 : SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_VERSION_TOO_LOW);
447 : 0 : goto err;
448 : : }
449 : :
450 [ - + ]: 200 : if (s->state == SSL23_ST_SR_CLNT_HELLO_B)
451 : : {
452 : : /* we have SSLv3/TLSv1 in an SSLv2 header
453 : : * (other cases skip this state) */
454 : :
455 : 0 : type=2;
456 : 0 : p=s->packet;
457 : 0 : v[0] = p[3]; /* == SSL3_VERSION_MAJOR */
458 : 0 : v[1] = p[4];
459 : :
460 : 0 : n=((p[0]&0x7f)<<8)|p[1];
461 [ # # ]: 0 : if (n > (1024*4))
462 : : {
463 : 0 : SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_LARGE);
464 : 0 : goto err;
465 : : }
466 : :
467 : 0 : j=ssl23_read_bytes(s,n+2);
468 [ # # ]: 0 : if (j <= 0) return(j);
469 : :
470 : 0 : ssl3_finish_mac(s, s->packet+2, s->packet_length-2);
471 [ # # ]: 0 : if (s->msg_callback)
472 : 0 : s->msg_callback(0, SSL2_VERSION, 0, s->packet+2, s->packet_length-2, s, s->msg_callback_arg); /* CLIENT-HELLO */
473 : :
474 : 0 : p=s->packet;
475 : 0 : p+=5;
476 : 0 : n2s(p,csl);
477 : 0 : n2s(p,sil);
478 : 0 : n2s(p,cl);
479 : 0 : d=(unsigned char *)s->init_buf->data;
480 [ # # ]: 0 : if ((csl+sil+cl+11) != s->packet_length) /* We can't have TLS extensions in SSL 2.0 format
481 : : * Client Hello, can we? Error condition should be
482 : : * '>' otherweise */
483 : : {
484 : 0 : SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_LENGTH_MISMATCH);
485 : 0 : goto err;
486 : : }
487 : :
488 : : /* record header: msg_type ... */
489 : 0 : *(d++) = SSL3_MT_CLIENT_HELLO;
490 : : /* ... and length (actual value will be written later) */
491 : 0 : d_len = d;
492 : 0 : d += 3;
493 : :
494 : : /* client_version */
495 : 0 : *(d++) = SSL3_VERSION_MAJOR; /* == v[0] */
496 : 0 : *(d++) = v[1];
497 : :
498 : : /* lets populate the random area */
499 : : /* get the challenge_length */
500 : 0 : i=(cl > SSL3_RANDOM_SIZE)?SSL3_RANDOM_SIZE:cl;
501 : : memset(d,0,SSL3_RANDOM_SIZE);
502 : 0 : memcpy(&(d[SSL3_RANDOM_SIZE-i]),&(p[csl+sil]),i);
503 : 0 : d+=SSL3_RANDOM_SIZE;
504 : :
505 : : /* no session-id reuse */
506 : 0 : *(d++)=0;
507 : :
508 : : /* ciphers */
509 : 0 : j=0;
510 : 0 : dd=d;
511 : 0 : d+=2;
512 [ # # ]: 0 : for (i=0; i<csl; i+=3)
513 : : {
514 [ # # ]: 0 : if (p[i] != 0) continue;
515 : 0 : *(d++)=p[i+1];
516 : 0 : *(d++)=p[i+2];
517 : 0 : j+=2;
518 : : }
519 : 0 : s2n(j,dd);
520 : :
521 : : /* COMPRESSION */
522 : 0 : *(d++)=1;
523 : 0 : *(d++)=0;
524 : :
525 : : #if 0
526 : : /* copy any remaining data with may be extensions */
527 : : p = p+csl+sil+cl;
528 : : while (p < s->packet+s->packet_length)
529 : : {
530 : : *(d++)=*(p++);
531 : : }
532 : : #endif
533 : :
534 : 0 : i = (d-(unsigned char *)s->init_buf->data) - 4;
535 : 0 : l2n3((long)i, d_len);
536 : :
537 : : /* get the data reused from the init_buf */
538 : 0 : s->s3->tmp.reuse_message=1;
539 : 0 : s->s3->tmp.message_type=SSL3_MT_CLIENT_HELLO;
540 : 0 : s->s3->tmp.message_size=i;
541 : : }
542 : :
543 : : /* imaginary new state (for program structure): */
544 : : /* s->state = SSL23_SR_CLNT_HELLO_C */
545 : :
546 [ - + ]: 200 : if (type == 1)
547 : : {
548 : : #ifdef OPENSSL_NO_SSL2
549 : : SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
550 : : goto err;
551 : : #else
552 : : /* we are talking sslv2 */
553 : : /* we need to clean up the SSLv3/TLSv1 setup and put in the
554 : : * sslv2 stuff. */
555 : :
556 [ # # ]: 0 : if (s->s2 == NULL)
557 : : {
558 [ # # ]: 0 : if (!ssl2_new(s))
559 : : goto err;
560 : : }
561 : : else
562 : 0 : ssl2_clear(s);
563 : :
564 [ # # ]: 0 : if (s->s3 != NULL) ssl3_free(s);
565 : :
566 [ # # ]: 0 : if (!BUF_MEM_grow_clean(s->init_buf,
567 : : SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER))
568 : : {
569 : : goto err;
570 : : }
571 : :
572 : 0 : s->state=SSL2_ST_GET_CLIENT_HELLO_A;
573 [ # # ]: 0 : if (s->options & SSL_OP_NO_TLSv1 && s->options & SSL_OP_NO_SSLv3)
574 : 0 : s->s2->ssl2_rollback=0;
575 : : else
576 : : /* reject SSL 2.0 session if client supports SSL 3.0 or TLS 1.0
577 : : * (SSL 3.0 draft/RFC 2246, App. E.2) */
578 : 0 : s->s2->ssl2_rollback=1;
579 : :
580 : : /* setup the n bytes we have read so we get them from
581 : : * the sslv2 buffer */
582 : 0 : s->rstate=SSL_ST_READ_HEADER;
583 : 0 : s->packet_length=n;
584 : 0 : s->packet= &(s->s2->rbuf[0]);
585 : 0 : memcpy(s->packet,buf,n);
586 : 0 : s->s2->rbuf_left=n;
587 : 0 : s->s2->rbuf_offs=0;
588 : :
589 : 0 : s->method=SSLv2_server_method();
590 : 0 : s->handshake_func=s->method->ssl_accept;
591 : : #endif
592 : : }
593 : :
594 [ + - ]: 200 : if ((type == 2) || (type == 3))
595 : : {
596 : : /* we have SSLv3/TLSv1 (type 2: SSL2 style, type 3: SSL3/TLS style) */
597 : :
598 [ + - ]: 200 : if (!ssl_init_wbio_buffer(s,1)) goto err;
599 : :
600 : : /* we are in this state */
601 : 200 : s->state=SSL3_ST_SR_CLNT_HELLO_A;
602 : :
603 [ + - ]: 200 : if (type == 3)
604 : : {
605 : : /* put the 'n' bytes we have read into the input buffer
606 : : * for SSLv3 */
607 : 200 : s->rstate=SSL_ST_READ_HEADER;
608 : 200 : s->packet_length=n;
609 [ - + ]: 200 : if (s->s3->rbuf.buf == NULL)
610 [ # # ]: 0 : if (!ssl3_setup_read_buffer(s))
611 : : goto err;
612 : :
613 : 200 : s->packet= &(s->s3->rbuf.buf[0]);
614 : 200 : memcpy(s->packet,buf,n);
615 : 200 : s->s3->rbuf.left=n;
616 : 200 : s->s3->rbuf.offset=0;
617 : : }
618 : : else
619 : : {
620 : 0 : s->packet_length=0;
621 : 0 : s->s3->rbuf.left=0;
622 : 0 : s->s3->rbuf.offset=0;
623 : : }
624 [ + - ]: 200 : if (s->version == TLS1_2_VERSION)
625 : 200 : s->method = TLSv1_2_server_method();
626 [ # # ]: 0 : else if (s->version == TLS1_1_VERSION)
627 : 0 : s->method = TLSv1_1_server_method();
628 [ # # ]: 0 : else if (s->version == TLS1_VERSION)
629 : 0 : s->method = TLSv1_server_method();
630 : : else
631 : 0 : s->method = SSLv3_server_method();
632 : : #if 0 /* ssl3_get_client_hello does this */
633 : : s->client_version=(v[0]<<8)|v[1];
634 : : #endif
635 : 200 : s->handshake_func=s->method->ssl_accept;
636 : : }
637 : :
638 [ - + ]: 200 : if ((type < 1) || (type > 3))
639 : : {
640 : : /* bad, very bad */
641 : 0 : SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_UNKNOWN_PROTOCOL);
642 : 0 : goto err;
643 : : }
644 : 200 : s->init_num=0;
645 : :
646 : : if (buf != buf_space) OPENSSL_free(buf);
647 : 200 : return(SSL_accept(s));
648 : : err:
649 : : if (buf != buf_space) OPENSSL_free(buf);
650 : : return(-1);
651 : : }
|
