a510b5bebe6e234f7e079d81b35ab16436e38a88
[oweals/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 <openssl/rand.h>
64 #include "ssl_locl.h"
65
66 #if defined(OPENSSL_SYS_VMS)
67 # include <sys/timeb.h>
68 #elif defined(OPENSSL_SYS_NETWARE) && !defined(_WINSOCK2API_)
69 # include <sys/timeval.h>
70 #elif defined(OPENSSL_SYS_VXWORKS)
71 # include <sys/times.h>
72 #elif !defined(OPENSSL_SYS_WIN32)
73 # include <sys/time.h>
74 #endif
75
76 static void get_current_time(struct timeval *t);
77 static int dtls1_set_handshake_header(SSL *s, int type, unsigned long len);
78 static int dtls1_handshake_write(SSL *s);
79 int dtls1_listen(SSL *s, struct sockaddr *client);
80 static unsigned int dtls1_link_min_mtu(void);
81
82 /* XDTLS:  figure out the right values */
83 static const unsigned int g_probable_mtu[] = { 1500, 512, 256 };
84
85 const SSL3_ENC_METHOD DTLSv1_enc_data = {
86     tls1_enc,
87     tls1_mac,
88     tls1_setup_key_block,
89     tls1_generate_master_secret,
90     tls1_change_cipher_state,
91     tls1_final_finish_mac,
92     TLS1_FINISH_MAC_LENGTH,
93     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
94     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
95     tls1_alert_code,
96     tls1_export_keying_material,
97     SSL_ENC_FLAG_DTLS | SSL_ENC_FLAG_EXPLICIT_IV,
98     DTLS1_HM_HEADER_LENGTH,
99     dtls1_set_handshake_header,
100     dtls1_handshake_write
101 };
102
103 const SSL3_ENC_METHOD DTLSv1_2_enc_data = {
104     tls1_enc,
105     tls1_mac,
106     tls1_setup_key_block,
107     tls1_generate_master_secret,
108     tls1_change_cipher_state,
109     tls1_final_finish_mac,
110     TLS1_FINISH_MAC_LENGTH,
111     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
112     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
113     tls1_alert_code,
114     tls1_export_keying_material,
115     SSL_ENC_FLAG_DTLS | SSL_ENC_FLAG_EXPLICIT_IV | SSL_ENC_FLAG_SIGALGS
116         | SSL_ENC_FLAG_SHA256_PRF | SSL_ENC_FLAG_TLS1_2_CIPHERS,
117     DTLS1_HM_HEADER_LENGTH,
118     dtls1_set_handshake_header,
119     dtls1_handshake_write
120 };
121
122 long dtls1_default_timeout(void)
123 {
124     /*
125      * 2 hours, the 24 hours mentioned in the DTLSv1 spec is way too long for
126      * http, the cache would over fill
127      */
128     return (60 * 60 * 2);
129 }
130
131 int dtls1_new(SSL *s)
132 {
133     DTLS1_STATE *d1;
134
135     if (!DTLS_RECORD_LAYER_new(&s->rlayer)) {
136         return 0;
137     }
138     
139     if (!ssl3_new(s))
140         return (0);
141     if ((d1 = OPENSSL_zalloc(sizeof(*d1))) == NULL) {
142         ssl3_free(s);
143         return (0);
144     }
145
146     d1->buffered_messages = pqueue_new();
147     d1->sent_messages = pqueue_new();
148
149     if (s->server) {
150         d1->cookie_len = sizeof(s->d1->cookie);
151     }
152
153     d1->link_mtu = 0;
154     d1->mtu = 0;
155
156     if (d1->buffered_messages == NULL || d1->sent_messages == NULL) {
157         pqueue_free(d1->buffered_messages);
158         pqueue_free(d1->sent_messages);
159         OPENSSL_free(d1);
160         ssl3_free(s);
161         return (0);
162     }
163
164     s->d1 = d1;
165     s->method->ssl_clear(s);
166     return (1);
167 }
168
169 static void dtls1_clear_queues(SSL *s)
170 {
171     pitem *item = NULL;
172     hm_fragment *frag = NULL;
173
174     while ((item = pqueue_pop(s->d1->buffered_messages)) != NULL) {
175         frag = (hm_fragment *)item->data;
176         dtls1_hm_fragment_free(frag);
177         pitem_free(item);
178     }
179
180     while ((item = pqueue_pop(s->d1->sent_messages)) != NULL) {
181         frag = (hm_fragment *)item->data;
182         dtls1_hm_fragment_free(frag);
183         pitem_free(item);
184     }
185 }
186
187 void dtls1_free(SSL *s)
188 {
189     DTLS_RECORD_LAYER_free(&s->rlayer);
190
191     ssl3_free(s);
192
193     dtls1_clear_queues(s);
194
195     pqueue_free(s->d1->buffered_messages);
196     pqueue_free(s->d1->sent_messages);
197
198     OPENSSL_free(s->d1);
199     s->d1 = NULL;
200 }
201
202 void dtls1_clear(SSL *s)
203 {
204     pqueue buffered_messages;
205     pqueue sent_messages;
206     unsigned int mtu;
207     unsigned int link_mtu;
208
209     DTLS_RECORD_LAYER_clear(&s->rlayer);
210
211     if (s->d1) {
212         buffered_messages = s->d1->buffered_messages;
213         sent_messages = s->d1->sent_messages;
214         mtu = s->d1->mtu;
215         link_mtu = s->d1->link_mtu;
216
217         dtls1_clear_queues(s);
218
219         memset(s->d1, 0, sizeof(*s->d1));
220
221         if (s->server) {
222             s->d1->cookie_len = sizeof(s->d1->cookie);
223         }
224
225         if (SSL_get_options(s) & SSL_OP_NO_QUERY_MTU) {
226             s->d1->mtu = mtu;
227             s->d1->link_mtu = link_mtu;
228         }
229
230         s->d1->buffered_messages = buffered_messages;
231         s->d1->sent_messages = sent_messages;
232     }
233
234     ssl3_clear(s);
235     if (s->options & SSL_OP_CISCO_ANYCONNECT)
236         s->client_version = s->version = DTLS1_BAD_VER;
237     else if (s->method->version == DTLS_ANY_VERSION)
238         s->version = DTLS1_2_VERSION;
239     else
240         s->version = s->method->version;
241 }
242
243 long dtls1_ctrl(SSL *s, int cmd, long larg, void *parg)
244 {
245     int ret = 0;
246
247     switch (cmd) {
248     case DTLS_CTRL_GET_TIMEOUT:
249         if (dtls1_get_timeout(s, (struct timeval *)parg) != NULL) {
250             ret = 1;
251         }
252         break;
253     case DTLS_CTRL_HANDLE_TIMEOUT:
254         ret = dtls1_handle_timeout(s);
255         break;
256     case DTLS_CTRL_LISTEN:
257         ret = dtls1_listen(s, parg);
258         break;
259     case SSL_CTRL_CHECK_PROTO_VERSION:
260         /*
261          * For library-internal use; checks that the current protocol is the
262          * is the highest enabled version.
263          */
264         if (s->max_proto_version == 0 && s->version == DTLS_MAX_VERSION)
265             return 1;
266         if (s->max_proto_version != 0 && s->version == s->max_proto_version)
267             return 1;
268         /* We're not limited by the max_proto_version but might still have
269          * other reasons why we use an older version like not using a
270          * version-flexible SSL_METHOD.  Check s->ctx->method as version
271          * negotiation may have changed s->method.
272          * This check can be removed when we only have version-flexible
273          * SSL_METHODs
274          */
275         if (s->version == s->ctx->method->version)
276             return 1;
277         /*
278          * Apparently we're using a version-flexible SSL_METHOD (not at its
279          * highest protocol version, not limited by max_proto_version).
280          */
281         if (s->ctx->method->version == DTLS_method()->version) {
282 #if DTLS_MAX_VERSION != DTLS1_2_VERSION
283 # error Code needs update for DTLS_method() support beyond DTLS1_2_VERSION.
284 #endif
285             if (!(s->options & SSL_OP_NO_DTLSv1_2))
286                 return s->version == DTLS1_2_VERSION;
287             if (!(s->options & SSL_OP_NO_DTLSv1))
288                 return s->version == DTLS1_VERSION;
289         }
290         return 0;               /* Unexpected state; fail closed. */
291     case DTLS_CTRL_SET_LINK_MTU:
292         if (larg < (long)dtls1_link_min_mtu())
293             return 0;
294         s->d1->link_mtu = larg;
295         return 1;
296     case DTLS_CTRL_GET_LINK_MIN_MTU:
297         return (long)dtls1_link_min_mtu();
298     case SSL_CTRL_SET_MTU:
299         /*
300          *  We may not have a BIO set yet so can't call dtls1_min_mtu()
301          *  We'll have to make do with dtls1_link_min_mtu() and max overhead
302          */
303         if (larg < (long)dtls1_link_min_mtu() - DTLS1_MAX_MTU_OVERHEAD)
304             return 0;
305         s->d1->mtu = larg;
306         return larg;
307     default:
308         ret = ssl3_ctrl(s, cmd, larg, parg);
309         break;
310     }
311     return (ret);
312 }
313
314 /*
315  * As it's impossible to use stream ciphers in "datagram" mode, this
316  * simple filter is designed to disengage them in DTLS. Unfortunately
317  * there is no universal way to identify stream SSL_CIPHER, so we have
318  * to explicitly list their SSL_* codes. Currently RC4 is the only one
319  * available, but if new ones emerge, they will have to be added...
320  */
321 const SSL_CIPHER *dtls1_get_cipher(unsigned int u)
322 {
323     const SSL_CIPHER *ciph = ssl3_get_cipher(u);
324
325     if (ciph != NULL) {
326         if (ciph->algorithm_enc == SSL_RC4)
327             return NULL;
328     }
329
330     return ciph;
331 }
332
333 void dtls1_start_timer(SSL *s)
334 {
335 #ifndef OPENSSL_NO_SCTP
336     /* Disable timer for SCTP */
337     if (BIO_dgram_is_sctp(SSL_get_wbio(s))) {
338         memset(&s->d1->next_timeout, 0, sizeof(s->d1->next_timeout));
339         return;
340     }
341 #endif
342
343     /* If timer is not set, initialize duration with 1 second */
344     if (s->d1->next_timeout.tv_sec == 0 && s->d1->next_timeout.tv_usec == 0) {
345         s->d1->timeout_duration = 1;
346     }
347
348     /* Set timeout to current time */
349     get_current_time(&(s->d1->next_timeout));
350
351     /* Add duration to current time */
352     s->d1->next_timeout.tv_sec += s->d1->timeout_duration;
353     BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0,
354              &(s->d1->next_timeout));
355 }
356
357 struct timeval *dtls1_get_timeout(SSL *s, struct timeval *timeleft)
358 {
359     struct timeval timenow;
360
361     /* If no timeout is set, just return NULL */
362     if (s->d1->next_timeout.tv_sec == 0 && s->d1->next_timeout.tv_usec == 0) {
363         return NULL;
364     }
365
366     /* Get current time */
367     get_current_time(&timenow);
368
369     /* If timer already expired, set remaining time to 0 */
370     if (s->d1->next_timeout.tv_sec < timenow.tv_sec ||
371         (s->d1->next_timeout.tv_sec == timenow.tv_sec &&
372          s->d1->next_timeout.tv_usec <= timenow.tv_usec)) {
373         memset(timeleft, 0, sizeof(*timeleft));
374         return timeleft;
375     }
376
377     /* Calculate time left until timer expires */
378     memcpy(timeleft, &(s->d1->next_timeout), sizeof(struct timeval));
379     timeleft->tv_sec -= timenow.tv_sec;
380     timeleft->tv_usec -= timenow.tv_usec;
381     if (timeleft->tv_usec < 0) {
382         timeleft->tv_sec--;
383         timeleft->tv_usec += 1000000;
384     }
385
386     /*
387      * If remaining time is less than 15 ms, set it to 0 to prevent issues
388      * because of small devergences with socket timeouts.
389      */
390     if (timeleft->tv_sec == 0 && timeleft->tv_usec < 15000) {
391         memset(timeleft, 0, sizeof(*timeleft));
392     }
393
394     return timeleft;
395 }
396
397 int dtls1_is_timer_expired(SSL *s)
398 {
399     struct timeval timeleft;
400
401     /* Get time left until timeout, return false if no timer running */
402     if (dtls1_get_timeout(s, &timeleft) == NULL) {
403         return 0;
404     }
405
406     /* Return false if timer is not expired yet */
407     if (timeleft.tv_sec > 0 || timeleft.tv_usec > 0) {
408         return 0;
409     }
410
411     /* Timer expired, so return true */
412     return 1;
413 }
414
415 void dtls1_double_timeout(SSL *s)
416 {
417     s->d1->timeout_duration *= 2;
418     if (s->d1->timeout_duration > 60)
419         s->d1->timeout_duration = 60;
420     dtls1_start_timer(s);
421 }
422
423 void dtls1_stop_timer(SSL *s)
424 {
425     /* Reset everything */
426     memset(&s->d1->timeout, 0, sizeof(s->d1->timeout));
427     memset(&s->d1->next_timeout, 0, sizeof(s->d1->next_timeout));
428     s->d1->timeout_duration = 1;
429     BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0,
430              &(s->d1->next_timeout));
431     /* Clear retransmission buffer */
432     dtls1_clear_record_buffer(s);
433 }
434
435 int dtls1_check_timeout_num(SSL *s)
436 {
437     unsigned int mtu;
438
439     s->d1->timeout.num_alerts++;
440
441     /* Reduce MTU after 2 unsuccessful retransmissions */
442     if (s->d1->timeout.num_alerts > 2
443         && !(SSL_get_options(s) & SSL_OP_NO_QUERY_MTU)) {
444         mtu =
445             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_GET_FALLBACK_MTU, 0,
446                      NULL);
447         if (mtu < s->d1->mtu)
448             s->d1->mtu = mtu;
449     }
450
451     if (s->d1->timeout.num_alerts > DTLS1_TMO_ALERT_COUNT) {
452         /* fail the connection, enough alerts have been sent */
453         SSLerr(SSL_F_DTLS1_CHECK_TIMEOUT_NUM, SSL_R_READ_TIMEOUT_EXPIRED);
454         return -1;
455     }
456
457     return 0;
458 }
459
460 int dtls1_handle_timeout(SSL *s)
461 {
462     /* if no timer is expired, don't do anything */
463     if (!dtls1_is_timer_expired(s)) {
464         return 0;
465     }
466
467     dtls1_double_timeout(s);
468
469     if (dtls1_check_timeout_num(s) < 0)
470         return -1;
471
472     s->d1->timeout.read_timeouts++;
473     if (s->d1->timeout.read_timeouts > DTLS1_TMO_READ_COUNT) {
474         s->d1->timeout.read_timeouts = 1;
475     }
476 #ifndef OPENSSL_NO_HEARTBEATS
477     if (s->tlsext_hb_pending) {
478         s->tlsext_hb_pending = 0;
479         return dtls1_heartbeat(s);
480     }
481 #endif
482
483     dtls1_start_timer(s);
484     return dtls1_retransmit_buffered_messages(s);
485 }
486
487 static void get_current_time(struct timeval *t)
488 {
489 #if defined(_WIN32)
490     SYSTEMTIME st;
491     union {
492         unsigned __int64 ul;
493         FILETIME ft;
494     } now;
495
496     GetSystemTime(&st);
497     SystemTimeToFileTime(&st, &now.ft);
498 # ifdef  __MINGW32__
499     now.ul -= 116444736000000000ULL;
500 # else
501     now.ul -= 116444736000000000UI64; /* re-bias to 1/1/1970 */
502 # endif
503     t->tv_sec = (long)(now.ul / 10000000);
504     t->tv_usec = ((int)(now.ul % 10000000)) / 10;
505 #elif defined(OPENSSL_SYS_VMS)
506     struct timeb tb;
507     ftime(&tb);
508     t->tv_sec = (long)tb.time;
509     t->tv_usec = (long)tb.millitm * 1000;
510 #else
511     gettimeofday(t, NULL);
512 #endif
513 }
514
515
516 #define LISTEN_SUCCESS              2
517 #define LISTEN_SEND_VERIFY_REQUEST  1
518
519
520 int dtls1_listen(SSL *s, struct sockaddr *client)
521 {
522     int next, n, ret = 0, clearpkt = 0;
523     unsigned char cookie[DTLS1_COOKIE_LENGTH];
524     unsigned char seq[SEQ_NUM_SIZE];
525     unsigned char *data, *p, *buf;
526     unsigned long reclen, fragoff, fraglen, msglen;
527     unsigned int rectype, versmajor, msgseq, msgtype, clientvers, cookielen;
528     BIO *rbio, *wbio;
529     BUF_MEM *bufm;
530     struct sockaddr_storage tmpclient;
531     PACKET pkt, msgpkt, msgpayload, session, cookiepkt;
532
533     /* Ensure there is no state left over from a previous invocation */
534     if (!SSL_clear(s))
535         return -1;
536
537     ERR_clear_error();
538
539     rbio = SSL_get_rbio(s);
540     wbio = SSL_get_wbio(s);
541
542     if(!rbio || !wbio) {
543         SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_BIO_NOT_SET);
544         return -1;
545     }
546
547     /*
548      * We only peek at incoming ClientHello's until we're sure we are going to
549      * to respond with a HelloVerifyRequest. If its a ClientHello with a valid
550      * cookie then we leave it in the BIO for dtls1_accept to handle.
551      */
552     BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_PEEK_MODE, 1, NULL);
553
554     /*
555      * Note: This check deliberately excludes DTLS1_BAD_VER because that version
556      * requires the MAC to be calculated *including* the first ClientHello
557      * (without the cookie). Since DTLSv1_listen is stateless that cannot be
558      * supported. DTLS1_BAD_VER must use cookies in a stateful manner (e.g. via
559      * SSL_accept)
560      */
561     if ((s->version & 0xff00) != (DTLS1_VERSION & 0xff00)) {
562         SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_UNSUPPORTED_SSL_VERSION);
563         return -1;
564     }
565
566     if (s->init_buf == NULL) {
567         if ((bufm = BUF_MEM_new()) == NULL) {
568             SSLerr(SSL_F_DTLS1_LISTEN, ERR_R_MALLOC_FAILURE);
569             return -1;
570         }
571
572         if (!BUF_MEM_grow(bufm, SSL3_RT_MAX_PLAIN_LENGTH)) {
573             BUF_MEM_free(bufm);
574             SSLerr(SSL_F_DTLS1_LISTEN, ERR_R_MALLOC_FAILURE);
575             return -1;
576         }
577         s->init_buf = bufm;
578     }
579     buf = (unsigned char *)s->init_buf->data;
580
581     do {
582         /* Get a packet */
583
584         clear_sys_error();
585         /*
586          * Technically a ClientHello could be SSL3_RT_MAX_PLAIN_LENGTH
587          * + DTLS1_RT_HEADER_LENGTH bytes long. Normally init_buf does not store
588          * the record header as well, but we do here. We've set up init_buf to
589          * be the standard size for simplicity. In practice we shouldn't ever
590          * receive a ClientHello as long as this. If we do it will get dropped
591          * in the record length check below.
592          */
593         n = BIO_read(rbio, buf, SSL3_RT_MAX_PLAIN_LENGTH);
594
595         if (n <= 0) {
596             if(BIO_should_retry(rbio)) {
597                 /* Non-blocking IO */
598                 goto end;
599             }
600             return -1;
601         }
602
603         /* If we hit any problems we need to clear this packet from the BIO */
604         clearpkt = 1;
605
606         if (!PACKET_buf_init(&pkt, buf, n)) {
607             SSLerr(SSL_F_DTLS1_LISTEN, ERR_R_INTERNAL_ERROR);
608             return -1;
609         }
610
611         /*
612          * Parse the received record. If there are any problems with it we just
613          * dump it - with no alert. RFC6347 says this "Unlike TLS, DTLS is
614          * resilient in the face of invalid records (e.g., invalid formatting,
615          * length, MAC, etc.).  In general, invalid records SHOULD be silently
616          * discarded, thus preserving the association; however, an error MAY be
617          * logged for diagnostic purposes."
618          */
619
620         /* this packet contained a partial record, dump it */
621         if (n < DTLS1_RT_HEADER_LENGTH) {
622             SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_RECORD_TOO_SMALL);
623             goto end;
624         }
625
626         if (s->msg_callback)
627             s->msg_callback(0, 0, SSL3_RT_HEADER, buf,
628                             DTLS1_RT_HEADER_LENGTH, s, s->msg_callback_arg);
629
630         /* Get the record header */
631         if (!PACKET_get_1(&pkt, &rectype)
632             || !PACKET_get_1(&pkt, &versmajor)) {
633             SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_LENGTH_MISMATCH);
634             goto end;
635         }
636
637         if (rectype != SSL3_RT_HANDSHAKE)  {
638             SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_UNEXPECTED_MESSAGE);
639             goto end;
640         }
641
642         /*
643          * Check record version number. We only check that the major version is
644          * the same.
645          */
646         if (versmajor != DTLS1_VERSION_MAJOR) {
647             SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_BAD_PROTOCOL_VERSION_NUMBER);
648             goto end;
649         }
650
651         if (!PACKET_forward(&pkt, 1)
652             /* Save the sequence number: 64 bits, with top 2 bytes = epoch */
653             || !PACKET_copy_bytes(&pkt, seq, SEQ_NUM_SIZE)
654             || !PACKET_get_length_prefixed_2(&pkt, &msgpkt)
655             || PACKET_remaining(&pkt) != 0) {
656             SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_LENGTH_MISMATCH);
657             goto end;
658         }
659
660         /* This is an initial ClientHello so the epoch has to be 0 */
661         if (seq[0] != 0 || seq[1] != 0) {
662             SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_UNEXPECTED_MESSAGE);
663             goto end;
664         }
665
666         /* Get a pointer to the raw message for the later callback */
667         data = PACKET_data(&msgpkt);
668
669         /* Finished processing the record header, now process the message */
670         if (!PACKET_get_1(&msgpkt, &msgtype)
671             || !PACKET_get_net_3(&msgpkt, &msglen)
672             || !PACKET_get_net_2(&msgpkt, &msgseq)
673             || !PACKET_get_net_3(&msgpkt, &fragoff)
674             || !PACKET_get_net_3(&msgpkt, &fraglen)
675             || !PACKET_get_sub_packet(&msgpkt, &msgpayload, msglen)
676             || PACKET_remaining(&msgpkt) != 0) {
677             SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_LENGTH_MISMATCH);
678             goto end;
679         }
680
681         if (msgtype != SSL3_MT_CLIENT_HELLO) {
682             SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_UNEXPECTED_MESSAGE);
683             goto end;
684         }
685
686         /* Message sequence number can only be 0 or 1 */
687         if(msgseq > 2) {
688             SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_INVALID_SEQUENCE_NUMBER);
689             goto end;
690         }
691
692         /* We don't support a fragmented ClientHello whilst listening */
693         if (fragoff != 0 || fraglen != msglen) {
694             SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_FRAGMENTED_CLIENT_HELLO);
695             goto end;
696         }
697
698         if (s->msg_callback)
699             s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, data,
700                             msglen + DTLS1_HM_HEADER_LENGTH, s,
701                             s->msg_callback_arg);
702
703         if (!PACKET_get_net_2(&msgpayload, &clientvers)) {
704             SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_LENGTH_MISMATCH);
705             goto end;
706         }
707
708         /*
709          * Verify client version is supported
710          */
711         if ((clientvers > (unsigned int)s->method->version &&
712                               s->method->version != DTLS_ANY_VERSION)) {
713             SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_WRONG_VERSION_NUMBER);
714             goto end;
715         }
716
717         if (!PACKET_forward(&msgpayload, SSL3_RANDOM_SIZE)
718             || !PACKET_get_length_prefixed_1(&msgpayload, &session)
719             || !PACKET_get_length_prefixed_1(&msgpayload, &cookiepkt)) {
720             SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_LENGTH_MISMATCH);
721             goto end;
722         }
723
724         /*
725          * Check if we have a cookie or not. If not we need to send a
726          * HelloVerifyRequest.
727          */
728         if (PACKET_remaining(&cookiepkt) == 0) {
729             next = LISTEN_SEND_VERIFY_REQUEST;
730         } else {
731             /*
732              * We have a cookie, so lets check it.
733              */
734             if (s->ctx->app_verify_cookie_cb == NULL) {
735                 SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_NO_VERIFY_COOKIE_CALLBACK);
736                 /* This is fatal */
737                 return -1;
738             }
739             if (s->ctx->app_verify_cookie_cb(s, PACKET_data(&cookiepkt),
740                                              PACKET_remaining(&cookiepkt)) ==
741                 0) {
742                 /*
743                  * We treat invalid cookies in the same was as no cookie as
744                  * per RFC6347
745                  */
746                 next = LISTEN_SEND_VERIFY_REQUEST;
747             } else {
748                 /* Cookie verification succeeded */
749                 next = LISTEN_SUCCESS;
750             }
751         }
752
753         if (next == LISTEN_SEND_VERIFY_REQUEST) {
754             /*
755              * There was no cookie in the ClientHello so we need to send a
756              * HelloVerifyRequest. If this fails we do not worry about trying
757              * to resend, we just drop it.
758              */
759
760             /*
761              * Dump the read packet, we don't need it any more. Ignore return
762              * value
763              */
764             BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_PEEK_MODE, 0, NULL);
765             BIO_read(rbio, buf, SSL3_RT_MAX_PLAIN_LENGTH);
766             BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_PEEK_MODE, 1, NULL);
767
768             /* Generate the cookie */
769             if (s->ctx->app_gen_cookie_cb == NULL ||
770                 s->ctx->app_gen_cookie_cb(s, cookie, &cookielen) == 0 ||
771                 cookielen > 255) {
772                 SSLerr(SSL_F_DTLS1_LISTEN, SSL_R_COOKIE_GEN_CALLBACK_FAILURE);
773                 /* This is fatal */
774                 return -1;
775             }
776
777             p = &buf[DTLS1_RT_HEADER_LENGTH];
778             msglen = dtls_raw_hello_verify_request(p + DTLS1_HM_HEADER_LENGTH,
779                                                    cookie, cookielen);
780
781             *p++ = DTLS1_MT_HELLO_VERIFY_REQUEST;
782
783             /* Message length */
784             l2n3(msglen, p);
785
786             /* Message sequence number is always 0 for a HelloVerifyRequest */
787             s2n(0, p);
788
789             /*
790              * We never fragment a HelloVerifyRequest, so fragment offset is 0
791              * and fragment length is message length
792              */
793             l2n3(0, p);
794             l2n3(msglen, p);
795
796             /* Set reclen equal to length of whole handshake message */
797             reclen = msglen + DTLS1_HM_HEADER_LENGTH;
798
799             /* Add the record header */
800             p = buf;
801
802             *(p++) = SSL3_RT_HANDSHAKE;
803             /*
804              * Special case: for hello verify request, client version 1.0 and we
805              * haven't decided which version to use yet send back using version
806              * 1.0 header: otherwise some clients will ignore it.
807              */
808             if (s->method->version == DTLS_ANY_VERSION) {
809                 *(p++) = DTLS1_VERSION >> 8;
810                 *(p++) = DTLS1_VERSION & 0xff;
811             } else {
812                 *(p++) = s->version >> 8;
813                 *(p++) = s->version & 0xff;
814             }
815
816             /*
817              * Record sequence number is always the same as in the received
818              * ClientHello
819              */
820             memcpy(p, seq, SEQ_NUM_SIZE);
821             p += SEQ_NUM_SIZE;
822
823             /* Length */
824             s2n(reclen, p);
825
826             /*
827              * Set reclen equal to length of whole record including record
828              * header
829              */
830             reclen += DTLS1_RT_HEADER_LENGTH;
831
832             if (s->msg_callback)
833                 s->msg_callback(1, 0, SSL3_RT_HEADER, buf,
834                                 DTLS1_RT_HEADER_LENGTH, s, s->msg_callback_arg);
835
836             /*
837              * This is unneccessary if rbio and wbio are one and the same - but
838              * maybe they're not.
839              */
840             if(BIO_dgram_get_peer(rbio, &tmpclient) <= 0
841                || BIO_dgram_set_peer(wbio, &tmpclient) <= 0) {
842                 SSLerr(SSL_F_DTLS1_LISTEN, ERR_R_INTERNAL_ERROR);
843                 goto end;
844             }
845
846             if (BIO_write(wbio, buf, reclen) < (int)reclen) {
847                 if(BIO_should_retry(wbio)) {
848                     /*
849                      * Non-blocking IO...but we're stateless, so we're just
850                      * going to drop this packet.
851                      */
852                     goto end;
853                 }
854                 return -1;
855             }
856
857             if (BIO_flush(wbio) <= 0) {
858                 if(BIO_should_retry(wbio)) {
859                     /*
860                      * Non-blocking IO...but we're stateless, so we're just
861                      * going to drop this packet.
862                      */
863                     goto end;
864                 }
865                 return -1;
866             }
867         }
868     } while (next != LISTEN_SUCCESS);
869
870     /*
871      * Set expected sequence numbers to continue the handshake.
872      */
873     s->d1->handshake_read_seq = 1;
874     s->d1->handshake_write_seq = 1;
875     s->d1->next_handshake_write_seq = 1;
876     DTLS_RECORD_LAYER_set_write_sequence(&s->rlayer, seq);
877
878     /*
879      * We are doing cookie exchange, so make sure we set that option in the
880      * SSL object
881      */
882     SSL_set_options(s, SSL_OP_COOKIE_EXCHANGE);
883
884     /*
885      * Tell the state machine that we've done the initial hello verify
886      * exchange
887      */
888     ossl_statem_set_hello_verify_done(s);
889
890     if(BIO_dgram_get_peer(rbio, client) <= 0) {
891         SSLerr(SSL_F_DTLS1_LISTEN, ERR_R_INTERNAL_ERROR);
892         return -1;
893     }
894
895     ret = 1;
896     clearpkt = 0;
897 end:
898     BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_PEEK_MODE, 0, NULL);
899     if (clearpkt) {
900         /* Dump this packet. Ignore return value */
901         BIO_read(rbio, buf, SSL3_RT_MAX_PLAIN_LENGTH);
902     }
903     return ret;
904 }
905
906 static int dtls1_set_handshake_header(SSL *s, int htype, unsigned long len)
907 {
908     unsigned char *p = (unsigned char *)s->init_buf->data;
909     dtls1_set_message_header(s, p, htype, len, 0, len);
910     s->init_num = (int)len + DTLS1_HM_HEADER_LENGTH;
911     s->init_off = 0;
912     /* Buffer the message to handle re-xmits */
913
914     if (!dtls1_buffer_message(s, 0))
915         return 0;
916
917     return 1;
918 }
919
920 static int dtls1_handshake_write(SSL *s)
921 {
922     return dtls1_do_write(s, SSL3_RT_HANDSHAKE);
923 }
924
925 #ifndef OPENSSL_NO_HEARTBEATS
926 int dtls1_process_heartbeat(SSL *s, unsigned char *p, unsigned int length)
927 {
928     unsigned char *pl;
929     unsigned short hbtype;
930     unsigned int payload;
931     unsigned int padding = 16;  /* Use minimum padding */
932
933     if (s->msg_callback)
934         s->msg_callback(0, s->version, TLS1_RT_HEARTBEAT,
935                         p, length, s, s->msg_callback_arg);
936
937     /* Read type and payload length first */
938     if (1 + 2 + 16 > length)
939         return 0;               /* silently discard */
940     if (length > SSL3_RT_MAX_PLAIN_LENGTH)
941         return 0;               /* silently discard per RFC 6520 sec. 4 */
942
943     hbtype = *p++;
944     n2s(p, payload);
945     if (1 + 2 + payload + 16 > length)
946         return 0;               /* silently discard per RFC 6520 sec. 4 */
947     pl = p;
948
949     if (hbtype == TLS1_HB_REQUEST) {
950         unsigned char *buffer, *bp;
951         unsigned int write_length = 1 /* heartbeat type */  +
952             2 /* heartbeat length */  +
953             payload + padding;
954         int r;
955
956         if (write_length > SSL3_RT_MAX_PLAIN_LENGTH)
957             return 0;
958
959         /*
960          * Allocate memory for the response, size is 1 byte message type,
961          * plus 2 bytes payload length, plus payload, plus padding
962          */
963         buffer = OPENSSL_malloc(write_length);
964         if (buffer == NULL)
965             return -1;
966         bp = buffer;
967
968         /* Enter response type, length and copy payload */
969         *bp++ = TLS1_HB_RESPONSE;
970         s2n(payload, bp);
971         memcpy(bp, pl, payload);
972         bp += payload;
973         /* Random padding */
974         if (RAND_bytes(bp, padding) <= 0) {
975             OPENSSL_free(buffer);
976             return -1;
977         }
978
979         r = dtls1_write_bytes(s, TLS1_RT_HEARTBEAT, buffer, write_length);
980
981         if (r >= 0 && s->msg_callback)
982             s->msg_callback(1, s->version, TLS1_RT_HEARTBEAT,
983                             buffer, write_length, s, s->msg_callback_arg);
984
985         OPENSSL_free(buffer);
986
987         if (r < 0)
988             return r;
989     } else if (hbtype == TLS1_HB_RESPONSE) {
990         unsigned int seq;
991
992         /*
993          * We only send sequence numbers (2 bytes unsigned int), and 16
994          * random bytes, so we just try to read the sequence number
995          */
996         n2s(pl, seq);
997
998         if (payload == 18 && seq == s->tlsext_hb_seq) {
999             dtls1_stop_timer(s);
1000             s->tlsext_hb_seq++;
1001             s->tlsext_hb_pending = 0;
1002         }
1003     }
1004
1005     return 0;
1006 }
1007
1008 int dtls1_heartbeat(SSL *s)
1009 {
1010     unsigned char *buf, *p;
1011     int ret = -1;
1012     unsigned int payload = 18;  /* Sequence number + random bytes */
1013     unsigned int padding = 16;  /* Use minimum padding */
1014
1015     /* Only send if peer supports and accepts HB requests... */
1016     if (!(s->tlsext_heartbeat & SSL_TLSEXT_HB_ENABLED) ||
1017         s->tlsext_heartbeat & SSL_TLSEXT_HB_DONT_SEND_REQUESTS) {
1018         SSLerr(SSL_F_DTLS1_HEARTBEAT, SSL_R_TLS_HEARTBEAT_PEER_DOESNT_ACCEPT);
1019         return -1;
1020     }
1021
1022     /* ...and there is none in flight yet... */
1023     if (s->tlsext_hb_pending) {
1024         SSLerr(SSL_F_DTLS1_HEARTBEAT, SSL_R_TLS_HEARTBEAT_PENDING);
1025         return -1;
1026     }
1027
1028     /* ...and no handshake in progress. */
1029     if (SSL_in_init(s) || ossl_statem_get_in_handshake(s)) {
1030         SSLerr(SSL_F_DTLS1_HEARTBEAT, SSL_R_UNEXPECTED_MESSAGE);
1031         return -1;
1032     }
1033
1034     /*-
1035      * Create HeartBeat message, we just use a sequence number
1036      * as payload to distuingish different messages and add
1037      * some random stuff.
1038      *  - Message Type, 1 byte
1039      *  - Payload Length, 2 bytes (unsigned int)
1040      *  - Payload, the sequence number (2 bytes uint)
1041      *  - Payload, random bytes (16 bytes uint)
1042      *  - Padding
1043      */
1044     buf = OPENSSL_malloc(1 + 2 + payload + padding);
1045     if (buf == NULL) {
1046         SSLerr(SSL_F_DTLS1_HEARTBEAT, ERR_R_MALLOC_FAILURE);
1047         return -1;
1048     }
1049     p = buf;
1050     /* Message Type */
1051     *p++ = TLS1_HB_REQUEST;
1052     /* Payload length (18 bytes here) */
1053     s2n(payload, p);
1054     /* Sequence number */
1055     s2n(s->tlsext_hb_seq, p);
1056     /* 16 random bytes */
1057     if (RAND_bytes(p, 16) <= 0) {
1058         SSLerr(SSL_F_DTLS1_HEARTBEAT, ERR_R_INTERNAL_ERROR);
1059         goto err;
1060     }
1061     p += 16;
1062     /* Random padding */
1063     if (RAND_bytes(p, padding) <= 0) {
1064         SSLerr(SSL_F_DTLS1_HEARTBEAT, ERR_R_INTERNAL_ERROR);
1065         goto err;
1066     }
1067
1068     ret = dtls1_write_bytes(s, TLS1_RT_HEARTBEAT, buf, 3 + payload + padding);
1069     if (ret >= 0) {
1070         if (s->msg_callback)
1071             s->msg_callback(1, s->version, TLS1_RT_HEARTBEAT,
1072                             buf, 3 + payload + padding,
1073                             s, s->msg_callback_arg);
1074
1075         dtls1_start_timer(s);
1076         s->tlsext_hb_pending = 1;
1077     }
1078
1079  err:
1080     OPENSSL_free(buf);
1081
1082     return ret;
1083 }
1084 #endif
1085
1086 int dtls1_shutdown(SSL *s)
1087 {
1088     int ret;
1089 #ifndef OPENSSL_NO_SCTP
1090     BIO *wbio;
1091
1092     wbio = SSL_get_wbio(s);
1093     if (wbio != NULL && BIO_dgram_is_sctp(wbio) &&
1094         !(s->shutdown & SSL_SENT_SHUTDOWN)) {
1095         ret = BIO_dgram_sctp_wait_for_dry(wbio);
1096         if (ret < 0)
1097             return -1;
1098
1099         if (ret == 0)
1100             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN, 1,
1101                      NULL);
1102     }
1103 #endif
1104     ret = ssl3_shutdown(s);
1105 #ifndef OPENSSL_NO_SCTP
1106     BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN, 0, NULL);
1107 #endif
1108     return ret;
1109 }
1110
1111 int dtls1_query_mtu(SSL *s)
1112 {
1113     if (s->d1->link_mtu) {
1114         s->d1->mtu =
1115             s->d1->link_mtu - BIO_dgram_get_mtu_overhead(SSL_get_wbio(s));
1116         s->d1->link_mtu = 0;
1117     }
1118
1119     /* AHA!  Figure out the MTU, and stick to the right size */
1120     if (s->d1->mtu < dtls1_min_mtu(s)) {
1121         if (!(SSL_get_options(s) & SSL_OP_NO_QUERY_MTU)) {
1122             s->d1->mtu =
1123                 BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL);
1124
1125             /*
1126              * I've seen the kernel return bogus numbers when it doesn't know
1127              * (initial write), so just make sure we have a reasonable number
1128              */
1129             if (s->d1->mtu < dtls1_min_mtu(s)) {
1130                 /* Set to min mtu */
1131                 s->d1->mtu = dtls1_min_mtu(s);
1132                 BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SET_MTU,
1133                          s->d1->mtu, NULL);
1134             }
1135         } else
1136             return 0;
1137     }
1138     return 1;
1139 }
1140
1141 static unsigned int dtls1_link_min_mtu(void)
1142 {
1143     return (g_probable_mtu[(sizeof(g_probable_mtu) /
1144                             sizeof(g_probable_mtu[0])) - 1]);
1145 }
1146
1147 unsigned int dtls1_min_mtu(SSL *s)
1148 {
1149     return dtls1_link_min_mtu() - BIO_dgram_get_mtu_overhead(SSL_get_wbio(s));
1150 }