summaryrefslogtreecommitdiff
path: root/src/lib/libssl/s3_pkt.c
diff options
context:
space:
mode:
authormarkus <>2002-09-05 12:51:50 +0000
committermarkus <>2002-09-05 12:51:50 +0000
commit15b5d84f9da2ce4bfae8580e56e34a859f74ad71 (patch)
treebf939e82d7fd73cc8a01cf6959002209972091bc /src/lib/libssl/s3_pkt.c
parent027351f729b9e837200dae6e1520cda6577ab930 (diff)
downloadopenbsd-15b5d84f9da2ce4bfae8580e56e34a859f74ad71.tar.gz
openbsd-15b5d84f9da2ce4bfae8580e56e34a859f74ad71.tar.bz2
openbsd-15b5d84f9da2ce4bfae8580e56e34a859f74ad71.zip
import openssl-0.9.7-beta1
Diffstat (limited to 'src/lib/libssl/s3_pkt.c')
-rw-r--r--src/lib/libssl/s3_pkt.c1064
1 files changed, 645 insertions, 419 deletions
diff --git a/src/lib/libssl/s3_pkt.c b/src/lib/libssl/s3_pkt.c
index 2385080347..43e8502b66 100644
--- a/src/lib/libssl/s3_pkt.c
+++ b/src/lib/libssl/s3_pkt.c
@@ -55,150 +55,165 @@
55 * copied and put under another distribution licence 55 * copied and put under another distribution licence
56 * [including the GNU Public Licence.] 56 * [including the GNU Public Licence.]
57 */ 57 */
58/* ====================================================================
59 * Copyright (c) 1998-2002 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 */
58 111
59#include <stdio.h> 112#include <stdio.h>
60#include <errno.h> 113#include <errno.h>
61#define USE_SOCKETS 114#define USE_SOCKETS
62#include "evp.h" 115#include <openssl/evp.h>
63#include "buffer.h" 116#include <openssl/buffer.h>
64#include "ssl_locl.h" 117#include "ssl_locl.h"
65 118
66/* SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_PEER_ERROR_NO_CIPHER); 119static int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
67 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_PEER_ERROR_NO_CERTIFICATE); 120 unsigned int len, int create_empty_fragment);
68 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_PEER_ERROR_CERTIFICATE); 121static int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
69 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE); 122 unsigned int len);
70 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_UNKNOWN_REMOTE_ERROR_TYPE);
71 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE);
72 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_BAD_RECORD_MAC);
73 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE);
74 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE);
75 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_NO_CERTIFICATE);
76 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_BAD_CERTIFICATE);
77 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE);
78 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED);
79 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED);
80 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN);
81 * SSLerr(SSL_F_GET_SERVER_HELLO,SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER);
82 */
83
84#ifndef NOPROTO
85static int do_ssl3_write(SSL *s, int type, char *buf, unsigned int len);
86static int ssl3_write_pending(SSL *s, int type, char *buf, unsigned int len);
87static int ssl3_get_record(SSL *s); 123static int ssl3_get_record(SSL *s);
88static int do_compress(SSL *ssl); 124static int do_compress(SSL *ssl);
89static int do_uncompress(SSL *ssl); 125static int do_uncompress(SSL *ssl);
90static int do_change_cipher_spec(SSL *ssl); 126static int do_change_cipher_spec(SSL *ssl);
91#else
92static int do_ssl3_write();
93static int ssl3_write_pending();
94static int ssl3_get_record();
95static int do_compress();
96static int do_uncompress();
97static int do_change_cipher_spec();
98#endif
99 127
100static int ssl3_read_n(s,n,max,extend) 128/* used only by ssl3_get_record */
101SSL *s; 129static int ssl3_read_n(SSL *s, int n, int max, int extend)
102int n;
103int max;
104int extend;
105 { 130 {
131 /* If extend == 0, obtain new n-byte packet; if extend == 1, increase
132 * packet by another n bytes.
133 * The packet will be in the sub-array of s->s3->rbuf.buf specified
134 * by s->packet and s->packet_length.
135 * (If s->read_ahead is set, 'max' bytes may be stored in rbuf
136 * [plus s->packet_length bytes if extend == 1].)
137 */
106 int i,off,newb; 138 int i,off,newb;
107 139
108 /* if there is stuff still in the buffer from a previous read, 140 if (!extend)
109 * and there is more than we want, take some. */ 141 {
142 /* start with empty packet ... */
143 if (s->s3->rbuf.left == 0)
144 s->s3->rbuf.offset = 0;
145 s->packet = s->s3->rbuf.buf + s->s3->rbuf.offset;
146 s->packet_length = 0;
147 /* ... now we can act as if 'extend' was set */
148 }
149
150 /* if there is enough in the buffer from a previous read, take some */
110 if (s->s3->rbuf.left >= (int)n) 151 if (s->s3->rbuf.left >= (int)n)
111 { 152 {
112 if (extend) 153 s->packet_length+=n;
113 s->packet_length+=n;
114 else
115 {
116 s->packet= &(s->s3->rbuf.buf[s->s3->rbuf.offset]);
117 s->packet_length=n;
118 }
119 s->s3->rbuf.left-=n; 154 s->s3->rbuf.left-=n;
120 s->s3->rbuf.offset+=n; 155 s->s3->rbuf.offset+=n;
121 return(n); 156 return(n);
122 } 157 }
123 158
124 /* else we need to read more data */ 159 /* else we need to read more data */
125 if (!s->read_ahead) max=n; 160 if (!s->read_ahead)
126 if (max > SSL3_RT_MAX_PACKET_SIZE) 161 max=n;
127 max=SSL3_RT_MAX_PACKET_SIZE;
128
129 /* First check if there is some left or we want to extend */
130 off=0;
131 if ( (s->s3->rbuf.left != 0) ||
132 ((s->packet_length != 0) && extend))
133 {
134 newb=s->s3->rbuf.left;
135 if (extend)
136 {
137 /* Copy bytes back to the front of the buffer
138 * Take the bytes already pointed to by 'packet'
139 * and take the extra ones on the end. */
140 off=s->packet_length;
141 if (s->packet != s->s3->rbuf.buf)
142 memcpy(s->s3->rbuf.buf,s->packet,newb+off);
143 }
144 else if (s->s3->rbuf.offset != 0)
145 { /* so the data is not at the start of the buffer */
146 memcpy(s->s3->rbuf.buf,
147 &(s->s3->rbuf.buf[s->s3->rbuf.offset]),newb);
148 s->s3->rbuf.offset=0;
149 }
150 162
151 s->s3->rbuf.left=0; 163 {
164 /* avoid buffer overflow */
165 int max_max = s->s3->rbuf.len - s->packet_length;
166 if (max > max_max)
167 max = max_max;
168 }
169 if (n > max) /* does not happen */
170 {
171 SSLerr(SSL_F_SSL3_READ_N,ERR_R_INTERNAL_ERROR);
172 return -1;
152 } 173 }
153 else
154 newb=0;
155 174
156 /* So we now have 'newb' bytes at the front of 175 off = s->packet_length;
157 * s->s3->rbuf.buf and need to read some more in on the end 176 newb = s->s3->rbuf.left;
158 * We start reading into the buffer at 's->s3->rbuf.offset' 177 /* Move any available bytes to front of buffer:
159 */ 178 * 'off' bytes already pointed to by 'packet',
160 s->packet=s->s3->rbuf.buf; 179 * 'newb' extra ones at the end */
180 if (s->packet != s->s3->rbuf.buf)
181 {
182 /* off > 0 */
183 memmove(s->s3->rbuf.buf, s->packet, off+newb);
184 s->packet = s->s3->rbuf.buf;
185 }
161 186
162 while (newb < n) 187 while (newb < n)
163 { 188 {
189 /* Now we have off+newb bytes at the front of s->s3->rbuf.buf and need
190 * to read in more until we have off+n (up to off+max if possible) */
191
164 clear_sys_error(); 192 clear_sys_error();
165 if (s->rbio != NULL) 193 if (s->rbio != NULL)
166 { 194 {
167 s->rwstate=SSL_READING; 195 s->rwstate=SSL_READING;
168 i=BIO_read(s->rbio, 196 i=BIO_read(s->rbio, &(s->s3->rbuf.buf[off+newb]), max-newb);
169 (char *)&(s->s3->rbuf.buf[off+newb]),
170 max-newb);
171 } 197 }
172 else 198 else
173 { 199 {
174 SSLerr(SSL_F_SSL3_READ_N,SSL_R_READ_BIO_NOT_SET); 200 SSLerr(SSL_F_SSL3_READ_N,SSL_R_READ_BIO_NOT_SET);
175 i= -1; 201 i = -1;
176 } 202 }
177 203
178 if (i <= 0) 204 if (i <= 0)
179 { 205 {
180 s->s3->rbuf.left+=newb; 206 s->s3->rbuf.left = newb;
181 return(i); 207 return(i);
182 } 208 }
183 newb+=i; 209 newb+=i;
184 } 210 }
185 211
186 /* record used data read */ 212 /* done reading, now the book-keeping */
187 if (newb > n) 213 s->s3->rbuf.offset = off + n;
188 { 214 s->s3->rbuf.left = newb - n;
189 s->s3->rbuf.offset=n+off; 215 s->packet_length += n;
190 s->s3->rbuf.left=newb-n; 216 s->rwstate=SSL_NOTHING;
191 }
192 else
193 {
194 s->s3->rbuf.offset=0;
195 s->s3->rbuf.left=0;
196 }
197
198 if (extend)
199 s->packet_length+=n;
200 else
201 s->packet_length+=n;
202 return(n); 217 return(n);
203 } 218 }
204 219
@@ -206,41 +221,45 @@ int extend;
206 * It will return <= 0 if more data is needed, normally due to an error 221 * It will return <= 0 if more data is needed, normally due to an error
207 * or non-blocking IO. 222 * or non-blocking IO.
208 * When it finishes, one packet has been decoded and can be found in 223 * When it finishes, one packet has been decoded and can be found in
209 * ssl->s3->rrec.type - is the type of record 224 * ssl->s3->rrec.type - is the type of record
210 * ssl->s3->rrec.data, - data 225 * ssl->s3->rrec.data, - data
211 * ssl->s3->rrec.length, - number of bytes 226 * ssl->s3->rrec.length, - number of bytes
212 */ 227 */
213static int ssl3_get_record(s) 228/* used only by ssl3_read_bytes */
214SSL *s; 229static int ssl3_get_record(SSL *s)
215 { 230 {
216 char tmp_buf[512];
217 int ssl_major,ssl_minor,al; 231 int ssl_major,ssl_minor,al;
218 int n,i,ret= -1; 232 int enc_err,n,i,ret= -1;
219 SSL3_BUFFER *rb;
220 SSL3_RECORD *rr; 233 SSL3_RECORD *rr;
221 SSL_SESSION *sess; 234 SSL_SESSION *sess;
222 unsigned char *p; 235 unsigned char *p;
223 unsigned char md[EVP_MAX_MD_SIZE]; 236 unsigned char md[EVP_MAX_MD_SIZE];
224 short version; 237 short version;
225 unsigned int mac_size; 238 unsigned int mac_size;
226 int clear=0,extra; 239 int clear=0;
240 size_t extra;
227 241
228 rr= &(s->s3->rrec); 242 rr= &(s->s3->rrec);
229 rb= &(s->s3->rbuf);
230 sess=s->session; 243 sess=s->session;
231 244
232 if (s->options & SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER) 245 if (s->options & SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER)
233 extra=SSL3_RT_MAX_EXTRA; 246 extra=SSL3_RT_MAX_EXTRA;
234 else 247 else
235 extra=0; 248 extra=0;
249 if (extra != s->s3->rbuf.len - SSL3_RT_MAX_PACKET_SIZE)
250 {
251 /* actually likely an application error: SLS_OP_MICROSOFT_BIG_SSLV3_BUFFER
252 * set after ssl3_setup_buffers() was done */
253 SSLerr(SSL_F_SSL3_GET_RECORD, ERR_R_INTERNAL_ERROR);
254 return -1;
255 }
236 256
237again: 257again:
238 /* check if we have the header */ 258 /* check if we have the header */
239 if ( (s->rstate != SSL_ST_READ_BODY) || 259 if ( (s->rstate != SSL_ST_READ_BODY) ||
240 (s->packet_length < SSL3_RT_HEADER_LENGTH)) 260 (s->packet_length < SSL3_RT_HEADER_LENGTH))
241 { 261 {
242 n=ssl3_read_n(s,SSL3_RT_HEADER_LENGTH, 262 n=ssl3_read_n(s, SSL3_RT_HEADER_LENGTH, s->s3->rbuf.len, 0);
243 SSL3_RT_MAX_PACKET_SIZE,0);
244 if (n <= 0) return(n); /* error or non-blocking */ 263 if (n <= 0) return(n); /* error or non-blocking */
245 s->rstate=SSL_ST_READ_BODY; 264 s->rstate=SSL_ST_READ_BODY;
246 265
@@ -277,35 +296,33 @@ again:
277 goto err; 296 goto err;
278 } 297 }
279 298
280 if (rr->length > 299 if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH+extra)
281 (unsigned int)SSL3_RT_MAX_ENCRYPTED_LENGTH+extra)
282 { 300 {
283 al=SSL_AD_RECORD_OVERFLOW; 301 al=SSL_AD_RECORD_OVERFLOW;
284 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_PACKET_LENGTH_TOO_LONG); 302 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_PACKET_LENGTH_TOO_LONG);
285 goto f_err; 303 goto f_err;
286 } 304 }
287 305
288 s->rstate=SSL_ST_READ_BODY; 306 /* now s->rstate == SSL_ST_READ_BODY */
289 } 307 }
290 308
291 /* get and decode the data */ 309 /* s->rstate == SSL_ST_READ_BODY, get and decode the data */
292 if (s->rstate == SSL_ST_READ_BODY) 310
311 if (rr->length > s->packet_length-SSL3_RT_HEADER_LENGTH)
293 { 312 {
294 if (rr->length > (s->packet_length-SSL3_RT_HEADER_LENGTH)) 313 /* now s->packet_length == SSL3_RT_HEADER_LENGTH */
295 { 314 i=rr->length;
296 i=rr->length; 315 n=ssl3_read_n(s,i,i,1);
297 /*-(s->packet_length-SSL3_RT_HEADER_LENGTH); */ 316 if (n <= 0) return(n); /* error or non-blocking io */
298 n=ssl3_read_n(s,i,i,1); 317 /* now n == rr->length,
299 if (n <= 0) return(n); /* error or non-blocking io */ 318 * and s->packet_length == SSL3_RT_HEADER_LENGTH + rr->length */
300 }
301 s->rstate=SSL_ST_READ_HEADER;
302 } 319 }
303 320
304 /* At this point, we have the data in s->packet and there should be 321 s->rstate=SSL_ST_READ_HEADER; /* set state for later operations */
305 * s->packet_length bytes, we must not 'overrun' this buffer :-)
306 * One of the following functions will copy the data from the
307 * s->packet buffer */
308 322
323 /* At this point, s->packet_length == SSL3_RT_HEADER_LNGTH + rr->length,
324 * and we have that many bytes in s->packet
325 */
309 rr->input= &(s->packet[SSL3_RT_HEADER_LENGTH]); 326 rr->input= &(s->packet[SSL3_RT_HEADER_LENGTH]);
310 327
311 /* ok, we can now read from 's->packet' data into 'rr' 328 /* ok, we can now read from 's->packet' data into 'rr'
@@ -315,14 +332,11 @@ again:
315 * When the data is 'copied' into the rr->data buffer, 332 * When the data is 'copied' into the rr->data buffer,
316 * rr->input will be pointed at the new buffer */ 333 * rr->input will be pointed at the new buffer */
317 334
318 /* Set the state for the following operations */
319 s->rstate=SSL_ST_READ_HEADER;
320
321 /* We now have - encrypted [ MAC [ compressed [ plain ] ] ] 335 /* We now have - encrypted [ MAC [ compressed [ plain ] ] ]
322 * rr->length bytes of encrypted compressed stuff. */ 336 * rr->length bytes of encrypted compressed stuff. */
323 337
324 /* check is not needed I belive */ 338 /* check is not needed I believe */
325 if (rr->length > (unsigned int)SSL3_RT_MAX_ENCRYPTED_LENGTH+extra) 339 if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH+extra)
326 { 340 {
327 al=SSL_AD_RECORD_OVERFLOW; 341 al=SSL_AD_RECORD_OVERFLOW;
328 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_ENCRYPTED_LENGTH_TOO_LONG); 342 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
@@ -331,18 +345,24 @@ again:
331 345
332 /* decrypt in place in 'rr->input' */ 346 /* decrypt in place in 'rr->input' */
333 rr->data=rr->input; 347 rr->data=rr->input;
334 memcpy(tmp_buf,rr->input,(rr->length > 512)?512:rr->length);
335 348
336 if (!s->method->ssl3_enc->enc(s,0)) 349 enc_err = s->method->ssl3_enc->enc(s,0);
350 if (enc_err <= 0)
337 { 351 {
338 al=SSL_AD_DECRYPT_ERROR; 352 if (enc_err == 0)
339 goto f_err; 353 /* SSLerr() and ssl3_send_alert() have been called */
354 goto err;
355
356 /* otherwise enc_err == -1 */
357 goto decryption_failed_or_bad_record_mac;
340 } 358 }
359
341#ifdef TLS_DEBUG 360#ifdef TLS_DEBUG
342printf("dec %d\n",rr->length); 361printf("dec %d\n",rr->length);
343{ int z; for (z=0; z<rr->length; z++) printf("%02X%c",rr->data[z],((z+1)%16)?' ':'\n'); } 362{ unsigned int z; for (z=0; z<rr->length; z++) printf("%02X%c",rr->data[z],((z+1)%16)?' ':'\n'); }
344printf("\n"); 363printf("\n");
345#endif 364#endif
365
346 /* r->length is now the compressed data plus mac */ 366 /* r->length is now the compressed data plus mac */
347 if ( (sess == NULL) || 367 if ( (sess == NULL) ||
348 (s->enc_read_ctx == NULL) || 368 (s->enc_read_ctx == NULL) ||
@@ -355,33 +375,37 @@ printf("\n");
355 375
356 if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+extra+mac_size) 376 if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+extra+mac_size)
357 { 377 {
378#if 0 /* OK only for stream ciphers (then rr->length is visible from ciphertext anyway) */
358 al=SSL_AD_RECORD_OVERFLOW; 379 al=SSL_AD_RECORD_OVERFLOW;
359 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_PRE_MAC_LENGTH_TOO_LONG); 380 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_PRE_MAC_LENGTH_TOO_LONG);
360 goto f_err; 381 goto f_err;
382#else
383 goto decryption_failed_or_bad_record_mac;
384#endif
361 } 385 }
362 /* check MAC for rr->input' */ 386 /* check the MAC for rr->input (it's in mac_size bytes at the tail) */
363 if (rr->length < mac_size) 387 if (rr->length < mac_size)
364 { 388 {
389#if 0 /* OK only for stream ciphers */
365 al=SSL_AD_DECODE_ERROR; 390 al=SSL_AD_DECODE_ERROR;
366 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_LENGTH_TOO_SHORT); 391 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_LENGTH_TOO_SHORT);
367 goto f_err; 392 goto f_err;
393#else
394 goto decryption_failed_or_bad_record_mac;
395#endif
368 } 396 }
369 rr->length-=mac_size; 397 rr->length-=mac_size;
370 i=s->method->ssl3_enc->mac(s,md,0); 398 i=s->method->ssl3_enc->mac(s,md,0);
371 if (memcmp(md,&(rr->data[rr->length]),mac_size) != 0) 399 if (memcmp(md,&(rr->data[rr->length]),mac_size) != 0)
372 { 400 {
373 al=SSL_AD_BAD_RECORD_MAC; 401 goto decryption_failed_or_bad_record_mac;
374 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_BAD_MAC_DECODE);
375 ret= -1;
376 goto f_err;
377 } 402 }
378 } 403 }
379 404
380 /* r->length is now just compressed */ 405 /* r->length is now just compressed */
381 if ((sess != NULL) && (sess->read_compression != NULL)) 406 if (s->expand != NULL)
382 { 407 {
383 if (rr->length > 408 if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+extra)
384 (unsigned int)SSL3_RT_MAX_COMPRESSED_LENGTH+extra)
385 { 409 {
386 al=SSL_AD_RECORD_OVERFLOW; 410 al=SSL_AD_RECORD_OVERFLOW;
387 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_COMPRESSED_LENGTH_TOO_LONG); 411 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_COMPRESSED_LENGTH_TOO_LONG);
@@ -395,7 +419,7 @@ printf("\n");
395 } 419 }
396 } 420 }
397 421
398 if (rr->length > (unsigned int)SSL3_RT_MAX_PLAIN_LENGTH+extra) 422 if (rr->length > SSL3_RT_MAX_PLAIN_LENGTH+extra)
399 { 423 {
400 al=SSL_AD_RECORD_OVERFLOW; 424 al=SSL_AD_RECORD_OVERFLOW;
401 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_DATA_LENGTH_TOO_LONG); 425 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_DATA_LENGTH_TOO_LONG);
@@ -418,33 +442,62 @@ printf("\n");
418 if (rr->length == 0) goto again; 442 if (rr->length == 0) goto again;
419 443
420 return(1); 444 return(1);
445
446decryption_failed_or_bad_record_mac:
447 /* Separate 'decryption_failed' alert was introduced with TLS 1.0,
448 * SSL 3.0 only has 'bad_record_mac'. But unless a decryption
449 * failure is directly visible from the ciphertext anyway,
450 * we should not reveal which kind of error occured -- this
451 * might become visible to an attacker (e.g. via logfile) */
452 al=SSL_AD_BAD_RECORD_MAC;
453 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
421f_err: 454f_err:
422 ssl3_send_alert(s,SSL3_AL_FATAL,al); 455 ssl3_send_alert(s,SSL3_AL_FATAL,al);
423err: 456err:
424 return(ret); 457 return(ret);
425 } 458 }
426 459
427static int do_uncompress(ssl) 460static int do_uncompress(SSL *ssl)
428SSL *ssl;
429 { 461 {
462 int i;
463 SSL3_RECORD *rr;
464
465 rr= &(ssl->s3->rrec);
466 i=COMP_expand_block(ssl->expand,rr->comp,
467 SSL3_RT_MAX_PLAIN_LENGTH,rr->data,(int)rr->length);
468 if (i < 0)
469 return(0);
470 else
471 rr->length=i;
472 rr->data=rr->comp;
473
430 return(1); 474 return(1);
431 } 475 }
432 476
433static int do_compress(ssl) 477static int do_compress(SSL *ssl)
434SSL *ssl;
435 { 478 {
479 int i;
480 SSL3_RECORD *wr;
481
482 wr= &(ssl->s3->wrec);
483 i=COMP_compress_block(ssl->compress,wr->data,
484 SSL3_RT_MAX_COMPRESSED_LENGTH,
485 wr->input,(int)wr->length);
486 if (i < 0)
487 return(0);
488 else
489 wr->length=i;
490
491 wr->input=wr->data;
436 return(1); 492 return(1);
437 } 493 }
438 494
439/* Call this to write data 495/* Call this to write data in records of type 'type'
440 * It will return <= 0 if not all data has been sent or non-blocking IO. 496 * It will return <= 0 if not all data has been sent or non-blocking IO.
441 */ 497 */
442int ssl3_write_bytes(s,type,buf,len) 498int ssl3_write_bytes(SSL *s, int type, const void *buf_, int len)
443SSL *s;
444int type;
445char *buf;
446int len;
447 { 499 {
500 const unsigned char *buf=buf_;
448 unsigned int tot,n,nw; 501 unsigned int tot,n,nw;
449 int i; 502 int i;
450 503
@@ -459,7 +512,7 @@ int len;
459 if (i == 0) 512 if (i == 0)
460 { 513 {
461 SSLerr(SSL_F_SSL3_WRITE_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE); 514 SSLerr(SSL_F_SSL3_WRITE_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
462 return(-1); 515 return -1;
463 } 516 }
464 } 517 }
465 518
@@ -470,37 +523,41 @@ int len;
470 nw=SSL3_RT_MAX_PLAIN_LENGTH; 523 nw=SSL3_RT_MAX_PLAIN_LENGTH;
471 else 524 else
472 nw=n; 525 nw=n;
473 526
474 i=do_ssl3_write(s,type,&(buf[tot]),nw); 527 i=do_ssl3_write(s, type, &(buf[tot]), nw, 0);
475 if (i <= 0) 528 if (i <= 0)
476 { 529 {
477 s->s3->wnum=tot; 530 s->s3->wnum=tot;
478 return(i); 531 return i;
479 } 532 }
480 533
481 if (type == SSL3_RT_HANDSHAKE) 534 if ((i == (int)n) ||
482 ssl3_finish_mac(s,(unsigned char *)&(buf[tot]),i); 535 (type == SSL3_RT_APPLICATION_DATA &&
483 536 (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE)))
484 if (i == (int)n) return(tot+i); 537 {
538 /* next chunk of data should get another prepended empty fragment
539 * in ciphersuites with known-IV weakness: */
540 s->s3->empty_fragment_done = 0;
541
542 return tot+i;
543 }
485 544
486 n-=i; 545 n-=i;
487 tot+=i; 546 tot+=i;
488 } 547 }
489 } 548 }
490 549
491static int do_ssl3_write(s,type,buf,len) 550static int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
492SSL *s; 551 unsigned int len, int create_empty_fragment)
493int type;
494char *buf;
495unsigned int len;
496 { 552 {
497 unsigned char *p,*plen; 553 unsigned char *p,*plen;
498 int i,mac_size,clear=0; 554 int i,mac_size,clear=0;
555 int prefix_len = 0;
499 SSL3_RECORD *wr; 556 SSL3_RECORD *wr;
500 SSL3_BUFFER *wb; 557 SSL3_BUFFER *wb;
501 SSL_SESSION *sess; 558 SSL_SESSION *sess;
502 559
503 /* first check is there is a SSL3_RECORD still being written 560 /* first check if there is a SSL3_BUFFER still being written
504 * out. This will happen with non blocking IO */ 561 * out. This will happen with non blocking IO */
505 if (s->s3->wbuf.left != 0) 562 if (s->s3->wbuf.left != 0)
506 return(ssl3_write_pending(s,type,buf,len)); 563 return(ssl3_write_pending(s,type,buf,len));
@@ -514,8 +571,9 @@ unsigned int len;
514 /* if it went, fall through and send more stuff */ 571 /* if it went, fall through and send more stuff */
515 } 572 }
516 573
517 if (len <= 0) return(len); 574 if (len == 0 && !create_empty_fragment)
518 575 return 0;
576
519 wr= &(s->s3->wrec); 577 wr= &(s->s3->wrec);
520 wb= &(s->s3->wbuf); 578 wb= &(s->s3->wbuf);
521 sess=s->session; 579 sess=s->session;
@@ -530,19 +588,47 @@ unsigned int len;
530 else 588 else
531 mac_size=EVP_MD_size(s->write_hash); 589 mac_size=EVP_MD_size(s->write_hash);
532 590
533 p=wb->buf; 591 /* 'create_empty_fragment' is true only when this function calls itself */
592 if (!clear && !create_empty_fragment && !s->s3->empty_fragment_done)
593 {
594 /* countermeasure against known-IV weakness in CBC ciphersuites
595 * (see http://www.openssl.org/~bodo/tls-cbc.txt) */
596
597 if (s->s3->need_empty_fragments && type == SSL3_RT_APPLICATION_DATA)
598 {
599 /* recursive function call with 'create_empty_fragment' set;
600 * this prepares and buffers the data for an empty fragment
601 * (these 'prefix_len' bytes are sent out later
602 * together with the actual payload) */
603 prefix_len = do_ssl3_write(s, type, buf, 0, 1);
604 if (prefix_len <= 0)
605 goto err;
606
607 if (s->s3->wbuf.len < (size_t)prefix_len + SSL3_RT_MAX_PACKET_SIZE)
608 {
609 /* insufficient space */
610 SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);
611 goto err;
612 }
613 }
614
615 s->s3->empty_fragment_done = 1;
616 }
617
618 p = wb->buf + prefix_len;
534 619
535 /* write the header */ 620 /* write the header */
621
536 *(p++)=type&0xff; 622 *(p++)=type&0xff;
537 wr->type=type; 623 wr->type=type;
538 624
539 *(p++)=(s->version>>8); 625 *(p++)=(s->version>>8);
540 *(p++)=s->version&0xff; 626 *(p++)=s->version&0xff;
541 627
542 /* record where we are to write out packet length */ 628 /* field where we are to write out packet length */
543 plen=p; 629 plen=p;
544 p+=2; 630 p+=2;
545 631
546 /* lets setup the record stuff. */ 632 /* lets setup the record stuff. */
547 wr->data=p; 633 wr->data=p;
548 wr->length=(int)len; 634 wr->length=(int)len;
@@ -552,7 +638,7 @@ unsigned int len;
552 * wr->data */ 638 * wr->data */
553 639
554 /* first we compress */ 640 /* first we compress */
555 if ((sess != NULL) && (sess->write_compression != NULL)) 641 if (s->compress != NULL)
556 { 642 {
557 if (!do_compress(s)) 643 if (!do_compress(s))
558 { 644 {
@@ -590,32 +676,40 @@ unsigned int len;
590 wr->type=type; /* not needed but helps for debugging */ 676 wr->type=type; /* not needed but helps for debugging */
591 wr->length+=SSL3_RT_HEADER_LENGTH; 677 wr->length+=SSL3_RT_HEADER_LENGTH;
592 678
593 /* Now lets setup wb */ 679 if (create_empty_fragment)
594 wb->left=wr->length; 680 {
595 wb->offset=0; 681 /* we are in a recursive call;
682 * just return the length, don't write out anything here
683 */
684 return wr->length;
685 }
686
687 /* now let's set up wb */
688 wb->left = prefix_len + wr->length;
689 wb->offset = 0;
596 690
691 /* memorize arguments so that ssl3_write_pending can detect bad write retries later */
597 s->s3->wpend_tot=len; 692 s->s3->wpend_tot=len;
598 s->s3->wpend_buf=buf; 693 s->s3->wpend_buf=buf;
599 s->s3->wpend_type=type; 694 s->s3->wpend_type=type;
600 s->s3->wpend_ret=len; 695 s->s3->wpend_ret=len;
601 696
602 /* we now just need to write the buffer */ 697 /* we now just need to write the buffer */
603 return(ssl3_write_pending(s,type,buf,len)); 698 return ssl3_write_pending(s,type,buf,len);
604err: 699err:
605 return(-1); 700 return -1;
606 } 701 }
607 702
608/* if s->s3->wbuf.left != 0, we need to call this */ 703/* if s->s3->wbuf.left != 0, we need to call this */
609static int ssl3_write_pending(s,type,buf,len) 704static int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
610SSL *s; 705 unsigned int len)
611int type;
612char *buf;
613unsigned int len;
614 { 706 {
615 int i; 707 int i;
616 708
617/* XXXX */ 709/* XXXX */
618 if ((s->s3->wpend_tot > (int)len) || (s->s3->wpend_buf != buf) 710 if ((s->s3->wpend_tot > (int)len)
711 || ((s->s3->wpend_buf != buf) &&
712 !(s->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER))
619 || (s->s3->wpend_type != type)) 713 || (s->s3->wpend_type != type))
620 { 714 {
621 SSLerr(SSL_F_SSL3_WRITE_PENDING,SSL_R_BAD_WRITE_RETRY); 715 SSLerr(SSL_F_SSL3_WRITE_PENDING,SSL_R_BAD_WRITE_RETRY);
@@ -650,23 +744,77 @@ unsigned int len;
650 } 744 }
651 } 745 }
652 746
653int ssl3_read_bytes(s,type,buf,len) 747/* Return up to 'len' payload bytes received in 'type' records.
654SSL *s; 748 * 'type' is one of the following:
655int type; 749 *
656char *buf; 750 * - SSL3_RT_HANDSHAKE (when ssl3_get_message calls us)
657int len; 751 * - SSL3_RT_APPLICATION_DATA (when ssl3_read calls us)
752 * - 0 (during a shutdown, no data has to be returned)
753 *
754 * If we don't have stored data to work from, read a SSL/TLS record first
755 * (possibly multiple records if we still don't have anything to return).
756 *
757 * This function must handle any surprises the peer may have for us, such as
758 * Alert records (e.g. close_notify), ChangeCipherSpec records (not really
759 * a surprise, but handled as if it were), or renegotiation requests.
760 * Also if record payloads contain fragments too small to process, we store
761 * them until there is enough for the respective protocol (the record protocol
762 * may use arbitrary fragmentation and even interleaving):
763 * Change cipher spec protocol
764 * just 1 byte needed, no need for keeping anything stored
765 * Alert protocol
766 * 2 bytes needed (AlertLevel, AlertDescription)
767 * Handshake protocol
768 * 4 bytes needed (HandshakeType, uint24 length) -- we just have
769 * to detect unexpected Client Hello and Hello Request messages
770 * here, anything else is handled by higher layers
771 * Application data protocol
772 * none of our business
773 */
774int ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
658 { 775 {
659 int al,i,j,n,ret; 776 int al,i,j,ret;
777 unsigned int n;
660 SSL3_RECORD *rr; 778 SSL3_RECORD *rr;
661 void (*cb)()=NULL; 779 void (*cb)(const SSL *ssl,int type2,int val)=NULL;
662 BIO *bio;
663 780
664 if (s->s3->rbuf.buf == NULL) /* Not initalised yet */ 781 if (s->s3->rbuf.buf == NULL) /* Not initialized yet */
665 if (!ssl3_setup_buffers(s)) 782 if (!ssl3_setup_buffers(s))
666 return(-1); 783 return(-1);
667 784
785 if ((type && (type != SSL3_RT_APPLICATION_DATA) && (type != SSL3_RT_HANDSHAKE) && type) ||
786 (peek && (type != SSL3_RT_APPLICATION_DATA)))
787 {
788 SSLerr(SSL_F_SSL3_READ_BYTES, ERR_R_INTERNAL_ERROR);
789 return -1;
790 }
791
792 if ((type == SSL3_RT_HANDSHAKE) && (s->s3->handshake_fragment_len > 0))
793 /* (partially) satisfy request from storage */
794 {
795 unsigned char *src = s->s3->handshake_fragment;
796 unsigned char *dst = buf;
797 unsigned int k;
798
799 /* peek == 0 */
800 n = 0;
801 while ((len > 0) && (s->s3->handshake_fragment_len > 0))
802 {
803 *dst++ = *src++;
804 len--; s->s3->handshake_fragment_len--;
805 n++;
806 }
807 /* move any remaining fragment bytes: */
808 for (k = 0; k < s->s3->handshake_fragment_len; k++)
809 s->s3->handshake_fragment[k] = *src++;
810 return n;
811 }
812
813 /* Now s->s3->handshake_fragment_len == 0 if type == SSL3_RT_HANDSHAKE. */
814
668 if (!s->in_handshake && SSL_in_init(s)) 815 if (!s->in_handshake && SSL_in_init(s))
669 { 816 {
817 /* type == SSL3_RT_APPLICATION_DATA */
670 i=s->handshake_func(s); 818 i=s->handshake_func(s);
671 if (i < 0) return(i); 819 if (i < 0) return(i);
672 if (i == 0) 820 if (i == 0)
@@ -678,13 +826,13 @@ int len;
678start: 826start:
679 s->rwstate=SSL_NOTHING; 827 s->rwstate=SSL_NOTHING;
680 828
681 /* s->s3->rrec.type - is the type of record 829 /* s->s3->rrec.type - is the type of record
682 * s->s3->rrec.data, - data 830 * s->s3->rrec.data, - data
683 * s->s3->rrec.off, - ofset into 'data' for next read 831 * s->s3->rrec.off, - offset into 'data' for next read
684 * s->s3->rrec.length, - number of bytes. */ 832 * s->s3->rrec.length, - number of bytes. */
685 rr= &(s->s3->rrec); 833 rr = &(s->s3->rrec);
686 834
687 /* get new packet */ 835 /* get new packet if necessary */
688 if ((rr->length == 0) || (s->rstate == SSL_ST_READ_BODY)) 836 if ((rr->length == 0) || (s->rstate == SSL_ST_READ_BODY))
689 { 837 {
690 ret=ssl3_get_record(s); 838 ret=ssl3_get_record(s);
@@ -693,14 +841,17 @@ start:
693 841
694 /* we now have a packet which can be read and processed */ 842 /* we now have a packet which can be read and processed */
695 843
696 if (s->s3->change_cipher_spec && (rr->type != SSL3_RT_HANDSHAKE)) 844 if (s->s3->change_cipher_spec /* set when we receive ChangeCipherSpec,
845 * reset by ssl3_get_finished */
846 && (rr->type != SSL3_RT_HANDSHAKE))
697 { 847 {
698 al=SSL_AD_UNEXPECTED_MESSAGE; 848 al=SSL_AD_UNEXPECTED_MESSAGE;
699 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_DATA_BETWEEN_CCS_AND_FINISHED); 849 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_DATA_BETWEEN_CCS_AND_FINISHED);
700 goto err; 850 goto err;
701 } 851 }
702 852
703 /* If the other end has shutdown, throw anything we read away */ 853 /* If the other end has shut down, throw anything we read away
854 * (even in 'peek' mode) */
704 if (s->shutdown & SSL_RECEIVED_SHUTDOWN) 855 if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
705 { 856 {
706 rr->length=0; 857 rr->length=0;
@@ -708,19 +859,107 @@ start:
708 return(0); 859 return(0);
709 } 860 }
710 861
711 /* Check for an incoming 'Client Request' message */ 862
712 if ((rr->type == SSL3_RT_HANDSHAKE) && (rr->length == 4) && 863 if (type == rr->type) /* SSL3_RT_APPLICATION_DATA or SSL3_RT_HANDSHAKE */
713 (rr->data[0] == SSL3_MT_CLIENT_REQUEST) && 864 {
865 /* make sure that we are not getting application data when we
866 * are doing a handshake for the first time */
867 if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) &&
868 (s->enc_read_ctx == NULL))
869 {
870 al=SSL_AD_UNEXPECTED_MESSAGE;
871 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_APP_DATA_IN_HANDSHAKE);
872 goto f_err;
873 }
874
875 if (len <= 0) return(len);
876
877 if ((unsigned int)len > rr->length)
878 n = rr->length;
879 else
880 n = (unsigned int)len;
881
882 memcpy(buf,&(rr->data[rr->off]),n);
883 if (!peek)
884 {
885 rr->length-=n;
886 rr->off+=n;
887 if (rr->length == 0)
888 {
889 s->rstate=SSL_ST_READ_HEADER;
890 rr->off=0;
891 }
892 }
893 return(n);
894 }
895
896
897 /* If we get here, then type != rr->type; if we have a handshake
898 * message, then it was unexpected (Hello Request or Client Hello). */
899
900 /* In case of record types for which we have 'fragment' storage,
901 * fill that so that we can process the data at a fixed place.
902 */
903 {
904 unsigned int dest_maxlen = 0;
905 unsigned char *dest = NULL;
906 unsigned int *dest_len = NULL;
907
908 if (rr->type == SSL3_RT_HANDSHAKE)
909 {
910 dest_maxlen = sizeof s->s3->handshake_fragment;
911 dest = s->s3->handshake_fragment;
912 dest_len = &s->s3->handshake_fragment_len;
913 }
914 else if (rr->type == SSL3_RT_ALERT)
915 {
916 dest_maxlen = sizeof s->s3->alert_fragment;
917 dest = s->s3->alert_fragment;
918 dest_len = &s->s3->alert_fragment_len;
919 }
920
921 if (dest_maxlen > 0)
922 {
923 n = dest_maxlen - *dest_len; /* available space in 'dest' */
924 if (rr->length < n)
925 n = rr->length; /* available bytes */
926
927 /* now move 'n' bytes: */
928 while (n-- > 0)
929 {
930 dest[(*dest_len)++] = rr->data[rr->off++];
931 rr->length--;
932 }
933
934 if (*dest_len < dest_maxlen)
935 goto start; /* fragment was too small */
936 }
937 }
938
939 /* s->s3->handshake_fragment_len == 4 iff rr->type == SSL3_RT_HANDSHAKE;
940 * s->s3->alert_fragment_len == 2 iff rr->type == SSL3_RT_ALERT.
941 * (Possibly rr is 'empty' now, i.e. rr->length may be 0.) */
942
943 /* If we are a client, check for an incoming 'Hello Request': */
944 if ((!s->server) &&
945 (s->s3->handshake_fragment_len >= 4) &&
946 (s->s3->handshake_fragment[0] == SSL3_MT_HELLO_REQUEST) &&
714 (s->session != NULL) && (s->session->cipher != NULL)) 947 (s->session != NULL) && (s->session->cipher != NULL))
715 { 948 {
716 if ((rr->data[1] != 0) || (rr->data[2] != 0) || 949 s->s3->handshake_fragment_len = 0;
717 (rr->data[3] != 0)) 950
951 if ((s->s3->handshake_fragment[1] != 0) ||
952 (s->s3->handshake_fragment[2] != 0) ||
953 (s->s3->handshake_fragment[3] != 0))
718 { 954 {
719 al=SSL_AD_DECODE_ERROR; 955 al=SSL_AD_DECODE_ERROR;
720 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_CLIENT_REQUEST); 956 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_HELLO_REQUEST);
721 goto err; 957 goto err;
722 } 958 }
723 959
960 if (s->msg_callback)
961 s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, s->s3->handshake_fragment, 4, s, s->msg_callback_arg);
962
724 if (SSL_is_init_finished(s) && 963 if (SSL_is_init_finished(s) &&
725 !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS) && 964 !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS) &&
726 !s->s3->renegotiate) 965 !s->s3->renegotiate)
@@ -728,228 +967,231 @@ start:
728 ssl3_renegotiate(s); 967 ssl3_renegotiate(s);
729 if (ssl3_renegotiate_check(s)) 968 if (ssl3_renegotiate_check(s))
730 { 969 {
731 n=s->handshake_func(s); 970 i=s->handshake_func(s);
732 if (n < 0) return(n); 971 if (i < 0) return(i);
733 if (n == 0) 972 if (i == 0)
734 { 973 {
735 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE); 974 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
736 return(-1); 975 return(-1);
737 } 976 }
977
978 if (!(s->mode & SSL_MODE_AUTO_RETRY))
979 {
980 if (s->s3->rbuf.left == 0) /* no read-ahead left? */
981 {
982 BIO *bio;
983 /* In the case where we try to read application data,
984 * but we trigger an SSL handshake, we return -1 with
985 * the retry option set. Otherwise renegotiation may
986 * cause nasty problems in the blocking world */
987 s->rwstate=SSL_READING;
988 bio=SSL_get_rbio(s);
989 BIO_clear_retry_flags(bio);
990 BIO_set_retry_read(bio);
991 return(-1);
992 }
993 }
738 } 994 }
739 } 995 }
740 rr->length=0; 996 /* we either finished a handshake or ignored the request,
741/* ZZZ */ goto start; 997 * now try again to obtain the (application) data we were asked for */
998 goto start;
742 } 999 }
743 1000
744 /* if it is not the type we want, or we have shutdown and want 1001 if (s->s3->alert_fragment_len >= 2)
745 * the peer shutdown */
746 if ((rr->type != type) || (s->shutdown & SSL_SENT_SHUTDOWN))
747 { 1002 {
748 if (rr->type == SSL3_RT_ALERT) 1003 int alert_level = s->s3->alert_fragment[0];
749 { 1004 int alert_descr = s->s3->alert_fragment[1];
750 if ((rr->length != 2) || (rr->off != 0))
751 {
752 al=SSL_AD_DECODE_ERROR;
753 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_ALERT_RECORD);
754 goto f_err;
755 }
756 1005
757 i=rr->data[0]; 1006 s->s3->alert_fragment_len = 0;
758 n=rr->data[1];
759 1007
760 /* clear from buffer */ 1008 if (s->msg_callback)
761 rr->length=0; 1009 s->msg_callback(0, s->version, SSL3_RT_ALERT, s->s3->alert_fragment, 2, s, s->msg_callback_arg);
762 1010
763 if (s->info_callback != NULL) 1011 if (s->info_callback != NULL)
764 cb=s->info_callback; 1012 cb=s->info_callback;
765 else if (s->ctx->info_callback != NULL) 1013 else if (s->ctx->info_callback != NULL)
766 cb=s->ctx->info_callback; 1014 cb=s->ctx->info_callback;
767 1015
768 if (cb != NULL) 1016 if (cb != NULL)
769 { 1017 {
770 j=(i<<8)|n; 1018 j = (alert_level << 8) | alert_descr;
771 cb(s,SSL_CB_READ_ALERT,j); 1019 cb(s, SSL_CB_READ_ALERT, j);
772 } 1020 }
773 1021
774 if (i == 1) 1022 if (alert_level == 1) /* warning */
775 { 1023 {
776 s->s3->warn_alert=n; 1024 s->s3->warn_alert = alert_descr;
777 if (n == SSL_AD_CLOSE_NOTIFY) 1025 if (alert_descr == SSL_AD_CLOSE_NOTIFY)
778 {
779 s->shutdown|=SSL_RECEIVED_SHUTDOWN;
780 return(0);
781 }
782 }
783 else if (i == 2)
784 { 1026 {
785 char tmp[16]; 1027 s->shutdown |= SSL_RECEIVED_SHUTDOWN;
786
787 s->rwstate=SSL_NOTHING;
788 s->s3->fatal_alert=n;
789 SSLerr(SSL_F_SSL3_READ_BYTES,1000+n);
790 sprintf(tmp,"%d",n);
791 ERR_add_error_data(2,"SSL alert number ",tmp);
792 s->shutdown|=SSL_RECEIVED_SHUTDOWN;
793 SSL_CTX_remove_session(s->ctx,s->session);
794 return(0); 1028 return(0);
795 } 1029 }
796 else
797 {
798 al=SSL_AD_ILLEGAL_PARAMETER;
799 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNKNOWN_ALERT_TYPE);
800 goto f_err;
801 }
802
803 rr->length=0;
804 goto start;
805 } 1030 }
806 1031 else if (alert_level == 2) /* fatal */
807 if (s->shutdown & SSL_SENT_SHUTDOWN)
808 { 1032 {
1033 char tmp[16];
1034
809 s->rwstate=SSL_NOTHING; 1035 s->rwstate=SSL_NOTHING;
810 rr->length=0; 1036 s->s3->fatal_alert = alert_descr;
1037 SSLerr(SSL_F_SSL3_READ_BYTES, SSL_AD_REASON_OFFSET + alert_descr);
1038 BIO_snprintf(tmp,sizeof tmp,"%d",alert_descr);
1039 ERR_add_error_data(2,"SSL alert number ",tmp);
1040 s->shutdown|=SSL_RECEIVED_SHUTDOWN;
1041 SSL_CTX_remove_session(s->ctx,s->session);
811 return(0); 1042 return(0);
812 } 1043 }
813 1044 else
814 if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC)
815 { 1045 {
816 if ( (rr->length != 1) || (rr->off != 0) || 1046 al=SSL_AD_ILLEGAL_PARAMETER;
817 (rr->data[0] != SSL3_MT_CCS)) 1047 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNKNOWN_ALERT_TYPE);
818 { 1048 goto f_err;
819 i=SSL_AD_ILLEGAL_PARAMETER;
820 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_CHANGE_CIPHER_SPEC);
821 goto err;
822 }
823
824 rr->length=0;
825 s->s3->change_cipher_spec=1;
826 if (!do_change_cipher_spec(s))
827 goto err;
828 else
829 goto start;
830 } 1049 }
831 1050
832 /* else we have a handshake */ 1051 goto start;
833 if ((rr->type == SSL3_RT_HANDSHAKE) && 1052 }
834 !s->in_handshake) 1053
1054 if (s->shutdown & SSL_SENT_SHUTDOWN) /* but we have not received a shutdown */
1055 {
1056 s->rwstate=SSL_NOTHING;
1057 rr->length=0;
1058 return(0);
1059 }
1060
1061 if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC)
1062 {
1063 /* 'Change Cipher Spec' is just a single byte, so we know
1064 * exactly what the record payload has to look like */
1065 if ( (rr->length != 1) || (rr->off != 0) ||
1066 (rr->data[0] != SSL3_MT_CCS))
835 { 1067 {
836 if (((s->state&SSL_ST_MASK) == SSL_ST_OK) && 1068 i=SSL_AD_ILLEGAL_PARAMETER;
837 !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS)) 1069 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_BAD_CHANGE_CIPHER_SPEC);
838 { 1070 goto err;
839 s->state=SSL_ST_BEFORE; 1071 }
840 s->new_session=1; 1072
841 } 1073 rr->length=0;
842 n=s->handshake_func(s);
843 if (n < 0) return(n);
844 if (n == 0)
845 {
846 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
847 return(-1);
848 }
849 1074
850 /* In the case where we try to read application data 1075 if (s->msg_callback)
851 * the first time, but we trigger an SSL handshake, we 1076 s->msg_callback(0, s->version, SSL3_RT_CHANGE_CIPHER_SPEC, rr->data, 1, s, s->msg_callback_arg);
852 * return -1 with the retry option set. I do this
853 * otherwise renegotiation can cause nasty problems
854 * in the non-blocking world */
855 1077
856 s->rwstate=SSL_READING; 1078 s->s3->change_cipher_spec=1;
857 bio=SSL_get_rbio(s); 1079 if (!do_change_cipher_spec(s))
858 BIO_clear_retry_flags(bio); 1080 goto err;
859 BIO_set_retry_read(bio); 1081 else
1082 goto start;
1083 }
1084
1085 /* Unexpected handshake message (Client Hello, or protocol violation) */
1086 if ((s->s3->handshake_fragment_len >= 4) && !s->in_handshake)
1087 {
1088 if (((s->state&SSL_ST_MASK) == SSL_ST_OK) &&
1089 !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS))
1090 {
1091#if 0 /* worked only because C operator preferences are not as expected (and
1092 * because this is not really needed for clients except for detecting
1093 * protocol violations): */
1094 s->state=SSL_ST_BEFORE|(s->server)
1095 ?SSL_ST_ACCEPT
1096 :SSL_ST_CONNECT;
1097#else
1098 s->state = s->server ? SSL_ST_ACCEPT : SSL_ST_CONNECT;
1099#endif
1100 s->new_session=1;
1101 }
1102 i=s->handshake_func(s);
1103 if (i < 0) return(i);
1104 if (i == 0)
1105 {
1106 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
860 return(-1); 1107 return(-1);
861 } 1108 }
862 1109
863 switch (rr->type) 1110 if (!(s->mode & SSL_MODE_AUTO_RETRY))
864 { 1111 {
865 default: 1112 if (s->s3->rbuf.left == 0) /* no read-ahead left? */
866#ifndef NO_TLS
867 /* TLS just ignores unknown message types */
868 if (s->version == TLS1_VERSION)
869 {
870 goto start;
871 }
872#endif
873 case SSL3_RT_CHANGE_CIPHER_SPEC:
874 case SSL3_RT_ALERT:
875 case SSL3_RT_HANDSHAKE:
876 al=SSL_AD_UNEXPECTED_MESSAGE;
877 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
878 goto f_err;
879 case SSL3_RT_APPLICATION_DATA:
880 /* At this point, we were expecting something else,
881 * but have application data. What we do is set the
882 * error, and return -1. On the way out, if the
883 * library was running inside ssl3_read() and it makes
884 * sense to read application data at this point, we
885 * will indulge it. This will mostly happen during
886 * session renegotiation.
887 */
888 if (s->s3->in_read_app_data &&
889 (s->s3->total_renegotiations != 0) &&
890 ((
891 (s->state & SSL_ST_CONNECT) &&
892 (s->state >= SSL3_ST_CW_CLNT_HELLO_A) &&
893 (s->state <= SSL3_ST_CR_SRVR_HELLO_A)
894 ) || (
895 (s->state & SSL_ST_ACCEPT) &&
896 (s->state <= SSL3_ST_SW_HELLO_REQ_A) &&
897 (s->state >= SSL3_ST_SR_CLNT_HELLO_A)
898 )
899 ))
900 { 1113 {
901 s->s3->in_read_app_data=0; 1114 BIO *bio;
1115 /* In the case where we try to read application data,
1116 * but we trigger an SSL handshake, we return -1 with
1117 * the retry option set. Otherwise renegotiation may
1118 * cause nasty problems in the blocking world */
1119 s->rwstate=SSL_READING;
1120 bio=SSL_get_rbio(s);
1121 BIO_clear_retry_flags(bio);
1122 BIO_set_retry_read(bio);
902 return(-1); 1123 return(-1);
903 } 1124 }
904 else
905 {
906 al=SSL_AD_UNEXPECTED_MESSAGE;
907 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
908 goto f_err;
909 }
910 } 1125 }
1126 goto start;
911 } 1127 }
912 1128
913 /* make sure that we are not getting application data when we 1129 switch (rr->type)
914 * are doing a handshake for the first time */
915 if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) &&
916 (s->enc_read_ctx == NULL))
917 { 1130 {
1131 default:
1132#ifndef OPENSSL_NO_TLS
1133 /* TLS just ignores unknown message types */
1134 if (s->version == TLS1_VERSION)
1135 {
1136 rr->length = 0;
1137 goto start;
1138 }
1139#endif
918 al=SSL_AD_UNEXPECTED_MESSAGE; 1140 al=SSL_AD_UNEXPECTED_MESSAGE;
919 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_APP_DATA_IN_HANDSHAKE); 1141 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
920 goto f_err; 1142 goto f_err;
1143 case SSL3_RT_CHANGE_CIPHER_SPEC:
1144 case SSL3_RT_ALERT:
1145 case SSL3_RT_HANDSHAKE:
1146 /* we already handled all of these, with the possible exception
1147 * of SSL3_RT_HANDSHAKE when s->in_handshake is set, but that
1148 * should not happen when type != rr->type */
1149 al=SSL_AD_UNEXPECTED_MESSAGE;
1150 SSLerr(SSL_F_SSL3_READ_BYTES,ERR_R_INTERNAL_ERROR);
1151 goto f_err;
1152 case SSL3_RT_APPLICATION_DATA:
1153 /* At this point, we were expecting handshake data,
1154 * but have application data. If the library was
1155 * running inside ssl3_read() (i.e. in_read_app_data
1156 * is set) and it makes sense to read application data
1157 * at this point (session renegotiation not yet started),
1158 * we will indulge it.
1159 */
1160 if (s->s3->in_read_app_data &&
1161 (s->s3->total_renegotiations != 0) &&
1162 ((
1163 (s->state & SSL_ST_CONNECT) &&
1164 (s->state >= SSL3_ST_CW_CLNT_HELLO_A) &&
1165 (s->state <= SSL3_ST_CR_SRVR_HELLO_A)
1166 ) || (
1167 (s->state & SSL_ST_ACCEPT) &&
1168 (s->state <= SSL3_ST_SW_HELLO_REQ_A) &&
1169 (s->state >= SSL3_ST_SR_CLNT_HELLO_A)
1170 )
1171 ))
1172 {
1173 s->s3->in_read_app_data=2;
1174 return(-1);
1175 }
1176 else
1177 {
1178 al=SSL_AD_UNEXPECTED_MESSAGE;
1179 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
1180 goto f_err;
1181 }
921 } 1182 }
1183 /* not reached */
922 1184
923 if (len <= 0) return(len);
924
925 if ((unsigned int)len > rr->length)
926 n=rr->length;
927 else
928 n=len;
929
930 memcpy(buf,&(rr->data[rr->off]),(unsigned int)n);
931 rr->length-=n;
932 rr->off+=n;
933 if (rr->length <= 0)
934 {
935 s->rstate=SSL_ST_READ_HEADER;
936 rr->off=0;
937 }
938
939 if (type == SSL3_RT_HANDSHAKE)
940 ssl3_finish_mac(s,(unsigned char *)buf,n);
941 return(n);
942f_err: 1185f_err:
943 ssl3_send_alert(s,SSL3_AL_FATAL,al); 1186 ssl3_send_alert(s,SSL3_AL_FATAL,al);
944err: 1187err:
945 return(-1); 1188 return(-1);
946 } 1189 }
947 1190
948static int do_change_cipher_spec(s) 1191static int do_change_cipher_spec(SSL *s)
949SSL *s;
950 { 1192 {
951 int i; 1193 int i;
952 unsigned char *sender; 1194 const char *sender;
953 int slen; 1195 int slen;
954 1196
955 if (s->state & SSL_ST_ACCEPT) 1197 if (s->state & SSL_ST_ACCEPT)
@@ -971,46 +1213,29 @@ SSL *s;
971 * the finished message */ 1213 * the finished message */
972 if (s->state & SSL_ST_CONNECT) 1214 if (s->state & SSL_ST_CONNECT)
973 { 1215 {
974 sender=s->method->ssl3_enc->server_finished; 1216 sender=s->method->ssl3_enc->server_finished_label;
975 slen=s->method->ssl3_enc->server_finished_len; 1217 slen=s->method->ssl3_enc->server_finished_label_len;
976 } 1218 }
977 else 1219 else
978 { 1220 {
979 sender=s->method->ssl3_enc->client_finished; 1221 sender=s->method->ssl3_enc->client_finished_label;
980 slen=s->method->ssl3_enc->client_finished_len; 1222 slen=s->method->ssl3_enc->client_finished_label_len;
981 } 1223 }
982 1224
983 s->method->ssl3_enc->final_finish_mac(s, 1225 s->s3->tmp.peer_finish_md_len = s->method->ssl3_enc->final_finish_mac(s,
984 &(s->s3->finish_dgst1), 1226 &(s->s3->finish_dgst1),
985 &(s->s3->finish_dgst2), 1227 &(s->s3->finish_dgst2),
986 sender,slen,&(s->s3->tmp.finish_md[0])); 1228 sender,slen,s->s3->tmp.peer_finish_md);
987 1229
988 return(1); 1230 return(1);
989 } 1231 }
990 1232
991int ssl3_do_write(s,type) 1233void ssl3_send_alert(SSL *s, int level, int desc)
992SSL *s;
993int type;
994 {
995 int ret;
996
997 ret=ssl3_write_bytes(s,type,(char *)
998 &(s->init_buf->data[s->init_off]),s->init_num);
999 if (ret == s->init_num)
1000 return(1);
1001 if (ret < 0) return(-1);
1002 s->init_off+=ret;
1003 s->init_num-=ret;
1004 return(0);
1005 }
1006
1007void ssl3_send_alert(s,level,desc)
1008SSL *s;
1009int level;
1010int desc;
1011 { 1234 {
1012 /* Map tls/ssl alert value to correct one */ 1235 /* Map tls/ssl alert value to correct one */
1013 desc=s->method->ssl3_enc->alert_value(desc); 1236 desc=s->method->ssl3_enc->alert_value(desc);
1237 if (s->version == SSL3_VERSION && desc == SSL_AD_PROTOCOL_VERSION)
1238 desc = SSL_AD_HANDSHAKE_FAILURE; /* SSL 3.0 does not have protocol_version alerts */
1014 if (desc < 0) return; 1239 if (desc < 0) return;
1015 /* If a fatal one, remove from cache */ 1240 /* If a fatal one, remove from cache */
1016 if ((level == 2) && (s->session != NULL)) 1241 if ((level == 2) && (s->session != NULL))
@@ -1019,37 +1244,39 @@ int desc;
1019 s->s3->alert_dispatch=1; 1244 s->s3->alert_dispatch=1;
1020 s->s3->send_alert[0]=level; 1245 s->s3->send_alert[0]=level;
1021 s->s3->send_alert[1]=desc; 1246 s->s3->send_alert[1]=desc;
1022 if (s->s3->wbuf.left == 0) /* data still being written out */ 1247 if (s->s3->wbuf.left == 0) /* data still being written out? */
1023 ssl3_dispatch_alert(s); 1248 ssl3_dispatch_alert(s);
1024 /* else data is still being written out, we will get written 1249 /* else data is still being written out, we will get written
1025 * some time in the future */ 1250 * some time in the future */
1026 } 1251 }
1027 1252
1028int ssl3_dispatch_alert(s) 1253int ssl3_dispatch_alert(SSL *s)
1029SSL *s;
1030 { 1254 {
1031 int i,j; 1255 int i,j;
1032 void (*cb)()=NULL; 1256 void (*cb)(const SSL *ssl,int type,int val)=NULL;
1033 1257
1034 s->s3->alert_dispatch=0; 1258 s->s3->alert_dispatch=0;
1035 i=do_ssl3_write(s,SSL3_RT_ALERT,&(s->s3->send_alert[0]),2); 1259 i = do_ssl3_write(s, SSL3_RT_ALERT, &s->s3->send_alert[0], 2, 0);
1036 if (i <= 0) 1260 if (i <= 0)
1037 { 1261 {
1038 s->s3->alert_dispatch=1; 1262 s->s3->alert_dispatch=1;
1039 } 1263 }
1040 else 1264 else
1041 { 1265 {
1042 /* If it is important, send it now. If the message 1266 /* Alert sent to BIO. If it is important, flush it now.
1043 * does not get sent due to non-blocking IO, we will 1267 * If the message does not get sent due to non-blocking IO,
1044 * not worry too much. */ 1268 * we will not worry too much. */
1045 if (s->s3->send_alert[0] == SSL3_AL_FATAL) 1269 if (s->s3->send_alert[0] == SSL3_AL_FATAL)
1046 BIO_flush(s->wbio); 1270 (void)BIO_flush(s->wbio);
1271
1272 if (s->msg_callback)
1273 s->msg_callback(1, s->version, SSL3_RT_ALERT, s->s3->send_alert, 2, s, s->msg_callback_arg);
1047 1274
1048 if (s->info_callback != NULL) 1275 if (s->info_callback != NULL)
1049 cb=s->info_callback; 1276 cb=s->info_callback;
1050 else if (s->ctx->info_callback != NULL) 1277 else if (s->ctx->info_callback != NULL)
1051 cb=s->ctx->info_callback; 1278 cb=s->ctx->info_callback;
1052 1279
1053 if (cb != NULL) 1280 if (cb != NULL)
1054 { 1281 {
1055 j=(s->s3->send_alert[0]<<8)|s->s3->send_alert[1]; 1282 j=(s->s3->send_alert[0]<<8)|s->s3->send_alert[1];
@@ -1058,4 +1285,3 @@ SSL *s;
1058 } 1285 }
1059 return(i); 1286 return(i);
1060 } 1287 }
1061
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-04-29 02:09:30 +0000