summaryrefslogtreecommitdiff
path: root/src/lib/libssl/s3_pkt.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libssl/s3_pkt.c')
-rw-r--r--src/lib/libssl/s3_pkt.c1041
1 files changed, 0 insertions, 1041 deletions
diff --git a/src/lib/libssl/s3_pkt.c b/src/lib/libssl/s3_pkt.c
deleted file mode 100644
index 7893d03123..0000000000
--- a/src/lib/libssl/s3_pkt.c
+++ /dev/null
@@ -1,1041 +0,0 @@
1/* ssl/s3_pkt.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 <errno.h>
61#define USE_SOCKETS
62#include <openssl/evp.h>
63#include <openssl/buffer.h>
64#include "ssl_locl.h"
65
66static int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
67 unsigned int len);
68static int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
69 unsigned int len);
70static int ssl3_get_record(SSL *s);
71static int do_compress(SSL *ssl);
72static int do_uncompress(SSL *ssl);
73static int do_change_cipher_spec(SSL *ssl);
74static int ssl3_read_n(SSL *s, int n, int max, int extend)
75 {
76 int i,off,newb;
77
78 /* if there is stuff still in the buffer from a previous read,
79 * and there is more than we want, take some. */
80 if (s->s3->rbuf.left >= (int)n)
81 {
82 if (extend)
83 s->packet_length+=n;
84 else
85 {
86 s->packet= &(s->s3->rbuf.buf[s->s3->rbuf.offset]);
87 s->packet_length=n;
88 }
89 s->s3->rbuf.left-=n;
90 s->s3->rbuf.offset+=n;
91 return(n);
92 }
93
94 /* else we need to read more data */
95 if (!s->read_ahead) max=n;
96 if (max > SSL3_RT_MAX_PACKET_SIZE)
97 max=SSL3_RT_MAX_PACKET_SIZE;
98
99 /* First check if there is some left or we want to extend */
100 off=0;
101 if ( (s->s3->rbuf.left != 0) ||
102 ((s->packet_length != 0) && extend))
103 {
104 newb=s->s3->rbuf.left;
105 if (extend)
106 {
107 /* Copy bytes back to the front of the buffer
108 * Take the bytes already pointed to by 'packet'
109 * and take the extra ones on the end. */
110 off=s->packet_length;
111 if (s->packet != s->s3->rbuf.buf)
112 memcpy(s->s3->rbuf.buf,s->packet,newb+off);
113 }
114 else if (s->s3->rbuf.offset != 0)
115 { /* so the data is not at the start of the buffer */
116 memcpy(s->s3->rbuf.buf,
117 &(s->s3->rbuf.buf[s->s3->rbuf.offset]),newb);
118 s->s3->rbuf.offset=0;
119 }
120
121 s->s3->rbuf.left=0;
122 }
123 else
124 newb=0;
125
126 /* So we now have 'newb' bytes at the front of
127 * s->s3->rbuf.buf and need to read some more in on the end
128 * We start reading into the buffer at 's->s3->rbuf.offset'
129 */
130 s->packet=s->s3->rbuf.buf;
131
132 while (newb < n)
133 {
134 clear_sys_error();
135 if (s->rbio != NULL)
136 {
137 s->rwstate=SSL_READING;
138 i=BIO_read(s->rbio,
139 (char *)&(s->s3->rbuf.buf[off+newb]),
140 max-newb);
141 }
142 else
143 {
144 SSLerr(SSL_F_SSL3_READ_N,SSL_R_READ_BIO_NOT_SET);
145 i= -1;
146 }
147
148 if (i <= 0)
149 {
150 s->s3->rbuf.left+=newb;
151 return(i);
152 }
153 newb+=i;
154 }
155
156 /* record used data read */
157 if (newb > n)
158 {
159 s->s3->rbuf.offset=n+off;
160 s->s3->rbuf.left=newb-n;
161 }
162 else
163 {
164 s->s3->rbuf.offset=0;
165 s->s3->rbuf.left=0;
166 }
167
168 if (extend)
169 s->packet_length+=n;
170 else
171 s->packet_length+=n;
172 return(n);
173 }
174
175/* Call this to get a new input record.
176 * It will return <= 0 if more data is needed, normally due to an error
177 * or non-blocking IO.
178 * When it finishes, one packet has been decoded and can be found in
179 * ssl->s3->rrec.type - is the type of record
180 * ssl->s3->rrec.data, - data
181 * ssl->s3->rrec.length, - number of bytes
182 */
183static int ssl3_get_record(SSL *s)
184 {
185 int ssl_major,ssl_minor,al;
186 int n,i,ret= -1;
187 SSL3_BUFFER *rb;
188 SSL3_RECORD *rr;
189 SSL_SESSION *sess;
190 unsigned char *p;
191 unsigned char md[EVP_MAX_MD_SIZE];
192 short version;
193 unsigned int mac_size;
194 int clear=0,extra;
195
196 rr= &(s->s3->rrec);
197 rb= &(s->s3->rbuf);
198 sess=s->session;
199
200 if (s->options & SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER)
201 extra=SSL3_RT_MAX_EXTRA;
202 else
203 extra=0;
204
205again:
206 /* check if we have the header */
207 if ( (s->rstate != SSL_ST_READ_BODY) ||
208 (s->packet_length < SSL3_RT_HEADER_LENGTH))
209 {
210 n=ssl3_read_n(s,SSL3_RT_HEADER_LENGTH,
211 SSL3_RT_MAX_PACKET_SIZE,0);
212 if (n <= 0) return(n); /* error or non-blocking */
213 s->rstate=SSL_ST_READ_BODY;
214
215 p=s->packet;
216
217 /* Pull apart the header into the SSL3_RECORD */
218 rr->type= *(p++);
219 ssl_major= *(p++);
220 ssl_minor= *(p++);
221 version=(ssl_major<<8)|ssl_minor;
222 n2s(p,rr->length);
223
224 /* Lets check version */
225 if (s->first_packet)
226 {
227 s->first_packet=0;
228 }
229 else
230 {
231 if (version != s->version)
232 {
233 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_WRONG_VERSION_NUMBER);
234 /* Send back error using their
235 * version number :-) */
236 s->version=version;
237 al=SSL_AD_PROTOCOL_VERSION;
238 goto f_err;
239 }
240 }
241
242 if ((version>>8) != SSL3_VERSION_MAJOR)
243 {
244 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_WRONG_VERSION_NUMBER);
245 goto err;
246 }
247
248 if (rr->length >
249 (unsigned int)SSL3_RT_MAX_ENCRYPTED_LENGTH+extra)
250 {
251 al=SSL_AD_RECORD_OVERFLOW;
252 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_PACKET_LENGTH_TOO_LONG);
253 goto f_err;
254 }
255
256 s->rstate=SSL_ST_READ_BODY;
257 }
258
259 /* get and decode the data */
260 if (s->rstate == SSL_ST_READ_BODY)
261 {
262 if (rr->length > (s->packet_length-SSL3_RT_HEADER_LENGTH))
263 {
264 i=rr->length;
265 /*-(s->packet_length-SSL3_RT_HEADER_LENGTH); */
266 n=ssl3_read_n(s,i,i,1);
267 if (n <= 0) return(n); /* error or non-blocking io */
268 }
269 s->rstate=SSL_ST_READ_HEADER;
270 }
271
272 /* At this point, we have the data in s->packet and there should be
273 * s->packet_length bytes, we must not 'overrun' this buffer :-)
274 * One of the following functions will copy the data from the
275 * s->packet buffer */
276
277 rr->input= &(s->packet[SSL3_RT_HEADER_LENGTH]);
278
279 /* ok, we can now read from 's->packet' data into 'rr'
280 * rr->input points at rr->length bytes, which
281 * need to be copied into rr->data by either
282 * the decryption or by the decompression
283 * When the data is 'copied' into the rr->data buffer,
284 * rr->input will be pointed at the new buffer */
285
286 /* Set the state for the following operations */
287 s->rstate=SSL_ST_READ_HEADER;
288
289 /* We now have - encrypted [ MAC [ compressed [ plain ] ] ]
290 * rr->length bytes of encrypted compressed stuff. */
291
292 /* check is not needed I belive */
293 if (rr->length > (unsigned int)SSL3_RT_MAX_ENCRYPTED_LENGTH+extra)
294 {
295 al=SSL_AD_RECORD_OVERFLOW;
296 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
297 goto f_err;
298 }
299
300 /* decrypt in place in 'rr->input' */
301 rr->data=rr->input;
302
303 if (!s->method->ssl3_enc->enc(s,0))
304 {
305 al=SSL_AD_DECRYPT_ERROR;
306 goto f_err;
307 }
308#ifdef TLS_DEBUG
309printf("dec %d\n",rr->length);
310{ unsigned int z; for (z=0; z<rr->length; z++) printf("%02X%c",rr->data[z],((z+1)%16)?' ':'\n'); }
311printf("\n");
312#endif
313 /* r->length is now the compressed data plus mac */
314 if ( (sess == NULL) ||
315 (s->enc_read_ctx == NULL) ||
316 (s->read_hash == NULL))
317 clear=1;
318
319 if (!clear)
320 {
321 mac_size=EVP_MD_size(s->read_hash);
322
323 if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+extra+mac_size)
324 {
325 al=SSL_AD_RECORD_OVERFLOW;
326 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_PRE_MAC_LENGTH_TOO_LONG);
327 goto f_err;
328 }
329 /* check MAC for rr->input' */
330 if (rr->length < mac_size)
331 {
332 al=SSL_AD_DECODE_ERROR;
333 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_LENGTH_TOO_SHORT);
334 goto f_err;
335 }
336 rr->length-=mac_size;
337 i=s->method->ssl3_enc->mac(s,md,0);
338 if (memcmp(md,&(rr->data[rr->length]),mac_size) != 0)
339 {
340 al=SSL_AD_BAD_RECORD_MAC;
341 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_BAD_MAC_DECODE);
342 ret= -1;
343 goto f_err;
344 }
345 }
346
347 /* r->length is now just compressed */
348 if (s->expand != NULL)
349 {
350 if (rr->length >
351 (unsigned int)SSL3_RT_MAX_COMPRESSED_LENGTH+extra)
352 {
353 al=SSL_AD_RECORD_OVERFLOW;
354 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_COMPRESSED_LENGTH_TOO_LONG);
355 goto f_err;
356 }
357 if (!do_uncompress(s))
358 {
359 al=SSL_AD_DECOMPRESSION_FAILURE;
360 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_BAD_DECOMPRESSION);
361 goto f_err;
362 }
363 }
364
365 if (rr->length > (unsigned int)SSL3_RT_MAX_PLAIN_LENGTH+extra)
366 {
367 al=SSL_AD_RECORD_OVERFLOW;
368 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_DATA_LENGTH_TOO_LONG);
369 goto f_err;
370 }
371
372 rr->off=0;
373 /* So at this point the following is true
374 * ssl->s3->rrec.type is the type of record
375 * ssl->s3->rrec.length == number of bytes in record
376 * ssl->s3->rrec.off == offset to first valid byte
377 * ssl->s3->rrec.data == where to take bytes from, increment
378 * after use :-).
379 */
380
381 /* we have pulled in a full packet so zero things */
382 s->packet_length=0;
383
384 /* just read a 0 length packet */
385 if (rr->length == 0) goto again;
386
387 return(1);
388f_err:
389 ssl3_send_alert(s,SSL3_AL_FATAL,al);
390err:
391 return(ret);
392 }
393
394static int do_uncompress(SSL *ssl)
395 {
396 int i;
397 SSL3_RECORD *rr;
398
399 rr= &(ssl->s3->rrec);
400 i=COMP_expand_block(ssl->expand,rr->comp,
401 SSL3_RT_MAX_PLAIN_LENGTH,rr->data,(int)rr->length);
402 if (i < 0)
403 return(0);
404 else
405 rr->length=i;
406 rr->data=rr->comp;
407
408 return(1);
409 }
410
411static int do_compress(SSL *ssl)
412 {
413 int i;
414 SSL3_RECORD *wr;
415
416 wr= &(ssl->s3->wrec);
417 i=COMP_compress_block(ssl->compress,wr->data,
418 SSL3_RT_MAX_COMPRESSED_LENGTH,
419 wr->input,(int)wr->length);
420 if (i < 0)
421 return(0);
422 else
423 wr->length=i;
424
425 wr->input=wr->data;
426 return(1);
427 }
428
429/* Call this to write data
430 * It will return <= 0 if not all data has been sent or non-blocking IO.
431 */
432int ssl3_write_bytes(SSL *s, int type, const void *_buf, int len)
433 {
434 const unsigned char *buf=_buf;
435 unsigned int tot,n,nw;
436 int i;
437
438 s->rwstate=SSL_NOTHING;
439 tot=s->s3->wnum;
440 s->s3->wnum=0;
441
442 if (SSL_in_init(s) && !s->in_handshake)
443 {
444 i=s->handshake_func(s);
445 if (i < 0) return(i);
446 if (i == 0)
447 {
448 SSLerr(SSL_F_SSL3_WRITE_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
449 return(-1);
450 }
451 }
452
453 n=(len-tot);
454 for (;;)
455 {
456 if (n > SSL3_RT_MAX_PLAIN_LENGTH)
457 nw=SSL3_RT_MAX_PLAIN_LENGTH;
458 else
459 nw=n;
460
461 i=do_ssl3_write(s,type,&(buf[tot]),nw);
462 if (i <= 0)
463 {
464 s->s3->wnum=tot;
465 return(i);
466 }
467
468 if (type == SSL3_RT_HANDSHAKE)
469 ssl3_finish_mac(s,&(buf[tot]),i);
470
471 if ((i == (int)n) ||
472 (type == SSL3_RT_APPLICATION_DATA &&
473 (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE)))
474 {
475 return(tot+i);
476 }
477
478 n-=i;
479 tot+=i;
480 }
481 }
482
483static int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
484 unsigned int len)
485 {
486 unsigned char *p,*plen;
487 int i,mac_size,clear=0;
488 SSL3_RECORD *wr;
489 SSL3_BUFFER *wb;
490 SSL_SESSION *sess;
491
492 /* first check is there is a SSL3_RECORD still being written
493 * out. This will happen with non blocking IO */
494 if (s->s3->wbuf.left != 0)
495 return(ssl3_write_pending(s,type,buf,len));
496
497 /* If we have an alert to send, lets send it */
498 if (s->s3->alert_dispatch)
499 {
500 i=ssl3_dispatch_alert(s);
501 if (i <= 0)
502 return(i);
503 /* if it went, fall through and send more stuff */
504 }
505
506 if (len <= 0) return(len);
507
508 wr= &(s->s3->wrec);
509 wb= &(s->s3->wbuf);
510 sess=s->session;
511
512 if ( (sess == NULL) ||
513 (s->enc_write_ctx == NULL) ||
514 (s->write_hash == NULL))
515 clear=1;
516
517 if (clear)
518 mac_size=0;
519 else
520 mac_size=EVP_MD_size(s->write_hash);
521
522 p=wb->buf;
523
524 /* write the header */
525 *(p++)=type&0xff;
526 wr->type=type;
527
528 *(p++)=(s->version>>8);
529 *(p++)=s->version&0xff;
530
531 /* record where we are to write out packet length */
532 plen=p;
533 p+=2;
534
535 /* lets setup the record stuff. */
536 wr->data=p;
537 wr->length=(int)len;
538 wr->input=(unsigned char *)buf;
539
540 /* we now 'read' from wr->input, wr->length bytes into
541 * wr->data */
542
543 /* first we compress */
544 if (s->compress != NULL)
545 {
546 if (!do_compress(s))
547 {
548 SSLerr(SSL_F_DO_SSL3_WRITE,SSL_R_COMPRESSION_FAILURE);
549 goto err;
550 }
551 }
552 else
553 {
554 memcpy(wr->data,wr->input,wr->length);
555 wr->input=wr->data;
556 }
557
558 /* we should still have the output to wr->data and the input
559 * from wr->input. Length should be wr->length.
560 * wr->data still points in the wb->buf */
561
562 if (mac_size != 0)
563 {
564 s->method->ssl3_enc->mac(s,&(p[wr->length]),1);
565 wr->length+=mac_size;
566 wr->input=p;
567 wr->data=p;
568 }
569
570 /* ssl3_enc can only have an error on read */
571 s->method->ssl3_enc->enc(s,1);
572
573 /* record length after mac and block padding */
574 s2n(wr->length,plen);
575
576 /* we should now have
577 * wr->data pointing to the encrypted data, which is
578 * wr->length long */
579 wr->type=type; /* not needed but helps for debugging */
580 wr->length+=SSL3_RT_HEADER_LENGTH;
581
582 /* Now lets setup wb */
583 wb->left=wr->length;
584 wb->offset=0;
585
586 s->s3->wpend_tot=len;
587 s->s3->wpend_buf=buf;
588 s->s3->wpend_type=type;
589 s->s3->wpend_ret=len;
590
591 /* we now just need to write the buffer */
592 return(ssl3_write_pending(s,type,buf,len));
593err:
594 return(-1);
595 }
596
597/* if s->s3->wbuf.left != 0, we need to call this */
598static int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
599 unsigned int len)
600 {
601 int i;
602
603/* XXXX */
604 if ((s->s3->wpend_tot > (int)len)
605 || ((s->s3->wpend_buf != buf) &&
606 !(s->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER))
607 || (s->s3->wpend_type != type))
608 {
609 SSLerr(SSL_F_SSL3_WRITE_PENDING,SSL_R_BAD_WRITE_RETRY);
610 return(-1);
611 }
612
613 for (;;)
614 {
615 clear_sys_error();
616 if (s->wbio != NULL)
617 {
618 s->rwstate=SSL_WRITING;
619 i=BIO_write(s->wbio,
620 (char *)&(s->s3->wbuf.buf[s->s3->wbuf.offset]),
621 (unsigned int)s->s3->wbuf.left);
622 }
623 else
624 {
625 SSLerr(SSL_F_SSL3_WRITE_PENDING,SSL_R_BIO_NOT_SET);
626 i= -1;
627 }
628 if (i == s->s3->wbuf.left)
629 {
630 s->s3->wbuf.left=0;
631 s->rwstate=SSL_NOTHING;
632 return(s->s3->wpend_ret);
633 }
634 else if (i <= 0)
635 return(i);
636 s->s3->wbuf.offset+=i;
637 s->s3->wbuf.left-=i;
638 }
639 }
640
641int ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len)
642 {
643 int al,i,j,n,ret;
644 SSL3_RECORD *rr;
645 void (*cb)()=NULL;
646 BIO *bio;
647
648 if (s->s3->rbuf.buf == NULL) /* Not initialize yet */
649 if (!ssl3_setup_buffers(s))
650 return(-1);
651
652 if (!s->in_handshake && SSL_in_init(s))
653 {
654 i=s->handshake_func(s);
655 if (i < 0) return(i);
656 if (i == 0)
657 {
658 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
659 return(-1);
660 }
661 }
662start:
663 s->rwstate=SSL_NOTHING;
664
665 /* s->s3->rrec.type - is the type of record
666 * s->s3->rrec.data, - data
667 * s->s3->rrec.off, - ofset into 'data' for next read
668 * s->s3->rrec.length, - number of bytes. */
669 rr= &(s->s3->rrec);
670
671 /* get new packet */
672 if ((rr->length == 0) || (s->rstate == SSL_ST_READ_BODY))
673 {
674 ret=ssl3_get_record(s);
675 if (ret <= 0) return(ret);
676 }
677
678 /* we now have a packet which can be read and processed */
679
680 if (s->s3->change_cipher_spec && (rr->type != SSL3_RT_HANDSHAKE))
681 {
682 al=SSL_AD_UNEXPECTED_MESSAGE;
683 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_DATA_BETWEEN_CCS_AND_FINISHED);
684 goto err;
685 }
686
687 /* If the other end has shutdown, throw anything we read away */
688 if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
689 {
690 rr->length=0;
691 s->rwstate=SSL_NOTHING;
692 return(0);
693 }
694
695 /* Check for an incoming 'Client Request' message */
696 if ((rr->type == SSL3_RT_HANDSHAKE) && (rr->length == 4) &&
697 (rr->data[0] == SSL3_MT_CLIENT_REQUEST) &&
698 (s->session != NULL) && (s->session->cipher != NULL))
699 {
700 if ((rr->data[1] != 0) || (rr->data[2] != 0) ||
701 (rr->data[3] != 0))
702 {
703 al=SSL_AD_DECODE_ERROR;
704 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_CLIENT_REQUEST);
705 goto err;
706 }
707
708 if (SSL_is_init_finished(s) &&
709 !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS) &&
710 !s->s3->renegotiate)
711 {
712 ssl3_renegotiate(s);
713 if (ssl3_renegotiate_check(s))
714 {
715 n=s->handshake_func(s);
716 if (n < 0) return(n);
717 if (n == 0)
718 {
719 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
720 return(-1);
721 }
722 }
723 }
724 rr->length=0;
725/* ZZZ */ goto start;
726 }
727
728 /* if it is not the type we want, or we have shutdown and want
729 * the peer shutdown */
730 if ((rr->type != type) || (s->shutdown & SSL_SENT_SHUTDOWN))
731 {
732 if (rr->type == SSL3_RT_ALERT)
733 {
734 if ((rr->length != 2) || (rr->off != 0))
735 {
736 al=SSL_AD_DECODE_ERROR;
737 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_ALERT_RECORD);
738 goto f_err;
739 }
740
741 i=rr->data[0];
742 n=rr->data[1];
743
744 /* clear from buffer */
745 rr->length=0;
746
747 if (s->info_callback != NULL)
748 cb=s->info_callback;
749 else if (s->ctx->info_callback != NULL)
750 cb=s->ctx->info_callback;
751
752 if (cb != NULL)
753 {
754 j=(i<<8)|n;
755 cb(s,SSL_CB_READ_ALERT,j);
756 }
757
758 if (i == 1)
759 {
760 s->s3->warn_alert=n;
761 if (n == SSL_AD_CLOSE_NOTIFY)
762 {
763 s->shutdown|=SSL_RECEIVED_SHUTDOWN;
764 return(0);
765 }
766 }
767 else if (i == 2)
768 {
769 char tmp[16];
770
771 s->rwstate=SSL_NOTHING;
772 s->s3->fatal_alert=n;
773 SSLerr(SSL_F_SSL3_READ_BYTES,
774 SSL_AD_REASON_OFFSET+n);
775 sprintf(tmp,"%d",n);
776 ERR_add_error_data(2,"SSL alert number ",tmp);
777 s->shutdown|=SSL_RECEIVED_SHUTDOWN;
778 SSL_CTX_remove_session(s->ctx,s->session);
779 return(0);
780 }
781 else
782 {
783 al=SSL_AD_ILLEGAL_PARAMETER;
784 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNKNOWN_ALERT_TYPE);
785 goto f_err;
786 }
787
788 rr->length=0;
789 goto start;
790 }
791
792 if (s->shutdown & SSL_SENT_SHUTDOWN)
793 {
794 s->rwstate=SSL_NOTHING;
795 rr->length=0;
796 return(0);
797 }
798
799 if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC)
800 {
801 if ( (rr->length != 1) || (rr->off != 0) ||
802 (rr->data[0] != SSL3_MT_CCS))
803 {
804 i=SSL_AD_ILLEGAL_PARAMETER;
805 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_CHANGE_CIPHER_SPEC);
806 goto err;
807 }
808
809 rr->length=0;
810 s->s3->change_cipher_spec=1;
811 if (!do_change_cipher_spec(s))
812 goto err;
813 else
814 goto start;
815 }
816
817 /* else we have a handshake */
818 if ((rr->type == SSL3_RT_HANDSHAKE) &&
819 !s->in_handshake)
820 {
821 if (((s->state&SSL_ST_MASK) == SSL_ST_OK) &&
822 !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS))
823 {
824 s->state=SSL_ST_BEFORE|(s->server)
825 ?SSL_ST_ACCEPT
826 :SSL_ST_CONNECT;
827 s->new_session=1;
828 }
829 n=s->handshake_func(s);
830 if (n < 0) return(n);
831 if (n == 0)
832 {
833 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
834 return(-1);
835 }
836
837 /* In the case where we try to read application data
838 * the first time, but we trigger an SSL handshake, we
839 * return -1 with the retry option set. I do this
840 * otherwise renegotiation can cause nasty problems
841 * in the non-blocking world */
842
843 s->rwstate=SSL_READING;
844 bio=SSL_get_rbio(s);
845 BIO_clear_retry_flags(bio);
846 BIO_set_retry_read(bio);
847 return(-1);
848 }
849
850 switch (rr->type)
851 {
852 default:
853#ifndef NO_TLS
854 /* TLS just ignores unknown message types */
855 if (s->version == TLS1_VERSION)
856 {
857 goto start;
858 }
859#endif
860 case SSL3_RT_CHANGE_CIPHER_SPEC:
861 case SSL3_RT_ALERT:
862 case SSL3_RT_HANDSHAKE:
863 al=SSL_AD_UNEXPECTED_MESSAGE;
864 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
865 goto f_err;
866 case SSL3_RT_APPLICATION_DATA:
867 /* At this point, we were expecting something else,
868 * but have application data. What we do is set the
869 * error, and return -1. On the way out, if the
870 * library was running inside ssl3_read() and it makes
871 * sense to read application data at this point, we
872 * will indulge it. This will mostly happen during
873 * session renegotiation.
874 */
875 if (s->s3->in_read_app_data &&
876 (s->s3->total_renegotiations != 0) &&
877 ((
878 (s->state & SSL_ST_CONNECT) &&
879 (s->state >= SSL3_ST_CW_CLNT_HELLO_A) &&
880 (s->state <= SSL3_ST_CR_SRVR_HELLO_A)
881 ) || (
882 (s->state & SSL_ST_ACCEPT) &&
883 (s->state <= SSL3_ST_SW_HELLO_REQ_A) &&
884 (s->state >= SSL3_ST_SR_CLNT_HELLO_A)
885 )
886 ))
887 {
888 s->s3->in_read_app_data=0;
889 return(-1);
890 }
891 else
892 {
893 al=SSL_AD_UNEXPECTED_MESSAGE;
894 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
895 goto f_err;
896 }
897 }
898 }
899
900 /* make sure that we are not getting application data when we
901 * are doing a handshake for the first time */
902 if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) &&
903 (s->enc_read_ctx == NULL))
904 {
905 al=SSL_AD_UNEXPECTED_MESSAGE;
906 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_APP_DATA_IN_HANDSHAKE);
907 goto f_err;
908 }
909
910 if (len <= 0) return(len);
911
912 if ((unsigned int)len > rr->length)
913 n=rr->length;
914 else
915 n=len;
916
917 memcpy(buf,&(rr->data[rr->off]),(unsigned int)n);
918 rr->length-=n;
919 rr->off+=n;
920 if (rr->length <= 0)
921 {
922 s->rstate=SSL_ST_READ_HEADER;
923 rr->off=0;
924 }
925
926 if (type == SSL3_RT_HANDSHAKE)
927 ssl3_finish_mac(s,buf,n);
928 return(n);
929f_err:
930 ssl3_send_alert(s,SSL3_AL_FATAL,al);
931err:
932 return(-1);
933 }
934
935static int do_change_cipher_spec(SSL *s)
936 {
937 int i;
938 unsigned char *sender;
939 int slen;
940
941 if (s->state & SSL_ST_ACCEPT)
942 i=SSL3_CHANGE_CIPHER_SERVER_READ;
943 else
944 i=SSL3_CHANGE_CIPHER_CLIENT_READ;
945
946 if (s->s3->tmp.key_block == NULL)
947 {
948 s->session->cipher=s->s3->tmp.new_cipher;
949 if (!s->method->ssl3_enc->setup_key_block(s)) return(0);
950 }
951
952 if (!s->method->ssl3_enc->change_cipher_state(s,i))
953 return(0);
954
955 /* we have to record the message digest at
956 * this point so we can get it before we read
957 * the finished message */
958 if (s->state & SSL_ST_CONNECT)
959 {
960 sender=s->method->ssl3_enc->server_finished;
961 slen=s->method->ssl3_enc->server_finished_len;
962 }
963 else
964 {
965 sender=s->method->ssl3_enc->client_finished;
966 slen=s->method->ssl3_enc->client_finished_len;
967 }
968
969 s->method->ssl3_enc->final_finish_mac(s,
970 &(s->s3->finish_dgst1),
971 &(s->s3->finish_dgst2),
972 sender,slen,&(s->s3->tmp.finish_md[0]));
973
974 return(1);
975 }
976
977int ssl3_do_write(SSL *s, int type)
978 {
979 int ret;
980
981 ret=ssl3_write_bytes(s,type,&s->init_buf->data[s->init_off],
982 s->init_num);
983 if (ret == s->init_num)
984 return(1);
985 if (ret < 0) return(-1);
986 s->init_off+=ret;
987 s->init_num-=ret;
988 return(0);
989 }
990
991void ssl3_send_alert(SSL *s, int level, int desc)
992 {
993 /* Map tls/ssl alert value to correct one */
994 desc=s->method->ssl3_enc->alert_value(desc);
995 if (desc < 0) return;
996 /* If a fatal one, remove from cache */
997 if ((level == 2) && (s->session != NULL))
998 SSL_CTX_remove_session(s->ctx,s->session);
999
1000 s->s3->alert_dispatch=1;
1001 s->s3->send_alert[0]=level;
1002 s->s3->send_alert[1]=desc;
1003 if (s->s3->wbuf.left == 0) /* data still being written out */
1004 ssl3_dispatch_alert(s);
1005 /* else data is still being written out, we will get written
1006 * some time in the future */
1007 }
1008
1009int ssl3_dispatch_alert(SSL *s)
1010 {
1011 int i,j;
1012 void (*cb)()=NULL;
1013
1014 s->s3->alert_dispatch=0;
1015 i=do_ssl3_write(s,SSL3_RT_ALERT,&s->s3->send_alert[0],2);
1016 if (i <= 0)
1017 {
1018 s->s3->alert_dispatch=1;
1019 }
1020 else
1021 {
1022 /* If it is important, send it now. If the message
1023 * does not get sent due to non-blocking IO, we will
1024 * not worry too much. */
1025 if (s->s3->send_alert[0] == SSL3_AL_FATAL)
1026 (void)BIO_flush(s->wbio);
1027
1028 if (s->info_callback != NULL)
1029 cb=s->info_callback;
1030 else if (s->ctx->info_callback != NULL)
1031 cb=s->ctx->info_callback;
1032
1033 if (cb != NULL)
1034 {
1035 j=(s->s3->send_alert[0]<<8)|s->s3->send_alert[1];
1036 cb(s,SSL_CB_WRITE_ALERT,j);
1037 }
1038 }
1039 return(i);
1040 }
1041
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-19 22:01:44 +0000