summaryrefslogtreecommitdiff
path: root/src/lib/libssl/s23_clnt.c
diff options
context:
space:
mode:
authorryker <>1998-10-05 20:13:14 +0000
committerryker <>1998-10-05 20:13:14 +0000
commitaeeae06a79815dc190061534d47236cec09f9e32 (patch)
tree851692b9c2f9c04f077666855641900f19fdb217 /src/lib/libssl/s23_clnt.c
parenta4f79641824cbf9f60ca9d1168d1fcc46717a82a (diff)
downloadopenbsd-aeeae06a79815dc190061534d47236cec09f9e32.tar.gz
openbsd-aeeae06a79815dc190061534d47236cec09f9e32.tar.bz2
openbsd-aeeae06a79815dc190061534d47236cec09f9e32.zip
Import of SSLeay-0.9.0b with RSA and IDEA stubbed + OpenBSD build
functionality for shared libs. Note that routines such as sslv2_init and friends that use RSA will not work due to lack of RSA in this library. Needs documentation and help from ports for easy upgrade to full functionality where legally possible.
Diffstat (limited to 'src/lib/libssl/s23_clnt.c')
-rw-r--r--src/lib/libssl/s23_clnt.c466
1 files changed, 466 insertions, 0 deletions
diff --git a/src/lib/libssl/s23_clnt.c b/src/lib/libssl/s23_clnt.c
new file mode 100644
index 0000000000..a4661ebb68
--- /dev/null
+++ b/src/lib/libssl/s23_clnt.c
@@ -0,0 +1,466 @@
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#include <stdio.h>
60#include "buffer.h"
61#include "rand.h"
62#include "objects.h"
63#include "evp.h"
64#include "ssl_locl.h"
65
66#define BREAK break
67
68#ifndef NOPROTO
69static int ssl23_client_hello(SSL *s);
70static int ssl23_get_server_hello(SSL *s);
71#else
72static int ssl23_client_hello();
73static int ssl23_get_server_hello();
74#endif
75
76static SSL_METHOD *ssl23_get_client_method(ver)
77int ver;
78 {
79 if (ver == SSL2_VERSION)
80 return(SSLv2_client_method());
81 else if (ver == SSL3_VERSION)
82 return(SSLv3_client_method());
83 else if (ver == TLS1_VERSION)
84 return(TLSv1_client_method());
85 else
86 return(NULL);
87 }
88
89SSL_METHOD *SSLv23_client_method()
90 {
91 static int init=1;
92 static SSL_METHOD SSLv23_client_data;
93
94 if (init)
95 {
96 init=0;
97 memcpy((char *)&SSLv23_client_data,
98 (char *)sslv23_base_method(),sizeof(SSL_METHOD));
99 SSLv23_client_data.ssl_connect=ssl23_connect;
100 SSLv23_client_data.get_ssl_method=ssl23_get_client_method;
101 }
102 return(&SSLv23_client_data);
103 }
104
105int ssl23_connect(s)
106SSL *s;
107 {
108 BUF_MEM *buf;
109 unsigned long Time=time(NULL);
110 void (*cb)()=NULL;
111 int ret= -1;
112 int new_state,state;
113
114 RAND_seed((unsigned char *)&Time,sizeof(Time));
115 ERR_clear_error();
116 clear_sys_error();
117
118 if (s->info_callback != NULL)
119 cb=s->info_callback;
120 else if (s->ctx->info_callback != NULL)
121 cb=s->ctx->info_callback;
122
123 if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s);
124 s->in_handshake++;
125
126 for (;;)
127 {
128 state=s->state;
129
130 switch(s->state)
131 {
132 case SSL_ST_BEFORE:
133 case SSL_ST_CONNECT:
134 case SSL_ST_BEFORE|SSL_ST_CONNECT:
135 case SSL_ST_OK|SSL_ST_CONNECT:
136
137 if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
138
139 /* s->version=TLS1_VERSION; */
140 s->type=SSL_ST_CONNECT;
141
142 if (s->init_buf == NULL)
143 {
144 if ((buf=BUF_MEM_new()) == NULL)
145 {
146 ret= -1;
147 goto end;
148 }
149 if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH))
150 {
151 ret= -1;
152 goto end;
153 }
154 s->init_buf=buf;
155 }
156
157 if (!ssl3_setup_buffers(s)) { ret= -1; goto end; }
158
159 ssl3_init_finished_mac(s);
160
161 s->state=SSL23_ST_CW_CLNT_HELLO_A;
162 s->ctx->sess_connect++;
163 s->init_num=0;
164 break;
165
166 case SSL23_ST_CW_CLNT_HELLO_A:
167 case SSL23_ST_CW_CLNT_HELLO_B:
168
169 s->shutdown=0;
170 ret=ssl23_client_hello(s);
171 if (ret <= 0) goto end;
172 s->state=SSL23_ST_CR_SRVR_HELLO_A;
173 s->init_num=0;
174
175 break;
176
177 case SSL23_ST_CR_SRVR_HELLO_A:
178 case SSL23_ST_CR_SRVR_HELLO_B:
179 ret=ssl23_get_server_hello(s);
180 if (ret >= 0) cb=NULL;
181 goto end;
182 break;
183
184 default:
185 SSLerr(SSL_F_SSL23_CONNECT,SSL_R_UNKNOWN_STATE);
186 ret= -1;
187 goto end;
188 /* break; */
189 }
190
191 if (s->debug) BIO_flush(s->wbio);
192
193 if ((cb != NULL) && (s->state != state))
194 {
195 new_state=s->state;
196 s->state=state;
197 cb(s,SSL_CB_CONNECT_LOOP,1);
198 s->state=new_state;
199 }
200 }
201end:
202 s->in_handshake--;
203 if (cb != NULL)
204 cb(s,SSL_CB_CONNECT_EXIT,ret);
205 return(ret);
206 }
207
208
209static int ssl23_client_hello(s)
210SSL *s;
211 {
212 unsigned char *buf;
213 unsigned char *p,*d;
214 int i,ch_len;
215
216 buf=(unsigned char *)s->init_buf->data;
217 if (s->state == SSL23_ST_CW_CLNT_HELLO_A)
218 {
219#if 0
220 /* don't reuse session-id's */
221 if (!ssl_get_new_session(s,0))
222 {
223 return(-1);
224 }
225#endif
226
227 p=s->s3->client_random;
228 RAND_bytes(p,SSL3_RANDOM_SIZE);
229
230 /* Do the message type and length last */
231 d= &(buf[2]);
232 p=d+9;
233
234 *(d++)=SSL2_MT_CLIENT_HELLO;
235 if (!(s->options & SSL_OP_NO_TLSv1))
236 {
237 *(d++)=TLS1_VERSION_MAJOR;
238 *(d++)=TLS1_VERSION_MINOR;
239 }
240 else if (!(s->options & SSL_OP_NO_SSLv3))
241 {
242 *(d++)=SSL3_VERSION_MAJOR;
243 *(d++)=SSL3_VERSION_MINOR;
244 }
245 else if (!(s->options & SSL_OP_NO_SSLv2))
246 {
247 *(d++)=SSL2_VERSION_MAJOR;
248 *(d++)=SSL2_VERSION_MINOR;
249 }
250 else
251 {
252 SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_PROTOCOLS_AVAILABLE);
253 return(-1);
254 }
255
256 /* Ciphers supported */
257 i=ssl_cipher_list_to_bytes(s,SSL_get_ciphers(s),p);
258 if (i == 0)
259 {
260 /* no ciphers */
261 SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_CIPHERS_AVAILABLE);
262 return(-1);
263 }
264 s2n(i,d);
265 p+=i;
266
267 /* put in the session-id, zero since there is no
268 * reuse. */
269#if 0
270 s->session->session_id_length=0;
271#endif
272 s2n(0,d);
273
274 if (s->options & SSL_OP_NETSCAPE_CHALLENGE_BUG)
275 ch_len=SSL2_CHALLENGE_LENGTH;
276 else
277 ch_len=SSL2_MAX_CHALLENGE_LENGTH;
278
279 /* write out sslv2 challenge */
280 if (SSL3_RANDOM_SIZE < ch_len)
281 i=SSL3_RANDOM_SIZE;
282 else
283 i=ch_len;
284 s2n(i,d);
285 memset(&(s->s3->client_random[0]),0,SSL3_RANDOM_SIZE);
286 RAND_bytes(&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i);
287 memcpy(p,&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i);
288 p+=i;
289
290 i= p- &(buf[2]);
291 buf[0]=((i>>8)&0xff)|0x80;
292 buf[1]=(i&0xff);
293
294 s->state=SSL23_ST_CW_CLNT_HELLO_B;
295 /* number of bytes to write */
296 s->init_num=i+2;
297 s->init_off=0;
298
299 ssl3_finish_mac(s,&(buf[2]),i);
300 }
301
302 /* SSL3_ST_CW_CLNT_HELLO_B */
303 return(ssl23_write_bytes(s));
304 }
305
306static int ssl23_get_server_hello(s)
307SSL *s;
308 {
309 char buf[8];
310 unsigned char *p;
311 int i,ch_len;
312 int n;
313
314 n=ssl23_read_bytes(s,7);
315
316 if (n != 7) return(n);
317 p=s->packet;
318
319 memcpy(buf,p,n);
320
321 if ((p[0] & 0x80) && (p[2] == SSL2_MT_SERVER_HELLO) &&
322 (p[5] == 0x00) && (p[6] == 0x02))
323 {
324 /* we are talking sslv2 */
325 /* we need to clean up the SSLv3 setup and put in the
326 * sslv2 stuff. */
327
328 if (s->options & SSL_OP_NO_SSLv2)
329 {
330 SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
331 goto err;
332 }
333 if (s->s2 == NULL)
334 {
335 if (!ssl2_new(s))
336 goto err;
337 }
338 else
339 ssl2_clear(s);
340
341 if (s->options & SSL_OP_NETSCAPE_CHALLENGE_BUG)
342 ch_len=SSL2_CHALLENGE_LENGTH;
343 else
344 ch_len=SSL2_MAX_CHALLENGE_LENGTH;
345
346 /* write out sslv2 challenge */
347 i=(SSL3_RANDOM_SIZE < ch_len)
348 ?SSL3_RANDOM_SIZE:ch_len;
349 s->s2->challenge_length=i;
350 memcpy(s->s2->challenge,
351 &(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i);
352
353 if (s->s3 != NULL) ssl3_free(s);
354
355 if (!BUF_MEM_grow(s->init_buf,
356 SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER))
357 {
358 SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,ERR_R_BUF_LIB);
359 goto err;
360 }
361
362 s->state=SSL2_ST_GET_SERVER_HELLO_A;
363 s->s2->ssl2_rollback=1;
364
365 /* setup the 5 bytes we have read so we get them from
366 * the sslv2 buffer */
367 s->rstate=SSL_ST_READ_HEADER;
368 s->packet_length=n;
369 s->packet= &(s->s2->rbuf[0]);
370 memcpy(s->packet,buf,n);
371 s->s2->rbuf_left=n;
372 s->s2->rbuf_offs=0;
373
374 /* we have already written one */
375 s->s2->write_sequence=1;
376
377 s->method=SSLv2_client_method();
378 s->handshake_func=s->method->ssl_connect;
379 }
380 else if ((p[0] == SSL3_RT_HANDSHAKE) &&
381 (p[1] == SSL3_VERSION_MAJOR) &&
382 ((p[2] == SSL3_VERSION_MINOR) ||
383 (p[2] == TLS1_VERSION_MINOR)) &&
384 (p[5] == SSL3_MT_SERVER_HELLO))
385 {
386 /* we have sslv3 or tls1 */
387
388 if (!ssl_init_wbio_buffer(s,1)) goto err;
389
390 /* we are in this state */
391 s->state=SSL3_ST_CR_SRVR_HELLO_A;
392
393 /* put the 5 bytes we have read into the input buffer
394 * for SSLv3 */
395 s->rstate=SSL_ST_READ_HEADER;
396 s->packet_length=n;
397 s->packet= &(s->s3->rbuf.buf[0]);
398 memcpy(s->packet,buf,n);
399 s->s3->rbuf.left=n;
400 s->s3->rbuf.offset=0;
401
402 if ((p[2] == SSL3_VERSION_MINOR) &&
403 !(s->options & SSL_OP_NO_SSLv3))
404 {
405 s->version=SSL3_VERSION;
406 s->method=SSLv3_client_method();
407 }
408 else if ((p[2] == TLS1_VERSION_MINOR) &&
409 !(s->options & SSL_OP_NO_TLSv1))
410 {
411 s->version=TLS1_VERSION;
412 s->method=TLSv1_client_method();
413 }
414 else
415 {
416 SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_PROTOCOL);
417 goto err;
418 }
419
420 s->handshake_func=s->method->ssl_connect;
421 }
422 else if ((p[0] == SSL3_RT_ALERT) &&
423 (p[1] == SSL3_VERSION_MAJOR) &&
424 ((p[2] == SSL3_VERSION_MINOR) ||
425 (p[2] == TLS1_VERSION_MINOR)) &&
426 (p[3] == 0) &&
427 (p[4] == 2))
428 {
429 void (*cb)()=NULL;
430 int j;
431
432 /* An alert */
433 if (s->info_callback != NULL)
434 cb=s->info_callback;
435 else if (s->ctx->info_callback != NULL)
436 cb=s->ctx->info_callback;
437
438 i=p[5];
439 if (cb != NULL)
440 {
441 j=(i<<8)|p[6];
442 cb(s,SSL_CB_READ_ALERT,j);
443 }
444
445 s->rwstate=SSL_NOTHING;
446 SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,1000+p[6]);
447 goto err;
448 }
449 else
450 {
451 SSLerr(SSL_F_SSL23_GET_SERVER_HELLO,SSL_R_UNKNOWN_PROTOCOL);
452 goto err;
453 }
454 s->init_num=0;
455
456 /* Since, if we are sending a ssl23 client hello, we are not
457 * reusing a session-id */
458 if (!ssl_get_new_session(s,0))
459 goto err;
460
461 s->first_packet=1;
462 return(SSL_connect(s));
463err:
464 return(-1);
465 }
466