Encapsulate s->s3->wrec
[openssl.git] / ssl / d1_lib.c
1 /* ssl/d1_lib.c */
2 /*
3  * DTLS implementation written by Nagendra Modadugu
4  * (nagendra@cs.stanford.edu) for the OpenSSL project 2005.
5  */
6 /* ====================================================================
7  * Copyright (c) 1999-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
60 #include <stdio.h>
61 #define USE_SOCKETS
62 #include <openssl/objects.h>
63 #include "ssl_locl.h"
64
65 #if defined(OPENSSL_SYS_VMS)
66 # include <sys/timeb.h>
67 #endif
68
69 static void get_current_time(struct timeval *t);
70 static int dtls1_set_handshake_header(SSL *s, int type, unsigned long len);
71 static int dtls1_handshake_write(SSL *s);
72 const char dtls1_version_str[] = "DTLSv1" OPENSSL_VERSION_PTEXT;
73 int dtls1_listen(SSL *s, struct sockaddr *client);
74
75 const SSL3_ENC_METHOD DTLSv1_enc_data = {
76     tls1_enc,
77     tls1_mac,
78     tls1_setup_key_block,
79     tls1_generate_master_secret,
80     tls1_change_cipher_state,
81     tls1_final_finish_mac,
82     TLS1_FINISH_MAC_LENGTH,
83     tls1_cert_verify_mac,
84     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
85     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
86     tls1_alert_code,
87     tls1_export_keying_material,
88     SSL_ENC_FLAG_DTLS | SSL_ENC_FLAG_EXPLICIT_IV,
89     DTLS1_HM_HEADER_LENGTH,
90     dtls1_set_handshake_header,
91     dtls1_handshake_write
92 };
93
94 const SSL3_ENC_METHOD DTLSv1_2_enc_data = {
95     tls1_enc,
96     tls1_mac,
97     tls1_setup_key_block,
98     tls1_generate_master_secret,
99     tls1_change_cipher_state,
100     tls1_final_finish_mac,
101     TLS1_FINISH_MAC_LENGTH,
102     tls1_cert_verify_mac,
103     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
104     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
105     tls1_alert_code,
106     tls1_export_keying_material,
107     SSL_ENC_FLAG_DTLS | SSL_ENC_FLAG_EXPLICIT_IV | SSL_ENC_FLAG_SIGALGS
108         | SSL_ENC_FLAG_SHA256_PRF | SSL_ENC_FLAG_TLS1_2_CIPHERS,
109     DTLS1_HM_HEADER_LENGTH,
110     dtls1_set_handshake_header,
111     dtls1_handshake_write
112 };
113
114 long dtls1_default_timeout(void)
115 {
116     /*
117      * 2 hours, the 24 hours mentioned in the DTLSv1 spec is way too long for
118      * http, the cache would over fill
119      */
120     return (60 * 60 * 2);
121 }
122
123 int dtls1_new(SSL *s)
124 {
125     DTLS1_STATE *d1;
126
127     if (!ssl3_new(s))
128         return (0);
129     if ((d1 = OPENSSL_malloc(sizeof *d1)) == NULL) {
130         ssl3_free(s);
131         return (0);
132     }
133     memset(d1, 0, sizeof *d1);
134
135     /* d1->handshake_epoch=0; */
136
137     d1->unprocessed_rcds.q = pqueue_new();
138     d1->processed_rcds.q = pqueue_new();
139     d1->buffered_messages = pqueue_new();
140     d1->sent_messages = pqueue_new();
141     d1->buffered_app_data.q = pqueue_new();
142
143     if (s->server) {
144         d1->cookie_len = sizeof(s->d1->cookie);
145     }
146
147     d1->link_mtu = 0;
148     d1->mtu = 0;
149
150     if (!d1->unprocessed_rcds.q || !d1->processed_rcds.q
151         || !d1->buffered_messages || !d1->sent_messages
152         || !d1->buffered_app_data.q) {
153         if (d1->unprocessed_rcds.q)
154             pqueue_free(d1->unprocessed_rcds.q);
155         if (d1->processed_rcds.q)
156             pqueue_free(d1->processed_rcds.q);
157         if (d1->buffered_messages)
158             pqueue_free(d1->buffered_messages);
159         if (d1->sent_messages)
160             pqueue_free(d1->sent_messages);
161         if (d1->buffered_app_data.q)
162             pqueue_free(d1->buffered_app_data.q);
163         OPENSSL_free(d1);
164         ssl3_free(s);
165         return (0);
166     }
167
168     s->d1 = d1;
169     s->method->ssl_clear(s);
170     return (1);
171 }
172
173 static void dtls1_clear_queues(SSL *s)
174 {
175     pitem *item = NULL;
176     hm_fragment *frag = NULL;
177     DTLS1_RECORD_DATA *rdata;
178
179     while ((item = pqueue_pop(s->d1->unprocessed_rcds.q)) != NULL) {
180         rdata = (DTLS1_RECORD_DATA *)item->data;
181         if (rdata->rbuf.buf) {
182             OPENSSL_free(rdata->rbuf.buf);
183         }
184         OPENSSL_free(item->data);
185         pitem_free(item);
186     }
187
188     while ((item = pqueue_pop(s->d1->processed_rcds.q)) != NULL) {
189         rdata = (DTLS1_RECORD_DATA *)item->data;
190         if (rdata->rbuf.buf) {
191             OPENSSL_free(rdata->rbuf.buf);
192         }
193         OPENSSL_free(item->data);
194         pitem_free(item);
195     }
196
197     while ((item = pqueue_pop(s->d1->buffered_messages)) != NULL) {
198         frag = (hm_fragment *)item->data;
199         dtls1_hm_fragment_free(frag);
200         pitem_free(item);
201     }
202
203     while ((item = pqueue_pop(s->d1->sent_messages)) != NULL) {
204         frag = (hm_fragment *)item->data;
205         dtls1_hm_fragment_free(frag);
206         pitem_free(item);
207     }
208
209     while ((item = pqueue_pop(s->d1->buffered_app_data.q)) != NULL) {
210         rdata = (DTLS1_RECORD_DATA *)item->data;
211         if (rdata->rbuf.buf) {
212             OPENSSL_free(rdata->rbuf.buf);
213         }
214         OPENSSL_free(item->data);
215         pitem_free(item);
216     }
217 }
218
219 void dtls1_free(SSL *s)
220 {
221     ssl3_free(s);
222
223     dtls1_clear_queues(s);
224
225     pqueue_free(s->d1->unprocessed_rcds.q);
226     pqueue_free(s->d1->processed_rcds.q);
227     pqueue_free(s->d1->buffered_messages);
228     pqueue_free(s->d1->sent_messages);
229     pqueue_free(s->d1->buffered_app_data.q);
230
231     OPENSSL_free(s->d1);
232     s->d1 = NULL;
233 }
234
235 void dtls1_clear(SSL *s)
236 {
237     pqueue unprocessed_rcds;
238     pqueue processed_rcds;
239     pqueue buffered_messages;
240     pqueue sent_messages;
241     pqueue buffered_app_data;
242     unsigned int mtu;
243     unsigned int link_mtu;
244
245     if (s->d1) {
246         unprocessed_rcds = s->d1->unprocessed_rcds.q;
247         processed_rcds = s->d1->processed_rcds.q;
248         buffered_messages = s->d1->buffered_messages;
249         sent_messages = s->d1->sent_messages;
250         buffered_app_data = s->d1->buffered_app_data.q;
251         mtu = s->d1->mtu;
252         link_mtu = s->d1->link_mtu;
253
254         dtls1_clear_queues(s);
255
256         memset(s->d1, 0, sizeof(*(s->d1)));
257
258         if (s->server) {
259             s->d1->cookie_len = sizeof(s->d1->cookie);
260         }
261
262         if (SSL_get_options(s) & SSL_OP_NO_QUERY_MTU) {
263             s->d1->mtu = mtu;
264             s->d1->link_mtu = link_mtu;
265         }
266
267         s->d1->unprocessed_rcds.q = unprocessed_rcds;
268         s->d1->processed_rcds.q = processed_rcds;
269         s->d1->buffered_messages = buffered_messages;
270         s->d1->sent_messages = sent_messages;
271         s->d1->buffered_app_data.q = buffered_app_data;
272     }
273
274     ssl3_clear(s);
275     if (s->options & SSL_OP_CISCO_ANYCONNECT)
276         s->client_version = s->version = DTLS1_BAD_VER;
277     else if (s->method->version == DTLS_ANY_VERSION)
278         s->version = DTLS1_2_VERSION;
279     else
280         s->version = s->method->version;
281 }
282
283 long dtls1_ctrl(SSL *s, int cmd, long larg, void *parg)
284 {
285     int ret = 0;
286
287     switch (cmd) {
288     case DTLS_CTRL_GET_TIMEOUT:
289         if (dtls1_get_timeout(s, (struct timeval *)parg) != NULL) {
290             ret = 1;
291         }
292         break;
293     case DTLS_CTRL_HANDLE_TIMEOUT:
294         ret = dtls1_handle_timeout(s);
295         break;
296     case DTLS_CTRL_LISTEN:
297         ret = dtls1_listen(s, parg);
298         break;
299     case SSL_CTRL_CHECK_PROTO_VERSION:
300         /*
301          * For library-internal use; checks that the current protocol is the
302          * highest enabled version (according to s->ctx->method, as version
303          * negotiation may have changed s->method).
304          */
305         if (s->version == s->ctx->method->version)
306             return 1;
307         /*
308          * Apparently we're using a version-flexible SSL_METHOD (not at its
309          * highest protocol version).
310          */
311         if (s->ctx->method->version == DTLS_method()->version) {
312 #if DTLS_MAX_VERSION != DTLS1_2_VERSION
313 # error Code needs update for DTLS_method() support beyond DTLS1_2_VERSION.
314 #endif
315             if (!(s->options & SSL_OP_NO_DTLSv1_2))
316                 return s->version == DTLS1_2_VERSION;
317             if (!(s->options & SSL_OP_NO_DTLSv1))
318                 return s->version == DTLS1_VERSION;
319         }
320         return 0;               /* Unexpected state; fail closed. */
321     case DTLS_CTRL_SET_LINK_MTU:
322         if (larg < (long)dtls1_link_min_mtu())
323             return 0;
324         s->d1->link_mtu = larg;
325         return 1;
326     case DTLS_CTRL_GET_LINK_MIN_MTU:
327         return (long)dtls1_link_min_mtu();
328     case SSL_CTRL_SET_MTU:
329         /*
330          *  We may not have a BIO set yet so can't call dtls1_min_mtu()
331          *  We'll have to make do with dtls1_link_min_mtu() and max overhead
332          */
333         if (larg < (long)dtls1_link_min_mtu() - DTLS1_MAX_MTU_OVERHEAD)
334             return 0;
335         s->d1->mtu = larg;
336         return larg;
337     default:
338         ret = ssl3_ctrl(s, cmd, larg, parg);
339         break;
340     }
341     return (ret);
342 }
343
344 /*
345  * As it's impossible to use stream ciphers in "datagram" mode, this
346  * simple filter is designed to disengage them in DTLS. Unfortunately
347  * there is no universal way to identify stream SSL_CIPHER, so we have
348  * to explicitly list their SSL_* codes. Currently RC4 is the only one
349  * available, but if new ones emerge, they will have to be added...
350  */
351 const SSL_CIPHER *dtls1_get_cipher(unsigned int u)
352 {
353     const SSL_CIPHER *ciph = ssl3_get_cipher(u);
354
355     if (ciph != NULL) {
356         if (ciph->algorithm_enc == SSL_RC4)
357             return NULL;
358     }
359
360     return ciph;
361 }
362
363 void dtls1_start_timer(SSL *s)
364 {
365 #ifndef OPENSSL_NO_SCTP
366     /* Disable timer for SCTP */
367     if (BIO_dgram_is_sctp(SSL_get_wbio(s))) {
368         memset(&(s->d1->next_timeout), 0, sizeof(struct timeval));
369         return;
370     }
371 #endif
372
373     /* If timer is not set, initialize duration with 1 second */
374     if (s->d1->next_timeout.tv_sec == 0 && s->d1->next_timeout.tv_usec == 0) {
375         s->d1->timeout_duration = 1;
376     }
377
378     /* Set timeout to current time */
379     get_current_time(&(s->d1->next_timeout));
380
381     /* Add duration to current time */
382     s->d1->next_timeout.tv_sec += s->d1->timeout_duration;
383     BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0,
384              &(s->d1->next_timeout));
385 }
386
387 struct timeval *dtls1_get_timeout(SSL *s, struct timeval *timeleft)
388 {
389     struct timeval timenow;
390
391     /* If no timeout is set, just return NULL */
392     if (s->d1->next_timeout.tv_sec == 0 && s->d1->next_timeout.tv_usec == 0) {
393         return NULL;
394     }
395
396     /* Get current time */
397     get_current_time(&timenow);
398
399     /* If timer already expired, set remaining time to 0 */
400     if (s->d1->next_timeout.tv_sec < timenow.tv_sec ||
401         (s->d1->next_timeout.tv_sec == timenow.tv_sec &&
402          s->d1->next_timeout.tv_usec <= timenow.tv_usec)) {
403         memset(timeleft, 0, sizeof(struct timeval));
404         return timeleft;
405     }
406
407     /* Calculate time left until timer expires */
408     memcpy(timeleft, &(s->d1->next_timeout), sizeof(struct timeval));
409     timeleft->tv_sec -= timenow.tv_sec;
410     timeleft->tv_usec -= timenow.tv_usec;
411     if (timeleft->tv_usec < 0) {
412         timeleft->tv_sec--;
413         timeleft->tv_usec += 1000000;
414     }
415
416     /*
417      * If remaining time is less than 15 ms, set it to 0 to prevent issues
418      * because of small devergences with socket timeouts.
419      */
420     if (timeleft->tv_sec == 0 && timeleft->tv_usec < 15000) {
421         memset(timeleft, 0, sizeof(struct timeval));
422     }
423
424     return timeleft;
425 }
426
427 int dtls1_is_timer_expired(SSL *s)
428 {
429     struct timeval timeleft;
430
431     /* Get time left until timeout, return false if no timer running */
432     if (dtls1_get_timeout(s, &timeleft) == NULL) {
433         return 0;
434     }
435
436     /* Return false if timer is not expired yet */
437     if (timeleft.tv_sec > 0 || timeleft.tv_usec > 0) {
438         return 0;
439     }
440
441     /* Timer expired, so return true */
442     return 1;
443 }
444
445 void dtls1_double_timeout(SSL *s)
446 {
447     s->d1->timeout_duration *= 2;
448     if (s->d1->timeout_duration > 60)
449         s->d1->timeout_duration = 60;
450     dtls1_start_timer(s);
451 }
452
453 void dtls1_stop_timer(SSL *s)
454 {
455     /* Reset everything */
456     memset(&(s->d1->timeout), 0, sizeof(struct dtls1_timeout_st));
457     memset(&(s->d1->next_timeout), 0, sizeof(struct timeval));
458     s->d1->timeout_duration = 1;
459     BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0,
460              &(s->d1->next_timeout));
461     /* Clear retransmission buffer */
462     dtls1_clear_record_buffer(s);
463 }
464
465 int dtls1_check_timeout_num(SSL *s)
466 {
467     unsigned int mtu;
468
469     s->d1->timeout.num_alerts++;
470
471     /* Reduce MTU after 2 unsuccessful retransmissions */
472     if (s->d1->timeout.num_alerts > 2
473         && !(SSL_get_options(s) & SSL_OP_NO_QUERY_MTU)) {
474         mtu =
475             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_GET_FALLBACK_MTU, 0,
476                      NULL);
477         if (mtu < s->d1->mtu)
478             s->d1->mtu = mtu;
479     }
480
481     if (s->d1->timeout.num_alerts > DTLS1_TMO_ALERT_COUNT) {
482         /* fail the connection, enough alerts have been sent */
483         SSLerr(SSL_F_DTLS1_CHECK_TIMEOUT_NUM, SSL_R_READ_TIMEOUT_EXPIRED);
484         return -1;
485     }
486
487     return 0;
488 }
489
490 int dtls1_handle_timeout(SSL *s)
491 {
492     /* if no timer is expired, don't do anything */
493     if (!dtls1_is_timer_expired(s)) {
494         return 0;
495     }
496
497     dtls1_double_timeout(s);
498
499     if (dtls1_check_timeout_num(s) < 0)
500         return -1;
501
502     s->d1->timeout.read_timeouts++;
503     if (s->d1->timeout.read_timeouts > DTLS1_TMO_READ_COUNT) {
504         s->d1->timeout.read_timeouts = 1;
505     }
506 #ifndef OPENSSL_NO_HEARTBEATS
507     if (s->tlsext_hb_pending) {
508         s->tlsext_hb_pending = 0;
509         return dtls1_heartbeat(s);
510     }
511 #endif
512
513     dtls1_start_timer(s);
514     return dtls1_retransmit_buffered_messages(s);
515 }
516
517 static void get_current_time(struct timeval *t)
518 {
519 #if defined(_WIN32)
520     SYSTEMTIME st;
521     union {
522         unsigned __int64 ul;
523         FILETIME ft;
524     } now;
525
526     GetSystemTime(&st);
527     SystemTimeToFileTime(&st, &now.ft);
528 # ifdef  __MINGW32__
529     now.ul -= 116444736000000000ULL;
530 # else
531     now.ul -= 116444736000000000UI64; /* re-bias to 1/1/1970 */
532 # endif
533     t->tv_sec = (long)(now.ul / 10000000);
534     t->tv_usec = ((int)(now.ul % 10000000)) / 10;
535 #elif defined(OPENSSL_SYS_VMS)
536     struct timeb tb;
537     ftime(&tb);
538     t->tv_sec = (long)tb.time;
539     t->tv_usec = (long)tb.millitm * 1000;
540 #else
541     gettimeofday(t, NULL);
542 #endif
543 }
544
545 int dtls1_listen(SSL *s, struct sockaddr *client)
546 {
547     int ret;
548
549     /* Ensure there is no state left over from a previous invocation */
550     if(!SSL_clear(s))
551         return -1;
552
553     SSL_set_options(s, SSL_OP_COOKIE_EXCHANGE);
554     s->d1->listen = 1;
555
556     ret = SSL_accept(s);
557     if (ret <= 0)
558         return ret;
559
560     (void)BIO_dgram_get_peer(SSL_get_rbio(s), client);
561     return 1;
562 }
563
564 static int dtls1_set_handshake_header(SSL *s, int htype, unsigned long len)
565 {
566     unsigned char *p = (unsigned char *)s->init_buf->data;
567     dtls1_set_message_header(s, p, htype, len, 0, len);
568     s->init_num = (int)len + DTLS1_HM_HEADER_LENGTH;
569     s->init_off = 0;
570     /* Buffer the message to handle re-xmits */
571
572     if(!dtls1_buffer_message(s, 0))
573         return 0;
574
575     return 1;
576 }
577
578 static int dtls1_handshake_write(SSL *s)
579 {
580     return dtls1_do_write(s, SSL3_RT_HANDSHAKE);
581 }