]>
Commit | Line | Data |
---|---|---|
36d16f8e BL |
1 | /* ssl/d1_pkt.c */ |
2 | /* | |
3 | * DTLS implementation written by Nagendra Modadugu | |
4 | * (nagendra@cs.stanford.edu) for the OpenSSL project 2005. | |
5 | */ | |
6 | /* ==================================================================== | |
7 | * Copyright (c) 1998-2005 The OpenSSL Project. All rights reserved. | |
8 | * | |
9 | * Redistribution and use in source and binary forms, with or without | |
10 | * modification, are permitted provided that the following conditions | |
11 | * are met: | |
12 | * | |
13 | * 1. Redistributions of source code must retain the above copyright | |
14 | * notice, this list of conditions and the following disclaimer. | |
15 | * | |
16 | * 2. Redistributions in binary form must reproduce the above copyright | |
17 | * notice, this list of conditions and the following disclaimer in | |
18 | * the documentation and/or other materials provided with the | |
19 | * distribution. | |
20 | * | |
21 | * 3. All advertising materials mentioning features or use of this | |
22 | * software must display the following acknowledgment: | |
23 | * "This product includes software developed by the OpenSSL Project | |
24 | * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" | |
25 | * | |
26 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | |
27 | * endorse or promote products derived from this software without | |
28 | * prior written permission. For written permission, please contact | |
29 | * openssl-core@openssl.org. | |
30 | * | |
31 | * 5. Products derived from this software may not be called "OpenSSL" | |
32 | * nor may "OpenSSL" appear in their names without prior written | |
33 | * permission of the OpenSSL Project. | |
34 | * | |
35 | * 6. Redistributions of any form whatsoever must retain the following | |
36 | * acknowledgment: | |
37 | * "This product includes software developed by the OpenSSL Project | |
38 | * for use in the OpenSSL Toolkit (http://www.openssl.org/)" | |
39 | * | |
40 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | |
41 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
42 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
43 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | |
44 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
45 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | |
46 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
47 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
49 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
50 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | |
51 | * OF THE POSSIBILITY OF SUCH DAMAGE. | |
52 | * ==================================================================== | |
53 | * | |
54 | * This product includes cryptographic software written by Eric Young | |
55 | * (eay@cryptsoft.com). This product includes software written by Tim | |
56 | * Hudson (tjh@cryptsoft.com). | |
57 | * | |
58 | */ | |
59 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | |
60 | * All rights reserved. | |
61 | * | |
62 | * This package is an SSL implementation written | |
63 | * by Eric Young (eay@cryptsoft.com). | |
64 | * The implementation was written so as to conform with Netscapes SSL. | |
65 | * | |
66 | * This library is free for commercial and non-commercial use as long as | |
67 | * the following conditions are aheared to. The following conditions | |
68 | * apply to all code found in this distribution, be it the RC4, RSA, | |
69 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | |
70 | * included with this distribution is covered by the same copyright terms | |
71 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | |
72 | * | |
73 | * Copyright remains Eric Young's, and as such any Copyright notices in | |
74 | * the code are not to be removed. | |
75 | * If this package is used in a product, Eric Young should be given attribution | |
76 | * as the author of the parts of the library used. | |
77 | * This can be in the form of a textual message at program startup or | |
78 | * in documentation (online or textual) provided with the package. | |
79 | * | |
80 | * Redistribution and use in source and binary forms, with or without | |
81 | * modification, are permitted provided that the following conditions | |
82 | * are met: | |
83 | * 1. Redistributions of source code must retain the copyright | |
84 | * notice, this list of conditions and the following disclaimer. | |
85 | * 2. Redistributions in binary form must reproduce the above copyright | |
86 | * notice, this list of conditions and the following disclaimer in the | |
87 | * documentation and/or other materials provided with the distribution. | |
88 | * 3. All advertising materials mentioning features or use of this software | |
89 | * must display the following acknowledgement: | |
90 | * "This product includes cryptographic software written by | |
91 | * Eric Young (eay@cryptsoft.com)" | |
92 | * The word 'cryptographic' can be left out if the rouines from the library | |
93 | * being used are not cryptographic related :-). | |
94 | * 4. If you include any Windows specific code (or a derivative thereof) from | |
95 | * the apps directory (application code) you must include an acknowledgement: | |
96 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | |
97 | * | |
98 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | |
99 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
100 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
101 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | |
102 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
103 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
104 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
105 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
106 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
107 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
108 | * SUCH DAMAGE. | |
109 | * | |
110 | * The licence and distribution terms for any publically available version or | |
111 | * derivative of this code cannot be changed. i.e. this code cannot simply be | |
112 | * copied and put under another distribution licence | |
113 | * [including the GNU Public Licence.] | |
114 | */ | |
115 | ||
116 | #include <stdio.h> | |
117 | #include <errno.h> | |
118 | #define USE_SOCKETS | |
119 | #include "ssl_locl.h" | |
120 | #include <openssl/evp.h> | |
121 | #include <openssl/buffer.h> | |
122 | #include <openssl/pqueue.h> | |
d527834a | 123 | #include <openssl/rand.h> |
36d16f8e | 124 | |
50ec3951 | 125 | /* mod 128 saturating subtract of two 64-bit values in big-endian order */ |
dffdb56b | 126 | static int satsub64be(const unsigned char *v1,const unsigned char *v2) |
50ec3951 AP |
127 | { int ret,sat,brw,i; |
128 | ||
129 | if (sizeof(long) == 8) do | |
130 | { const union { long one; char little; } is_endian = {1}; | |
131 | long l; | |
132 | ||
133 | if (is_endian.little) break; | |
134 | /* not reached on little-endians */ | |
135 | /* following test is redundant, because input is | |
136 | * always aligned, but I take no chances... */ | |
137 | if (((size_t)v1|(size_t)v2)&0x7) break; | |
138 | ||
44eff497 AP |
139 | l = *((long *)v1); |
140 | l -= *((long *)v2); | |
50ec3951 AP |
141 | if (l>128) return 128; |
142 | else if (l<-128) return -128; | |
143 | else return (int)l; | |
144 | } while (0); | |
145 | ||
146 | ret = (int)v1[7]-(int)v2[7]; | |
147 | sat = 0; | |
148 | brw = ret>>8; /* brw is either 0 or -1 */ | |
149 | if (ret & 0x80) | |
150 | { for (i=6;i>=0;i--) | |
151 | { brw += (int)v1[i]-(int)v2[i]; | |
152 | sat |= ~brw; | |
153 | brw >>= 8; | |
dffdb56b | 154 | } |
dffdb56b | 155 | } |
50ec3951 AP |
156 | else |
157 | { for (i=6;i>=0;i--) | |
158 | { brw += (int)v1[i]-(int)v2[i]; | |
159 | sat |= brw; | |
160 | brw >>= 8; | |
161 | } | |
162 | } | |
163 | brw <<= 8; /* brw is either 0 or -256 */ | |
164 | ||
165 | if (sat&0xff) return brw | 0x80; | |
166 | else return brw + (ret&0xFF); | |
167 | } | |
dffdb56b | 168 | |
36d16f8e BL |
169 | static int have_handshake_fragment(SSL *s, int type, unsigned char *buf, |
170 | int len, int peek); | |
50ec3951 | 171 | static int dtls1_record_replay_check(SSL *s, DTLS1_BITMAP *bitmap); |
36d16f8e BL |
172 | static void dtls1_record_bitmap_update(SSL *s, DTLS1_BITMAP *bitmap); |
173 | static DTLS1_BITMAP *dtls1_get_bitmap(SSL *s, SSL3_RECORD *rr, | |
174 | unsigned int *is_next_epoch); | |
175 | #if 0 | |
176 | static int dtls1_record_needs_buffering(SSL *s, SSL3_RECORD *rr, | |
177 | unsigned short *priority, unsigned long *offset); | |
178 | #endif | |
179 | static int dtls1_buffer_record(SSL *s, record_pqueue *q, | |
dffdb56b | 180 | unsigned char *priority); |
36d16f8e | 181 | static int dtls1_process_record(SSL *s); |
36d16f8e BL |
182 | static void dtls1_clear_timeouts(SSL *s); |
183 | ||
36d16f8e BL |
184 | /* copy buffered record into SSL structure */ |
185 | static int | |
186 | dtls1_copy_record(SSL *s, pitem *item) | |
187 | { | |
188 | DTLS1_RECORD_DATA *rdata; | |
189 | ||
190 | rdata = (DTLS1_RECORD_DATA *)item->data; | |
191 | ||
192 | if (s->s3->rbuf.buf != NULL) | |
193 | OPENSSL_free(s->s3->rbuf.buf); | |
194 | ||
195 | s->packet = rdata->packet; | |
196 | s->packet_length = rdata->packet_length; | |
197 | memcpy(&(s->s3->rbuf), &(rdata->rbuf), sizeof(SSL3_BUFFER)); | |
198 | memcpy(&(s->s3->rrec), &(rdata->rrec), sizeof(SSL3_RECORD)); | |
b7463c88 DSH |
199 | |
200 | /* Set proper sequence number for mac calculation */ | |
201 | memcpy(&(s->s3->read_sequence[2]), &(rdata->packet[5]), 6); | |
36d16f8e BL |
202 | |
203 | return(1); | |
204 | } | |
205 | ||
206 | ||
207 | static int | |
dffdb56b AP |
208 | dtls1_buffer_record(SSL *s, record_pqueue *queue, unsigned char *priority) |
209 | { | |
210 | DTLS1_RECORD_DATA *rdata; | |
36d16f8e BL |
211 | pitem *item; |
212 | ||
8d932f6f DSH |
213 | /* Limit the size of the queue to prevent DOS attacks */ |
214 | if (pqueue_size(queue->q) >= 100) | |
215 | return 0; | |
216 | ||
36d16f8e BL |
217 | rdata = OPENSSL_malloc(sizeof(DTLS1_RECORD_DATA)); |
218 | item = pitem_new(priority, rdata); | |
219 | if (rdata == NULL || item == NULL) | |
220 | { | |
221 | if (rdata != NULL) OPENSSL_free(rdata); | |
222 | if (item != NULL) pitem_free(item); | |
223 | ||
beb056b3 | 224 | SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR); |
36d16f8e BL |
225 | return(0); |
226 | } | |
227 | ||
228 | rdata->packet = s->packet; | |
229 | rdata->packet_length = s->packet_length; | |
230 | memcpy(&(rdata->rbuf), &(s->s3->rbuf), sizeof(SSL3_BUFFER)); | |
231 | memcpy(&(rdata->rrec), &(s->s3->rrec), sizeof(SSL3_RECORD)); | |
232 | ||
233 | item->data = rdata; | |
234 | ||
235 | /* insert should not fail, since duplicates are dropped */ | |
236 | if (pqueue_insert(queue->q, item) == NULL) | |
237 | { | |
238 | OPENSSL_free(rdata); | |
239 | pitem_free(item); | |
240 | return(0); | |
241 | } | |
242 | ||
243 | s->packet = NULL; | |
244 | s->packet_length = 0; | |
245 | memset(&(s->s3->rbuf), 0, sizeof(SSL3_BUFFER)); | |
246 | memset(&(s->s3->rrec), 0, sizeof(SSL3_RECORD)); | |
247 | ||
8c5a2bd6 NL |
248 | if (!ssl3_setup_buffers(s)) |
249 | { | |
250 | SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR); | |
251 | OPENSSL_free(rdata); | |
252 | pitem_free(item); | |
253 | return(0); | |
254 | } | |
36d16f8e BL |
255 | |
256 | return(1); | |
dffdb56b | 257 | } |
36d16f8e BL |
258 | |
259 | ||
260 | static int | |
261 | dtls1_retrieve_buffered_record(SSL *s, record_pqueue *queue) | |
262 | { | |
263 | pitem *item; | |
264 | ||
265 | item = pqueue_pop(queue->q); | |
266 | if (item) | |
267 | { | |
268 | dtls1_copy_record(s, item); | |
269 | ||
270 | OPENSSL_free(item->data); | |
271 | pitem_free(item); | |
272 | ||
273 | return(1); | |
274 | } | |
275 | ||
276 | return(0); | |
277 | } | |
278 | ||
279 | ||
280 | /* retrieve a buffered record that belongs to the new epoch, i.e., not processed | |
281 | * yet */ | |
282 | #define dtls1_get_unprocessed_record(s) \ | |
283 | dtls1_retrieve_buffered_record((s), \ | |
284 | &((s)->d1->unprocessed_rcds)) | |
285 | ||
286 | /* retrieve a buffered record that belongs to the current epoch, ie, processed */ | |
287 | #define dtls1_get_processed_record(s) \ | |
288 | dtls1_retrieve_buffered_record((s), \ | |
289 | &((s)->d1->processed_rcds)) | |
290 | ||
291 | static int | |
292 | dtls1_process_buffered_records(SSL *s) | |
293 | { | |
294 | pitem *item; | |
295 | ||
296 | item = pqueue_peek(s->d1->unprocessed_rcds.q); | |
297 | if (item) | |
298 | { | |
36d16f8e BL |
299 | /* Check if epoch is current. */ |
300 | if (s->d1->unprocessed_rcds.epoch != s->d1->r_epoch) | |
301 | return(1); /* Nothing to do. */ | |
302 | ||
303 | /* Process all the records. */ | |
304 | while (pqueue_peek(s->d1->unprocessed_rcds.q)) | |
305 | { | |
306 | dtls1_get_unprocessed_record(s); | |
307 | if ( ! dtls1_process_record(s)) | |
308 | return(0); | |
309 | dtls1_buffer_record(s, &(s->d1->processed_rcds), | |
310 | s->s3->rrec.seq_num); | |
311 | } | |
312 | } | |
313 | ||
314 | /* sync epoch numbers once all the unprocessed records | |
315 | * have been processed */ | |
316 | s->d1->processed_rcds.epoch = s->d1->r_epoch; | |
317 | s->d1->unprocessed_rcds.epoch = s->d1->r_epoch + 1; | |
318 | ||
319 | return(1); | |
320 | } | |
321 | ||
322 | ||
323 | #if 0 | |
324 | ||
325 | static int | |
326 | dtls1_get_buffered_record(SSL *s) | |
327 | { | |
328 | pitem *item; | |
188b0579 RL |
329 | PQ_64BIT priority = |
330 | (((PQ_64BIT)s->d1->handshake_read_seq) << 32) | | |
331 | ((PQ_64BIT)s->d1->r_msg_hdr.frag_off); | |
36d16f8e BL |
332 | |
333 | if ( ! SSL_in_init(s)) /* if we're not (re)negotiating, | |
334 | nothing buffered */ | |
335 | return 0; | |
336 | ||
337 | ||
338 | item = pqueue_peek(s->d1->rcvd_records); | |
339 | if (item && item->priority == priority) | |
340 | { | |
341 | /* Check if we've received the record of interest. It must be | |
342 | * a handshake record, since data records as passed up without | |
343 | * buffering */ | |
344 | DTLS1_RECORD_DATA *rdata; | |
345 | item = pqueue_pop(s->d1->rcvd_records); | |
346 | rdata = (DTLS1_RECORD_DATA *)item->data; | |
347 | ||
348 | if (s->s3->rbuf.buf != NULL) | |
349 | OPENSSL_free(s->s3->rbuf.buf); | |
350 | ||
351 | s->packet = rdata->packet; | |
352 | s->packet_length = rdata->packet_length; | |
353 | memcpy(&(s->s3->rbuf), &(rdata->rbuf), sizeof(SSL3_BUFFER)); | |
354 | memcpy(&(s->s3->rrec), &(rdata->rrec), sizeof(SSL3_RECORD)); | |
355 | ||
356 | OPENSSL_free(item->data); | |
357 | pitem_free(item); | |
358 | ||
359 | /* s->d1->next_expected_seq_num++; */ | |
360 | return(1); | |
361 | } | |
362 | ||
363 | return 0; | |
364 | } | |
365 | ||
366 | #endif | |
367 | ||
368 | static int | |
369 | dtls1_process_record(SSL *s) | |
370 | { | |
50ec3951 | 371 | int i,al; |
36d16f8e | 372 | int clear=0; |
50ec3951 | 373 | int enc_err; |
36d16f8e | 374 | SSL_SESSION *sess; |
50ec3951 | 375 | SSL3_RECORD *rr; |
36d16f8e BL |
376 | unsigned int mac_size; |
377 | unsigned char md[EVP_MAX_MD_SIZE]; | |
378 | ||
379 | ||
380 | rr= &(s->s3->rrec); | |
50ec3951 | 381 | sess = s->session; |
36d16f8e BL |
382 | |
383 | /* At this point, s->packet_length == SSL3_RT_HEADER_LNGTH + rr->length, | |
384 | * and we have that many bytes in s->packet | |
385 | */ | |
386 | rr->input= &(s->packet[DTLS1_RT_HEADER_LENGTH]); | |
387 | ||
388 | /* ok, we can now read from 's->packet' data into 'rr' | |
389 | * rr->input points at rr->length bytes, which | |
390 | * need to be copied into rr->data by either | |
391 | * the decryption or by the decompression | |
392 | * When the data is 'copied' into the rr->data buffer, | |
393 | * rr->input will be pointed at the new buffer */ | |
394 | ||
395 | /* We now have - encrypted [ MAC [ compressed [ plain ] ] ] | |
396 | * rr->length bytes of encrypted compressed stuff. */ | |
397 | ||
398 | /* check is not needed I believe */ | |
399 | if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) | |
400 | { | |
401 | al=SSL_AD_RECORD_OVERFLOW; | |
beb056b3 | 402 | SSLerr(SSL_F_DTLS1_PROCESS_RECORD,SSL_R_ENCRYPTED_LENGTH_TOO_LONG); |
36d16f8e BL |
403 | goto f_err; |
404 | } | |
405 | ||
406 | /* decrypt in place in 'rr->input' */ | |
407 | rr->data=rr->input; | |
408 | ||
409 | enc_err = s->method->ssl3_enc->enc(s,0); | |
410 | if (enc_err <= 0) | |
411 | { | |
d41ce00b DSH |
412 | /* decryption failed, silently discard message */ |
413 | if (enc_err < 0) | |
414 | { | |
415 | rr->length = 0; | |
416 | s->packet_length = 0; | |
417 | } | |
418 | goto err; | |
36d16f8e BL |
419 | } |
420 | ||
421 | #ifdef TLS_DEBUG | |
422 | printf("dec %d\n",rr->length); | |
423 | { unsigned int z; for (z=0; z<rr->length; z++) printf("%02X%c",rr->data[z],((z+1)%16)?' ':'\n'); } | |
424 | printf("\n"); | |
425 | #endif | |
426 | ||
427 | /* r->length is now the compressed data plus mac */ | |
50ec3951 | 428 | if ( (sess == NULL) || |
36d16f8e BL |
429 | (s->enc_read_ctx == NULL) || |
430 | (s->read_hash == NULL)) | |
fe1c7fec | 431 | clear=1; |
36d16f8e BL |
432 | |
433 | if (!clear) | |
434 | { | |
fe1c7fec | 435 | /* !clear => s->read_hash != NULL => mac_size != -1 */ |
0eab41fb BL |
436 | int t; |
437 | t=EVP_MD_CTX_size(s->read_hash); | |
438 | OPENSSL_assert(t >= 0); | |
439 | mac_size=t; | |
36d16f8e BL |
440 | |
441 | if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+mac_size) | |
442 | { | |
443 | #if 0 /* OK only for stream ciphers (then rr->length is visible from ciphertext anyway) */ | |
444 | al=SSL_AD_RECORD_OVERFLOW; | |
beb056b3 | 445 | SSLerr(SSL_F_DTLS1_PROCESS_RECORD,SSL_R_PRE_MAC_LENGTH_TOO_LONG); |
36d16f8e BL |
446 | goto f_err; |
447 | #else | |
3122d1d3 | 448 | goto err; |
36d16f8e BL |
449 | #endif |
450 | } | |
451 | /* check the MAC for rr->input (it's in mac_size bytes at the tail) */ | |
452 | if (rr->length < mac_size) | |
453 | { | |
454 | #if 0 /* OK only for stream ciphers */ | |
455 | al=SSL_AD_DECODE_ERROR; | |
beb056b3 | 456 | SSLerr(SSL_F_DTLS1_PROCESS_RECORD,SSL_R_LENGTH_TOO_SHORT); |
36d16f8e BL |
457 | goto f_err; |
458 | #else | |
3122d1d3 | 459 | goto err; |
36d16f8e BL |
460 | #endif |
461 | } | |
462 | rr->length-=mac_size; | |
463 | i=s->method->ssl3_enc->mac(s,md,0); | |
0eab41fb | 464 | if (i < 0 || memcmp(md,&(rr->data[rr->length]),mac_size) != 0) |
36d16f8e | 465 | { |
3122d1d3 | 466 | goto err; |
36d16f8e BL |
467 | } |
468 | } | |
469 | ||
470 | /* r->length is now just compressed */ | |
471 | if (s->expand != NULL) | |
472 | { | |
473 | if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH) | |
474 | { | |
475 | al=SSL_AD_RECORD_OVERFLOW; | |
beb056b3 | 476 | SSLerr(SSL_F_DTLS1_PROCESS_RECORD,SSL_R_COMPRESSED_LENGTH_TOO_LONG); |
36d16f8e BL |
477 | goto f_err; |
478 | } | |
479 | if (!ssl3_do_uncompress(s)) | |
480 | { | |
481 | al=SSL_AD_DECOMPRESSION_FAILURE; | |
beb056b3 | 482 | SSLerr(SSL_F_DTLS1_PROCESS_RECORD,SSL_R_BAD_DECOMPRESSION); |
36d16f8e BL |
483 | goto f_err; |
484 | } | |
485 | } | |
486 | ||
487 | if (rr->length > SSL3_RT_MAX_PLAIN_LENGTH) | |
488 | { | |
489 | al=SSL_AD_RECORD_OVERFLOW; | |
beb056b3 | 490 | SSLerr(SSL_F_DTLS1_PROCESS_RECORD,SSL_R_DATA_LENGTH_TOO_LONG); |
36d16f8e BL |
491 | goto f_err; |
492 | } | |
493 | ||
494 | rr->off=0; | |
495 | /* So at this point the following is true | |
496 | * ssl->s3->rrec.type is the type of record | |
497 | * ssl->s3->rrec.length == number of bytes in record | |
498 | * ssl->s3->rrec.off == offset to first valid byte | |
499 | * ssl->s3->rrec.data == where to take bytes from, increment | |
500 | * after use :-). | |
501 | */ | |
502 | ||
503 | /* we have pulled in a full packet so zero things */ | |
504 | s->packet_length=0; | |
50ec3951 AP |
505 | dtls1_record_bitmap_update(s, &(s->d1->bitmap));/* Mark receipt of record. */ |
506 | return(1); | |
36d16f8e | 507 | |
36d16f8e BL |
508 | f_err: |
509 | ssl3_send_alert(s,SSL3_AL_FATAL,al); | |
510 | err: | |
511 | return(0); | |
512 | } | |
513 | ||
514 | ||
515 | /* Call this to get a new input record. | |
516 | * It will return <= 0 if more data is needed, normally due to an error | |
517 | * or non-blocking IO. | |
518 | * When it finishes, one packet has been decoded and can be found in | |
519 | * ssl->s3->rrec.type - is the type of record | |
520 | * ssl->s3->rrec.data, - data | |
521 | * ssl->s3->rrec.length, - number of bytes | |
522 | */ | |
523 | /* used only by dtls1_read_bytes */ | |
524 | int dtls1_get_record(SSL *s) | |
525 | { | |
fc007d02 | 526 | int ssl_major,ssl_minor; |
36d16f8e BL |
527 | int i,n; |
528 | SSL3_RECORD *rr; | |
04f9095d | 529 | unsigned char *p = NULL; |
7432d073 | 530 | unsigned short version; |
36d16f8e | 531 | DTLS1_BITMAP *bitmap; |
dffdb56b | 532 | unsigned int is_next_epoch; |
36d16f8e BL |
533 | |
534 | rr= &(s->s3->rrec); | |
36d16f8e | 535 | |
dffdb56b AP |
536 | /* The epoch may have changed. If so, process all the |
537 | * pending records. This is a non-blocking operation. */ | |
3122d1d3 | 538 | dtls1_process_buffered_records(s); |
36d16f8e BL |
539 | |
540 | /* if we're renegotiating, then there may be buffered records */ | |
541 | if (dtls1_get_processed_record(s)) | |
542 | return 1; | |
543 | ||
544 | /* get something from the wire */ | |
545 | again: | |
546 | /* check if we have the header */ | |
547 | if ( (s->rstate != SSL_ST_READ_BODY) || | |
548 | (s->packet_length < DTLS1_RT_HEADER_LENGTH)) | |
549 | { | |
550 | n=ssl3_read_n(s, DTLS1_RT_HEADER_LENGTH, s->s3->rbuf.len, 0); | |
551 | /* read timeout is handled by dtls1_read_bytes */ | |
552 | if (n <= 0) return(n); /* error or non-blocking */ | |
553 | ||
5c168710 DSH |
554 | /* this packet contained a partial record, dump it */ |
555 | if (s->packet_length != DTLS1_RT_HEADER_LENGTH) | |
556 | { | |
557 | s->packet_length = 0; | |
558 | goto again; | |
559 | } | |
36d16f8e BL |
560 | |
561 | s->rstate=SSL_ST_READ_BODY; | |
562 | ||
563 | p=s->packet; | |
564 | ||
565 | /* Pull apart the header into the DTLS1_RECORD */ | |
566 | rr->type= *(p++); | |
567 | ssl_major= *(p++); | |
568 | ssl_minor= *(p++); | |
569 | version=(ssl_major<<8)|ssl_minor; | |
570 | ||
dffdb56b | 571 | /* sequence number is 64 bits, with top 2 bytes = epoch */ |
36d16f8e BL |
572 | n2s(p,rr->epoch); |
573 | ||
188b0579 RL |
574 | memcpy(&(s->s3->read_sequence[2]), p, 6); |
575 | p+=6; | |
576 | ||
36d16f8e BL |
577 | n2s(p,rr->length); |
578 | ||
579 | /* Lets check version */ | |
1e24b3a0 | 580 | if (!s->first_packet) |
36d16f8e BL |
581 | { |
582 | if (version != s->version) | |
583 | { | |
baacd8d4 DSH |
584 | /* unexpected version, silently discard */ |
585 | rr->length = 0; | |
586 | s->packet_length = 0; | |
587 | goto again; | |
36d16f8e BL |
588 | } |
589 | } | |
590 | ||
8711efb4 | 591 | if ((version & 0xff00) != (s->version & 0xff00)) |
36d16f8e | 592 | { |
baacd8d4 DSH |
593 | /* wrong version, silently discard record */ |
594 | rr->length = 0; | |
595 | s->packet_length = 0; | |
596 | goto again; | |
36d16f8e BL |
597 | } |
598 | ||
599 | if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) | |
600 | { | |
baacd8d4 DSH |
601 | /* record too long, silently discard it */ |
602 | rr->length = 0; | |
603 | s->packet_length = 0; | |
604 | goto again; | |
36d16f8e BL |
605 | } |
606 | ||
607 | /* now s->rstate == SSL_ST_READ_BODY */ | |
608 | } | |
609 | ||
610 | /* s->rstate == SSL_ST_READ_BODY, get and decode the data */ | |
611 | ||
612 | if (rr->length > s->packet_length-DTLS1_RT_HEADER_LENGTH) | |
613 | { | |
614 | /* now s->packet_length == DTLS1_RT_HEADER_LENGTH */ | |
615 | i=rr->length; | |
616 | n=ssl3_read_n(s,i,i,1); | |
617 | if (n <= 0) return(n); /* error or non-blocking io */ | |
618 | ||
619 | /* this packet contained a partial record, dump it */ | |
620 | if ( n != i) | |
621 | { | |
9458530d | 622 | rr->length = 0; |
36d16f8e BL |
623 | s->packet_length = 0; |
624 | goto again; | |
625 | } | |
626 | ||
627 | /* now n == rr->length, | |
628 | * and s->packet_length == DTLS1_RT_HEADER_LENGTH + rr->length */ | |
629 | } | |
630 | s->rstate=SSL_ST_READ_HEADER; /* set state for later operations */ | |
631 | ||
632 | /* match epochs. NULL means the packet is dropped on the floor */ | |
633 | bitmap = dtls1_get_bitmap(s, rr, &is_next_epoch); | |
634 | if ( bitmap == NULL) | |
50ec3951 | 635 | { |
9458530d | 636 | rr->length = 0; |
50ec3951 AP |
637 | s->packet_length = 0; /* dump this record */ |
638 | goto again; /* get another record */ | |
36d16f8e BL |
639 | } |
640 | ||
e9f613ac DSH |
641 | /* Check whether this is a repeat, or aged record. |
642 | * Don't check if we're listening and this message is | |
643 | * a ClientHello. They can look as if they're replayed, | |
644 | * since they arrive from different connections and | |
645 | * would be dropped unnecessarily. | |
646 | */ | |
647 | if (!(s->d1->listen && rr->type == SSL3_RT_HANDSHAKE && | |
648 | *p == SSL3_MT_CLIENT_HELLO) && | |
649 | !dtls1_record_replay_check(s, bitmap)) | |
36d16f8e | 650 | { |
570006f3 | 651 | rr->length = 0; |
36d16f8e BL |
652 | s->packet_length=0; /* dump this record */ |
653 | goto again; /* get another record */ | |
654 | } | |
655 | ||
656 | /* just read a 0 length packet */ | |
657 | if (rr->length == 0) goto again; | |
658 | ||
dffdb56b | 659 | /* If this record is from the next epoch (either HM or ALERT), |
ff12f88b | 660 | * and a handshake is currently in progress, buffer it since it |
d41ce00b DSH |
661 | * cannot be processed at this time. However, do not buffer |
662 | * anything while listening. | |
663 | */ | |
dffdb56b AP |
664 | if (is_next_epoch) |
665 | { | |
d41ce00b | 666 | if ((SSL_in_init(s) || s->in_handshake) && !s->d1->listen) |
ff12f88b DSH |
667 | { |
668 | dtls1_buffer_record(s, &(s->d1->unprocessed_rcds), rr->seq_num); | |
669 | } | |
9458530d | 670 | rr->length = 0; |
dffdb56b AP |
671 | s->packet_length = 0; |
672 | goto again; | |
673 | } | |
36d16f8e | 674 | |
3122d1d3 DSH |
675 | if (!dtls1_process_record(s)) |
676 | { | |
677 | rr->length = 0; | |
678 | s->packet_length = 0; /* dump this record */ | |
679 | goto again; /* get another record */ | |
680 | } | |
36d16f8e BL |
681 | |
682 | dtls1_clear_timeouts(s); /* done waiting */ | |
683 | return(1); | |
684 | ||
36d16f8e BL |
685 | } |
686 | ||
687 | /* Return up to 'len' payload bytes received in 'type' records. | |
688 | * 'type' is one of the following: | |
689 | * | |
690 | * - SSL3_RT_HANDSHAKE (when ssl3_get_message calls us) | |
691 | * - SSL3_RT_APPLICATION_DATA (when ssl3_read calls us) | |
692 | * - 0 (during a shutdown, no data has to be returned) | |
693 | * | |
694 | * If we don't have stored data to work from, read a SSL/TLS record first | |
695 | * (possibly multiple records if we still don't have anything to return). | |
696 | * | |
697 | * This function must handle any surprises the peer may have for us, such as | |
698 | * Alert records (e.g. close_notify), ChangeCipherSpec records (not really | |
699 | * a surprise, but handled as if it were), or renegotiation requests. | |
700 | * Also if record payloads contain fragments too small to process, we store | |
701 | * them until there is enough for the respective protocol (the record protocol | |
702 | * may use arbitrary fragmentation and even interleaving): | |
703 | * Change cipher spec protocol | |
704 | * just 1 byte needed, no need for keeping anything stored | |
705 | * Alert protocol | |
706 | * 2 bytes needed (AlertLevel, AlertDescription) | |
707 | * Handshake protocol | |
708 | * 4 bytes needed (HandshakeType, uint24 length) -- we just have | |
709 | * to detect unexpected Client Hello and Hello Request messages | |
710 | * here, anything else is handled by higher layers | |
711 | * Application data protocol | |
712 | * none of our business | |
713 | */ | |
714 | int dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek) | |
715 | { | |
716 | int al,i,j,ret; | |
717 | unsigned int n; | |
718 | SSL3_RECORD *rr; | |
719 | void (*cb)(const SSL *ssl,int type2,int val)=NULL; | |
720 | ||
721 | if (s->s3->rbuf.buf == NULL) /* Not initialized yet */ | |
722 | if (!ssl3_setup_buffers(s)) | |
723 | return(-1); | |
724 | ||
725 | /* XXX: check what the second '&& type' is about */ | |
726 | if ((type && (type != SSL3_RT_APPLICATION_DATA) && | |
727 | (type != SSL3_RT_HANDSHAKE) && type) || | |
728 | (peek && (type != SSL3_RT_APPLICATION_DATA))) | |
729 | { | |
beb056b3 | 730 | SSLerr(SSL_F_DTLS1_READ_BYTES, ERR_R_INTERNAL_ERROR); |
36d16f8e BL |
731 | return -1; |
732 | } | |
733 | ||
734 | /* check whether there's a handshake message (client hello?) waiting */ | |
735 | if ( (ret = have_handshake_fragment(s, type, buf, len, peek))) | |
736 | return ret; | |
737 | ||
738 | /* Now s->d1->handshake_fragment_len == 0 if type == SSL3_RT_HANDSHAKE. */ | |
739 | ||
740 | if (!s->in_handshake && SSL_in_init(s)) | |
741 | { | |
742 | /* type == SSL3_RT_APPLICATION_DATA */ | |
743 | i=s->handshake_func(s); | |
744 | if (i < 0) return(i); | |
745 | if (i == 0) | |
746 | { | |
beb056b3 | 747 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE); |
36d16f8e BL |
748 | return(-1); |
749 | } | |
750 | } | |
751 | ||
752 | start: | |
753 | s->rwstate=SSL_NOTHING; | |
754 | ||
755 | /* s->s3->rrec.type - is the type of record | |
756 | * s->s3->rrec.data, - data | |
757 | * s->s3->rrec.off, - offset into 'data' for next read | |
758 | * s->s3->rrec.length, - number of bytes. */ | |
759 | rr = &(s->s3->rrec); | |
760 | ||
e5fa864f DSH |
761 | /* We are not handshaking and have no data yet, |
762 | * so process data buffered during the last handshake | |
763 | * in advance, if any. | |
764 | */ | |
765 | if (s->state == SSL_ST_OK && rr->length == 0) | |
766 | { | |
767 | pitem *item; | |
768 | item = pqueue_pop(s->d1->buffered_app_data.q); | |
769 | if (item) | |
770 | { | |
771 | dtls1_copy_record(s, item); | |
772 | ||
773 | OPENSSL_free(item->data); | |
774 | pitem_free(item); | |
775 | } | |
776 | } | |
eb38b26d DSH |
777 | |
778 | /* Check for timeout */ | |
b972fbaa DSH |
779 | if (dtls1_handle_timeout(s) > 0) |
780 | goto start; | |
eb38b26d | 781 | |
36d16f8e BL |
782 | /* get new packet if necessary */ |
783 | if ((rr->length == 0) || (s->rstate == SSL_ST_READ_BODY)) | |
784 | { | |
785 | ret=dtls1_get_record(s); | |
786 | if (ret <= 0) | |
787 | { | |
788 | ret = dtls1_read_failed(s, ret); | |
789 | /* anything other than a timeout is an error */ | |
790 | if (ret <= 0) | |
791 | return(ret); | |
792 | else | |
793 | goto start; | |
794 | } | |
795 | } | |
796 | ||
797 | /* we now have a packet which can be read and processed */ | |
798 | ||
799 | if (s->s3->change_cipher_spec /* set when we receive ChangeCipherSpec, | |
800 | * reset by ssl3_get_finished */ | |
801 | && (rr->type != SSL3_RT_HANDSHAKE)) | |
802 | { | |
e5fa864f DSH |
803 | /* We now have application data between CCS and Finished. |
804 | * Most likely the packets were reordered on their way, so | |
805 | * buffer the application data for later processing rather | |
806 | * than dropping the connection. | |
807 | */ | |
47e6a60e | 808 | dtls1_buffer_record(s, &(s->d1->buffered_app_data), rr->seq_num); |
e5fa864f DSH |
809 | rr->length = 0; |
810 | goto start; | |
36d16f8e BL |
811 | } |
812 | ||
813 | /* If the other end has shut down, throw anything we read away | |
814 | * (even in 'peek' mode) */ | |
815 | if (s->shutdown & SSL_RECEIVED_SHUTDOWN) | |
816 | { | |
817 | rr->length=0; | |
818 | s->rwstate=SSL_NOTHING; | |
819 | return(0); | |
820 | } | |
821 | ||
822 | ||
823 | if (type == rr->type) /* SSL3_RT_APPLICATION_DATA or SSL3_RT_HANDSHAKE */ | |
824 | { | |
825 | /* make sure that we are not getting application data when we | |
826 | * are doing a handshake for the first time */ | |
827 | if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) && | |
828 | (s->enc_read_ctx == NULL)) | |
829 | { | |
830 | al=SSL_AD_UNEXPECTED_MESSAGE; | |
beb056b3 | 831 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_APP_DATA_IN_HANDSHAKE); |
36d16f8e BL |
832 | goto f_err; |
833 | } | |
834 | ||
835 | if (len <= 0) return(len); | |
836 | ||
837 | if ((unsigned int)len > rr->length) | |
838 | n = rr->length; | |
839 | else | |
840 | n = (unsigned int)len; | |
841 | ||
842 | memcpy(buf,&(rr->data[rr->off]),n); | |
843 | if (!peek) | |
844 | { | |
845 | rr->length-=n; | |
846 | rr->off+=n; | |
847 | if (rr->length == 0) | |
848 | { | |
849 | s->rstate=SSL_ST_READ_HEADER; | |
850 | rr->off=0; | |
851 | } | |
852 | } | |
853 | return(n); | |
854 | } | |
855 | ||
856 | ||
857 | /* If we get here, then type != rr->type; if we have a handshake | |
858 | * message, then it was unexpected (Hello Request or Client Hello). */ | |
859 | ||
860 | /* In case of record types for which we have 'fragment' storage, | |
861 | * fill that so that we can process the data at a fixed place. | |
862 | */ | |
863 | { | |
4e321ffa | 864 | unsigned int k, dest_maxlen = 0; |
36d16f8e BL |
865 | unsigned char *dest = NULL; |
866 | unsigned int *dest_len = NULL; | |
867 | ||
868 | if (rr->type == SSL3_RT_HANDSHAKE) | |
869 | { | |
870 | dest_maxlen = sizeof s->d1->handshake_fragment; | |
871 | dest = s->d1->handshake_fragment; | |
872 | dest_len = &s->d1->handshake_fragment_len; | |
873 | } | |
874 | else if (rr->type == SSL3_RT_ALERT) | |
875 | { | |
876 | dest_maxlen = sizeof(s->d1->alert_fragment); | |
877 | dest = s->d1->alert_fragment; | |
878 | dest_len = &s->d1->alert_fragment_len; | |
879 | } | |
e5fa864f DSH |
880 | /* else it's a CCS message, or application data or wrong */ |
881 | else if (rr->type != SSL3_RT_CHANGE_CIPHER_SPEC) | |
882 | { | |
883 | /* Application data while renegotiating | |
884 | * is allowed. Try again reading. | |
885 | */ | |
886 | if (rr->type == SSL3_RT_APPLICATION_DATA) | |
887 | { | |
888 | BIO *bio; | |
889 | s->s3->in_read_app_data=2; | |
890 | bio=SSL_get_rbio(s); | |
891 | s->rwstate=SSL_READING; | |
892 | BIO_clear_retry_flags(bio); | |
893 | BIO_set_retry_read(bio); | |
894 | return(-1); | |
895 | } | |
36d16f8e | 896 | |
e5fa864f DSH |
897 | /* Not certain if this is the right error handling */ |
898 | al=SSL_AD_UNEXPECTED_MESSAGE; | |
899 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_UNEXPECTED_RECORD); | |
900 | goto f_err; | |
901 | } | |
36d16f8e BL |
902 | |
903 | if (dest_maxlen > 0) | |
904 | { | |
905 | /* XDTLS: In a pathalogical case, the Client Hello | |
906 | * may be fragmented--don't always expect dest_maxlen bytes */ | |
907 | if ( rr->length < dest_maxlen) | |
908 | { | |
d4938995 AP |
909 | #ifdef DTLS1_AD_MISSING_HANDSHAKE_MESSAGE |
910 | /* | |
911 | * for normal alerts rr->length is 2, while | |
912 | * dest_maxlen is 7 if we were to handle this | |
913 | * non-existing alert... | |
914 | */ | |
915 | FIX ME | |
916 | #endif | |
36d16f8e BL |
917 | s->rstate=SSL_ST_READ_HEADER; |
918 | rr->length = 0; | |
919 | goto start; | |
920 | } | |
921 | ||
922 | /* now move 'n' bytes: */ | |
4e321ffa | 923 | for ( k = 0; k < dest_maxlen; k++) |
36d16f8e | 924 | { |
4e321ffa | 925 | dest[k] = rr->data[rr->off++]; |
36d16f8e BL |
926 | rr->length--; |
927 | } | |
928 | *dest_len = dest_maxlen; | |
929 | } | |
930 | } | |
931 | ||
932 | /* s->d1->handshake_fragment_len == 12 iff rr->type == SSL3_RT_HANDSHAKE; | |
933 | * s->d1->alert_fragment_len == 7 iff rr->type == SSL3_RT_ALERT. | |
934 | * (Possibly rr is 'empty' now, i.e. rr->length may be 0.) */ | |
935 | ||
936 | /* If we are a client, check for an incoming 'Hello Request': */ | |
937 | if ((!s->server) && | |
938 | (s->d1->handshake_fragment_len >= DTLS1_HM_HEADER_LENGTH) && | |
939 | (s->d1->handshake_fragment[0] == SSL3_MT_HELLO_REQUEST) && | |
940 | (s->session != NULL) && (s->session->cipher != NULL)) | |
941 | { | |
942 | s->d1->handshake_fragment_len = 0; | |
943 | ||
944 | if ((s->d1->handshake_fragment[1] != 0) || | |
945 | (s->d1->handshake_fragment[2] != 0) || | |
946 | (s->d1->handshake_fragment[3] != 0)) | |
947 | { | |
948 | al=SSL_AD_DECODE_ERROR; | |
beb056b3 | 949 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_BAD_HELLO_REQUEST); |
36d16f8e BL |
950 | goto err; |
951 | } | |
952 | ||
953 | /* no need to check sequence number on HELLO REQUEST messages */ | |
954 | ||
955 | if (s->msg_callback) | |
956 | s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, | |
957 | s->d1->handshake_fragment, 4, s, s->msg_callback_arg); | |
958 | ||
959 | if (SSL_is_init_finished(s) && | |
960 | !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS) && | |
961 | !s->s3->renegotiate) | |
962 | { | |
44959ee4 | 963 | s->new_session = 1; |
36d16f8e BL |
964 | ssl3_renegotiate(s); |
965 | if (ssl3_renegotiate_check(s)) | |
966 | { | |
967 | i=s->handshake_func(s); | |
968 | if (i < 0) return(i); | |
969 | if (i == 0) | |
970 | { | |
beb056b3 | 971 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE); |
36d16f8e BL |
972 | return(-1); |
973 | } | |
974 | ||
975 | if (!(s->mode & SSL_MODE_AUTO_RETRY)) | |
976 | { | |
977 | if (s->s3->rbuf.left == 0) /* no read-ahead left? */ | |
978 | { | |
979 | BIO *bio; | |
980 | /* In the case where we try to read application data, | |
981 | * but we trigger an SSL handshake, we return -1 with | |
982 | * the retry option set. Otherwise renegotiation may | |
983 | * cause nasty problems in the blocking world */ | |
984 | s->rwstate=SSL_READING; | |
985 | bio=SSL_get_rbio(s); | |
986 | BIO_clear_retry_flags(bio); | |
987 | BIO_set_retry_read(bio); | |
988 | return(-1); | |
989 | } | |
990 | } | |
991 | } | |
992 | } | |
993 | /* we either finished a handshake or ignored the request, | |
994 | * now try again to obtain the (application) data we were asked for */ | |
995 | goto start; | |
996 | } | |
997 | ||
998 | if (s->d1->alert_fragment_len >= DTLS1_AL_HEADER_LENGTH) | |
999 | { | |
1000 | int alert_level = s->d1->alert_fragment[0]; | |
1001 | int alert_descr = s->d1->alert_fragment[1]; | |
1002 | ||
1003 | s->d1->alert_fragment_len = 0; | |
1004 | ||
1005 | if (s->msg_callback) | |
1006 | s->msg_callback(0, s->version, SSL3_RT_ALERT, | |
1007 | s->d1->alert_fragment, 2, s, s->msg_callback_arg); | |
1008 | ||
1009 | if (s->info_callback != NULL) | |
1010 | cb=s->info_callback; | |
1011 | else if (s->ctx->info_callback != NULL) | |
1012 | cb=s->ctx->info_callback; | |
1013 | ||
1014 | if (cb != NULL) | |
1015 | { | |
1016 | j = (alert_level << 8) | alert_descr; | |
1017 | cb(s, SSL_CB_READ_ALERT, j); | |
1018 | } | |
1019 | ||
1020 | if (alert_level == 1) /* warning */ | |
1021 | { | |
1022 | s->s3->warn_alert = alert_descr; | |
1023 | if (alert_descr == SSL_AD_CLOSE_NOTIFY) | |
1024 | { | |
1025 | s->shutdown |= SSL_RECEIVED_SHUTDOWN; | |
1026 | return(0); | |
1027 | } | |
1028 | #if 0 | |
1029 | /* XXX: this is a possible improvement in the future */ | |
1030 | /* now check if it's a missing record */ | |
1031 | if (alert_descr == DTLS1_AD_MISSING_HANDSHAKE_MESSAGE) | |
1032 | { | |
1033 | unsigned short seq; | |
1034 | unsigned int frag_off; | |
1035 | unsigned char *p = &(s->d1->alert_fragment[2]); | |
1036 | ||
1037 | n2s(p, seq); | |
1038 | n2l3(p, frag_off); | |
1039 | ||
e5fa864f DSH |
1040 | dtls1_retransmit_message(s, |
1041 | dtls1_get_queue_priority(frag->msg_header.seq, 0), | |
1042 | frag_off, &found); | |
36d16f8e BL |
1043 | if ( ! found && SSL_in_init(s)) |
1044 | { | |
1045 | /* fprintf( stderr,"in init = %d\n", SSL_in_init(s)); */ | |
1046 | /* requested a message not yet sent, | |
1047 | send an alert ourselves */ | |
1048 | ssl3_send_alert(s,SSL3_AL_WARNING, | |
1049 | DTLS1_AD_MISSING_HANDSHAKE_MESSAGE); | |
1050 | } | |
1051 | } | |
1052 | #endif | |
1053 | } | |
1054 | else if (alert_level == 2) /* fatal */ | |
1055 | { | |
1056 | char tmp[16]; | |
1057 | ||
1058 | s->rwstate=SSL_NOTHING; | |
1059 | s->s3->fatal_alert = alert_descr; | |
beb056b3 | 1060 | SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_AD_REASON_OFFSET + alert_descr); |
36d16f8e BL |
1061 | BIO_snprintf(tmp,sizeof tmp,"%d",alert_descr); |
1062 | ERR_add_error_data(2,"SSL alert number ",tmp); | |
1063 | s->shutdown|=SSL_RECEIVED_SHUTDOWN; | |
1064 | SSL_CTX_remove_session(s->ctx,s->session); | |
1065 | return(0); | |
1066 | } | |
1067 | else | |
1068 | { | |
1069 | al=SSL_AD_ILLEGAL_PARAMETER; | |
beb056b3 | 1070 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_UNKNOWN_ALERT_TYPE); |
36d16f8e BL |
1071 | goto f_err; |
1072 | } | |
1073 | ||
1074 | goto start; | |
1075 | } | |
1076 | ||
1077 | if (s->shutdown & SSL_SENT_SHUTDOWN) /* but we have not received a shutdown */ | |
1078 | { | |
1079 | s->rwstate=SSL_NOTHING; | |
1080 | rr->length=0; | |
1081 | return(0); | |
1082 | } | |
1083 | ||
1084 | if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) | |
89c333e3 AP |
1085 | { |
1086 | struct ccs_header_st ccs_hdr; | |
ef236ec3 | 1087 | unsigned int ccs_hdr_len = DTLS1_CCS_HEADER_LENGTH; |
36d16f8e BL |
1088 | |
1089 | dtls1_get_ccs_header(rr->data, &ccs_hdr); | |
1090 | ||
8711efb4 DSH |
1091 | if (s->version == DTLS1_BAD_VER) |
1092 | ccs_hdr_len = 3; | |
1093 | ||
89c333e3 AP |
1094 | /* 'Change Cipher Spec' is just a single byte, so we know |
1095 | * exactly what the record payload has to look like */ | |
1096 | /* XDTLS: check that epoch is consistent */ | |
8711efb4 | 1097 | if ( (rr->length != ccs_hdr_len) || |
89c333e3 | 1098 | (rr->off != 0) || (rr->data[0] != SSL3_MT_CCS)) |
36d16f8e | 1099 | { |
89c333e3 AP |
1100 | i=SSL_AD_ILLEGAL_PARAMETER; |
1101 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_BAD_CHANGE_CIPHER_SPEC); | |
1102 | goto err; | |
36d16f8e | 1103 | } |
89c333e3 AP |
1104 | |
1105 | rr->length=0; | |
1106 | ||
1107 | if (s->msg_callback) | |
1108 | s->msg_callback(0, s->version, SSL3_RT_CHANGE_CIPHER_SPEC, | |
1109 | rr->data, 1, s, s->msg_callback_arg); | |
1110 | ||
58f41a92 DSH |
1111 | /* We can't process a CCS now, because previous handshake |
1112 | * messages are still missing, so just drop it. | |
1113 | */ | |
1114 | if (!s->d1->change_cipher_spec_ok) | |
1115 | { | |
1116 | goto start; | |
1117 | } | |
1118 | ||
1119 | s->d1->change_cipher_spec_ok = 0; | |
1120 | ||
89c333e3 AP |
1121 | s->s3->change_cipher_spec=1; |
1122 | if (!ssl3_do_change_cipher_spec(s)) | |
1123 | goto err; | |
1124 | ||
1125 | /* do this whenever CCS is processed */ | |
1126 | dtls1_reset_seq_numbers(s, SSL3_CC_READ); | |
1127 | ||
8711efb4 DSH |
1128 | if (s->version == DTLS1_BAD_VER) |
1129 | s->d1->handshake_read_seq++; | |
1130 | ||
89c333e3 | 1131 | goto start; |
36d16f8e BL |
1132 | } |
1133 | ||
1134 | /* Unexpected handshake message (Client Hello, or protocol violation) */ | |
1135 | if ((s->d1->handshake_fragment_len >= DTLS1_HM_HEADER_LENGTH) && | |
1136 | !s->in_handshake) | |
1137 | { | |
1138 | struct hm_header_st msg_hdr; | |
1139 | ||
1140 | /* this may just be a stale retransmit */ | |
1141 | dtls1_get_message_header(rr->data, &msg_hdr); | |
1142 | if( rr->epoch != s->d1->r_epoch) | |
1143 | { | |
1144 | rr->length = 0; | |
1145 | goto start; | |
1146 | } | |
1147 | ||
e5fa864f DSH |
1148 | /* If we are server, we may have a repeated FINISHED of the |
1149 | * client here, then retransmit our CCS and FINISHED. | |
1150 | */ | |
1151 | if (msg_hdr.type == SSL3_MT_FINISHED) | |
1152 | { | |
1153 | dtls1_retransmit_buffered_messages(s); | |
1154 | rr->length = 0; | |
1155 | goto start; | |
1156 | } | |
1157 | ||
36d16f8e BL |
1158 | if (((s->state&SSL_ST_MASK) == SSL_ST_OK) && |
1159 | !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS)) | |
1160 | { | |
1161 | #if 0 /* worked only because C operator preferences are not as expected (and | |
1162 | * because this is not really needed for clients except for detecting | |
1163 | * protocol violations): */ | |
1164 | s->state=SSL_ST_BEFORE|(s->server) | |
1165 | ?SSL_ST_ACCEPT | |
1166 | :SSL_ST_CONNECT; | |
1167 | #else | |
1168 | s->state = s->server ? SSL_ST_ACCEPT : SSL_ST_CONNECT; | |
1169 | #endif | |
44959ee4 | 1170 | s->renegotiate=1; |
36d16f8e BL |
1171 | s->new_session=1; |
1172 | } | |
1173 | i=s->handshake_func(s); | |
1174 | if (i < 0) return(i); | |
1175 | if (i == 0) | |
1176 | { | |
beb056b3 | 1177 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE); |
36d16f8e BL |
1178 | return(-1); |
1179 | } | |
1180 | ||
1181 | if (!(s->mode & SSL_MODE_AUTO_RETRY)) | |
1182 | { | |
1183 | if (s->s3->rbuf.left == 0) /* no read-ahead left? */ | |
1184 | { | |
1185 | BIO *bio; | |
1186 | /* In the case where we try to read application data, | |
1187 | * but we trigger an SSL handshake, we return -1 with | |
1188 | * the retry option set. Otherwise renegotiation may | |
1189 | * cause nasty problems in the blocking world */ | |
1190 | s->rwstate=SSL_READING; | |
1191 | bio=SSL_get_rbio(s); | |
1192 | BIO_clear_retry_flags(bio); | |
1193 | BIO_set_retry_read(bio); | |
1194 | return(-1); | |
1195 | } | |
1196 | } | |
1197 | goto start; | |
1198 | } | |
1199 | ||
1200 | switch (rr->type) | |
1201 | { | |
1202 | default: | |
1203 | #ifndef OPENSSL_NO_TLS | |
1204 | /* TLS just ignores unknown message types */ | |
1205 | if (s->version == TLS1_VERSION) | |
1206 | { | |
1207 | rr->length = 0; | |
1208 | goto start; | |
1209 | } | |
1210 | #endif | |
1211 | al=SSL_AD_UNEXPECTED_MESSAGE; | |
beb056b3 | 1212 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_UNEXPECTED_RECORD); |
36d16f8e BL |
1213 | goto f_err; |
1214 | case SSL3_RT_CHANGE_CIPHER_SPEC: | |
1215 | case SSL3_RT_ALERT: | |
1216 | case SSL3_RT_HANDSHAKE: | |
1217 | /* we already handled all of these, with the possible exception | |
1218 | * of SSL3_RT_HANDSHAKE when s->in_handshake is set, but that | |
1219 | * should not happen when type != rr->type */ | |
1220 | al=SSL_AD_UNEXPECTED_MESSAGE; | |
beb056b3 | 1221 | SSLerr(SSL_F_DTLS1_READ_BYTES,ERR_R_INTERNAL_ERROR); |
36d16f8e BL |
1222 | goto f_err; |
1223 | case SSL3_RT_APPLICATION_DATA: | |
1224 | /* At this point, we were expecting handshake data, | |
1225 | * but have application data. If the library was | |
1226 | * running inside ssl3_read() (i.e. in_read_app_data | |
1227 | * is set) and it makes sense to read application data | |
1228 | * at this point (session renegotiation not yet started), | |
1229 | * we will indulge it. | |
1230 | */ | |
1231 | if (s->s3->in_read_app_data && | |
1232 | (s->s3->total_renegotiations != 0) && | |
1233 | (( | |
1234 | (s->state & SSL_ST_CONNECT) && | |
1235 | (s->state >= SSL3_ST_CW_CLNT_HELLO_A) && | |
1236 | (s->state <= SSL3_ST_CR_SRVR_HELLO_A) | |
1237 | ) || ( | |
1238 | (s->state & SSL_ST_ACCEPT) && | |
1239 | (s->state <= SSL3_ST_SW_HELLO_REQ_A) && | |
1240 | (s->state >= SSL3_ST_SR_CLNT_HELLO_A) | |
1241 | ) | |
1242 | )) | |
1243 | { | |
1244 | s->s3->in_read_app_data=2; | |
1245 | return(-1); | |
1246 | } | |
1247 | else | |
1248 | { | |
1249 | al=SSL_AD_UNEXPECTED_MESSAGE; | |
beb056b3 | 1250 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_UNEXPECTED_RECORD); |
36d16f8e BL |
1251 | goto f_err; |
1252 | } | |
1253 | } | |
1254 | /* not reached */ | |
1255 | ||
1256 | f_err: | |
1257 | ssl3_send_alert(s,SSL3_AL_FATAL,al); | |
1258 | err: | |
1259 | return(-1); | |
1260 | } | |
1261 | ||
1262 | int | |
1263 | dtls1_write_app_data_bytes(SSL *s, int type, const void *buf_, int len) | |
1264 | { | |
36d16f8e BL |
1265 | int i; |
1266 | ||
1267 | if (SSL_in_init(s) && !s->in_handshake) | |
1268 | { | |
1269 | i=s->handshake_func(s); | |
1270 | if (i < 0) return(i); | |
1271 | if (i == 0) | |
1272 | { | |
beb056b3 | 1273 | SSLerr(SSL_F_DTLS1_WRITE_APP_DATA_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE); |
36d16f8e BL |
1274 | return -1; |
1275 | } | |
1276 | } | |
1277 | ||
480b9e5d | 1278 | if (len > SSL3_RT_MAX_PLAIN_LENGTH) |
36d16f8e | 1279 | { |
480b9e5d DSH |
1280 | SSLerr(SSL_F_DTLS1_WRITE_APP_DATA_BYTES,SSL_R_DTLS_MESSAGE_TOO_BIG); |
1281 | return -1; | |
36d16f8e BL |
1282 | } |
1283 | ||
480b9e5d DSH |
1284 | i = dtls1_write_bytes(s, type, buf_, len); |
1285 | return i; | |
36d16f8e BL |
1286 | } |
1287 | ||
1288 | ||
1289 | /* this only happens when a client hello is received and a handshake | |
1290 | * is started. */ | |
1291 | static int | |
1292 | have_handshake_fragment(SSL *s, int type, unsigned char *buf, | |
1293 | int len, int peek) | |
1294 | { | |
1295 | ||
1296 | if ((type == SSL3_RT_HANDSHAKE) && (s->d1->handshake_fragment_len > 0)) | |
1297 | /* (partially) satisfy request from storage */ | |
1298 | { | |
1299 | unsigned char *src = s->d1->handshake_fragment; | |
1300 | unsigned char *dst = buf; | |
1301 | unsigned int k,n; | |
1302 | ||
1303 | /* peek == 0 */ | |
1304 | n = 0; | |
1305 | while ((len > 0) && (s->d1->handshake_fragment_len > 0)) | |
1306 | { | |
1307 | *dst++ = *src++; | |
1308 | len--; s->d1->handshake_fragment_len--; | |
1309 | n++; | |
1310 | } | |
1311 | /* move any remaining fragment bytes: */ | |
1312 | for (k = 0; k < s->d1->handshake_fragment_len; k++) | |
1313 | s->d1->handshake_fragment[k] = *src++; | |
1314 | return n; | |
1315 | } | |
1316 | ||
1317 | return 0; | |
1318 | } | |
1319 | ||
1320 | ||
1321 | ||
1322 | ||
1323 | /* Call this to write data in records of type 'type' | |
1324 | * It will return <= 0 if not all data has been sent or non-blocking IO. | |
1325 | */ | |
480b9e5d | 1326 | int dtls1_write_bytes(SSL *s, int type, const void *buf, int len) |
36d16f8e | 1327 | { |
36d16f8e | 1328 | int i; |
36d16f8e | 1329 | |
480b9e5d | 1330 | OPENSSL_assert(len <= SSL3_RT_MAX_PLAIN_LENGTH); |
36d16f8e | 1331 | s->rwstate=SSL_NOTHING; |
480b9e5d | 1332 | i=do_dtls1_write(s, type, buf, len, 0); |
51ec776b | 1333 | return i; |
36d16f8e BL |
1334 | } |
1335 | ||
beb056b3 | 1336 | int do_dtls1_write(SSL *s, int type, const unsigned char *buf, unsigned int len, int create_empty_fragment) |
36d16f8e BL |
1337 | { |
1338 | unsigned char *p,*pseq; | |
1339 | int i,mac_size,clear=0; | |
1340 | int prefix_len = 0; | |
1341 | SSL3_RECORD *wr; | |
1342 | SSL3_BUFFER *wb; | |
1343 | SSL_SESSION *sess; | |
1344 | int bs; | |
1345 | ||
1346 | /* first check if there is a SSL3_BUFFER still being written | |
1347 | * out. This will happen with non blocking IO */ | |
1348 | if (s->s3->wbuf.left != 0) | |
1349 | { | |
1350 | OPENSSL_assert(0); /* XDTLS: want to see if we ever get here */ | |
1351 | return(ssl3_write_pending(s,type,buf,len)); | |
1352 | } | |
1353 | ||
1354 | /* If we have an alert to send, lets send it */ | |
1355 | if (s->s3->alert_dispatch) | |
1356 | { | |
1357 | i=s->method->ssl_dispatch_alert(s); | |
1358 | if (i <= 0) | |
1359 | return(i); | |
1360 | /* if it went, fall through and send more stuff */ | |
1361 | } | |
1362 | ||
1363 | if (len == 0 && !create_empty_fragment) | |
1364 | return 0; | |
1365 | ||
1366 | wr= &(s->s3->wrec); | |
1367 | wb= &(s->s3->wbuf); | |
1368 | sess=s->session; | |
1369 | ||
1370 | if ( (sess == NULL) || | |
1371 | (s->enc_write_ctx == NULL) || | |
b948e2c5 | 1372 | (EVP_MD_CTX_md(s->write_hash) == NULL)) |
36d16f8e BL |
1373 | clear=1; |
1374 | ||
1375 | if (clear) | |
1376 | mac_size=0; | |
1377 | else | |
0eab41fb | 1378 | { |
b948e2c5 | 1379 | mac_size=EVP_MD_CTX_size(s->write_hash); |
0eab41fb BL |
1380 | if (mac_size < 0) |
1381 | goto err; | |
1382 | } | |
36d16f8e BL |
1383 | |
1384 | /* DTLS implements explicit IV, so no need for empty fragments */ | |
1385 | #if 0 | |
1386 | /* 'create_empty_fragment' is true only when this function calls itself */ | |
1387 | if (!clear && !create_empty_fragment && !s->s3->empty_fragment_done | |
8711efb4 | 1388 | && SSL_version(s) != DTLS1_VERSION && SSL_version(s) != DTLS1_BAD_VER) |
36d16f8e BL |
1389 | { |
1390 | /* countermeasure against known-IV weakness in CBC ciphersuites | |
1391 | * (see http://www.openssl.org/~bodo/tls-cbc.txt) | |
1392 | */ | |
1393 | ||
1394 | if (s->s3->need_empty_fragments && type == SSL3_RT_APPLICATION_DATA) | |
1395 | { | |
1396 | /* recursive function call with 'create_empty_fragment' set; | |
1397 | * this prepares and buffers the data for an empty fragment | |
1398 | * (these 'prefix_len' bytes are sent out later | |
1399 | * together with the actual payload) */ | |
1400 | prefix_len = s->method->do_ssl_write(s, type, buf, 0, 1); | |
1401 | if (prefix_len <= 0) | |
1402 | goto err; | |
1403 | ||
1404 | if (s->s3->wbuf.len < (size_t)prefix_len + SSL3_RT_MAX_PACKET_SIZE) | |
1405 | { | |
1406 | /* insufficient space */ | |
beb056b3 | 1407 | SSLerr(SSL_F_DO_DTLS1_WRITE, ERR_R_INTERNAL_ERROR); |
36d16f8e BL |
1408 | goto err; |
1409 | } | |
1410 | } | |
1411 | ||
1412 | s->s3->empty_fragment_done = 1; | |
1413 | } | |
1414 | #endif | |
36d16f8e BL |
1415 | p = wb->buf + prefix_len; |
1416 | ||
1417 | /* write the header */ | |
1418 | ||
1419 | *(p++)=type&0xff; | |
1420 | wr->type=type; | |
1421 | ||
1422 | *(p++)=(s->version>>8); | |
1423 | *(p++)=s->version&0xff; | |
1424 | ||
1425 | /* field where we are to write out packet epoch, seq num and len */ | |
1426 | pseq=p; | |
1427 | p+=10; | |
1428 | ||
1429 | /* lets setup the record stuff. */ | |
1430 | ||
1431 | /* Make space for the explicit IV in case of CBC. | |
1432 | * (this is a bit of a boundary violation, but what the heck). | |
1433 | */ | |
1434 | if ( s->enc_write_ctx && | |
1435 | (EVP_CIPHER_mode( s->enc_write_ctx->cipher ) & EVP_CIPH_CBC_MODE)) | |
1436 | bs = EVP_CIPHER_block_size(s->enc_write_ctx->cipher); | |
1437 | else | |
1438 | bs = 0; | |
1439 | ||
1440 | wr->data=p + bs; /* make room for IV in case of CBC */ | |
1441 | wr->length=(int)len; | |
1442 | wr->input=(unsigned char *)buf; | |
1443 | ||
1444 | /* we now 'read' from wr->input, wr->length bytes into | |
1445 | * wr->data */ | |
1446 | ||
1447 | /* first we compress */ | |
1448 | if (s->compress != NULL) | |
1449 | { | |
1450 | if (!ssl3_do_compress(s)) | |
1451 | { | |
beb056b3 | 1452 | SSLerr(SSL_F_DO_DTLS1_WRITE,SSL_R_COMPRESSION_FAILURE); |
36d16f8e BL |
1453 | goto err; |
1454 | } | |
1455 | } | |
1456 | else | |
1457 | { | |
1458 | memcpy(wr->data,wr->input,wr->length); | |
1459 | wr->input=wr->data; | |
1460 | } | |
1461 | ||
1462 | /* we should still have the output to wr->data and the input | |
1463 | * from wr->input. Length should be wr->length. | |
1464 | * wr->data still points in the wb->buf */ | |
1465 | ||
1466 | if (mac_size != 0) | |
1467 | { | |
0eab41fb BL |
1468 | if(s->method->ssl3_enc->mac(s,&(p[wr->length + bs]),1) < 0) |
1469 | goto err; | |
36d16f8e BL |
1470 | wr->length+=mac_size; |
1471 | } | |
1472 | ||
1473 | /* this is true regardless of mac size */ | |
1474 | wr->input=p; | |
1475 | wr->data=p; | |
1476 | ||
1477 | ||
1478 | /* ssl3_enc can only have an error on read */ | |
d527834a AP |
1479 | if (bs) /* bs != 0 in case of CBC */ |
1480 | { | |
1481 | RAND_pseudo_bytes(p,bs); | |
1482 | /* master IV and last CBC residue stand for | |
1483 | * the rest of randomness */ | |
1484 | wr->length += bs; | |
1485 | } | |
1486 | ||
36d16f8e BL |
1487 | s->method->ssl3_enc->enc(s,1); |
1488 | ||
1489 | /* record length after mac and block padding */ | |
1490 | /* if (type == SSL3_RT_APPLICATION_DATA || | |
1491 | (type == SSL3_RT_ALERT && ! SSL_in_init(s))) */ | |
1492 | ||
1493 | /* there's only one epoch between handshake and app data */ | |
1494 | ||
1495 | s2n(s->d1->w_epoch, pseq); | |
1496 | ||
1497 | /* XDTLS: ?? */ | |
1498 | /* else | |
1499 | s2n(s->d1->handshake_epoch, pseq); */ | |
1500 | ||
188b0579 RL |
1501 | memcpy(pseq, &(s->s3->write_sequence[2]), 6); |
1502 | pseq+=6; | |
36d16f8e BL |
1503 | s2n(wr->length,pseq); |
1504 | ||
1505 | /* we should now have | |
1506 | * wr->data pointing to the encrypted data, which is | |
1507 | * wr->length long */ | |
1508 | wr->type=type; /* not needed but helps for debugging */ | |
1509 | wr->length+=DTLS1_RT_HEADER_LENGTH; | |
1510 | ||
1511 | #if 0 /* this is now done at the message layer */ | |
1512 | /* buffer the record, making it easy to handle retransmits */ | |
1513 | if ( type == SSL3_RT_HANDSHAKE || type == SSL3_RT_CHANGE_CIPHER_SPEC) | |
1514 | dtls1_buffer_record(s, wr->data, wr->length, | |
188b0579 | 1515 | *((PQ_64BIT *)&(s->s3->write_sequence[0]))); |
36d16f8e BL |
1516 | #endif |
1517 | ||
1518 | ssl3_record_sequence_update(&(s->s3->write_sequence[0])); | |
1519 | ||
1520 | if (create_empty_fragment) | |
1521 | { | |
1522 | /* we are in a recursive call; | |
1523 | * just return the length, don't write out anything here | |
1524 | */ | |
1525 | return wr->length; | |
1526 | } | |
1527 | ||
1528 | /* now let's set up wb */ | |
1529 | wb->left = prefix_len + wr->length; | |
1530 | wb->offset = 0; | |
1531 | ||
1532 | /* memorize arguments so that ssl3_write_pending can detect bad write retries later */ | |
1533 | s->s3->wpend_tot=len; | |
1534 | s->s3->wpend_buf=buf; | |
1535 | s->s3->wpend_type=type; | |
1536 | s->s3->wpend_ret=len; | |
1537 | ||
1538 | /* we now just need to write the buffer */ | |
1539 | return ssl3_write_pending(s,type,buf,len); | |
1540 | err: | |
1541 | return -1; | |
1542 | } | |
1543 | ||
1544 | ||
1545 | ||
50ec3951 | 1546 | static int dtls1_record_replay_check(SSL *s, DTLS1_BITMAP *bitmap) |
36d16f8e | 1547 | { |
dffdb56b AP |
1548 | int cmp; |
1549 | unsigned int shift; | |
1550 | const unsigned char *seq = s->s3->read_sequence; | |
36d16f8e | 1551 | |
dffdb56b AP |
1552 | cmp = satsub64be(seq,bitmap->max_seq_num); |
1553 | if (cmp > 0) | |
188b0579 | 1554 | { |
50ec3951 | 1555 | memcpy (s->s3->rrec.seq_num,seq,8); |
dffdb56b | 1556 | return 1; /* this record in new */ |
188b0579 | 1557 | } |
dffdb56b AP |
1558 | shift = -cmp; |
1559 | if (shift >= sizeof(bitmap->map)*8) | |
1560 | return 0; /* stale, outside the window */ | |
1561 | else if (bitmap->map & (1UL<<shift)) | |
36d16f8e | 1562 | return 0; /* record previously received */ |
dffdb56b | 1563 | |
50ec3951 | 1564 | memcpy (s->s3->rrec.seq_num,seq,8); |
36d16f8e BL |
1565 | return 1; |
1566 | } | |
1567 | ||
1568 | ||
1569 | static void dtls1_record_bitmap_update(SSL *s, DTLS1_BITMAP *bitmap) | |
1570 | { | |
dffdb56b | 1571 | int cmp; |
36d16f8e | 1572 | unsigned int shift; |
dffdb56b | 1573 | const unsigned char *seq = s->s3->read_sequence; |
36d16f8e | 1574 | |
dffdb56b AP |
1575 | cmp = satsub64be(seq,bitmap->max_seq_num); |
1576 | if (cmp > 0) | |
36d16f8e | 1577 | { |
dffdb56b AP |
1578 | shift = cmp; |
1579 | if (shift < sizeof(bitmap->map)*8) | |
1580 | bitmap->map <<= shift, bitmap->map |= 1UL; | |
1581 | else | |
1582 | bitmap->map = 1UL; | |
1583 | memcpy(bitmap->max_seq_num,seq,8); | |
36d16f8e | 1584 | } |
dffdb56b AP |
1585 | else { |
1586 | shift = -cmp; | |
1587 | if (shift < sizeof(bitmap->map)*8) | |
1588 | bitmap->map |= 1UL<<shift; | |
36d16f8e BL |
1589 | } |
1590 | } | |
1591 | ||
1592 | ||
1593 | int dtls1_dispatch_alert(SSL *s) | |
1594 | { | |
1595 | int i,j; | |
1596 | void (*cb)(const SSL *ssl,int type,int val)=NULL; | |
d4938995 | 1597 | unsigned char buf[DTLS1_AL_HEADER_LENGTH]; |
4e321ffa | 1598 | unsigned char *ptr = &buf[0]; |
36d16f8e BL |
1599 | |
1600 | s->s3->alert_dispatch=0; | |
1601 | ||
1602 | memset(buf, 0x00, sizeof(buf)); | |
1603 | *ptr++ = s->s3->send_alert[0]; | |
1604 | *ptr++ = s->s3->send_alert[1]; | |
1605 | ||
01c76c66 | 1606 | #ifdef DTLS1_AD_MISSING_HANDSHAKE_MESSAGE |
36d16f8e BL |
1607 | if (s->s3->send_alert[1] == DTLS1_AD_MISSING_HANDSHAKE_MESSAGE) |
1608 | { | |
1609 | s2n(s->d1->handshake_read_seq, ptr); | |
1610 | #if 0 | |
1611 | if ( s->d1->r_msg_hdr.frag_off == 0) /* waiting for a new msg */ | |
1612 | ||
1613 | else | |
1614 | s2n(s->d1->r_msg_hdr.seq, ptr); /* partial msg read */ | |
1615 | #endif | |
1616 | ||
1617 | #if 0 | |
1618 | fprintf(stderr, "s->d1->handshake_read_seq = %d, s->d1->r_msg_hdr.seq = %d\n",s->d1->handshake_read_seq,s->d1->r_msg_hdr.seq); | |
1619 | #endif | |
1620 | l2n3(s->d1->r_msg_hdr.frag_off, ptr); | |
1621 | } | |
01c76c66 | 1622 | #endif |
36d16f8e BL |
1623 | |
1624 | i = do_dtls1_write(s, SSL3_RT_ALERT, &buf[0], sizeof(buf), 0); | |
1625 | if (i <= 0) | |
1626 | { | |
1627 | s->s3->alert_dispatch=1; | |
1628 | /* fprintf( stderr, "not done with alert\n" ); */ | |
1629 | } | |
1630 | else | |
1631 | { | |
01c76c66 BM |
1632 | if (s->s3->send_alert[0] == SSL3_AL_FATAL |
1633 | #ifdef DTLS1_AD_MISSING_HANDSHAKE_MESSAGE | |
1634 | || s->s3->send_alert[1] == DTLS1_AD_MISSING_HANDSHAKE_MESSAGE | |
1635 | #endif | |
1636 | ) | |
36d16f8e BL |
1637 | (void)BIO_flush(s->wbio); |
1638 | ||
1639 | if (s->msg_callback) | |
1640 | s->msg_callback(1, s->version, SSL3_RT_ALERT, s->s3->send_alert, | |
1641 | 2, s, s->msg_callback_arg); | |
1642 | ||
1643 | if (s->info_callback != NULL) | |
1644 | cb=s->info_callback; | |
1645 | else if (s->ctx->info_callback != NULL) | |
1646 | cb=s->ctx->info_callback; | |
1647 | ||
1648 | if (cb != NULL) | |
1649 | { | |
1650 | j=(s->s3->send_alert[0]<<8)|s->s3->send_alert[1]; | |
1651 | cb(s,SSL_CB_WRITE_ALERT,j); | |
1652 | } | |
1653 | } | |
1654 | return(i); | |
1655 | } | |
1656 | ||
1657 | ||
1658 | static DTLS1_BITMAP * | |
1659 | dtls1_get_bitmap(SSL *s, SSL3_RECORD *rr, unsigned int *is_next_epoch) | |
1660 | { | |
1661 | ||
1662 | *is_next_epoch = 0; | |
1663 | ||
1664 | /* In current epoch, accept HM, CCS, DATA, & ALERT */ | |
1665 | if (rr->epoch == s->d1->r_epoch) | |
1666 | return &s->d1->bitmap; | |
1667 | ||
1668 | /* Only HM and ALERT messages can be from the next epoch */ | |
6c61726b | 1669 | else if (rr->epoch == (unsigned long)(s->d1->r_epoch + 1) && |
36d16f8e BL |
1670 | (rr->type == SSL3_RT_HANDSHAKE || |
1671 | rr->type == SSL3_RT_ALERT)) | |
1672 | { | |
1673 | *is_next_epoch = 1; | |
1674 | return &s->d1->next_bitmap; | |
1675 | } | |
1676 | ||
1677 | return NULL; | |
1678 | } | |
1679 | ||
1680 | #if 0 | |
1681 | static int | |
1682 | dtls1_record_needs_buffering(SSL *s, SSL3_RECORD *rr, unsigned short *priority, | |
1683 | unsigned long *offset) | |
1684 | { | |
1685 | ||
1686 | /* alerts are passed up immediately */ | |
1687 | if ( rr->type == SSL3_RT_APPLICATION_DATA || | |
1688 | rr->type == SSL3_RT_ALERT) | |
1689 | return 0; | |
1690 | ||
1691 | /* Only need to buffer if a handshake is underway. | |
1692 | * (this implies that Hello Request and Client Hello are passed up | |
1693 | * immediately) */ | |
1694 | if ( SSL_in_init(s)) | |
1695 | { | |
1696 | unsigned char *data = rr->data; | |
1697 | /* need to extract the HM/CCS sequence number here */ | |
1698 | if ( rr->type == SSL3_RT_HANDSHAKE || | |
1699 | rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) | |
1700 | { | |
1701 | unsigned short seq_num; | |
1702 | struct hm_header_st msg_hdr; | |
1703 | struct ccs_header_st ccs_hdr; | |
1704 | ||
1705 | if ( rr->type == SSL3_RT_HANDSHAKE) | |
1706 | { | |
1707 | dtls1_get_message_header(data, &msg_hdr); | |
1708 | seq_num = msg_hdr.seq; | |
1709 | *offset = msg_hdr.frag_off; | |
1710 | } | |
1711 | else | |
1712 | { | |
1713 | dtls1_get_ccs_header(data, &ccs_hdr); | |
1714 | seq_num = ccs_hdr.seq; | |
1715 | *offset = 0; | |
1716 | } | |
1717 | ||
1718 | /* this is either a record we're waiting for, or a | |
1719 | * retransmit of something we happened to previously | |
1720 | * receive (higher layers will drop the repeat silently */ | |
1721 | if ( seq_num < s->d1->handshake_read_seq) | |
1722 | return 0; | |
1723 | if (rr->type == SSL3_RT_HANDSHAKE && | |
1724 | seq_num == s->d1->handshake_read_seq && | |
1725 | msg_hdr.frag_off < s->d1->r_msg_hdr.frag_off) | |
1726 | return 0; | |
1727 | else if ( seq_num == s->d1->handshake_read_seq && | |
1728 | (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC || | |
1729 | msg_hdr.frag_off == s->d1->r_msg_hdr.frag_off)) | |
1730 | return 0; | |
1731 | else | |
1732 | { | |
1733 | *priority = seq_num; | |
1734 | return 1; | |
1735 | } | |
1736 | } | |
1737 | else /* unknown record type */ | |
1738 | return 0; | |
1739 | } | |
1740 | ||
1741 | return 0; | |
1742 | } | |
1743 | #endif | |
1744 | ||
1745 | void | |
1746 | dtls1_reset_seq_numbers(SSL *s, int rw) | |
1747 | { | |
1748 | unsigned char *seq; | |
1749 | unsigned int seq_bytes = sizeof(s->s3->read_sequence); | |
1750 | ||
1751 | if ( rw & SSL3_CC_READ) | |
1752 | { | |
1753 | seq = s->s3->read_sequence; | |
1754 | s->d1->r_epoch++; | |
dffdb56b | 1755 | memcpy(&(s->d1->bitmap), &(s->d1->next_bitmap), sizeof(DTLS1_BITMAP)); |
36d16f8e BL |
1756 | memset(&(s->d1->next_bitmap), 0x00, sizeof(DTLS1_BITMAP)); |
1757 | } | |
1758 | else | |
1759 | { | |
1760 | seq = s->s3->write_sequence; | |
e5fa864f | 1761 | memcpy(s->d1->last_write_sequence, seq, sizeof(s->s3->write_sequence)); |
36d16f8e BL |
1762 | s->d1->w_epoch++; |
1763 | } | |
1764 | ||
1765 | memset(seq, 0x00, seq_bytes); | |
1766 | } | |
1767 | ||
36d16f8e BL |
1768 | |
1769 | static void | |
1770 | dtls1_clear_timeouts(SSL *s) | |
1771 | { | |
1772 | memset(&(s->d1->timeout), 0x00, sizeof(struct dtls1_timeout_st)); | |
1773 | } |