]>
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 | 182 | |
36d16f8e BL |
183 | /* copy buffered record into SSL structure */ |
184 | static int | |
185 | dtls1_copy_record(SSL *s, pitem *item) | |
186 | { | |
187 | DTLS1_RECORD_DATA *rdata; | |
188 | ||
189 | rdata = (DTLS1_RECORD_DATA *)item->data; | |
190 | ||
191 | if (s->s3->rbuf.buf != NULL) | |
192 | OPENSSL_free(s->s3->rbuf.buf); | |
193 | ||
194 | s->packet = rdata->packet; | |
195 | s->packet_length = rdata->packet_length; | |
196 | memcpy(&(s->s3->rbuf), &(rdata->rbuf), sizeof(SSL3_BUFFER)); | |
197 | memcpy(&(s->s3->rrec), &(rdata->rrec), sizeof(SSL3_RECORD)); | |
9f4dd3e3 DSH |
198 | |
199 | /* Set proper sequence number for mac calculation */ | |
200 | memcpy(&(s->s3->read_sequence[2]), &(rdata->packet[5]), 6); | |
36d16f8e BL |
201 | |
202 | return(1); | |
203 | } | |
204 | ||
205 | ||
206 | static int | |
dffdb56b AP |
207 | dtls1_buffer_record(SSL *s, record_pqueue *queue, unsigned char *priority) |
208 | { | |
209 | DTLS1_RECORD_DATA *rdata; | |
36d16f8e BL |
210 | pitem *item; |
211 | ||
88b48dc6 DSH |
212 | /* Limit the size of the queue to prevent DOS attacks */ |
213 | if (pqueue_size(queue->q) >= 100) | |
214 | return 0; | |
04685bc9 | 215 | |
36d16f8e BL |
216 | rdata = OPENSSL_malloc(sizeof(DTLS1_RECORD_DATA)); |
217 | item = pitem_new(priority, rdata); | |
218 | if (rdata == NULL || item == NULL) | |
219 | { | |
220 | if (rdata != NULL) OPENSSL_free(rdata); | |
221 | if (item != NULL) pitem_free(item); | |
222 | ||
beb056b3 | 223 | SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR); |
36d16f8e BL |
224 | return(0); |
225 | } | |
226 | ||
227 | rdata->packet = s->packet; | |
228 | rdata->packet_length = s->packet_length; | |
229 | memcpy(&(rdata->rbuf), &(s->s3->rbuf), sizeof(SSL3_BUFFER)); | |
230 | memcpy(&(rdata->rrec), &(s->s3->rrec), sizeof(SSL3_RECORD)); | |
231 | ||
232 | item->data = rdata; | |
233 | ||
e065e6cd DSH |
234 | #ifndef OPENSSL_NO_SCTP |
235 | /* Store bio_dgram_sctp_rcvinfo struct */ | |
236 | if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && | |
237 | (s->state == SSL3_ST_SR_FINISHED_A || s->state == SSL3_ST_CR_FINISHED_A)) { | |
238 | BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SCTP_GET_RCVINFO, sizeof(rdata->recordinfo), &rdata->recordinfo); | |
239 | } | |
240 | #endif | |
241 | ||
36d16f8e BL |
242 | s->packet = NULL; |
243 | s->packet_length = 0; | |
244 | memset(&(s->s3->rbuf), 0, sizeof(SSL3_BUFFER)); | |
245 | memset(&(s->s3->rrec), 0, sizeof(SSL3_RECORD)); | |
246 | ||
8c5a2bd6 NL |
247 | if (!ssl3_setup_buffers(s)) |
248 | { | |
249 | SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR); | |
04685bc9 MC |
250 | if (rdata->rbuf.buf != NULL) |
251 | OPENSSL_free(rdata->rbuf.buf); | |
8c5a2bd6 NL |
252 | OPENSSL_free(rdata); |
253 | pitem_free(item); | |
04685bc9 | 254 | return(-1); |
8c5a2bd6 | 255 | } |
a07856a0 DR |
256 | |
257 | /* insert should not fail, since duplicates are dropped */ | |
258 | if (pqueue_insert(queue->q, item) == NULL) | |
259 | { | |
056389eb | 260 | SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR); |
04685bc9 MC |
261 | if (rdata->rbuf.buf != NULL) |
262 | OPENSSL_free(rdata->rbuf.buf); | |
a07856a0 DR |
263 | OPENSSL_free(rdata); |
264 | pitem_free(item); | |
04685bc9 | 265 | return(-1); |
a07856a0 DR |
266 | } |
267 | ||
36d16f8e | 268 | return(1); |
dffdb56b | 269 | } |
36d16f8e BL |
270 | |
271 | ||
272 | static int | |
273 | dtls1_retrieve_buffered_record(SSL *s, record_pqueue *queue) | |
274 | { | |
275 | pitem *item; | |
276 | ||
277 | item = pqueue_pop(queue->q); | |
278 | if (item) | |
279 | { | |
280 | dtls1_copy_record(s, item); | |
281 | ||
282 | OPENSSL_free(item->data); | |
283 | pitem_free(item); | |
284 | ||
285 | return(1); | |
286 | } | |
287 | ||
288 | return(0); | |
289 | } | |
290 | ||
291 | ||
292 | /* retrieve a buffered record that belongs to the new epoch, i.e., not processed | |
293 | * yet */ | |
294 | #define dtls1_get_unprocessed_record(s) \ | |
295 | dtls1_retrieve_buffered_record((s), \ | |
296 | &((s)->d1->unprocessed_rcds)) | |
297 | ||
298 | /* retrieve a buffered record that belongs to the current epoch, ie, processed */ | |
299 | #define dtls1_get_processed_record(s) \ | |
300 | dtls1_retrieve_buffered_record((s), \ | |
301 | &((s)->d1->processed_rcds)) | |
302 | ||
303 | static int | |
304 | dtls1_process_buffered_records(SSL *s) | |
305 | { | |
306 | pitem *item; | |
307 | ||
308 | item = pqueue_peek(s->d1->unprocessed_rcds.q); | |
309 | if (item) | |
310 | { | |
36d16f8e BL |
311 | /* Check if epoch is current. */ |
312 | if (s->d1->unprocessed_rcds.epoch != s->d1->r_epoch) | |
313 | return(1); /* Nothing to do. */ | |
314 | ||
315 | /* Process all the records. */ | |
316 | while (pqueue_peek(s->d1->unprocessed_rcds.q)) | |
317 | { | |
318 | dtls1_get_unprocessed_record(s); | |
319 | if ( ! dtls1_process_record(s)) | |
320 | return(0); | |
04685bc9 MC |
321 | if(dtls1_buffer_record(s, &(s->d1->processed_rcds), |
322 | s->s3->rrec.seq_num)<0) | |
323 | return -1; | |
36d16f8e BL |
324 | } |
325 | } | |
326 | ||
327 | /* sync epoch numbers once all the unprocessed records | |
328 | * have been processed */ | |
329 | s->d1->processed_rcds.epoch = s->d1->r_epoch; | |
330 | s->d1->unprocessed_rcds.epoch = s->d1->r_epoch + 1; | |
331 | ||
332 | return(1); | |
333 | } | |
334 | ||
335 | ||
336 | #if 0 | |
337 | ||
338 | static int | |
339 | dtls1_get_buffered_record(SSL *s) | |
340 | { | |
341 | pitem *item; | |
188b0579 RL |
342 | PQ_64BIT priority = |
343 | (((PQ_64BIT)s->d1->handshake_read_seq) << 32) | | |
344 | ((PQ_64BIT)s->d1->r_msg_hdr.frag_off); | |
36d16f8e BL |
345 | |
346 | if ( ! SSL_in_init(s)) /* if we're not (re)negotiating, | |
347 | nothing buffered */ | |
348 | return 0; | |
349 | ||
350 | ||
351 | item = pqueue_peek(s->d1->rcvd_records); | |
352 | if (item && item->priority == priority) | |
353 | { | |
354 | /* Check if we've received the record of interest. It must be | |
355 | * a handshake record, since data records as passed up without | |
356 | * buffering */ | |
357 | DTLS1_RECORD_DATA *rdata; | |
358 | item = pqueue_pop(s->d1->rcvd_records); | |
359 | rdata = (DTLS1_RECORD_DATA *)item->data; | |
360 | ||
361 | if (s->s3->rbuf.buf != NULL) | |
362 | OPENSSL_free(s->s3->rbuf.buf); | |
363 | ||
364 | s->packet = rdata->packet; | |
365 | s->packet_length = rdata->packet_length; | |
366 | memcpy(&(s->s3->rbuf), &(rdata->rbuf), sizeof(SSL3_BUFFER)); | |
367 | memcpy(&(s->s3->rrec), &(rdata->rrec), sizeof(SSL3_RECORD)); | |
368 | ||
369 | OPENSSL_free(item->data); | |
370 | pitem_free(item); | |
371 | ||
372 | /* s->d1->next_expected_seq_num++; */ | |
373 | return(1); | |
374 | } | |
375 | ||
376 | return 0; | |
377 | } | |
378 | ||
379 | #endif | |
380 | ||
381 | static int | |
382 | dtls1_process_record(SSL *s) | |
383 | { | |
50ec3951 | 384 | int i,al; |
50ec3951 | 385 | int enc_err; |
36d16f8e | 386 | SSL_SESSION *sess; |
50ec3951 | 387 | SSL3_RECORD *rr; |
ec07246a | 388 | unsigned int mac_size, orig_len; |
36d16f8e | 389 | unsigned char md[EVP_MAX_MD_SIZE]; |
36d16f8e BL |
390 | |
391 | rr= &(s->s3->rrec); | |
50ec3951 | 392 | sess = s->session; |
36d16f8e BL |
393 | |
394 | /* At this point, s->packet_length == SSL3_RT_HEADER_LNGTH + rr->length, | |
395 | * and we have that many bytes in s->packet | |
396 | */ | |
397 | rr->input= &(s->packet[DTLS1_RT_HEADER_LENGTH]); | |
398 | ||
399 | /* ok, we can now read from 's->packet' data into 'rr' | |
400 | * rr->input points at rr->length bytes, which | |
401 | * need to be copied into rr->data by either | |
402 | * the decryption or by the decompression | |
403 | * When the data is 'copied' into the rr->data buffer, | |
404 | * rr->input will be pointed at the new buffer */ | |
405 | ||
406 | /* We now have - encrypted [ MAC [ compressed [ plain ] ] ] | |
407 | * rr->length bytes of encrypted compressed stuff. */ | |
408 | ||
409 | /* check is not needed I believe */ | |
410 | if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) | |
411 | { | |
412 | al=SSL_AD_RECORD_OVERFLOW; | |
beb056b3 | 413 | SSLerr(SSL_F_DTLS1_PROCESS_RECORD,SSL_R_ENCRYPTED_LENGTH_TOO_LONG); |
36d16f8e BL |
414 | goto f_err; |
415 | } | |
416 | ||
417 | /* decrypt in place in 'rr->input' */ | |
418 | rr->data=rr->input; | |
419 | ||
420 | enc_err = s->method->ssl3_enc->enc(s,0); | |
9f27de17 BL |
421 | /* enc_err is: |
422 | * 0: (in non-constant time) if the record is publically invalid. | |
423 | * 1: if the padding is valid | |
424 | * -1: if the padding is invalid */ | |
425 | if (enc_err == 0) | |
36d16f8e | 426 | { |
9f27de17 BL |
427 | /* For DTLS we simply ignore bad packets. */ |
428 | rr->length = 0; | |
429 | s->packet_length = 0; | |
430 | goto err; | |
36d16f8e BL |
431 | } |
432 | ||
433 | #ifdef TLS_DEBUG | |
434 | printf("dec %d\n",rr->length); | |
435 | { unsigned int z; for (z=0; z<rr->length; z++) printf("%02X%c",rr->data[z],((z+1)%16)?' ':'\n'); } | |
436 | printf("\n"); | |
437 | #endif | |
438 | ||
439 | /* r->length is now the compressed data plus mac */ | |
9f27de17 BL |
440 | if ((sess != NULL) && |
441 | (s->enc_read_ctx != NULL) && | |
442 | (EVP_MD_CTX_md(s->read_hash) != NULL)) | |
36d16f8e | 443 | { |
9f27de17 BL |
444 | /* s->read_hash != NULL => mac_size != -1 */ |
445 | unsigned char *mac = NULL; | |
446 | unsigned char mac_tmp[EVP_MAX_MD_SIZE]; | |
447 | mac_size=EVP_MD_CTX_size(s->read_hash); | |
448 | OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE); | |
449 | ||
8545f73b AP |
450 | /* kludge: *_cbc_remove_padding passes padding length in rr->type */ |
451 | orig_len = rr->length+((unsigned int)rr->type>>8); | |
452 | ||
9f27de17 BL |
453 | /* orig_len is the length of the record before any padding was |
454 | * removed. This is public information, as is the MAC in use, | |
455 | * therefore we can safely process the record in a different | |
456 | * amount of time if it's too short to possibly contain a MAC. | |
457 | */ | |
ec07246a | 458 | if (orig_len < mac_size || |
9f27de17 BL |
459 | /* CBC records must have a padding length byte too. */ |
460 | (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE && | |
ec07246a | 461 | orig_len < mac_size+1)) |
36d16f8e | 462 | { |
9f27de17 | 463 | al=SSL_AD_DECODE_ERROR; |
35d732fc | 464 | SSLerr(SSL_F_DTLS1_PROCESS_RECORD,SSL_R_LENGTH_TOO_SHORT); |
36d16f8e | 465 | goto f_err; |
36d16f8e | 466 | } |
9f27de17 BL |
467 | |
468 | if (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE) | |
36d16f8e | 469 | { |
9f27de17 BL |
470 | /* We update the length so that the TLS header bytes |
471 | * can be constructed correctly but we need to extract | |
472 | * the MAC in constant time from within the record, | |
473 | * without leaking the contents of the padding bytes. | |
474 | * */ | |
475 | mac = mac_tmp; | |
ec07246a | 476 | ssl3_cbc_copy_mac(mac_tmp, rr, mac_size, orig_len); |
2dc4b0db | 477 | rr->length -= mac_size; |
36d16f8e | 478 | } |
2dc4b0db | 479 | else |
36d16f8e | 480 | { |
ec07246a | 481 | /* In this case there's no padding, so |orig_len| |
9f27de17 BL |
482 | * equals |rec->length| and we checked that there's |
483 | * enough bytes for |mac_size| above. */ | |
484 | rr->length -= mac_size; | |
485 | mac = &rr->data[rr->length]; | |
36d16f8e | 486 | } |
9f27de17 BL |
487 | |
488 | i=s->method->ssl3_enc->mac(s,md,0 /* not send */); | |
489 | if (i < 0 || mac == NULL || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0) | |
490 | enc_err = -1; | |
491 | if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+mac_size) | |
492 | enc_err = -1; | |
36d16f8e BL |
493 | } |
494 | ||
9f27de17 | 495 | if (enc_err < 0) |
0044739a DSH |
496 | { |
497 | /* decryption failed, silently discard message */ | |
498 | rr->length = 0; | |
499 | s->packet_length = 0; | |
500 | goto err; | |
501 | } | |
502 | ||
36d16f8e BL |
503 | /* r->length is now just compressed */ |
504 | if (s->expand != NULL) | |
505 | { | |
506 | if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH) | |
507 | { | |
508 | al=SSL_AD_RECORD_OVERFLOW; | |
beb056b3 | 509 | SSLerr(SSL_F_DTLS1_PROCESS_RECORD,SSL_R_COMPRESSED_LENGTH_TOO_LONG); |
36d16f8e BL |
510 | goto f_err; |
511 | } | |
512 | if (!ssl3_do_uncompress(s)) | |
513 | { | |
514 | al=SSL_AD_DECOMPRESSION_FAILURE; | |
beb056b3 | 515 | SSLerr(SSL_F_DTLS1_PROCESS_RECORD,SSL_R_BAD_DECOMPRESSION); |
36d16f8e BL |
516 | goto f_err; |
517 | } | |
518 | } | |
519 | ||
520 | if (rr->length > SSL3_RT_MAX_PLAIN_LENGTH) | |
521 | { | |
522 | al=SSL_AD_RECORD_OVERFLOW; | |
beb056b3 | 523 | SSLerr(SSL_F_DTLS1_PROCESS_RECORD,SSL_R_DATA_LENGTH_TOO_LONG); |
36d16f8e BL |
524 | goto f_err; |
525 | } | |
526 | ||
527 | rr->off=0; | |
3e9a08ec TH |
528 | /*- |
529 | * So at this point the following is true | |
36d16f8e BL |
530 | * ssl->s3->rrec.type is the type of record |
531 | * ssl->s3->rrec.length == number of bytes in record | |
532 | * ssl->s3->rrec.off == offset to first valid byte | |
533 | * ssl->s3->rrec.data == where to take bytes from, increment | |
534 | * after use :-). | |
535 | */ | |
536 | ||
537 | /* we have pulled in a full packet so zero things */ | |
538 | s->packet_length=0; | |
50ec3951 | 539 | return(1); |
36d16f8e | 540 | |
36d16f8e BL |
541 | f_err: |
542 | ssl3_send_alert(s,SSL3_AL_FATAL,al); | |
543 | err: | |
544 | return(0); | |
545 | } | |
546 | ||
547 | ||
3e9a08ec TH |
548 | /*- |
549 | * Call this to get a new input record. | |
36d16f8e BL |
550 | * It will return <= 0 if more data is needed, normally due to an error |
551 | * or non-blocking IO. | |
552 | * When it finishes, one packet has been decoded and can be found in | |
553 | * ssl->s3->rrec.type - is the type of record | |
554 | * ssl->s3->rrec.data, - data | |
555 | * ssl->s3->rrec.length, - number of bytes | |
556 | */ | |
557 | /* used only by dtls1_read_bytes */ | |
558 | int dtls1_get_record(SSL *s) | |
559 | { | |
5a03e3ac | 560 | int ssl_major,ssl_minor; |
36d16f8e BL |
561 | int i,n; |
562 | SSL3_RECORD *rr; | |
ad187f89 | 563 | unsigned char *p = NULL; |
7432d073 | 564 | unsigned short version; |
36d16f8e | 565 | DTLS1_BITMAP *bitmap; |
dffdb56b | 566 | unsigned int is_next_epoch; |
36d16f8e BL |
567 | |
568 | rr= &(s->s3->rrec); | |
36d16f8e | 569 | |
dffdb56b AP |
570 | /* The epoch may have changed. If so, process all the |
571 | * pending records. This is a non-blocking operation. */ | |
04685bc9 MC |
572 | if(dtls1_process_buffered_records(s)<0) |
573 | return -1; | |
36d16f8e BL |
574 | |
575 | /* if we're renegotiating, then there may be buffered records */ | |
576 | if (dtls1_get_processed_record(s)) | |
577 | return 1; | |
578 | ||
579 | /* get something from the wire */ | |
580 | again: | |
581 | /* check if we have the header */ | |
582 | if ( (s->rstate != SSL_ST_READ_BODY) || | |
583 | (s->packet_length < DTLS1_RT_HEADER_LENGTH)) | |
584 | { | |
585 | n=ssl3_read_n(s, DTLS1_RT_HEADER_LENGTH, s->s3->rbuf.len, 0); | |
586 | /* read timeout is handled by dtls1_read_bytes */ | |
587 | if (n <= 0) return(n); /* error or non-blocking */ | |
588 | ||
cddd0016 DSH |
589 | /* this packet contained a partial record, dump it */ |
590 | if (s->packet_length != DTLS1_RT_HEADER_LENGTH) | |
591 | { | |
592 | s->packet_length = 0; | |
593 | goto again; | |
594 | } | |
36d16f8e BL |
595 | |
596 | s->rstate=SSL_ST_READ_BODY; | |
597 | ||
598 | p=s->packet; | |
599 | ||
600 | /* Pull apart the header into the DTLS1_RECORD */ | |
601 | rr->type= *(p++); | |
602 | ssl_major= *(p++); | |
603 | ssl_minor= *(p++); | |
604 | version=(ssl_major<<8)|ssl_minor; | |
605 | ||
dffdb56b | 606 | /* sequence number is 64 bits, with top 2 bytes = epoch */ |
36d16f8e BL |
607 | n2s(p,rr->epoch); |
608 | ||
188b0579 RL |
609 | memcpy(&(s->s3->read_sequence[2]), p, 6); |
610 | p+=6; | |
611 | ||
36d16f8e BL |
612 | n2s(p,rr->length); |
613 | ||
614 | /* Lets check version */ | |
1e24b3a0 | 615 | if (!s->first_packet) |
36d16f8e BL |
616 | { |
617 | if (version != s->version) | |
618 | { | |
08b20979 DSH |
619 | /* unexpected version, silently discard */ |
620 | rr->length = 0; | |
621 | s->packet_length = 0; | |
622 | goto again; | |
36d16f8e BL |
623 | } |
624 | } | |
625 | ||
b452f433 | 626 | if ((version & 0xff00) != (s->version & 0xff00)) |
36d16f8e | 627 | { |
08b20979 DSH |
628 | /* wrong version, silently discard record */ |
629 | rr->length = 0; | |
630 | s->packet_length = 0; | |
631 | goto again; | |
36d16f8e BL |
632 | } |
633 | ||
634 | if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) | |
635 | { | |
08b20979 DSH |
636 | /* record too long, silently discard it */ |
637 | rr->length = 0; | |
638 | s->packet_length = 0; | |
639 | goto again; | |
36d16f8e BL |
640 | } |
641 | ||
642 | /* now s->rstate == SSL_ST_READ_BODY */ | |
643 | } | |
644 | ||
645 | /* s->rstate == SSL_ST_READ_BODY, get and decode the data */ | |
646 | ||
647 | if (rr->length > s->packet_length-DTLS1_RT_HEADER_LENGTH) | |
648 | { | |
649 | /* now s->packet_length == DTLS1_RT_HEADER_LENGTH */ | |
650 | i=rr->length; | |
651 | n=ssl3_read_n(s,i,i,1); | |
36d16f8e BL |
652 | /* this packet contained a partial record, dump it */ |
653 | if ( n != i) | |
654 | { | |
2b3cd246 | 655 | rr->length = 0; |
36d16f8e BL |
656 | s->packet_length = 0; |
657 | goto again; | |
658 | } | |
659 | ||
660 | /* now n == rr->length, | |
661 | * and s->packet_length == DTLS1_RT_HEADER_LENGTH + rr->length */ | |
662 | } | |
663 | s->rstate=SSL_ST_READ_HEADER; /* set state for later operations */ | |
664 | ||
665 | /* match epochs. NULL means the packet is dropped on the floor */ | |
666 | bitmap = dtls1_get_bitmap(s, rr, &is_next_epoch); | |
667 | if ( bitmap == NULL) | |
50ec3951 | 668 | { |
2b3cd246 | 669 | rr->length = 0; |
50ec3951 AP |
670 | s->packet_length = 0; /* dump this record */ |
671 | goto again; /* get another record */ | |
36d16f8e BL |
672 | } |
673 | ||
e065e6cd DSH |
674 | #ifndef OPENSSL_NO_SCTP |
675 | /* Only do replay check if no SCTP bio */ | |
676 | if (!BIO_dgram_is_sctp(SSL_get_rbio(s))) | |
677 | { | |
678 | #endif | |
679 | /* Check whether this is a repeat, or aged record. | |
680 | * Don't check if we're listening and this message is | |
681 | * a ClientHello. They can look as if they're replayed, | |
682 | * since they arrive from different connections and | |
683 | * would be dropped unnecessarily. | |
684 | */ | |
685 | if (!(s->d1->listen && rr->type == SSL3_RT_HANDSHAKE && | |
45fe66b8 MC |
686 | s->packet_length > DTLS1_RT_HEADER_LENGTH && |
687 | s->packet[DTLS1_RT_HEADER_LENGTH] == SSL3_MT_CLIENT_HELLO) && | |
e065e6cd DSH |
688 | !dtls1_record_replay_check(s, bitmap)) |
689 | { | |
690 | rr->length = 0; | |
691 | s->packet_length=0; /* dump this record */ | |
692 | goto again; /* get another record */ | |
693 | } | |
694 | #ifndef OPENSSL_NO_SCTP | |
695 | } | |
696 | #endif | |
36d16f8e BL |
697 | |
698 | /* just read a 0 length packet */ | |
699 | if (rr->length == 0) goto again; | |
700 | ||
dffdb56b | 701 | /* If this record is from the next epoch (either HM or ALERT), |
6dfd3cf6 | 702 | * and a handshake is currently in progress, buffer it since it |
ec5d74f8 DSH |
703 | * cannot be processed at this time. However, do not buffer |
704 | * anything while listening. | |
705 | */ | |
dffdb56b AP |
706 | if (is_next_epoch) |
707 | { | |
ec5d74f8 | 708 | if ((SSL_in_init(s) || s->in_handshake) && !s->d1->listen) |
6dfd3cf6 | 709 | { |
04685bc9 MC |
710 | if(dtls1_buffer_record(s, &(s->d1->unprocessed_rcds), rr->seq_num)<0) |
711 | return -1; | |
712 | dtls1_record_bitmap_update(s, bitmap);/* Mark receipt of record. */ | |
6dfd3cf6 | 713 | } |
2b3cd246 | 714 | rr->length = 0; |
dffdb56b AP |
715 | s->packet_length = 0; |
716 | goto again; | |
717 | } | |
36d16f8e | 718 | |
30e8defe DSH |
719 | if (!dtls1_process_record(s)) |
720 | { | |
721 | rr->length = 0; | |
722 | s->packet_length = 0; /* dump this record */ | |
723 | goto again; /* get another record */ | |
724 | } | |
04685bc9 | 725 | dtls1_record_bitmap_update(s, bitmap);/* Mark receipt of record. */ |
36d16f8e | 726 | |
36d16f8e BL |
727 | return(1); |
728 | ||
36d16f8e BL |
729 | } |
730 | ||
3e9a08ec TH |
731 | /*- |
732 | * Return up to 'len' payload bytes received in 'type' records. | |
36d16f8e BL |
733 | * 'type' is one of the following: |
734 | * | |
735 | * - SSL3_RT_HANDSHAKE (when ssl3_get_message calls us) | |
736 | * - SSL3_RT_APPLICATION_DATA (when ssl3_read calls us) | |
737 | * - 0 (during a shutdown, no data has to be returned) | |
738 | * | |
739 | * If we don't have stored data to work from, read a SSL/TLS record first | |
740 | * (possibly multiple records if we still don't have anything to return). | |
741 | * | |
742 | * This function must handle any surprises the peer may have for us, such as | |
743 | * Alert records (e.g. close_notify), ChangeCipherSpec records (not really | |
744 | * a surprise, but handled as if it were), or renegotiation requests. | |
745 | * Also if record payloads contain fragments too small to process, we store | |
746 | * them until there is enough for the respective protocol (the record protocol | |
747 | * may use arbitrary fragmentation and even interleaving): | |
748 | * Change cipher spec protocol | |
749 | * just 1 byte needed, no need for keeping anything stored | |
750 | * Alert protocol | |
751 | * 2 bytes needed (AlertLevel, AlertDescription) | |
752 | * Handshake protocol | |
753 | * 4 bytes needed (HandshakeType, uint24 length) -- we just have | |
754 | * to detect unexpected Client Hello and Hello Request messages | |
755 | * here, anything else is handled by higher layers | |
756 | * Application data protocol | |
757 | * none of our business | |
758 | */ | |
759 | int dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek) | |
760 | { | |
761 | int al,i,j,ret; | |
762 | unsigned int n; | |
763 | SSL3_RECORD *rr; | |
764 | void (*cb)(const SSL *ssl,int type2,int val)=NULL; | |
765 | ||
766 | if (s->s3->rbuf.buf == NULL) /* Not initialized yet */ | |
767 | if (!ssl3_setup_buffers(s)) | |
768 | return(-1); | |
769 | ||
770 | /* XXX: check what the second '&& type' is about */ | |
771 | if ((type && (type != SSL3_RT_APPLICATION_DATA) && | |
772 | (type != SSL3_RT_HANDSHAKE) && type) || | |
773 | (peek && (type != SSL3_RT_APPLICATION_DATA))) | |
774 | { | |
beb056b3 | 775 | SSLerr(SSL_F_DTLS1_READ_BYTES, ERR_R_INTERNAL_ERROR); |
36d16f8e BL |
776 | return -1; |
777 | } | |
778 | ||
779 | /* check whether there's a handshake message (client hello?) waiting */ | |
780 | if ( (ret = have_handshake_fragment(s, type, buf, len, peek))) | |
781 | return ret; | |
782 | ||
783 | /* Now s->d1->handshake_fragment_len == 0 if type == SSL3_RT_HANDSHAKE. */ | |
784 | ||
e065e6cd DSH |
785 | #ifndef OPENSSL_NO_SCTP |
786 | /* Continue handshake if it had to be interrupted to read | |
787 | * app data with SCTP. | |
788 | */ | |
789 | if ((!s->in_handshake && SSL_in_init(s)) || | |
790 | (BIO_dgram_is_sctp(SSL_get_rbio(s)) && | |
791 | (s->state == DTLS1_SCTP_ST_SR_READ_SOCK || s->state == DTLS1_SCTP_ST_CR_READ_SOCK) && | |
792 | s->s3->in_read_app_data != 2)) | |
793 | #else | |
36d16f8e | 794 | if (!s->in_handshake && SSL_in_init(s)) |
e065e6cd | 795 | #endif |
36d16f8e BL |
796 | { |
797 | /* type == SSL3_RT_APPLICATION_DATA */ | |
798 | i=s->handshake_func(s); | |
799 | if (i < 0) return(i); | |
800 | if (i == 0) | |
801 | { | |
beb056b3 | 802 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE); |
36d16f8e BL |
803 | return(-1); |
804 | } | |
805 | } | |
806 | ||
807 | start: | |
808 | s->rwstate=SSL_NOTHING; | |
809 | ||
3e9a08ec TH |
810 | /*- |
811 | * s->s3->rrec.type - is the type of record | |
36d16f8e BL |
812 | * s->s3->rrec.data, - data |
813 | * s->s3->rrec.off, - offset into 'data' for next read | |
3e9a08ec TH |
814 | * s->s3->rrec.length, - number of bytes. |
815 | */ | |
36d16f8e BL |
816 | rr = &(s->s3->rrec); |
817 | ||
3c0ce01c DSH |
818 | /* We are not handshaking and have no data yet, |
819 | * so process data buffered during the last handshake | |
820 | * in advance, if any. | |
821 | */ | |
822 | if (s->state == SSL_ST_OK && rr->length == 0) | |
823 | { | |
824 | pitem *item; | |
825 | item = pqueue_pop(s->d1->buffered_app_data.q); | |
826 | if (item) | |
827 | { | |
e065e6cd DSH |
828 | #ifndef OPENSSL_NO_SCTP |
829 | /* Restore bio_dgram_sctp_rcvinfo struct */ | |
830 | if (BIO_dgram_is_sctp(SSL_get_rbio(s))) | |
831 | { | |
832 | DTLS1_RECORD_DATA *rdata = (DTLS1_RECORD_DATA *) item->data; | |
833 | BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SCTP_SET_RCVINFO, sizeof(rdata->recordinfo), &rdata->recordinfo); | |
834 | } | |
835 | #endif | |
836 | ||
3c0ce01c DSH |
837 | dtls1_copy_record(s, item); |
838 | ||
839 | OPENSSL_free(item->data); | |
840 | pitem_free(item); | |
841 | } | |
842 | } | |
d6584eba DSH |
843 | |
844 | /* Check for timeout */ | |
a4bade7a DSH |
845 | if (dtls1_handle_timeout(s) > 0) |
846 | goto start; | |
d6584eba | 847 | |
36d16f8e BL |
848 | /* get new packet if necessary */ |
849 | if ((rr->length == 0) || (s->rstate == SSL_ST_READ_BODY)) | |
850 | { | |
851 | ret=dtls1_get_record(s); | |
852 | if (ret <= 0) | |
853 | { | |
854 | ret = dtls1_read_failed(s, ret); | |
855 | /* anything other than a timeout is an error */ | |
856 | if (ret <= 0) | |
857 | return(ret); | |
858 | else | |
859 | goto start; | |
860 | } | |
861 | } | |
862 | ||
76bf0cf2 MT |
863 | if (s->d1->listen && rr->type != SSL3_RT_HANDSHAKE) |
864 | { | |
865 | rr->length = 0; | |
866 | goto start; | |
867 | } | |
868 | ||
36d16f8e BL |
869 | /* we now have a packet which can be read and processed */ |
870 | ||
871 | if (s->s3->change_cipher_spec /* set when we receive ChangeCipherSpec, | |
872 | * reset by ssl3_get_finished */ | |
873 | && (rr->type != SSL3_RT_HANDSHAKE)) | |
874 | { | |
3c0ce01c DSH |
875 | /* We now have application data between CCS and Finished. |
876 | * Most likely the packets were reordered on their way, so | |
877 | * buffer the application data for later processing rather | |
878 | * than dropping the connection. | |
879 | */ | |
04685bc9 MC |
880 | if(dtls1_buffer_record(s, &(s->d1->buffered_app_data), rr->seq_num)<0) |
881 | { | |
882 | SSLerr(SSL_F_DTLS1_READ_BYTES, ERR_R_INTERNAL_ERROR); | |
883 | return -1; | |
884 | } | |
3c0ce01c DSH |
885 | rr->length = 0; |
886 | goto start; | |
36d16f8e BL |
887 | } |
888 | ||
889 | /* If the other end has shut down, throw anything we read away | |
890 | * (even in 'peek' mode) */ | |
891 | if (s->shutdown & SSL_RECEIVED_SHUTDOWN) | |
892 | { | |
893 | rr->length=0; | |
894 | s->rwstate=SSL_NOTHING; | |
895 | return(0); | |
896 | } | |
897 | ||
898 | ||
899 | if (type == rr->type) /* SSL3_RT_APPLICATION_DATA or SSL3_RT_HANDSHAKE */ | |
900 | { | |
901 | /* make sure that we are not getting application data when we | |
902 | * are doing a handshake for the first time */ | |
903 | if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) && | |
904 | (s->enc_read_ctx == NULL)) | |
905 | { | |
906 | al=SSL_AD_UNEXPECTED_MESSAGE; | |
beb056b3 | 907 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_APP_DATA_IN_HANDSHAKE); |
36d16f8e BL |
908 | goto f_err; |
909 | } | |
910 | ||
911 | if (len <= 0) return(len); | |
912 | ||
913 | if ((unsigned int)len > rr->length) | |
914 | n = rr->length; | |
915 | else | |
916 | n = (unsigned int)len; | |
917 | ||
918 | memcpy(buf,&(rr->data[rr->off]),n); | |
919 | if (!peek) | |
920 | { | |
921 | rr->length-=n; | |
922 | rr->off+=n; | |
923 | if (rr->length == 0) | |
924 | { | |
925 | s->rstate=SSL_ST_READ_HEADER; | |
926 | rr->off=0; | |
927 | } | |
928 | } | |
e065e6cd DSH |
929 | |
930 | #ifndef OPENSSL_NO_SCTP | |
931 | /* We were about to renegotiate but had to read | |
932 | * belated application data first, so retry. | |
933 | */ | |
934 | if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && | |
935 | rr->type == SSL3_RT_APPLICATION_DATA && | |
936 | (s->state == DTLS1_SCTP_ST_SR_READ_SOCK || s->state == DTLS1_SCTP_ST_CR_READ_SOCK)) | |
937 | { | |
938 | s->rwstate=SSL_READING; | |
939 | BIO_clear_retry_flags(SSL_get_rbio(s)); | |
940 | BIO_set_retry_read(SSL_get_rbio(s)); | |
941 | } | |
942 | ||
943 | /* We might had to delay a close_notify alert because | |
944 | * of reordered app data. If there was an alert and there | |
945 | * is no message to read anymore, finally set shutdown. | |
946 | */ | |
947 | if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && | |
948 | s->d1->shutdown_received && !BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s))) | |
949 | { | |
950 | s->shutdown |= SSL_RECEIVED_SHUTDOWN; | |
951 | return(0); | |
952 | } | |
953 | #endif | |
36d16f8e BL |
954 | return(n); |
955 | } | |
956 | ||
957 | ||
958 | /* If we get here, then type != rr->type; if we have a handshake | |
959 | * message, then it was unexpected (Hello Request or Client Hello). */ | |
960 | ||
961 | /* In case of record types for which we have 'fragment' storage, | |
962 | * fill that so that we can process the data at a fixed place. | |
963 | */ | |
964 | { | |
4e321ffa | 965 | unsigned int k, dest_maxlen = 0; |
36d16f8e BL |
966 | unsigned char *dest = NULL; |
967 | unsigned int *dest_len = NULL; | |
968 | ||
969 | if (rr->type == SSL3_RT_HANDSHAKE) | |
970 | { | |
971 | dest_maxlen = sizeof s->d1->handshake_fragment; | |
972 | dest = s->d1->handshake_fragment; | |
973 | dest_len = &s->d1->handshake_fragment_len; | |
974 | } | |
975 | else if (rr->type == SSL3_RT_ALERT) | |
976 | { | |
977 | dest_maxlen = sizeof(s->d1->alert_fragment); | |
978 | dest = s->d1->alert_fragment; | |
979 | dest_len = &s->d1->alert_fragment_len; | |
980 | } | |
bd6941cf DSH |
981 | #ifndef OPENSSL_NO_HEARTBEATS |
982 | else if (rr->type == TLS1_RT_HEARTBEAT) | |
983 | { | |
984 | dtls1_process_heartbeat(s); | |
985 | ||
986 | /* Exit and notify application to read again */ | |
987 | rr->length = 0; | |
988 | s->rwstate=SSL_READING; | |
989 | BIO_clear_retry_flags(SSL_get_rbio(s)); | |
990 | BIO_set_retry_read(SSL_get_rbio(s)); | |
991 | return(-1); | |
992 | } | |
993 | #endif | |
3c0ce01c DSH |
994 | /* else it's a CCS message, or application data or wrong */ |
995 | else if (rr->type != SSL3_RT_CHANGE_CIPHER_SPEC) | |
996 | { | |
997 | /* Application data while renegotiating | |
998 | * is allowed. Try again reading. | |
999 | */ | |
1000 | if (rr->type == SSL3_RT_APPLICATION_DATA) | |
1001 | { | |
1002 | BIO *bio; | |
1003 | s->s3->in_read_app_data=2; | |
1004 | bio=SSL_get_rbio(s); | |
1005 | s->rwstate=SSL_READING; | |
1006 | BIO_clear_retry_flags(bio); | |
1007 | BIO_set_retry_read(bio); | |
1008 | return(-1); | |
1009 | } | |
36d16f8e | 1010 | |
3c0ce01c DSH |
1011 | /* Not certain if this is the right error handling */ |
1012 | al=SSL_AD_UNEXPECTED_MESSAGE; | |
1013 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_UNEXPECTED_RECORD); | |
1014 | goto f_err; | |
1015 | } | |
36d16f8e BL |
1016 | |
1017 | if (dest_maxlen > 0) | |
1018 | { | |
1019 | /* XDTLS: In a pathalogical case, the Client Hello | |
1020 | * may be fragmented--don't always expect dest_maxlen bytes */ | |
1021 | if ( rr->length < dest_maxlen) | |
1022 | { | |
d4938995 AP |
1023 | #ifdef DTLS1_AD_MISSING_HANDSHAKE_MESSAGE |
1024 | /* | |
1025 | * for normal alerts rr->length is 2, while | |
1026 | * dest_maxlen is 7 if we were to handle this | |
1027 | * non-existing alert... | |
1028 | */ | |
1029 | FIX ME | |
1030 | #endif | |
36d16f8e BL |
1031 | s->rstate=SSL_ST_READ_HEADER; |
1032 | rr->length = 0; | |
1033 | goto start; | |
1034 | } | |
1035 | ||
1036 | /* now move 'n' bytes: */ | |
4e321ffa | 1037 | for ( k = 0; k < dest_maxlen; k++) |
36d16f8e | 1038 | { |
4e321ffa | 1039 | dest[k] = rr->data[rr->off++]; |
36d16f8e BL |
1040 | rr->length--; |
1041 | } | |
1042 | *dest_len = dest_maxlen; | |
1043 | } | |
1044 | } | |
1045 | ||
1046 | /* s->d1->handshake_fragment_len == 12 iff rr->type == SSL3_RT_HANDSHAKE; | |
1047 | * s->d1->alert_fragment_len == 7 iff rr->type == SSL3_RT_ALERT. | |
1048 | * (Possibly rr is 'empty' now, i.e. rr->length may be 0.) */ | |
1049 | ||
1050 | /* If we are a client, check for an incoming 'Hello Request': */ | |
1051 | if ((!s->server) && | |
1052 | (s->d1->handshake_fragment_len >= DTLS1_HM_HEADER_LENGTH) && | |
1053 | (s->d1->handshake_fragment[0] == SSL3_MT_HELLO_REQUEST) && | |
1054 | (s->session != NULL) && (s->session->cipher != NULL)) | |
1055 | { | |
1056 | s->d1->handshake_fragment_len = 0; | |
1057 | ||
1058 | if ((s->d1->handshake_fragment[1] != 0) || | |
1059 | (s->d1->handshake_fragment[2] != 0) || | |
1060 | (s->d1->handshake_fragment[3] != 0)) | |
1061 | { | |
1062 | al=SSL_AD_DECODE_ERROR; | |
beb056b3 | 1063 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_BAD_HELLO_REQUEST); |
36d16f8e BL |
1064 | goto err; |
1065 | } | |
1066 | ||
1067 | /* no need to check sequence number on HELLO REQUEST messages */ | |
1068 | ||
1069 | if (s->msg_callback) | |
1070 | s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, | |
1071 | s->d1->handshake_fragment, 4, s, s->msg_callback_arg); | |
1072 | ||
1073 | if (SSL_is_init_finished(s) && | |
1074 | !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS) && | |
1075 | !s->s3->renegotiate) | |
1076 | { | |
83a3af9f | 1077 | s->d1->handshake_read_seq++; |
c6dd154b | 1078 | s->new_session = 1; |
36d16f8e BL |
1079 | ssl3_renegotiate(s); |
1080 | if (ssl3_renegotiate_check(s)) | |
1081 | { | |
1082 | i=s->handshake_func(s); | |
1083 | if (i < 0) return(i); | |
1084 | if (i == 0) | |
1085 | { | |
beb056b3 | 1086 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE); |
36d16f8e BL |
1087 | return(-1); |
1088 | } | |
1089 | ||
1090 | if (!(s->mode & SSL_MODE_AUTO_RETRY)) | |
1091 | { | |
1092 | if (s->s3->rbuf.left == 0) /* no read-ahead left? */ | |
1093 | { | |
1094 | BIO *bio; | |
1095 | /* In the case where we try to read application data, | |
1096 | * but we trigger an SSL handshake, we return -1 with | |
1097 | * the retry option set. Otherwise renegotiation may | |
1098 | * cause nasty problems in the blocking world */ | |
1099 | s->rwstate=SSL_READING; | |
1100 | bio=SSL_get_rbio(s); | |
1101 | BIO_clear_retry_flags(bio); | |
1102 | BIO_set_retry_read(bio); | |
1103 | return(-1); | |
1104 | } | |
1105 | } | |
1106 | } | |
1107 | } | |
1108 | /* we either finished a handshake or ignored the request, | |
1109 | * now try again to obtain the (application) data we were asked for */ | |
1110 | goto start; | |
1111 | } | |
1112 | ||
1113 | if (s->d1->alert_fragment_len >= DTLS1_AL_HEADER_LENGTH) | |
1114 | { | |
1115 | int alert_level = s->d1->alert_fragment[0]; | |
1116 | int alert_descr = s->d1->alert_fragment[1]; | |
1117 | ||
1118 | s->d1->alert_fragment_len = 0; | |
1119 | ||
1120 | if (s->msg_callback) | |
1121 | s->msg_callback(0, s->version, SSL3_RT_ALERT, | |
1122 | s->d1->alert_fragment, 2, s, s->msg_callback_arg); | |
1123 | ||
1124 | if (s->info_callback != NULL) | |
1125 | cb=s->info_callback; | |
1126 | else if (s->ctx->info_callback != NULL) | |
1127 | cb=s->ctx->info_callback; | |
1128 | ||
1129 | if (cb != NULL) | |
1130 | { | |
1131 | j = (alert_level << 8) | alert_descr; | |
1132 | cb(s, SSL_CB_READ_ALERT, j); | |
1133 | } | |
1134 | ||
1135 | if (alert_level == 1) /* warning */ | |
1136 | { | |
1137 | s->s3->warn_alert = alert_descr; | |
1138 | if (alert_descr == SSL_AD_CLOSE_NOTIFY) | |
1139 | { | |
e065e6cd DSH |
1140 | #ifndef OPENSSL_NO_SCTP |
1141 | /* With SCTP and streams the socket may deliver app data | |
1142 | * after a close_notify alert. We have to check this | |
1143 | * first so that nothing gets discarded. | |
1144 | */ | |
1145 | if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && | |
1146 | BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s))) | |
1147 | { | |
1148 | s->d1->shutdown_received = 1; | |
1149 | s->rwstate=SSL_READING; | |
1150 | BIO_clear_retry_flags(SSL_get_rbio(s)); | |
1151 | BIO_set_retry_read(SSL_get_rbio(s)); | |
1152 | return -1; | |
1153 | } | |
1154 | #endif | |
36d16f8e BL |
1155 | s->shutdown |= SSL_RECEIVED_SHUTDOWN; |
1156 | return(0); | |
1157 | } | |
1158 | #if 0 | |
1159 | /* XXX: this is a possible improvement in the future */ | |
1160 | /* now check if it's a missing record */ | |
1161 | if (alert_descr == DTLS1_AD_MISSING_HANDSHAKE_MESSAGE) | |
1162 | { | |
1163 | unsigned short seq; | |
1164 | unsigned int frag_off; | |
1165 | unsigned char *p = &(s->d1->alert_fragment[2]); | |
1166 | ||
1167 | n2s(p, seq); | |
1168 | n2l3(p, frag_off); | |
1169 | ||
c900a78c DSH |
1170 | dtls1_retransmit_message(s, |
1171 | dtls1_get_queue_priority(frag->msg_header.seq, 0), | |
1172 | frag_off, &found); | |
36d16f8e BL |
1173 | if ( ! found && SSL_in_init(s)) |
1174 | { | |
1175 | /* fprintf( stderr,"in init = %d\n", SSL_in_init(s)); */ | |
1176 | /* requested a message not yet sent, | |
1177 | send an alert ourselves */ | |
1178 | ssl3_send_alert(s,SSL3_AL_WARNING, | |
1179 | DTLS1_AD_MISSING_HANDSHAKE_MESSAGE); | |
1180 | } | |
1181 | } | |
1182 | #endif | |
1183 | } | |
1184 | else if (alert_level == 2) /* fatal */ | |
1185 | { | |
1186 | char tmp[16]; | |
1187 | ||
1188 | s->rwstate=SSL_NOTHING; | |
1189 | s->s3->fatal_alert = alert_descr; | |
beb056b3 | 1190 | SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_AD_REASON_OFFSET + alert_descr); |
36d16f8e BL |
1191 | BIO_snprintf(tmp,sizeof tmp,"%d",alert_descr); |
1192 | ERR_add_error_data(2,"SSL alert number ",tmp); | |
1193 | s->shutdown|=SSL_RECEIVED_SHUTDOWN; | |
1194 | SSL_CTX_remove_session(s->ctx,s->session); | |
1195 | return(0); | |
1196 | } | |
1197 | else | |
1198 | { | |
1199 | al=SSL_AD_ILLEGAL_PARAMETER; | |
beb056b3 | 1200 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_UNKNOWN_ALERT_TYPE); |
36d16f8e BL |
1201 | goto f_err; |
1202 | } | |
1203 | ||
1204 | goto start; | |
1205 | } | |
1206 | ||
1207 | if (s->shutdown & SSL_SENT_SHUTDOWN) /* but we have not received a shutdown */ | |
1208 | { | |
1209 | s->rwstate=SSL_NOTHING; | |
1210 | rr->length=0; | |
1211 | return(0); | |
1212 | } | |
1213 | ||
1214 | if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) | |
89c333e3 AP |
1215 | { |
1216 | struct ccs_header_st ccs_hdr; | |
dfc8e96d | 1217 | unsigned int ccs_hdr_len = DTLS1_CCS_HEADER_LENGTH; |
36d16f8e BL |
1218 | |
1219 | dtls1_get_ccs_header(rr->data, &ccs_hdr); | |
1220 | ||
b452f433 DSH |
1221 | if (s->version == DTLS1_BAD_VER) |
1222 | ccs_hdr_len = 3; | |
1223 | ||
89c333e3 AP |
1224 | /* 'Change Cipher Spec' is just a single byte, so we know |
1225 | * exactly what the record payload has to look like */ | |
1226 | /* XDTLS: check that epoch is consistent */ | |
b452f433 | 1227 | if ( (rr->length != ccs_hdr_len) || |
89c333e3 | 1228 | (rr->off != 0) || (rr->data[0] != SSL3_MT_CCS)) |
36d16f8e | 1229 | { |
89c333e3 AP |
1230 | i=SSL_AD_ILLEGAL_PARAMETER; |
1231 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_BAD_CHANGE_CIPHER_SPEC); | |
1232 | goto err; | |
36d16f8e | 1233 | } |
89c333e3 AP |
1234 | |
1235 | rr->length=0; | |
1236 | ||
1237 | if (s->msg_callback) | |
1238 | s->msg_callback(0, s->version, SSL3_RT_CHANGE_CIPHER_SPEC, | |
1239 | rr->data, 1, s, s->msg_callback_arg); | |
1240 | ||
4e63da06 DSH |
1241 | /* We can't process a CCS now, because previous handshake |
1242 | * messages are still missing, so just drop it. | |
1243 | */ | |
1244 | if (!s->d1->change_cipher_spec_ok) | |
1245 | { | |
1246 | goto start; | |
1247 | } | |
1248 | ||
1249 | s->d1->change_cipher_spec_ok = 0; | |
1250 | ||
89c333e3 AP |
1251 | s->s3->change_cipher_spec=1; |
1252 | if (!ssl3_do_change_cipher_spec(s)) | |
1253 | goto err; | |
1254 | ||
1255 | /* do this whenever CCS is processed */ | |
1256 | dtls1_reset_seq_numbers(s, SSL3_CC_READ); | |
1257 | ||
b452f433 DSH |
1258 | if (s->version == DTLS1_BAD_VER) |
1259 | s->d1->handshake_read_seq++; | |
1260 | ||
e065e6cd DSH |
1261 | #ifndef OPENSSL_NO_SCTP |
1262 | /* Remember that a CCS has been received, | |
1263 | * so that an old key of SCTP-Auth can be | |
1264 | * deleted when a CCS is sent. Will be ignored | |
1265 | * if no SCTP is used | |
1266 | */ | |
1267 | BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD, 1, NULL); | |
1268 | #endif | |
1269 | ||
89c333e3 | 1270 | goto start; |
36d16f8e BL |
1271 | } |
1272 | ||
1273 | /* Unexpected handshake message (Client Hello, or protocol violation) */ | |
1274 | if ((s->d1->handshake_fragment_len >= DTLS1_HM_HEADER_LENGTH) && | |
1275 | !s->in_handshake) | |
1276 | { | |
1277 | struct hm_header_st msg_hdr; | |
1278 | ||
1279 | /* this may just be a stale retransmit */ | |
1280 | dtls1_get_message_header(rr->data, &msg_hdr); | |
1281 | if( rr->epoch != s->d1->r_epoch) | |
1282 | { | |
1283 | rr->length = 0; | |
1284 | goto start; | |
1285 | } | |
1286 | ||
c900a78c DSH |
1287 | /* If we are server, we may have a repeated FINISHED of the |
1288 | * client here, then retransmit our CCS and FINISHED. | |
1289 | */ | |
1290 | if (msg_hdr.type == SSL3_MT_FINISHED) | |
1291 | { | |
ce1605b5 DSH |
1292 | if (dtls1_check_timeout_num(s) < 0) |
1293 | return -1; | |
1294 | ||
c900a78c DSH |
1295 | dtls1_retransmit_buffered_messages(s); |
1296 | rr->length = 0; | |
1297 | goto start; | |
1298 | } | |
1299 | ||
36d16f8e BL |
1300 | if (((s->state&SSL_ST_MASK) == SSL_ST_OK) && |
1301 | !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS)) | |
1302 | { | |
1303 | #if 0 /* worked only because C operator preferences are not as expected (and | |
1304 | * because this is not really needed for clients except for detecting | |
1305 | * protocol violations): */ | |
1306 | s->state=SSL_ST_BEFORE|(s->server) | |
1307 | ?SSL_ST_ACCEPT | |
1308 | :SSL_ST_CONNECT; | |
1309 | #else | |
1310 | s->state = s->server ? SSL_ST_ACCEPT : SSL_ST_CONNECT; | |
1311 | #endif | |
c6dd154b | 1312 | s->renegotiate=1; |
36d16f8e BL |
1313 | s->new_session=1; |
1314 | } | |
1315 | i=s->handshake_func(s); | |
1316 | if (i < 0) return(i); | |
1317 | if (i == 0) | |
1318 | { | |
beb056b3 | 1319 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE); |
36d16f8e BL |
1320 | return(-1); |
1321 | } | |
1322 | ||
1323 | if (!(s->mode & SSL_MODE_AUTO_RETRY)) | |
1324 | { | |
1325 | if (s->s3->rbuf.left == 0) /* no read-ahead left? */ | |
1326 | { | |
1327 | BIO *bio; | |
1328 | /* In the case where we try to read application data, | |
1329 | * but we trigger an SSL handshake, we return -1 with | |
1330 | * the retry option set. Otherwise renegotiation may | |
1331 | * cause nasty problems in the blocking world */ | |
1332 | s->rwstate=SSL_READING; | |
1333 | bio=SSL_get_rbio(s); | |
1334 | BIO_clear_retry_flags(bio); | |
1335 | BIO_set_retry_read(bio); | |
1336 | return(-1); | |
1337 | } | |
1338 | } | |
1339 | goto start; | |
1340 | } | |
1341 | ||
1342 | switch (rr->type) | |
1343 | { | |
1344 | default: | |
1345 | #ifndef OPENSSL_NO_TLS | |
1346 | /* TLS just ignores unknown message types */ | |
1347 | if (s->version == TLS1_VERSION) | |
1348 | { | |
1349 | rr->length = 0; | |
1350 | goto start; | |
1351 | } | |
1352 | #endif | |
1353 | al=SSL_AD_UNEXPECTED_MESSAGE; | |
beb056b3 | 1354 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_UNEXPECTED_RECORD); |
36d16f8e BL |
1355 | goto f_err; |
1356 | case SSL3_RT_CHANGE_CIPHER_SPEC: | |
1357 | case SSL3_RT_ALERT: | |
1358 | case SSL3_RT_HANDSHAKE: | |
1359 | /* we already handled all of these, with the possible exception | |
1360 | * of SSL3_RT_HANDSHAKE when s->in_handshake is set, but that | |
1361 | * should not happen when type != rr->type */ | |
1362 | al=SSL_AD_UNEXPECTED_MESSAGE; | |
beb056b3 | 1363 | SSLerr(SSL_F_DTLS1_READ_BYTES,ERR_R_INTERNAL_ERROR); |
36d16f8e BL |
1364 | goto f_err; |
1365 | case SSL3_RT_APPLICATION_DATA: | |
1366 | /* At this point, we were expecting handshake data, | |
1367 | * but have application data. If the library was | |
1368 | * running inside ssl3_read() (i.e. in_read_app_data | |
1369 | * is set) and it makes sense to read application data | |
1370 | * at this point (session renegotiation not yet started), | |
1371 | * we will indulge it. | |
1372 | */ | |
1373 | if (s->s3->in_read_app_data && | |
1374 | (s->s3->total_renegotiations != 0) && | |
1375 | (( | |
1376 | (s->state & SSL_ST_CONNECT) && | |
1377 | (s->state >= SSL3_ST_CW_CLNT_HELLO_A) && | |
1378 | (s->state <= SSL3_ST_CR_SRVR_HELLO_A) | |
1379 | ) || ( | |
1380 | (s->state & SSL_ST_ACCEPT) && | |
1381 | (s->state <= SSL3_ST_SW_HELLO_REQ_A) && | |
1382 | (s->state >= SSL3_ST_SR_CLNT_HELLO_A) | |
1383 | ) | |
1384 | )) | |
1385 | { | |
1386 | s->s3->in_read_app_data=2; | |
1387 | return(-1); | |
1388 | } | |
1389 | else | |
1390 | { | |
1391 | al=SSL_AD_UNEXPECTED_MESSAGE; | |
beb056b3 | 1392 | SSLerr(SSL_F_DTLS1_READ_BYTES,SSL_R_UNEXPECTED_RECORD); |
36d16f8e BL |
1393 | goto f_err; |
1394 | } | |
1395 | } | |
1396 | /* not reached */ | |
1397 | ||
1398 | f_err: | |
1399 | ssl3_send_alert(s,SSL3_AL_FATAL,al); | |
1400 | err: | |
1401 | return(-1); | |
1402 | } | |
1403 | ||
1404 | int | |
1405 | dtls1_write_app_data_bytes(SSL *s, int type, const void *buf_, int len) | |
1406 | { | |
36d16f8e BL |
1407 | int i; |
1408 | ||
e065e6cd DSH |
1409 | #ifndef OPENSSL_NO_SCTP |
1410 | /* Check if we have to continue an interrupted handshake | |
1411 | * for reading belated app data with SCTP. | |
1412 | */ | |
1413 | if ((SSL_in_init(s) && !s->in_handshake) || | |
1414 | (BIO_dgram_is_sctp(SSL_get_wbio(s)) && | |
1415 | (s->state == DTLS1_SCTP_ST_SR_READ_SOCK || s->state == DTLS1_SCTP_ST_CR_READ_SOCK))) | |
1416 | #else | |
1417 | if (SSL_in_init(s) && !s->in_handshake) | |
1418 | #endif | |
36d16f8e BL |
1419 | { |
1420 | i=s->handshake_func(s); | |
1421 | if (i < 0) return(i); | |
1422 | if (i == 0) | |
1423 | { | |
beb056b3 | 1424 | SSLerr(SSL_F_DTLS1_WRITE_APP_DATA_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE); |
36d16f8e BL |
1425 | return -1; |
1426 | } | |
1427 | } | |
1428 | ||
17f8d8db | 1429 | if (len > SSL3_RT_MAX_PLAIN_LENGTH) |
36d16f8e | 1430 | { |
17f8d8db DSH |
1431 | SSLerr(SSL_F_DTLS1_WRITE_APP_DATA_BYTES,SSL_R_DTLS_MESSAGE_TOO_BIG); |
1432 | return -1; | |
36d16f8e BL |
1433 | } |
1434 | ||
17f8d8db DSH |
1435 | i = dtls1_write_bytes(s, type, buf_, len); |
1436 | return i; | |
36d16f8e BL |
1437 | } |
1438 | ||
1439 | ||
1440 | /* this only happens when a client hello is received and a handshake | |
1441 | * is started. */ | |
1442 | static int | |
1443 | have_handshake_fragment(SSL *s, int type, unsigned char *buf, | |
1444 | int len, int peek) | |
1445 | { | |
1446 | ||
1447 | if ((type == SSL3_RT_HANDSHAKE) && (s->d1->handshake_fragment_len > 0)) | |
1448 | /* (partially) satisfy request from storage */ | |
1449 | { | |
1450 | unsigned char *src = s->d1->handshake_fragment; | |
1451 | unsigned char *dst = buf; | |
1452 | unsigned int k,n; | |
1453 | ||
1454 | /* peek == 0 */ | |
1455 | n = 0; | |
1456 | while ((len > 0) && (s->d1->handshake_fragment_len > 0)) | |
1457 | { | |
1458 | *dst++ = *src++; | |
1459 | len--; s->d1->handshake_fragment_len--; | |
1460 | n++; | |
1461 | } | |
1462 | /* move any remaining fragment bytes: */ | |
1463 | for (k = 0; k < s->d1->handshake_fragment_len; k++) | |
1464 | s->d1->handshake_fragment[k] = *src++; | |
1465 | return n; | |
1466 | } | |
1467 | ||
1468 | return 0; | |
1469 | } | |
1470 | ||
1471 | ||
1472 | ||
1473 | ||
1474 | /* Call this to write data in records of type 'type' | |
1475 | * It will return <= 0 if not all data has been sent or non-blocking IO. | |
1476 | */ | |
17f8d8db | 1477 | int dtls1_write_bytes(SSL *s, int type, const void *buf, int len) |
36d16f8e | 1478 | { |
36d16f8e | 1479 | int i; |
36d16f8e | 1480 | |
17f8d8db | 1481 | OPENSSL_assert(len <= SSL3_RT_MAX_PLAIN_LENGTH); |
36d16f8e | 1482 | s->rwstate=SSL_NOTHING; |
17f8d8db | 1483 | i=do_dtls1_write(s, type, buf, len, 0); |
51ec776b | 1484 | return i; |
36d16f8e BL |
1485 | } |
1486 | ||
beb056b3 | 1487 | int do_dtls1_write(SSL *s, int type, const unsigned char *buf, unsigned int len, int create_empty_fragment) |
36d16f8e BL |
1488 | { |
1489 | unsigned char *p,*pseq; | |
1490 | int i,mac_size,clear=0; | |
1491 | int prefix_len = 0; | |
1492 | SSL3_RECORD *wr; | |
1493 | SSL3_BUFFER *wb; | |
1494 | SSL_SESSION *sess; | |
1495 | int bs; | |
1496 | ||
1497 | /* first check if there is a SSL3_BUFFER still being written | |
1498 | * out. This will happen with non blocking IO */ | |
1499 | if (s->s3->wbuf.left != 0) | |
1500 | { | |
1501 | OPENSSL_assert(0); /* XDTLS: want to see if we ever get here */ | |
1502 | return(ssl3_write_pending(s,type,buf,len)); | |
1503 | } | |
1504 | ||
1505 | /* If we have an alert to send, lets send it */ | |
1506 | if (s->s3->alert_dispatch) | |
1507 | { | |
1508 | i=s->method->ssl_dispatch_alert(s); | |
1509 | if (i <= 0) | |
1510 | return(i); | |
1511 | /* if it went, fall through and send more stuff */ | |
1512 | } | |
1513 | ||
1514 | if (len == 0 && !create_empty_fragment) | |
1515 | return 0; | |
1516 | ||
1517 | wr= &(s->s3->wrec); | |
1518 | wb= &(s->s3->wbuf); | |
1519 | sess=s->session; | |
1520 | ||
1521 | if ( (sess == NULL) || | |
1522 | (s->enc_write_ctx == NULL) || | |
b948e2c5 | 1523 | (EVP_MD_CTX_md(s->write_hash) == NULL)) |
36d16f8e BL |
1524 | clear=1; |
1525 | ||
1526 | if (clear) | |
1527 | mac_size=0; | |
1528 | else | |
0eab41fb | 1529 | { |
b948e2c5 | 1530 | mac_size=EVP_MD_CTX_size(s->write_hash); |
0eab41fb BL |
1531 | if (mac_size < 0) |
1532 | goto err; | |
1533 | } | |
36d16f8e BL |
1534 | |
1535 | /* DTLS implements explicit IV, so no need for empty fragments */ | |
1536 | #if 0 | |
1537 | /* 'create_empty_fragment' is true only when this function calls itself */ | |
1538 | if (!clear && !create_empty_fragment && !s->s3->empty_fragment_done | |
b452f433 | 1539 | && SSL_version(s) != DTLS1_VERSION && SSL_version(s) != DTLS1_BAD_VER) |
36d16f8e BL |
1540 | { |
1541 | /* countermeasure against known-IV weakness in CBC ciphersuites | |
1542 | * (see http://www.openssl.org/~bodo/tls-cbc.txt) | |
1543 | */ | |
1544 | ||
1545 | if (s->s3->need_empty_fragments && type == SSL3_RT_APPLICATION_DATA) | |
1546 | { | |
1547 | /* recursive function call with 'create_empty_fragment' set; | |
1548 | * this prepares and buffers the data for an empty fragment | |
1549 | * (these 'prefix_len' bytes are sent out later | |
1550 | * together with the actual payload) */ | |
1551 | prefix_len = s->method->do_ssl_write(s, type, buf, 0, 1); | |
1552 | if (prefix_len <= 0) | |
1553 | goto err; | |
1554 | ||
1555 | if (s->s3->wbuf.len < (size_t)prefix_len + SSL3_RT_MAX_PACKET_SIZE) | |
1556 | { | |
1557 | /* insufficient space */ | |
beb056b3 | 1558 | SSLerr(SSL_F_DO_DTLS1_WRITE, ERR_R_INTERNAL_ERROR); |
36d16f8e BL |
1559 | goto err; |
1560 | } | |
1561 | } | |
1562 | ||
1563 | s->s3->empty_fragment_done = 1; | |
1564 | } | |
1565 | #endif | |
36d16f8e BL |
1566 | p = wb->buf + prefix_len; |
1567 | ||
1568 | /* write the header */ | |
1569 | ||
1570 | *(p++)=type&0xff; | |
1571 | wr->type=type; | |
1572 | ||
1573 | *(p++)=(s->version>>8); | |
1574 | *(p++)=s->version&0xff; | |
1575 | ||
1576 | /* field where we are to write out packet epoch, seq num and len */ | |
1577 | pseq=p; | |
1578 | p+=10; | |
1579 | ||
1580 | /* lets setup the record stuff. */ | |
1581 | ||
1582 | /* Make space for the explicit IV in case of CBC. | |
1583 | * (this is a bit of a boundary violation, but what the heck). | |
1584 | */ | |
1585 | if ( s->enc_write_ctx && | |
1586 | (EVP_CIPHER_mode( s->enc_write_ctx->cipher ) & EVP_CIPH_CBC_MODE)) | |
1587 | bs = EVP_CIPHER_block_size(s->enc_write_ctx->cipher); | |
1588 | else | |
1589 | bs = 0; | |
1590 | ||
1591 | wr->data=p + bs; /* make room for IV in case of CBC */ | |
1592 | wr->length=(int)len; | |
1593 | wr->input=(unsigned char *)buf; | |
1594 | ||
1595 | /* we now 'read' from wr->input, wr->length bytes into | |
1596 | * wr->data */ | |
1597 | ||
1598 | /* first we compress */ | |
1599 | if (s->compress != NULL) | |
1600 | { | |
1601 | if (!ssl3_do_compress(s)) | |
1602 | { | |
beb056b3 | 1603 | SSLerr(SSL_F_DO_DTLS1_WRITE,SSL_R_COMPRESSION_FAILURE); |
36d16f8e BL |
1604 | goto err; |
1605 | } | |
1606 | } | |
1607 | else | |
1608 | { | |
1609 | memcpy(wr->data,wr->input,wr->length); | |
1610 | wr->input=wr->data; | |
1611 | } | |
1612 | ||
1613 | /* we should still have the output to wr->data and the input | |
1614 | * from wr->input. Length should be wr->length. | |
1615 | * wr->data still points in the wb->buf */ | |
1616 | ||
1617 | if (mac_size != 0) | |
1618 | { | |
0eab41fb BL |
1619 | if(s->method->ssl3_enc->mac(s,&(p[wr->length + bs]),1) < 0) |
1620 | goto err; | |
36d16f8e BL |
1621 | wr->length+=mac_size; |
1622 | } | |
1623 | ||
1624 | /* this is true regardless of mac size */ | |
1625 | wr->input=p; | |
1626 | wr->data=p; | |
1627 | ||
1628 | ||
1629 | /* ssl3_enc can only have an error on read */ | |
d527834a AP |
1630 | if (bs) /* bs != 0 in case of CBC */ |
1631 | { | |
1632 | RAND_pseudo_bytes(p,bs); | |
1633 | /* master IV and last CBC residue stand for | |
1634 | * the rest of randomness */ | |
1635 | wr->length += bs; | |
1636 | } | |
1637 | ||
244d0955 | 1638 | if(s->method->ssl3_enc->enc(s,1) < 1) goto err; |
36d16f8e BL |
1639 | |
1640 | /* record length after mac and block padding */ | |
1641 | /* if (type == SSL3_RT_APPLICATION_DATA || | |
1642 | (type == SSL3_RT_ALERT && ! SSL_in_init(s))) */ | |
1643 | ||
1644 | /* there's only one epoch between handshake and app data */ | |
1645 | ||
1646 | s2n(s->d1->w_epoch, pseq); | |
1647 | ||
1648 | /* XDTLS: ?? */ | |
1649 | /* else | |
1650 | s2n(s->d1->handshake_epoch, pseq); */ | |
1651 | ||
188b0579 RL |
1652 | memcpy(pseq, &(s->s3->write_sequence[2]), 6); |
1653 | pseq+=6; | |
36d16f8e BL |
1654 | s2n(wr->length,pseq); |
1655 | ||
1656 | /* we should now have | |
1657 | * wr->data pointing to the encrypted data, which is | |
1658 | * wr->length long */ | |
1659 | wr->type=type; /* not needed but helps for debugging */ | |
1660 | wr->length+=DTLS1_RT_HEADER_LENGTH; | |
1661 | ||
1662 | #if 0 /* this is now done at the message layer */ | |
1663 | /* buffer the record, making it easy to handle retransmits */ | |
1664 | if ( type == SSL3_RT_HANDSHAKE || type == SSL3_RT_CHANGE_CIPHER_SPEC) | |
1665 | dtls1_buffer_record(s, wr->data, wr->length, | |
188b0579 | 1666 | *((PQ_64BIT *)&(s->s3->write_sequence[0]))); |
36d16f8e BL |
1667 | #endif |
1668 | ||
1669 | ssl3_record_sequence_update(&(s->s3->write_sequence[0])); | |
1670 | ||
1671 | if (create_empty_fragment) | |
1672 | { | |
1673 | /* we are in a recursive call; | |
1674 | * just return the length, don't write out anything here | |
1675 | */ | |
1676 | return wr->length; | |
1677 | } | |
1678 | ||
1679 | /* now let's set up wb */ | |
1680 | wb->left = prefix_len + wr->length; | |
1681 | wb->offset = 0; | |
1682 | ||
1683 | /* memorize arguments so that ssl3_write_pending can detect bad write retries later */ | |
1684 | s->s3->wpend_tot=len; | |
1685 | s->s3->wpend_buf=buf; | |
1686 | s->s3->wpend_type=type; | |
1687 | s->s3->wpend_ret=len; | |
1688 | ||
1689 | /* we now just need to write the buffer */ | |
1690 | return ssl3_write_pending(s,type,buf,len); | |
1691 | err: | |
1692 | return -1; | |
1693 | } | |
1694 | ||
1695 | ||
1696 | ||
50ec3951 | 1697 | static int dtls1_record_replay_check(SSL *s, DTLS1_BITMAP *bitmap) |
36d16f8e | 1698 | { |
dffdb56b AP |
1699 | int cmp; |
1700 | unsigned int shift; | |
1701 | const unsigned char *seq = s->s3->read_sequence; | |
36d16f8e | 1702 | |
dffdb56b AP |
1703 | cmp = satsub64be(seq,bitmap->max_seq_num); |
1704 | if (cmp > 0) | |
188b0579 | 1705 | { |
50ec3951 | 1706 | memcpy (s->s3->rrec.seq_num,seq,8); |
dffdb56b | 1707 | return 1; /* this record in new */ |
188b0579 | 1708 | } |
dffdb56b AP |
1709 | shift = -cmp; |
1710 | if (shift >= sizeof(bitmap->map)*8) | |
1711 | return 0; /* stale, outside the window */ | |
1712 | else if (bitmap->map & (1UL<<shift)) | |
36d16f8e | 1713 | return 0; /* record previously received */ |
dffdb56b | 1714 | |
50ec3951 | 1715 | memcpy (s->s3->rrec.seq_num,seq,8); |
36d16f8e BL |
1716 | return 1; |
1717 | } | |
1718 | ||
1719 | ||
1720 | static void dtls1_record_bitmap_update(SSL *s, DTLS1_BITMAP *bitmap) | |
1721 | { | |
dffdb56b | 1722 | int cmp; |
36d16f8e | 1723 | unsigned int shift; |
dffdb56b | 1724 | const unsigned char *seq = s->s3->read_sequence; |
36d16f8e | 1725 | |
dffdb56b AP |
1726 | cmp = satsub64be(seq,bitmap->max_seq_num); |
1727 | if (cmp > 0) | |
36d16f8e | 1728 | { |
dffdb56b AP |
1729 | shift = cmp; |
1730 | if (shift < sizeof(bitmap->map)*8) | |
1731 | bitmap->map <<= shift, bitmap->map |= 1UL; | |
1732 | else | |
1733 | bitmap->map = 1UL; | |
1734 | memcpy(bitmap->max_seq_num,seq,8); | |
36d16f8e | 1735 | } |
dffdb56b AP |
1736 | else { |
1737 | shift = -cmp; | |
1738 | if (shift < sizeof(bitmap->map)*8) | |
1739 | bitmap->map |= 1UL<<shift; | |
36d16f8e BL |
1740 | } |
1741 | } | |
1742 | ||
1743 | ||
1744 | int dtls1_dispatch_alert(SSL *s) | |
1745 | { | |
1746 | int i,j; | |
1747 | void (*cb)(const SSL *ssl,int type,int val)=NULL; | |
d4938995 | 1748 | unsigned char buf[DTLS1_AL_HEADER_LENGTH]; |
4e321ffa | 1749 | unsigned char *ptr = &buf[0]; |
36d16f8e BL |
1750 | |
1751 | s->s3->alert_dispatch=0; | |
1752 | ||
1753 | memset(buf, 0x00, sizeof(buf)); | |
1754 | *ptr++ = s->s3->send_alert[0]; | |
1755 | *ptr++ = s->s3->send_alert[1]; | |
1756 | ||
01c76c66 | 1757 | #ifdef DTLS1_AD_MISSING_HANDSHAKE_MESSAGE |
36d16f8e BL |
1758 | if (s->s3->send_alert[1] == DTLS1_AD_MISSING_HANDSHAKE_MESSAGE) |
1759 | { | |
1760 | s2n(s->d1->handshake_read_seq, ptr); | |
1761 | #if 0 | |
1762 | if ( s->d1->r_msg_hdr.frag_off == 0) /* waiting for a new msg */ | |
1763 | ||
1764 | else | |
1765 | s2n(s->d1->r_msg_hdr.seq, ptr); /* partial msg read */ | |
1766 | #endif | |
1767 | ||
1768 | #if 0 | |
1769 | 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); | |
1770 | #endif | |
1771 | l2n3(s->d1->r_msg_hdr.frag_off, ptr); | |
1772 | } | |
01c76c66 | 1773 | #endif |
36d16f8e BL |
1774 | |
1775 | i = do_dtls1_write(s, SSL3_RT_ALERT, &buf[0], sizeof(buf), 0); | |
1776 | if (i <= 0) | |
1777 | { | |
1778 | s->s3->alert_dispatch=1; | |
1779 | /* fprintf( stderr, "not done with alert\n" ); */ | |
1780 | } | |
1781 | else | |
1782 | { | |
01c76c66 BM |
1783 | if (s->s3->send_alert[0] == SSL3_AL_FATAL |
1784 | #ifdef DTLS1_AD_MISSING_HANDSHAKE_MESSAGE | |
1785 | || s->s3->send_alert[1] == DTLS1_AD_MISSING_HANDSHAKE_MESSAGE | |
1786 | #endif | |
1787 | ) | |
36d16f8e BL |
1788 | (void)BIO_flush(s->wbio); |
1789 | ||
1790 | if (s->msg_callback) | |
1791 | s->msg_callback(1, s->version, SSL3_RT_ALERT, s->s3->send_alert, | |
1792 | 2, s, s->msg_callback_arg); | |
1793 | ||
1794 | if (s->info_callback != NULL) | |
1795 | cb=s->info_callback; | |
1796 | else if (s->ctx->info_callback != NULL) | |
1797 | cb=s->ctx->info_callback; | |
1798 | ||
1799 | if (cb != NULL) | |
1800 | { | |
1801 | j=(s->s3->send_alert[0]<<8)|s->s3->send_alert[1]; | |
1802 | cb(s,SSL_CB_WRITE_ALERT,j); | |
1803 | } | |
1804 | } | |
1805 | return(i); | |
1806 | } | |
1807 | ||
1808 | ||
1809 | static DTLS1_BITMAP * | |
1810 | dtls1_get_bitmap(SSL *s, SSL3_RECORD *rr, unsigned int *is_next_epoch) | |
1811 | { | |
1812 | ||
1813 | *is_next_epoch = 0; | |
1814 | ||
1815 | /* In current epoch, accept HM, CCS, DATA, & ALERT */ | |
1816 | if (rr->epoch == s->d1->r_epoch) | |
1817 | return &s->d1->bitmap; | |
1818 | ||
1819 | /* Only HM and ALERT messages can be from the next epoch */ | |
6c61726b | 1820 | else if (rr->epoch == (unsigned long)(s->d1->r_epoch + 1) && |
36d16f8e BL |
1821 | (rr->type == SSL3_RT_HANDSHAKE || |
1822 | rr->type == SSL3_RT_ALERT)) | |
1823 | { | |
1824 | *is_next_epoch = 1; | |
1825 | return &s->d1->next_bitmap; | |
1826 | } | |
1827 | ||
1828 | return NULL; | |
1829 | } | |
1830 | ||
1831 | #if 0 | |
1832 | static int | |
1833 | dtls1_record_needs_buffering(SSL *s, SSL3_RECORD *rr, unsigned short *priority, | |
1834 | unsigned long *offset) | |
1835 | { | |
1836 | ||
1837 | /* alerts are passed up immediately */ | |
1838 | if ( rr->type == SSL3_RT_APPLICATION_DATA || | |
1839 | rr->type == SSL3_RT_ALERT) | |
1840 | return 0; | |
1841 | ||
1842 | /* Only need to buffer if a handshake is underway. | |
1843 | * (this implies that Hello Request and Client Hello are passed up | |
1844 | * immediately) */ | |
1845 | if ( SSL_in_init(s)) | |
1846 | { | |
1847 | unsigned char *data = rr->data; | |
1848 | /* need to extract the HM/CCS sequence number here */ | |
1849 | if ( rr->type == SSL3_RT_HANDSHAKE || | |
1850 | rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) | |
1851 | { | |
1852 | unsigned short seq_num; | |
1853 | struct hm_header_st msg_hdr; | |
1854 | struct ccs_header_st ccs_hdr; | |
1855 | ||
1856 | if ( rr->type == SSL3_RT_HANDSHAKE) | |
1857 | { | |
1858 | dtls1_get_message_header(data, &msg_hdr); | |
1859 | seq_num = msg_hdr.seq; | |
1860 | *offset = msg_hdr.frag_off; | |
1861 | } | |
1862 | else | |
1863 | { | |
1864 | dtls1_get_ccs_header(data, &ccs_hdr); | |
1865 | seq_num = ccs_hdr.seq; | |
1866 | *offset = 0; | |
1867 | } | |
1868 | ||
1869 | /* this is either a record we're waiting for, or a | |
1870 | * retransmit of something we happened to previously | |
1871 | * receive (higher layers will drop the repeat silently */ | |
1872 | if ( seq_num < s->d1->handshake_read_seq) | |
1873 | return 0; | |
1874 | if (rr->type == SSL3_RT_HANDSHAKE && | |
1875 | seq_num == s->d1->handshake_read_seq && | |
1876 | msg_hdr.frag_off < s->d1->r_msg_hdr.frag_off) | |
1877 | return 0; | |
1878 | else if ( seq_num == s->d1->handshake_read_seq && | |
1879 | (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC || | |
1880 | msg_hdr.frag_off == s->d1->r_msg_hdr.frag_off)) | |
1881 | return 0; | |
1882 | else | |
1883 | { | |
1884 | *priority = seq_num; | |
1885 | return 1; | |
1886 | } | |
1887 | } | |
1888 | else /* unknown record type */ | |
1889 | return 0; | |
1890 | } | |
1891 | ||
1892 | return 0; | |
1893 | } | |
1894 | #endif | |
1895 | ||
1896 | void | |
1897 | dtls1_reset_seq_numbers(SSL *s, int rw) | |
1898 | { | |
1899 | unsigned char *seq; | |
1900 | unsigned int seq_bytes = sizeof(s->s3->read_sequence); | |
1901 | ||
1902 | if ( rw & SSL3_CC_READ) | |
1903 | { | |
1904 | seq = s->s3->read_sequence; | |
1905 | s->d1->r_epoch++; | |
dffdb56b | 1906 | memcpy(&(s->d1->bitmap), &(s->d1->next_bitmap), sizeof(DTLS1_BITMAP)); |
36d16f8e BL |
1907 | memset(&(s->d1->next_bitmap), 0x00, sizeof(DTLS1_BITMAP)); |
1908 | } | |
1909 | else | |
1910 | { | |
1911 | seq = s->s3->write_sequence; | |
c900a78c | 1912 | memcpy(s->d1->last_write_sequence, seq, sizeof(s->s3->write_sequence)); |
36d16f8e BL |
1913 | s->d1->w_epoch++; |
1914 | } | |
1915 | ||
1916 | memset(seq, 0x00, seq_bytes); | |
1917 | } |