summaryrefslogtreecommitdiff
path: root/src/lib/libssl/s23_srvr.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_srvr.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_srvr.c')
-rw-r--r--src/lib/libssl/s23_srvr.c499
1 files changed, 499 insertions, 0 deletions
diff --git a/src/lib/libssl/s23_srvr.c b/src/lib/libssl/s23_srvr.c
new file mode 100644
index 0000000000..c7b9ecbcf2
--- /dev/null
+++ b/src/lib/libssl/s23_srvr.c
@@ -0,0 +1,499 @@
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#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
69int ssl23_get_client_hello(SSL *s);
70#else
71int ssl23_get_client_hello();
72#endif
73
74static SSL_METHOD *ssl23_get_server_method(ver)
75int ver;
76 {
77 if (ver == SSL2_VERSION)
78 return(SSLv2_server_method());
79 else if (ver == SSL3_VERSION)
80 return(SSLv3_server_method());
81 else if (ver == TLS1_VERSION)
82 return(TLSv1_server_method());
83 else
84 return(NULL);
85 }
86
87SSL_METHOD *SSLv23_server_method()
88 {
89 static int init=1;
90 static SSL_METHOD SSLv23_server_data;
91
92 if (init)
93 {
94 init=0;
95 memcpy((char *)&SSLv23_server_data,
96 (char *)sslv23_base_method(),sizeof(SSL_METHOD));
97 SSLv23_server_data.ssl_accept=ssl23_accept;
98 SSLv23_server_data.get_ssl_method=ssl23_get_server_method;
99 }
100 return(&SSLv23_server_data);
101 }
102
103int ssl23_accept(s)
104SSL *s;
105 {
106 BUF_MEM *buf;
107 unsigned long Time=time(NULL);
108 void (*cb)()=NULL;
109 int ret= -1;
110 int new_state,state;
111
112 RAND_seed((unsigned char *)&Time,sizeof(Time));
113 ERR_clear_error();
114 clear_sys_error();
115
116 if (s->info_callback != NULL)
117 cb=s->info_callback;
118 else if (s->ctx->info_callback != NULL)
119 cb=s->ctx->info_callback;
120
121 if (!SSL_in_init(s) || SSL_in_before(s)) SSL_clear(s);
122 s->in_handshake++;
123
124 for (;;)
125 {
126 state=s->state;
127
128 switch(s->state)
129 {
130 case SSL_ST_BEFORE:
131 case SSL_ST_ACCEPT:
132 case SSL_ST_BEFORE|SSL_ST_ACCEPT:
133 case SSL_ST_OK|SSL_ST_ACCEPT:
134
135 if (cb != NULL) cb(s,SSL_CB_HANDSHAKE_START,1);
136
137 /* s->version=SSL3_VERSION; */
138 s->type=SSL_ST_ACCEPT;
139
140 if (s->init_buf == NULL)
141 {
142 if ((buf=BUF_MEM_new()) == NULL)
143 {
144 ret= -1;
145 goto end;
146 }
147 if (!BUF_MEM_grow(buf,SSL3_RT_MAX_PLAIN_LENGTH))
148 {
149 ret= -1;
150 goto end;
151 }
152 s->init_buf=buf;
153 }
154
155 ssl3_init_finished_mac(s);
156
157 s->state=SSL23_ST_SR_CLNT_HELLO_A;
158 s->ctx->sess_accept++;
159 s->init_num=0;
160 break;
161
162 case SSL23_ST_SR_CLNT_HELLO_A:
163 case SSL23_ST_SR_CLNT_HELLO_B:
164
165 s->shutdown=0;
166 ret=ssl23_get_client_hello(s);
167 if (ret >= 0) cb=NULL;
168 goto end;
169 break;
170
171 default:
172 SSLerr(SSL_F_SSL23_ACCEPT,SSL_R_UNKNOWN_STATE);
173 ret= -1;
174 goto end;
175 /* break; */
176 }
177
178 if ((cb != NULL) && (s->state != state))
179 {
180 new_state=s->state;
181 s->state=state;
182 cb(s,SSL_CB_ACCEPT_LOOP,1);
183 s->state=new_state;
184 }
185 }
186end:
187 if (cb != NULL)
188 cb(s,SSL_CB_ACCEPT_EXIT,ret);
189 s->in_handshake--;
190 return(ret);
191 }
192
193
194int ssl23_get_client_hello(s)
195SSL *s;
196 {
197 char buf_space[8];
198 char *buf= &(buf_space[0]);
199 unsigned char *p,*d,*dd;
200 unsigned int i;
201 unsigned int csl,sil,cl;
202 int n=0,j,tls1=0;
203 int type=0,use_sslv2_strong=0;
204
205 /* read the initial header */
206 if (s->state == SSL23_ST_SR_CLNT_HELLO_A)
207 {
208 if (!ssl3_setup_buffers(s)) goto err;
209
210 n=ssl23_read_bytes(s,7);
211 if (n != 7) return(n);
212
213 p=s->packet;
214
215 memcpy(buf,p,n);
216
217 if ((p[0] & 0x80) && (p[2] == SSL2_MT_CLIENT_HELLO))
218 {
219 /* SSLv2 header */
220 if ((p[3] == 0x00) && (p[4] == 0x02))
221 {
222 /* SSLv2 */
223 if (!(s->options & SSL_OP_NO_SSLv2))
224 type=1;
225 }
226 else if (p[3] == SSL3_VERSION_MAJOR)
227 {
228 /* SSLv3/TLSv1 */
229 if (p[4] >= TLS1_VERSION_MINOR)
230 {
231 if (!(s->options & SSL_OP_NO_TLSv1))
232 {
233 tls1=1;
234 s->state=SSL23_ST_SR_CLNT_HELLO_B;
235 }
236 else if (!(s->options & SSL_OP_NO_SSLv3))
237 {
238 s->state=SSL23_ST_SR_CLNT_HELLO_B;
239 }
240 }
241 else if (!(s->options & SSL_OP_NO_SSLv3))
242 s->state=SSL23_ST_SR_CLNT_HELLO_B;
243
244 if (s->options & SSL_OP_NON_EXPORT_FIRST)
245 {
246 STACK *sk;
247 SSL_CIPHER *c;
248 int ne2,ne3;
249
250 j=((p[0]&0x7f)<<8)|p[1];
251 if (j > (1024*4))
252 {
253 SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_LARGE);
254 goto err;
255 }
256
257 n=ssl23_read_bytes(s,j+2);
258 if (n <= 0) return(n);
259 p=s->packet;
260
261 if ((buf=Malloc(n)) == NULL)
262 {
263 SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,ERR_R_MALLOC_FAILURE);
264 goto err;
265 }
266 memcpy(buf,p,n);
267
268 p+=5;
269 n2s(p,csl);
270 p+=4;
271
272 sk=ssl_bytes_to_cipher_list(
273 s,p,csl,NULL);
274 if (sk != NULL)
275 {
276 ne2=ne3=0;
277 for (j=0; j<sk_num(sk); j++)
278 {
279 c=(SSL_CIPHER *)sk_value(sk,j);
280 if (!(c->algorithms & SSL_EXP))
281 {
282 if ((c->id>>24L) == 2L)
283 ne2=1;
284 else
285 ne3=1;
286 }
287 }
288 if (ne2 && !ne3)
289 {
290 type=1;
291 use_sslv2_strong=1;
292 goto next_bit;
293 }
294 }
295 }
296 }
297 }
298 else if ((p[0] == SSL3_RT_HANDSHAKE) &&
299 (p[1] == SSL3_VERSION_MAJOR) &&
300 (p[5] == SSL3_MT_CLIENT_HELLO))
301 {
302 /* true SSLv3 or tls1 */
303 if (p[2] >= TLS1_VERSION_MINOR)
304 {
305 if (!(s->options & SSL_OP_NO_TLSv1))
306 {
307 type=3;
308 tls1=1;
309 }
310 else if (!(s->options & SSL_OP_NO_SSLv3))
311 type=3;
312 }
313 else if (!(s->options & SSL_OP_NO_SSLv3))
314 type=3;
315 }
316 else if ((strncmp("GET ", p,4) == 0) ||
317 (strncmp("POST ",p,5) == 0) ||
318 (strncmp("HEAD ",p,5) == 0) ||
319 (strncmp("PUT ", p,4) == 0))
320 {
321 SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTP_REQUEST);
322 goto err;
323 }
324 else if (strncmp("CONNECT",p,7) == 0)
325 {
326 SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_HTTPS_PROXY_REQUEST);
327 goto err;
328 }
329 }
330
331next_bit:
332 if (s->state == SSL23_ST_SR_CLNT_HELLO_B)
333 {
334 /* we have a SSLv3/TLSv1 in a SSLv2 header */
335 type=2;
336 p=s->packet;
337 n=((p[0]&0x7f)<<8)|p[1];
338 if (n > (1024*4))
339 {
340 SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_TOO_LARGE);
341 goto err;
342 }
343
344 j=ssl23_read_bytes(s,n+2);
345 if (j <= 0) return(j);
346
347 ssl3_finish_mac(s,&(s->packet[2]),s->packet_length-2);
348
349 p=s->packet;
350 p+=5;
351 n2s(p,csl);
352 n2s(p,sil);
353 n2s(p,cl);
354 d=(unsigned char *)s->init_buf->data;
355 if ((csl+sil+cl+11) != s->packet_length)
356 {
357 SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_RECORD_LENGTH_MISMATCH);
358 goto err;
359 }
360
361 *(d++)=SSL3_VERSION_MAJOR;
362 if (tls1)
363 *(d++)=TLS1_VERSION_MINOR;
364 else
365 *(d++)=SSL3_VERSION_MINOR;
366
367 /* lets populate the random area */
368 /* get the chalenge_length */
369 i=(cl > SSL3_RANDOM_SIZE)?SSL3_RANDOM_SIZE:cl;
370 memset(d,0,SSL3_RANDOM_SIZE);
371 memcpy(&(d[SSL3_RANDOM_SIZE-i]),&(p[csl+sil]),i);
372 d+=SSL3_RANDOM_SIZE;
373
374 /* no session-id reuse */
375 *(d++)=0;
376
377 /* ciphers */
378 j=0;
379 dd=d;
380 d+=2;
381 for (i=0; i<csl; i+=3)
382 {
383 if (p[i] != 0) continue;
384 *(d++)=p[i+1];
385 *(d++)=p[i+2];
386 j+=2;
387 }
388 s2n(j,dd);
389
390 /* compression */
391 *(d++)=1;
392 *(d++)=0;
393
394 i=(d-(unsigned char *)s->init_buf->data);
395
396 /* get the data reused from the init_buf */
397 s->s3->tmp.reuse_message=1;
398 s->s3->tmp.message_type=SSL3_MT_CLIENT_HELLO;
399 s->s3->tmp.message_size=i;
400 }
401
402 if (type == 1)
403 {
404 /* we are talking sslv2 */
405 /* we need to clean up the SSLv3/TLSv1 setup and put in the
406 * sslv2 stuff. */
407
408 if (s->s2 == NULL)
409 {
410 if (!ssl2_new(s))
411 goto err;
412 }
413 else
414 ssl2_clear(s);
415
416 if (s->s3 != NULL) ssl3_free(s);
417
418 if (!BUF_MEM_grow(s->init_buf,
419 SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER))
420 {
421 goto err;
422 }
423
424 s->state=SSL2_ST_GET_CLIENT_HELLO_A;
425 if ((s->options & SSL_OP_MSIE_SSLV2_RSA_PADDING) ||
426 use_sslv2_strong)
427 s->s2->ssl2_rollback=0;
428 else
429 s->s2->ssl2_rollback=1;
430
431 /* setup the 5 bytes we have read so we get them from
432 * the sslv2 buffer */
433 s->rstate=SSL_ST_READ_HEADER;
434 s->packet_length=n;
435 s->packet= &(s->s2->rbuf[0]);
436 memcpy(s->packet,buf,n);
437 s->s2->rbuf_left=n;
438 s->s2->rbuf_offs=0;
439
440 s->method=SSLv2_server_method();
441 s->handshake_func=s->method->ssl_accept;
442 }
443
444 if ((type == 2) || (type == 3))
445 {
446 /* we have SSLv3/TLSv1 */
447
448 if (!ssl_init_wbio_buffer(s,1)) goto err;
449
450 /* we are in this state */
451 s->state=SSL3_ST_SR_CLNT_HELLO_A;
452
453 if (type == 3)
454 {
455 /* put the 'n' bytes we have read into the input buffer
456 * for SSLv3 */
457 s->rstate=SSL_ST_READ_HEADER;
458 s->packet_length=n;
459 s->packet= &(s->s3->rbuf.buf[0]);
460 memcpy(s->packet,buf,n);
461 s->s3->rbuf.left=n;
462 s->s3->rbuf.offset=0;
463 }
464 else
465 {
466 s->packet_length=0;
467 s->s3->rbuf.left=0;
468 s->s3->rbuf.offset=0;
469 }
470
471 if (tls1)
472 {
473 s->version=TLS1_VERSION;
474 s->method=TLSv1_server_method();
475 }
476 else
477 {
478 s->version=SSL3_VERSION;
479 s->method=SSLv3_server_method();
480 }
481 s->handshake_func=s->method->ssl_accept;
482 }
483
484 if ((type < 1) || (type > 3))
485 {
486 /* bad, very bad */
487 SSLerr(SSL_F_SSL23_GET_CLIENT_HELLO,SSL_R_UNKNOWN_PROTOCOL);
488 goto err;
489 }
490 s->init_num=0;
491
492 if (buf != buf_space) Free(buf);
493 s->first_packet=1;
494 return(SSL_accept(s));
495err:
496 if (buf != buf_space) Free(buf);
497 return(-1);
498 }
499
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-04-26 08:30:47 +0000