]>
Commit | Line | Data |
---|---|---|
36d16f8e | 1 | /* ssl/d1_pkt.c */ |
0f113f3e | 2 | /* |
36d16f8e | 3 | * DTLS implementation written by Nagendra Modadugu |
0f113f3e | 4 | * (nagendra@cs.stanford.edu) for the OpenSSL project 2005. |
36d16f8e BL |
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 | |
0f113f3e | 14 | * notice, this list of conditions and the following disclaimer. |
36d16f8e BL |
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. | |
0f113f3e | 65 | * |
36d16f8e BL |
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). | |
0f113f3e | 72 | * |
36d16f8e BL |
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. | |
0f113f3e | 79 | * |
36d16f8e BL |
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 :-). | |
0f113f3e | 94 | * 4. If you include any Windows specific code (or a derivative thereof) from |
36d16f8e BL |
95 | * the apps directory (application code) you must include an acknowledgement: |
96 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | |
0f113f3e | 97 | * |
36d16f8e BL |
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. | |
0f113f3e | 109 | * |
36d16f8e BL |
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 | |
999005e4 | 119 | #include "../ssl_locl.h" |
36d16f8e BL |
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 */ |
0f113f3e MC |
126 | static int satsub64be(const unsigned char *v1, const unsigned char *v2) |
127 | { | |
128 | int ret, sat, brw, i; | |
129 | ||
130 | if (sizeof(long) == 8) | |
131 | do { | |
132 | const union { | |
133 | long one; | |
134 | char little; | |
135 | } is_endian = { | |
136 | 1 | |
137 | }; | |
138 | long l; | |
139 | ||
140 | if (is_endian.little) | |
141 | break; | |
142 | /* not reached on little-endians */ | |
143 | /* | |
144 | * following test is redundant, because input is always aligned, | |
145 | * but I take no chances... | |
146 | */ | |
147 | if (((size_t)v1 | (size_t)v2) & 0x7) | |
148 | break; | |
149 | ||
150 | l = *((long *)v1); | |
151 | l -= *((long *)v2); | |
152 | if (l > 128) | |
153 | return 128; | |
154 | else if (l < -128) | |
155 | return -128; | |
156 | else | |
157 | return (int)l; | |
158 | } while (0); | |
159 | ||
160 | ret = (int)v1[7] - (int)v2[7]; | |
161 | sat = 0; | |
162 | brw = ret >> 8; /* brw is either 0 or -1 */ | |
163 | if (ret & 0x80) { | |
164 | for (i = 6; i >= 0; i--) { | |
165 | brw += (int)v1[i] - (int)v2[i]; | |
166 | sat |= ~brw; | |
167 | brw >>= 8; | |
168 | } | |
169 | } else { | |
170 | for (i = 6; i >= 0; i--) { | |
171 | brw += (int)v1[i] - (int)v2[i]; | |
172 | sat |= brw; | |
173 | brw >>= 8; | |
174 | } | |
175 | } | |
176 | brw <<= 8; /* brw is either 0 or -256 */ | |
177 | ||
178 | if (sat & 0xff) | |
179 | return brw | 0x80; | |
180 | else | |
181 | return brw + (ret & 0xFF); | |
50ec3951 | 182 | } |
dffdb56b | 183 | |
0f113f3e MC |
184 | static int have_handshake_fragment(SSL *s, int type, unsigned char *buf, |
185 | int len, int peek); | |
36d16f8e | 186 | |
36d16f8e | 187 | /* copy buffered record into SSL structure */ |
0f113f3e MC |
188 | static int dtls1_copy_record(SSL *s, pitem *item) |
189 | { | |
36d16f8e BL |
190 | DTLS1_RECORD_DATA *rdata; |
191 | ||
192 | rdata = (DTLS1_RECORD_DATA *)item->data; | |
0f113f3e | 193 | |
88c23039 | 194 | SSL3_BUFFER_release(&s->rlayer.rbuf); |
0f113f3e | 195 | |
7a7048af MC |
196 | s->rlayer.packet = rdata->packet; |
197 | s->rlayer.packet_length = rdata->packet_length; | |
88c23039 MC |
198 | memcpy(&s->rlayer.rbuf, &(rdata->rbuf), sizeof(SSL3_BUFFER)); |
199 | memcpy(&s->rlayer.rrec, &(rdata->rrec), sizeof(SSL3_RECORD)); | |
36d16f8e | 200 | |
0f113f3e MC |
201 | /* Set proper sequence number for mac calculation */ |
202 | memcpy(&(s->s3->read_sequence[2]), &(rdata->packet[5]), 6); | |
203 | ||
204 | return (1); | |
205 | } | |
36d16f8e | 206 | |
fe589e61 | 207 | int |
dffdb56b | 208 | dtls1_buffer_record(SSL *s, record_pqueue *queue, unsigned char *priority) |
0f113f3e MC |
209 | { |
210 | DTLS1_RECORD_DATA *rdata; | |
211 | pitem *item; | |
212 | ||
213 | /* Limit the size of the queue to prevent DOS attacks */ | |
214 | if (pqueue_size(queue->q) >= 100) | |
215 | return 0; | |
216 | ||
217 | rdata = OPENSSL_malloc(sizeof(DTLS1_RECORD_DATA)); | |
218 | item = pitem_new(priority, rdata); | |
219 | if (rdata == NULL || item == NULL) { | |
220 | if (rdata != NULL) | |
221 | OPENSSL_free(rdata); | |
222 | if (item != NULL) | |
223 | pitem_free(item); | |
224 | ||
225 | SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR); | |
06c6a2b4 | 226 | return -1; |
0f113f3e MC |
227 | } |
228 | ||
7a7048af MC |
229 | rdata->packet = s->rlayer.packet; |
230 | rdata->packet_length = s->rlayer.packet_length; | |
88c23039 MC |
231 | memcpy(&(rdata->rbuf), &s->rlayer.rbuf, sizeof(SSL3_BUFFER)); |
232 | memcpy(&(rdata->rrec), &s->rlayer.rrec, sizeof(SSL3_RECORD)); | |
0f113f3e MC |
233 | |
234 | item->data = rdata; | |
36d16f8e | 235 | |
7e159e01 | 236 | #ifndef OPENSSL_NO_SCTP |
0f113f3e MC |
237 | /* Store bio_dgram_sctp_rcvinfo struct */ |
238 | if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && | |
239 | (s->state == SSL3_ST_SR_FINISHED_A | |
240 | || s->state == SSL3_ST_CR_FINISHED_A)) { | |
241 | BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SCTP_GET_RCVINFO, | |
242 | sizeof(rdata->recordinfo), &rdata->recordinfo); | |
243 | } | |
7e159e01 DSH |
244 | #endif |
245 | ||
7a7048af MC |
246 | s->rlayer.packet = NULL; |
247 | s->rlayer.packet_length = 0; | |
88c23039 MC |
248 | memset(&s->rlayer.rbuf, 0, sizeof(SSL3_BUFFER)); |
249 | memset(&s->rlayer.rrec, 0, sizeof(SSL3_RECORD)); | |
0f113f3e MC |
250 | |
251 | if (!ssl3_setup_buffers(s)) { | |
252 | SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR); | |
253 | if (rdata->rbuf.buf != NULL) | |
254 | OPENSSL_free(rdata->rbuf.buf); | |
255 | OPENSSL_free(rdata); | |
256 | pitem_free(item); | |
257 | return (-1); | |
258 | } | |
36d16f8e | 259 | |
0f113f3e MC |
260 | /* insert should not fail, since duplicates are dropped */ |
261 | if (pqueue_insert(queue->q, item) == NULL) { | |
262 | SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR); | |
263 | if (rdata->rbuf.buf != NULL) | |
264 | OPENSSL_free(rdata->rbuf.buf); | |
265 | OPENSSL_free(rdata); | |
266 | pitem_free(item); | |
267 | return (-1); | |
268 | } | |
36d16f8e | 269 | |
0f113f3e MC |
270 | return (1); |
271 | } | |
272 | ||
fe589e61 | 273 | int dtls1_retrieve_buffered_record(SSL *s, record_pqueue *queue) |
0f113f3e | 274 | { |
36d16f8e BL |
275 | pitem *item; |
276 | ||
277 | item = pqueue_pop(queue->q); | |
0f113f3e | 278 | if (item) { |
36d16f8e BL |
279 | dtls1_copy_record(s, item); |
280 | ||
281 | OPENSSL_free(item->data); | |
0f113f3e | 282 | pitem_free(item); |
36d16f8e | 283 | |
0f113f3e | 284 | return (1); |
36d16f8e BL |
285 | } |
286 | ||
0f113f3e MC |
287 | return (0); |
288 | } | |
36d16f8e | 289 | |
0f113f3e MC |
290 | /* |
291 | * retrieve a buffered record that belongs to the new epoch, i.e., not | |
292 | * processed yet | |
293 | */ | |
36d16f8e BL |
294 | #define dtls1_get_unprocessed_record(s) \ |
295 | dtls1_retrieve_buffered_record((s), \ | |
296 | &((s)->d1->unprocessed_rcds)) | |
297 | ||
36d16f8e | 298 | |
fe589e61 | 299 | int dtls1_process_buffered_records(SSL *s) |
0f113f3e | 300 | { |
36d16f8e | 301 | pitem *item; |
0f113f3e | 302 | |
36d16f8e | 303 | item = pqueue_peek(s->d1->unprocessed_rcds.q); |
0f113f3e | 304 | if (item) { |
36d16f8e BL |
305 | /* Check if epoch is current. */ |
306 | if (s->d1->unprocessed_rcds.epoch != s->d1->r_epoch) | |
0f113f3e MC |
307 | return (1); /* Nothing to do. */ |
308 | ||
36d16f8e | 309 | /* Process all the records. */ |
0f113f3e | 310 | while (pqueue_peek(s->d1->unprocessed_rcds.q)) { |
36d16f8e | 311 | dtls1_get_unprocessed_record(s); |
0f113f3e MC |
312 | if (!dtls1_process_record(s)) |
313 | return (0); | |
314 | if (dtls1_buffer_record(s, &(s->d1->processed_rcds), | |
88c23039 | 315 | SSL3_RECORD_get_seq_num(&s->rlayer.rrec)) < 0) |
103b171d | 316 | return -1; |
36d16f8e | 317 | } |
0f113f3e | 318 | } |
36d16f8e | 319 | |
0f113f3e MC |
320 | /* |
321 | * sync epoch numbers once all the unprocessed records have been | |
322 | * processed | |
323 | */ | |
36d16f8e BL |
324 | s->d1->processed_rcds.epoch = s->d1->r_epoch; |
325 | s->d1->unprocessed_rcds.epoch = s->d1->r_epoch + 1; | |
326 | ||
0f113f3e MC |
327 | return (1); |
328 | } | |
36d16f8e | 329 | |
36d16f8e | 330 | |
1d97c843 TH |
331 | /*- |
332 | * Return up to 'len' payload bytes received in 'type' records. | |
36d16f8e BL |
333 | * 'type' is one of the following: |
334 | * | |
335 | * - SSL3_RT_HANDSHAKE (when ssl3_get_message calls us) | |
336 | * - SSL3_RT_APPLICATION_DATA (when ssl3_read calls us) | |
337 | * - 0 (during a shutdown, no data has to be returned) | |
338 | * | |
339 | * If we don't have stored data to work from, read a SSL/TLS record first | |
340 | * (possibly multiple records if we still don't have anything to return). | |
341 | * | |
342 | * This function must handle any surprises the peer may have for us, such as | |
343 | * Alert records (e.g. close_notify), ChangeCipherSpec records (not really | |
344 | * a surprise, but handled as if it were), or renegotiation requests. | |
345 | * Also if record payloads contain fragments too small to process, we store | |
346 | * them until there is enough for the respective protocol (the record protocol | |
347 | * may use arbitrary fragmentation and even interleaving): | |
348 | * Change cipher spec protocol | |
349 | * just 1 byte needed, no need for keeping anything stored | |
350 | * Alert protocol | |
351 | * 2 bytes needed (AlertLevel, AlertDescription) | |
352 | * Handshake protocol | |
353 | * 4 bytes needed (HandshakeType, uint24 length) -- we just have | |
354 | * to detect unexpected Client Hello and Hello Request messages | |
355 | * here, anything else is handled by higher layers | |
356 | * Application data protocol | |
357 | * none of our business | |
358 | */ | |
359 | int dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek) | |
0f113f3e MC |
360 | { |
361 | int al, i, j, ret; | |
362 | unsigned int n; | |
363 | SSL3_RECORD *rr; | |
364 | void (*cb) (const SSL *ssl, int type2, int val) = NULL; | |
365 | ||
88c23039 | 366 | if (!SSL3_BUFFER_is_initialised(&s->rlayer.rbuf)) { |
28d59af8 | 367 | /* Not initialized yet */ |
0f113f3e MC |
368 | if (!ssl3_setup_buffers(s)) |
369 | return (-1); | |
28d59af8 | 370 | } |
0f113f3e MC |
371 | |
372 | if ((type && (type != SSL3_RT_APPLICATION_DATA) && | |
373 | (type != SSL3_RT_HANDSHAKE)) || | |
374 | (peek && (type != SSL3_RT_APPLICATION_DATA))) { | |
375 | SSLerr(SSL_F_DTLS1_READ_BYTES, ERR_R_INTERNAL_ERROR); | |
376 | return -1; | |
377 | } | |
378 | ||
379 | /* | |
380 | * check whether there's a handshake message (client hello?) waiting | |
381 | */ | |
382 | if ((ret = have_handshake_fragment(s, type, buf, len, peek))) | |
383 | return ret; | |
384 | ||
385 | /* | |
386 | * Now s->d1->handshake_fragment_len == 0 if type == SSL3_RT_HANDSHAKE. | |
387 | */ | |
36d16f8e | 388 | |
7e159e01 | 389 | #ifndef OPENSSL_NO_SCTP |
0f113f3e MC |
390 | /* |
391 | * Continue handshake if it had to be interrupted to read app data with | |
392 | * SCTP. | |
393 | */ | |
394 | if ((!s->in_handshake && SSL_in_init(s)) || | |
395 | (BIO_dgram_is_sctp(SSL_get_rbio(s)) && | |
396 | (s->state == DTLS1_SCTP_ST_SR_READ_SOCK | |
397 | || s->state == DTLS1_SCTP_ST_CR_READ_SOCK) | |
398 | && s->s3->in_read_app_data != 2)) | |
7e159e01 | 399 | #else |
0f113f3e | 400 | if (!s->in_handshake && SSL_in_init(s)) |
7e159e01 | 401 | #endif |
0f113f3e MC |
402 | { |
403 | /* type == SSL3_RT_APPLICATION_DATA */ | |
404 | i = s->handshake_func(s); | |
405 | if (i < 0) | |
406 | return (i); | |
407 | if (i == 0) { | |
408 | SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE); | |
409 | return (-1); | |
410 | } | |
411 | } | |
412 | ||
413 | start: | |
414 | s->rwstate = SSL_NOTHING; | |
415 | ||
50e735f9 MC |
416 | /*- |
417 | * s->s3->rrec.type - is the type of record | |
418 | * s->s3->rrec.data, - data | |
419 | * s->s3->rrec.off, - offset into 'data' for next read | |
420 | * s->s3->rrec.length, - number of bytes. | |
421 | */ | |
88c23039 | 422 | rr = &s->rlayer.rrec; |
0f113f3e MC |
423 | |
424 | /* | |
425 | * We are not handshaking and have no data yet, so process data buffered | |
426 | * during the last handshake in advance, if any. | |
427 | */ | |
428 | if (s->state == SSL_ST_OK && rr->length == 0) { | |
429 | pitem *item; | |
430 | item = pqueue_pop(s->d1->buffered_app_data.q); | |
431 | if (item) { | |
7e159e01 | 432 | #ifndef OPENSSL_NO_SCTP |
0f113f3e MC |
433 | /* Restore bio_dgram_sctp_rcvinfo struct */ |
434 | if (BIO_dgram_is_sctp(SSL_get_rbio(s))) { | |
435 | DTLS1_RECORD_DATA *rdata = (DTLS1_RECORD_DATA *)item->data; | |
436 | BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SCTP_SET_RCVINFO, | |
437 | sizeof(rdata->recordinfo), &rdata->recordinfo); | |
438 | } | |
7e159e01 DSH |
439 | #endif |
440 | ||
0f113f3e MC |
441 | dtls1_copy_record(s, item); |
442 | ||
443 | OPENSSL_free(item->data); | |
444 | pitem_free(item); | |
445 | } | |
446 | } | |
447 | ||
448 | /* Check for timeout */ | |
449 | if (dtls1_handle_timeout(s) > 0) | |
450 | goto start; | |
451 | ||
452 | /* get new packet if necessary */ | |
295c3f41 | 453 | if ((rr->length == 0) || (s->rlayer.rstate == SSL_ST_READ_BODY)) { |
0f113f3e MC |
454 | ret = dtls1_get_record(s); |
455 | if (ret <= 0) { | |
456 | ret = dtls1_read_failed(s, ret); | |
457 | /* anything other than a timeout is an error */ | |
458 | if (ret <= 0) | |
459 | return (ret); | |
460 | else | |
461 | goto start; | |
462 | } | |
463 | } | |
464 | ||
465 | if (s->d1->listen && rr->type != SSL3_RT_HANDSHAKE) { | |
466 | rr->length = 0; | |
467 | goto start; | |
468 | } | |
469 | ||
470 | /* we now have a packet which can be read and processed */ | |
471 | ||
472 | if (s->s3->change_cipher_spec /* set when we receive ChangeCipherSpec, | |
473 | * reset by ssl3_get_finished */ | |
474 | && (rr->type != SSL3_RT_HANDSHAKE)) { | |
475 | /* | |
476 | * We now have application data between CCS and Finished. Most likely | |
477 | * the packets were reordered on their way, so buffer the application | |
478 | * data for later processing rather than dropping the connection. | |
479 | */ | |
480 | if (dtls1_buffer_record(s, &(s->d1->buffered_app_data), rr->seq_num) < | |
481 | 0) { | |
482 | SSLerr(SSL_F_DTLS1_READ_BYTES, ERR_R_INTERNAL_ERROR); | |
483 | return -1; | |
484 | } | |
485 | rr->length = 0; | |
486 | goto start; | |
487 | } | |
488 | ||
489 | /* | |
490 | * If the other end has shut down, throw anything we read away (even in | |
491 | * 'peek' mode) | |
492 | */ | |
493 | if (s->shutdown & SSL_RECEIVED_SHUTDOWN) { | |
494 | rr->length = 0; | |
495 | s->rwstate = SSL_NOTHING; | |
496 | return (0); | |
497 | } | |
498 | ||
499 | if (type == rr->type) { /* SSL3_RT_APPLICATION_DATA or | |
500 | * SSL3_RT_HANDSHAKE */ | |
501 | /* | |
502 | * make sure that we are not getting application data when we are | |
503 | * doing a handshake for the first time | |
504 | */ | |
505 | if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) && | |
506 | (s->enc_read_ctx == NULL)) { | |
507 | al = SSL_AD_UNEXPECTED_MESSAGE; | |
508 | SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_APP_DATA_IN_HANDSHAKE); | |
509 | goto f_err; | |
510 | } | |
7e159e01 | 511 | |
0f113f3e MC |
512 | if (len <= 0) |
513 | return (len); | |
514 | ||
515 | if ((unsigned int)len > rr->length) | |
516 | n = rr->length; | |
517 | else | |
518 | n = (unsigned int)len; | |
519 | ||
520 | memcpy(buf, &(rr->data[rr->off]), n); | |
521 | if (!peek) { | |
522 | rr->length -= n; | |
523 | rr->off += n; | |
524 | if (rr->length == 0) { | |
295c3f41 | 525 | s->rlayer.rstate = SSL_ST_READ_HEADER; |
0f113f3e MC |
526 | rr->off = 0; |
527 | } | |
528 | } | |
7e159e01 | 529 | #ifndef OPENSSL_NO_SCTP |
0f113f3e MC |
530 | /* |
531 | * We were about to renegotiate but had to read belated application | |
532 | * data first, so retry. | |
533 | */ | |
534 | if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && | |
535 | rr->type == SSL3_RT_APPLICATION_DATA && | |
536 | (s->state == DTLS1_SCTP_ST_SR_READ_SOCK | |
537 | || s->state == DTLS1_SCTP_ST_CR_READ_SOCK)) { | |
538 | s->rwstate = SSL_READING; | |
539 | BIO_clear_retry_flags(SSL_get_rbio(s)); | |
540 | BIO_set_retry_read(SSL_get_rbio(s)); | |
541 | } | |
542 | ||
543 | /* | |
544 | * We might had to delay a close_notify alert because of reordered | |
545 | * app data. If there was an alert and there is no message to read | |
546 | * anymore, finally set shutdown. | |
547 | */ | |
548 | if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && | |
549 | s->d1->shutdown_received | |
550 | && !BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s))) { | |
551 | s->shutdown |= SSL_RECEIVED_SHUTDOWN; | |
552 | return (0); | |
553 | } | |
554 | #endif | |
555 | return (n); | |
556 | } | |
557 | ||
558 | /* | |
559 | * If we get here, then type != rr->type; if we have a handshake message, | |
560 | * then it was unexpected (Hello Request or Client Hello). | |
561 | */ | |
562 | ||
563 | /* | |
564 | * In case of record types for which we have 'fragment' storage, fill | |
565 | * that so that we can process the data at a fixed place. | |
566 | */ | |
567 | { | |
568 | unsigned int k, dest_maxlen = 0; | |
569 | unsigned char *dest = NULL; | |
570 | unsigned int *dest_len = NULL; | |
571 | ||
572 | if (rr->type == SSL3_RT_HANDSHAKE) { | |
573 | dest_maxlen = sizeof s->d1->handshake_fragment; | |
574 | dest = s->d1->handshake_fragment; | |
575 | dest_len = &s->d1->handshake_fragment_len; | |
576 | } else if (rr->type == SSL3_RT_ALERT) { | |
577 | dest_maxlen = sizeof(s->d1->alert_fragment); | |
578 | dest = s->d1->alert_fragment; | |
579 | dest_len = &s->d1->alert_fragment_len; | |
580 | } | |
4817504d | 581 | #ifndef OPENSSL_NO_HEARTBEATS |
0f113f3e | 582 | else if (rr->type == TLS1_RT_HEARTBEAT) { |
69f68237 | 583 | /* We allow a 0 return */ |
2c60ed04 MC |
584 | if(dtls1_process_heartbeat(s, SSL3_RECORD_get_data(&s->rlayer.rrec), |
585 | SSL3_RECORD_get_length(&s->rlayer.rrec)) < 0) { | |
69f68237 MC |
586 | return -1; |
587 | } | |
0f113f3e MC |
588 | /* Exit and notify application to read again */ |
589 | rr->length = 0; | |
590 | s->rwstate = SSL_READING; | |
591 | BIO_clear_retry_flags(SSL_get_rbio(s)); | |
592 | BIO_set_retry_read(SSL_get_rbio(s)); | |
593 | return (-1); | |
594 | } | |
4817504d | 595 | #endif |
0f113f3e MC |
596 | /* else it's a CCS message, or application data or wrong */ |
597 | else if (rr->type != SSL3_RT_CHANGE_CIPHER_SPEC) { | |
598 | /* | |
599 | * Application data while renegotiating is allowed. Try again | |
600 | * reading. | |
601 | */ | |
602 | if (rr->type == SSL3_RT_APPLICATION_DATA) { | |
603 | BIO *bio; | |
604 | s->s3->in_read_app_data = 2; | |
605 | bio = SSL_get_rbio(s); | |
606 | s->rwstate = SSL_READING; | |
607 | BIO_clear_retry_flags(bio); | |
608 | BIO_set_retry_read(bio); | |
609 | return (-1); | |
610 | } | |
611 | ||
612 | /* Not certain if this is the right error handling */ | |
613 | al = SSL_AD_UNEXPECTED_MESSAGE; | |
614 | SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_UNEXPECTED_RECORD); | |
615 | goto f_err; | |
616 | } | |
617 | ||
618 | if (dest_maxlen > 0) { | |
619 | /* | |
620 | * XDTLS: In a pathalogical case, the Client Hello may be | |
621 | * fragmented--don't always expect dest_maxlen bytes | |
622 | */ | |
623 | if (rr->length < dest_maxlen) { | |
d4938995 | 624 | #ifdef DTLS1_AD_MISSING_HANDSHAKE_MESSAGE |
0f113f3e MC |
625 | /* |
626 | * for normal alerts rr->length is 2, while | |
627 | * dest_maxlen is 7 if we were to handle this | |
628 | * non-existing alert... | |
629 | */ | |
630 | FIX ME | |
d4938995 | 631 | #endif |
295c3f41 | 632 | s->rlayer.rstate = SSL_ST_READ_HEADER; |
0f113f3e MC |
633 | rr->length = 0; |
634 | goto start; | |
635 | } | |
636 | ||
637 | /* now move 'n' bytes: */ | |
638 | for (k = 0; k < dest_maxlen; k++) { | |
639 | dest[k] = rr->data[rr->off++]; | |
640 | rr->length--; | |
641 | } | |
642 | *dest_len = dest_maxlen; | |
643 | } | |
644 | } | |
645 | ||
35a1cc90 MC |
646 | /*- |
647 | * s->d1->handshake_fragment_len == 12 iff rr->type == SSL3_RT_HANDSHAKE; | |
648 | * s->d1->alert_fragment_len == 7 iff rr->type == SSL3_RT_ALERT. | |
649 | * (Possibly rr is 'empty' now, i.e. rr->length may be 0.) | |
650 | */ | |
0f113f3e MC |
651 | |
652 | /* If we are a client, check for an incoming 'Hello Request': */ | |
653 | if ((!s->server) && | |
654 | (s->d1->handshake_fragment_len >= DTLS1_HM_HEADER_LENGTH) && | |
655 | (s->d1->handshake_fragment[0] == SSL3_MT_HELLO_REQUEST) && | |
656 | (s->session != NULL) && (s->session->cipher != NULL)) { | |
657 | s->d1->handshake_fragment_len = 0; | |
658 | ||
659 | if ((s->d1->handshake_fragment[1] != 0) || | |
660 | (s->d1->handshake_fragment[2] != 0) || | |
661 | (s->d1->handshake_fragment[3] != 0)) { | |
662 | al = SSL_AD_DECODE_ERROR; | |
663 | SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_BAD_HELLO_REQUEST); | |
664 | goto err; | |
665 | } | |
666 | ||
667 | /* | |
668 | * no need to check sequence number on HELLO REQUEST messages | |
669 | */ | |
670 | ||
671 | if (s->msg_callback) | |
672 | s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, | |
673 | s->d1->handshake_fragment, 4, s, | |
674 | s->msg_callback_arg); | |
675 | ||
676 | if (SSL_is_init_finished(s) && | |
677 | !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS) && | |
678 | !s->s3->renegotiate) { | |
679 | s->d1->handshake_read_seq++; | |
680 | s->new_session = 1; | |
681 | ssl3_renegotiate(s); | |
682 | if (ssl3_renegotiate_check(s)) { | |
683 | i = s->handshake_func(s); | |
684 | if (i < 0) | |
685 | return (i); | |
686 | if (i == 0) { | |
687 | SSLerr(SSL_F_DTLS1_READ_BYTES, | |
688 | SSL_R_SSL_HANDSHAKE_FAILURE); | |
689 | return (-1); | |
690 | } | |
691 | ||
692 | if (!(s->mode & SSL_MODE_AUTO_RETRY)) { | |
88c23039 | 693 | if (SSL3_BUFFER_get_left(&s->rlayer.rbuf) == 0) { |
28d59af8 | 694 | /* no read-ahead left? */ |
0f113f3e MC |
695 | BIO *bio; |
696 | /* | |
697 | * In the case where we try to read application data, | |
698 | * but we trigger an SSL handshake, we return -1 with | |
699 | * the retry option set. Otherwise renegotiation may | |
700 | * cause nasty problems in the blocking world | |
701 | */ | |
702 | s->rwstate = SSL_READING; | |
703 | bio = SSL_get_rbio(s); | |
704 | BIO_clear_retry_flags(bio); | |
705 | BIO_set_retry_read(bio); | |
706 | return (-1); | |
707 | } | |
708 | } | |
709 | } | |
710 | } | |
711 | /* | |
712 | * we either finished a handshake or ignored the request, now try | |
713 | * again to obtain the (application) data we were asked for | |
714 | */ | |
715 | goto start; | |
716 | } | |
717 | ||
718 | if (s->d1->alert_fragment_len >= DTLS1_AL_HEADER_LENGTH) { | |
719 | int alert_level = s->d1->alert_fragment[0]; | |
720 | int alert_descr = s->d1->alert_fragment[1]; | |
721 | ||
722 | s->d1->alert_fragment_len = 0; | |
723 | ||
724 | if (s->msg_callback) | |
725 | s->msg_callback(0, s->version, SSL3_RT_ALERT, | |
726 | s->d1->alert_fragment, 2, s, s->msg_callback_arg); | |
727 | ||
728 | if (s->info_callback != NULL) | |
729 | cb = s->info_callback; | |
730 | else if (s->ctx->info_callback != NULL) | |
731 | cb = s->ctx->info_callback; | |
732 | ||
733 | if (cb != NULL) { | |
734 | j = (alert_level << 8) | alert_descr; | |
735 | cb(s, SSL_CB_READ_ALERT, j); | |
736 | } | |
737 | ||
fd865cad | 738 | if (alert_level == SSL3_AL_WARNING) { |
0f113f3e MC |
739 | s->s3->warn_alert = alert_descr; |
740 | if (alert_descr == SSL_AD_CLOSE_NOTIFY) { | |
7e159e01 | 741 | #ifndef OPENSSL_NO_SCTP |
0f113f3e MC |
742 | /* |
743 | * With SCTP and streams the socket may deliver app data | |
744 | * after a close_notify alert. We have to check this first so | |
745 | * that nothing gets discarded. | |
746 | */ | |
747 | if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && | |
748 | BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s))) { | |
749 | s->d1->shutdown_received = 1; | |
750 | s->rwstate = SSL_READING; | |
751 | BIO_clear_retry_flags(SSL_get_rbio(s)); | |
752 | BIO_set_retry_read(SSL_get_rbio(s)); | |
753 | return -1; | |
754 | } | |
7e159e01 | 755 | #endif |
0f113f3e MC |
756 | s->shutdown |= SSL_RECEIVED_SHUTDOWN; |
757 | return (0); | |
758 | } | |
36d16f8e BL |
759 | #if 0 |
760 | /* XXX: this is a possible improvement in the future */ | |
0f113f3e MC |
761 | /* now check if it's a missing record */ |
762 | if (alert_descr == DTLS1_AD_MISSING_HANDSHAKE_MESSAGE) { | |
763 | unsigned short seq; | |
764 | unsigned int frag_off; | |
765 | unsigned char *p = &(s->d1->alert_fragment[2]); | |
766 | ||
767 | n2s(p, seq); | |
768 | n2l3(p, frag_off); | |
769 | ||
770 | dtls1_retransmit_message(s, | |
771 | dtls1_get_queue_priority | |
772 | (frag->msg_header.seq, 0), frag_off, | |
773 | &found); | |
774 | if (!found && SSL_in_init(s)) { | |
775 | /* | |
776 | * fprintf( stderr,"in init = %d\n", SSL_in_init(s)); | |
777 | */ | |
778 | /* | |
779 | * requested a message not yet sent, send an alert | |
780 | * ourselves | |
781 | */ | |
782 | ssl3_send_alert(s, SSL3_AL_WARNING, | |
783 | DTLS1_AD_MISSING_HANDSHAKE_MESSAGE); | |
784 | } | |
785 | } | |
36d16f8e | 786 | #endif |
fd865cad | 787 | } else if (alert_level == SSL3_AL_FATAL) { |
0f113f3e MC |
788 | char tmp[16]; |
789 | ||
790 | s->rwstate = SSL_NOTHING; | |
791 | s->s3->fatal_alert = alert_descr; | |
792 | SSLerr(SSL_F_DTLS1_READ_BYTES, | |
793 | SSL_AD_REASON_OFFSET + alert_descr); | |
794 | BIO_snprintf(tmp, sizeof tmp, "%d", alert_descr); | |
795 | ERR_add_error_data(2, "SSL alert number ", tmp); | |
796 | s->shutdown |= SSL_RECEIVED_SHUTDOWN; | |
797 | SSL_CTX_remove_session(s->ctx, s->session); | |
798 | return (0); | |
799 | } else { | |
800 | al = SSL_AD_ILLEGAL_PARAMETER; | |
801 | SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_UNKNOWN_ALERT_TYPE); | |
802 | goto f_err; | |
803 | } | |
804 | ||
805 | goto start; | |
806 | } | |
807 | ||
808 | if (s->shutdown & SSL_SENT_SHUTDOWN) { /* but we have not received a | |
809 | * shutdown */ | |
810 | s->rwstate = SSL_NOTHING; | |
811 | rr->length = 0; | |
812 | return (0); | |
813 | } | |
814 | ||
815 | if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) { | |
816 | struct ccs_header_st ccs_hdr; | |
817 | unsigned int ccs_hdr_len = DTLS1_CCS_HEADER_LENGTH; | |
818 | ||
819 | dtls1_get_ccs_header(rr->data, &ccs_hdr); | |
820 | ||
821 | if (s->version == DTLS1_BAD_VER) | |
822 | ccs_hdr_len = 3; | |
823 | ||
824 | /* | |
825 | * 'Change Cipher Spec' is just a single byte, so we know exactly | |
826 | * what the record payload has to look like | |
827 | */ | |
828 | /* XDTLS: check that epoch is consistent */ | |
829 | if ((rr->length != ccs_hdr_len) || | |
830 | (rr->off != 0) || (rr->data[0] != SSL3_MT_CCS)) { | |
831 | i = SSL_AD_ILLEGAL_PARAMETER; | |
832 | SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_BAD_CHANGE_CIPHER_SPEC); | |
833 | goto err; | |
834 | } | |
835 | ||
836 | rr->length = 0; | |
837 | ||
838 | if (s->msg_callback) | |
839 | s->msg_callback(0, s->version, SSL3_RT_CHANGE_CIPHER_SPEC, | |
840 | rr->data, 1, s, s->msg_callback_arg); | |
841 | ||
842 | /* | |
843 | * We can't process a CCS now, because previous handshake messages | |
844 | * are still missing, so just drop it. | |
845 | */ | |
846 | if (!s->d1->change_cipher_spec_ok) { | |
847 | goto start; | |
848 | } | |
849 | ||
850 | s->d1->change_cipher_spec_ok = 0; | |
851 | ||
852 | s->s3->change_cipher_spec = 1; | |
853 | if (!ssl3_do_change_cipher_spec(s)) | |
854 | goto err; | |
855 | ||
856 | /* do this whenever CCS is processed */ | |
857 | dtls1_reset_seq_numbers(s, SSL3_CC_READ); | |
858 | ||
859 | if (s->version == DTLS1_BAD_VER) | |
860 | s->d1->handshake_read_seq++; | |
8711efb4 | 861 | |
7e159e01 | 862 | #ifndef OPENSSL_NO_SCTP |
0f113f3e MC |
863 | /* |
864 | * Remember that a CCS has been received, so that an old key of | |
865 | * SCTP-Auth can be deleted when a CCS is sent. Will be ignored if no | |
866 | * SCTP is used | |
867 | */ | |
868 | BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD, 1, NULL); | |
7e159e01 DSH |
869 | #endif |
870 | ||
0f113f3e MC |
871 | goto start; |
872 | } | |
873 | ||
874 | /* | |
875 | * Unexpected handshake message (Client Hello, or protocol violation) | |
876 | */ | |
877 | if ((s->d1->handshake_fragment_len >= DTLS1_HM_HEADER_LENGTH) && | |
878 | !s->in_handshake) { | |
879 | struct hm_header_st msg_hdr; | |
880 | ||
881 | /* this may just be a stale retransmit */ | |
882 | dtls1_get_message_header(rr->data, &msg_hdr); | |
883 | if (rr->epoch != s->d1->r_epoch) { | |
884 | rr->length = 0; | |
885 | goto start; | |
886 | } | |
887 | ||
888 | /* | |
889 | * If we are server, we may have a repeated FINISHED of the client | |
890 | * here, then retransmit our CCS and FINISHED. | |
891 | */ | |
892 | if (msg_hdr.type == SSL3_MT_FINISHED) { | |
893 | if (dtls1_check_timeout_num(s) < 0) | |
894 | return -1; | |
895 | ||
17dd65e6 | 896 | dtls1_retransmit_buffered_messages(s); |
0f113f3e MC |
897 | rr->length = 0; |
898 | goto start; | |
899 | } | |
900 | ||
901 | if (((s->state & SSL_ST_MASK) == SSL_ST_OK) && | |
902 | !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS)) { | |
0f113f3e | 903 | s->state = s->server ? SSL_ST_ACCEPT : SSL_ST_CONNECT; |
0f113f3e MC |
904 | s->renegotiate = 1; |
905 | s->new_session = 1; | |
906 | } | |
907 | i = s->handshake_func(s); | |
908 | if (i < 0) | |
909 | return (i); | |
910 | if (i == 0) { | |
911 | SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE); | |
912 | return (-1); | |
913 | } | |
914 | ||
915 | if (!(s->mode & SSL_MODE_AUTO_RETRY)) { | |
88c23039 | 916 | if (SSL3_BUFFER_get_left(&s->rlayer.rbuf) == 0) { |
28d59af8 | 917 | /* no read-ahead left? */ |
0f113f3e MC |
918 | BIO *bio; |
919 | /* | |
920 | * In the case where we try to read application data, but we | |
921 | * trigger an SSL handshake, we return -1 with the retry | |
922 | * option set. Otherwise renegotiation may cause nasty | |
923 | * problems in the blocking world | |
924 | */ | |
925 | s->rwstate = SSL_READING; | |
926 | bio = SSL_get_rbio(s); | |
927 | BIO_clear_retry_flags(bio); | |
928 | BIO_set_retry_read(bio); | |
929 | return (-1); | |
930 | } | |
931 | } | |
932 | goto start; | |
933 | } | |
934 | ||
935 | switch (rr->type) { | |
936 | default: | |
0f113f3e MC |
937 | /* TLS just ignores unknown message types */ |
938 | if (s->version == TLS1_VERSION) { | |
939 | rr->length = 0; | |
940 | goto start; | |
941 | } | |
0f113f3e MC |
942 | al = SSL_AD_UNEXPECTED_MESSAGE; |
943 | SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_UNEXPECTED_RECORD); | |
944 | goto f_err; | |
945 | case SSL3_RT_CHANGE_CIPHER_SPEC: | |
946 | case SSL3_RT_ALERT: | |
947 | case SSL3_RT_HANDSHAKE: | |
948 | /* | |
949 | * we already handled all of these, with the possible exception of | |
950 | * SSL3_RT_HANDSHAKE when s->in_handshake is set, but that should not | |
951 | * happen when type != rr->type | |
952 | */ | |
953 | al = SSL_AD_UNEXPECTED_MESSAGE; | |
954 | SSLerr(SSL_F_DTLS1_READ_BYTES, ERR_R_INTERNAL_ERROR); | |
955 | goto f_err; | |
956 | case SSL3_RT_APPLICATION_DATA: | |
957 | /* | |
958 | * At this point, we were expecting handshake data, but have | |
959 | * application data. If the library was running inside ssl3_read() | |
960 | * (i.e. in_read_app_data is set) and it makes sense to read | |
961 | * application data at this point (session renegotiation not yet | |
962 | * started), we will indulge it. | |
963 | */ | |
964 | if (s->s3->in_read_app_data && | |
965 | (s->s3->total_renegotiations != 0) && | |
966 | (((s->state & SSL_ST_CONNECT) && | |
967 | (s->state >= SSL3_ST_CW_CLNT_HELLO_A) && | |
968 | (s->state <= SSL3_ST_CR_SRVR_HELLO_A) | |
969 | ) || ((s->state & SSL_ST_ACCEPT) && | |
970 | (s->state <= SSL3_ST_SW_HELLO_REQ_A) && | |
971 | (s->state >= SSL3_ST_SR_CLNT_HELLO_A) | |
972 | ) | |
973 | )) { | |
974 | s->s3->in_read_app_data = 2; | |
975 | return (-1); | |
976 | } else { | |
977 | al = SSL_AD_UNEXPECTED_MESSAGE; | |
978 | SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_UNEXPECTED_RECORD); | |
979 | goto f_err; | |
980 | } | |
981 | } | |
982 | /* not reached */ | |
983 | ||
984 | f_err: | |
985 | ssl3_send_alert(s, SSL3_AL_FATAL, al); | |
986 | err: | |
987 | return (-1); | |
988 | } | |
989 | ||
0f113f3e MC |
990 | |
991 | /* | |
992 | * this only happens when a client hello is received and a handshake | |
993 | * is started. | |
994 | */ | |
36d16f8e | 995 | static int |
0f113f3e MC |
996 | have_handshake_fragment(SSL *s, int type, unsigned char *buf, |
997 | int len, int peek) | |
998 | { | |
999 | ||
1000 | if ((type == SSL3_RT_HANDSHAKE) && (s->d1->handshake_fragment_len > 0)) | |
1001 | /* (partially) satisfy request from storage */ | |
1002 | { | |
1003 | unsigned char *src = s->d1->handshake_fragment; | |
1004 | unsigned char *dst = buf; | |
1005 | unsigned int k, n; | |
1006 | ||
1007 | /* peek == 0 */ | |
1008 | n = 0; | |
1009 | while ((len > 0) && (s->d1->handshake_fragment_len > 0)) { | |
1010 | *dst++ = *src++; | |
1011 | len--; | |
1012 | s->d1->handshake_fragment_len--; | |
1013 | n++; | |
1014 | } | |
1015 | /* move any remaining fragment bytes: */ | |
1016 | for (k = 0; k < s->d1->handshake_fragment_len; k++) | |
1017 | s->d1->handshake_fragment[k] = *src++; | |
1018 | return n; | |
1019 | } | |
1020 | ||
1021 | return 0; | |
1022 | } | |
1023 | ||
1024 | /* | |
1025 | * Call this to write data in records of type 'type' It will return <= 0 if | |
1026 | * not all data has been sent or non-blocking IO. | |
36d16f8e | 1027 | */ |
480b9e5d | 1028 | int dtls1_write_bytes(SSL *s, int type, const void *buf, int len) |
0f113f3e MC |
1029 | { |
1030 | int i; | |
1031 | ||
1032 | OPENSSL_assert(len <= SSL3_RT_MAX_PLAIN_LENGTH); | |
1033 | s->rwstate = SSL_NOTHING; | |
1034 | i = do_dtls1_write(s, type, buf, len, 0); | |
1035 | return i; | |
1036 | } | |
1037 | ||
1038 | int do_dtls1_write(SSL *s, int type, const unsigned char *buf, | |
1039 | unsigned int len, int create_empty_fragment) | |
1040 | { | |
1041 | unsigned char *p, *pseq; | |
1042 | int i, mac_size, clear = 0; | |
1043 | int prefix_len = 0; | |
1044 | int eivlen; | |
1045 | SSL3_RECORD *wr; | |
1046 | SSL3_BUFFER *wb; | |
1047 | SSL_SESSION *sess; | |
1048 | ||
88c23039 | 1049 | wb = &s->rlayer.wbuf; |
db9a32e7 | 1050 | |
0f113f3e MC |
1051 | /* |
1052 | * first check if there is a SSL3_BUFFER still being written out. This | |
1053 | * will happen with non blocking IO | |
1054 | */ | |
db9a32e7 | 1055 | if (SSL3_BUFFER_get_left(wb) != 0) { |
0f113f3e MC |
1056 | OPENSSL_assert(0); /* XDTLS: want to see if we ever get here */ |
1057 | return (ssl3_write_pending(s, type, buf, len)); | |
1058 | } | |
1059 | ||
1060 | /* If we have an alert to send, lets send it */ | |
1061 | if (s->s3->alert_dispatch) { | |
1062 | i = s->method->ssl_dispatch_alert(s); | |
1063 | if (i <= 0) | |
1064 | return (i); | |
1065 | /* if it went, fall through and send more stuff */ | |
1066 | } | |
1067 | ||
1068 | if (len == 0 && !create_empty_fragment) | |
1069 | return 0; | |
1070 | ||
88c23039 | 1071 | wr = &s->rlayer.wrec; |
0f113f3e MC |
1072 | sess = s->session; |
1073 | ||
1074 | if ((sess == NULL) || | |
1075 | (s->enc_write_ctx == NULL) || (EVP_MD_CTX_md(s->write_hash) == NULL)) | |
1076 | clear = 1; | |
1077 | ||
1078 | if (clear) | |
1079 | mac_size = 0; | |
1080 | else { | |
1081 | mac_size = EVP_MD_CTX_size(s->write_hash); | |
1082 | if (mac_size < 0) | |
1083 | goto err; | |
1084 | } | |
1085 | ||
0f113f3e MC |
1086 | p = wb->buf + prefix_len; |
1087 | ||
1088 | /* write the header */ | |
1089 | ||
1090 | *(p++) = type & 0xff; | |
1091 | wr->type = type; | |
1092 | /* | |
1093 | * Special case: for hello verify request, client version 1.0 and we | |
1094 | * haven't decided which version to use yet send back using version 1.0 | |
1095 | * header: otherwise some clients will ignore it. | |
1096 | */ | |
1097 | if (s->method->version == DTLS_ANY_VERSION) { | |
1098 | *(p++) = DTLS1_VERSION >> 8; | |
1099 | *(p++) = DTLS1_VERSION & 0xff; | |
1100 | } else { | |
1101 | *(p++) = s->version >> 8; | |
1102 | *(p++) = s->version & 0xff; | |
1103 | } | |
1104 | ||
1105 | /* field where we are to write out packet epoch, seq num and len */ | |
1106 | pseq = p; | |
1107 | p += 10; | |
1108 | ||
1109 | /* Explicit IV length, block ciphers appropriate version flag */ | |
1110 | if (s->enc_write_ctx) { | |
1111 | int mode = EVP_CIPHER_CTX_mode(s->enc_write_ctx); | |
1112 | if (mode == EVP_CIPH_CBC_MODE) { | |
1113 | eivlen = EVP_CIPHER_CTX_iv_length(s->enc_write_ctx); | |
1114 | if (eivlen <= 1) | |
1115 | eivlen = 0; | |
1116 | } | |
1117 | /* Need explicit part of IV for GCM mode */ | |
1118 | else if (mode == EVP_CIPH_GCM_MODE) | |
1119 | eivlen = EVP_GCM_TLS_EXPLICIT_IV_LEN; | |
1120 | else | |
1121 | eivlen = 0; | |
1122 | } else | |
1123 | eivlen = 0; | |
1124 | ||
1125 | /* lets setup the record stuff. */ | |
1126 | wr->data = p + eivlen; /* make room for IV in case of CBC */ | |
1127 | wr->length = (int)len; | |
1128 | wr->input = (unsigned char *)buf; | |
1129 | ||
1130 | /* | |
1131 | * we now 'read' from wr->input, wr->length bytes into wr->data | |
1132 | */ | |
1133 | ||
1134 | /* first we compress */ | |
1135 | if (s->compress != NULL) { | |
1136 | if (!ssl3_do_compress(s)) { | |
1137 | SSLerr(SSL_F_DO_DTLS1_WRITE, SSL_R_COMPRESSION_FAILURE); | |
1138 | goto err; | |
1139 | } | |
1140 | } else { | |
1141 | memcpy(wr->data, wr->input, wr->length); | |
1142 | wr->input = wr->data; | |
1143 | } | |
36d16f8e | 1144 | |
0f113f3e MC |
1145 | /* |
1146 | * we should still have the output to wr->data and the input from | |
1147 | * wr->input. Length should be wr->length. wr->data still points in the | |
1148 | * wb->buf | |
1149 | */ | |
36d16f8e | 1150 | |
0f113f3e MC |
1151 | if (mac_size != 0) { |
1152 | if (s->method->ssl3_enc->mac(s, &(p[wr->length + eivlen]), 1) < 0) | |
1153 | goto err; | |
1154 | wr->length += mac_size; | |
1155 | } | |
36d16f8e | 1156 | |
0f113f3e MC |
1157 | /* this is true regardless of mac size */ |
1158 | wr->input = p; | |
1159 | wr->data = p; | |
36d16f8e | 1160 | |
0f113f3e MC |
1161 | if (eivlen) |
1162 | wr->length += eivlen; | |
36d16f8e | 1163 | |
0f113f3e MC |
1164 | if (s->method->ssl3_enc->enc(s, 1) < 1) |
1165 | goto err; | |
36d16f8e | 1166 | |
0f113f3e MC |
1167 | /* record length after mac and block padding */ |
1168 | /* | |
1169 | * if (type == SSL3_RT_APPLICATION_DATA || (type == SSL3_RT_ALERT && ! | |
1170 | * SSL_in_init(s))) | |
1171 | */ | |
36d16f8e | 1172 | |
0f113f3e | 1173 | /* there's only one epoch between handshake and app data */ |
36d16f8e | 1174 | |
0f113f3e | 1175 | s2n(s->d1->w_epoch, pseq); |
36d16f8e | 1176 | |
0f113f3e MC |
1177 | /* XDTLS: ?? */ |
1178 | /* | |
1179 | * else s2n(s->d1->handshake_epoch, pseq); | |
1180 | */ | |
36d16f8e | 1181 | |
0f113f3e MC |
1182 | memcpy(pseq, &(s->s3->write_sequence[2]), 6); |
1183 | pseq += 6; | |
1184 | s2n(wr->length, pseq); | |
36d16f8e | 1185 | |
0f113f3e MC |
1186 | if (s->msg_callback) |
1187 | s->msg_callback(1, 0, SSL3_RT_HEADER, pseq - DTLS1_RT_HEADER_LENGTH, | |
1188 | DTLS1_RT_HEADER_LENGTH, s, s->msg_callback_arg); | |
36d16f8e | 1189 | |
0f113f3e MC |
1190 | /* |
1191 | * we should now have wr->data pointing to the encrypted data, which is | |
1192 | * wr->length long | |
1193 | */ | |
1194 | wr->type = type; /* not needed but helps for debugging */ | |
1195 | wr->length += DTLS1_RT_HEADER_LENGTH; | |
36d16f8e | 1196 | |
0f113f3e | 1197 | ssl3_record_sequence_update(&(s->s3->write_sequence[0])); |
36d16f8e | 1198 | |
0f113f3e MC |
1199 | if (create_empty_fragment) { |
1200 | /* | |
1201 | * we are in a recursive call; just return the length, don't write | |
1202 | * out anything here | |
1203 | */ | |
1204 | return wr->length; | |
1205 | } | |
36d16f8e | 1206 | |
0f113f3e MC |
1207 | /* now let's set up wb */ |
1208 | wb->left = prefix_len + wr->length; | |
1209 | wb->offset = 0; | |
1210 | ||
1211 | /* | |
1212 | * memorize arguments so that ssl3_write_pending can detect bad write | |
1213 | * retries later | |
1214 | */ | |
1215 | s->s3->wpend_tot = len; | |
1216 | s->s3->wpend_buf = buf; | |
1217 | s->s3->wpend_type = type; | |
1218 | s->s3->wpend_ret = len; | |
1219 | ||
1220 | /* we now just need to write the buffer */ | |
1221 | return ssl3_write_pending(s, type, buf, len); | |
1222 | err: | |
1223 | return -1; | |
1224 | } | |
36d16f8e | 1225 | |
fe589e61 | 1226 | int dtls1_record_replay_check(SSL *s, DTLS1_BITMAP *bitmap) |
0f113f3e MC |
1227 | { |
1228 | int cmp; | |
1229 | unsigned int shift; | |
1230 | const unsigned char *seq = s->s3->read_sequence; | |
1231 | ||
1232 | cmp = satsub64be(seq, bitmap->max_seq_num); | |
1233 | if (cmp > 0) { | |
88c23039 | 1234 | SSL3_RECORD_set_seq_num(&s->rlayer.rrec, seq); |
0f113f3e MC |
1235 | return 1; /* this record in new */ |
1236 | } | |
1237 | shift = -cmp; | |
1238 | if (shift >= sizeof(bitmap->map) * 8) | |
1239 | return 0; /* stale, outside the window */ | |
1240 | else if (bitmap->map & (1UL << shift)) | |
1241 | return 0; /* record previously received */ | |
1242 | ||
88c23039 | 1243 | SSL3_RECORD_set_seq_num(&s->rlayer.rrec, seq); |
0f113f3e MC |
1244 | return 1; |
1245 | } | |
1246 | ||
fe589e61 | 1247 | void dtls1_record_bitmap_update(SSL *s, DTLS1_BITMAP *bitmap) |
0f113f3e MC |
1248 | { |
1249 | int cmp; | |
1250 | unsigned int shift; | |
1251 | const unsigned char *seq = s->s3->read_sequence; | |
1252 | ||
1253 | cmp = satsub64be(seq, bitmap->max_seq_num); | |
1254 | if (cmp > 0) { | |
1255 | shift = cmp; | |
1256 | if (shift < sizeof(bitmap->map) * 8) | |
1257 | bitmap->map <<= shift, bitmap->map |= 1UL; | |
1258 | else | |
1259 | bitmap->map = 1UL; | |
1260 | memcpy(bitmap->max_seq_num, seq, 8); | |
1261 | } else { | |
1262 | shift = -cmp; | |
1263 | if (shift < sizeof(bitmap->map) * 8) | |
1264 | bitmap->map |= 1UL << shift; | |
1265 | } | |
1266 | } | |
1267 | ||
fe589e61 | 1268 | DTLS1_BITMAP *dtls1_get_bitmap(SSL *s, SSL3_RECORD *rr, |
0f113f3e MC |
1269 | unsigned int *is_next_epoch) |
1270 | { | |
1271 | ||
36d16f8e BL |
1272 | *is_next_epoch = 0; |
1273 | ||
1274 | /* In current epoch, accept HM, CCS, DATA, & ALERT */ | |
1275 | if (rr->epoch == s->d1->r_epoch) | |
1276 | return &s->d1->bitmap; | |
1277 | ||
1278 | /* Only HM and ALERT messages can be from the next epoch */ | |
6c61726b | 1279 | else if (rr->epoch == (unsigned long)(s->d1->r_epoch + 1) && |
0f113f3e | 1280 | (rr->type == SSL3_RT_HANDSHAKE || rr->type == SSL3_RT_ALERT)) { |
36d16f8e BL |
1281 | *is_next_epoch = 1; |
1282 | return &s->d1->next_bitmap; | |
0f113f3e | 1283 | } |
36d16f8e BL |
1284 | |
1285 | return NULL; | |
0f113f3e | 1286 | } |
36d16f8e | 1287 | |
0f113f3e MC |
1288 | void dtls1_reset_seq_numbers(SSL *s, int rw) |
1289 | { | |
1290 | unsigned char *seq; | |
1291 | unsigned int seq_bytes = sizeof(s->s3->read_sequence); | |
1292 | ||
1293 | if (rw & SSL3_CC_READ) { | |
1294 | seq = s->s3->read_sequence; | |
1295 | s->d1->r_epoch++; | |
1296 | memcpy(&(s->d1->bitmap), &(s->d1->next_bitmap), sizeof(DTLS1_BITMAP)); | |
1297 | memset(&(s->d1->next_bitmap), 0x00, sizeof(DTLS1_BITMAP)); | |
1298 | } else { | |
1299 | seq = s->s3->write_sequence; | |
1300 | memcpy(s->d1->last_write_sequence, seq, | |
1301 | sizeof(s->s3->write_sequence)); | |
1302 | s->d1->w_epoch++; | |
1303 | } | |
1304 | ||
1305 | memset(seq, 0x00, seq_bytes); | |
1306 | } |