1 /*
2 * UDP proxy: emulate an unreliable UDP connection for DTLS testing
3 *
4 * Copyright The Mbed TLS Contributors
5 * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
6 */
7
8 /*
9 * Warning: this is an internal utility program we use for tests.
10 * It does break some abstractions from the NET layer, and is thus NOT an
11 * example of good general usage.
12 */
13
14 #if !defined(MBEDTLS_CONFIG_FILE)
15 #include "mbedtls/config.h"
16 #else
17 #include MBEDTLS_CONFIG_FILE
18 #endif
19
20 #if defined(MBEDTLS_PLATFORM_C)
21 #include "mbedtls/platform.h"
22 #else
23 #include <stdio.h>
24 #include <stdlib.h>
25 #if defined(MBEDTLS_HAVE_TIME)
26 #include <time.h>
27 #define mbedtls_time time
28 #define mbedtls_time_t time_t
29 #endif
30 #define mbedtls_printf printf
31 #define mbedtls_calloc calloc
32 #define mbedtls_free free
33 #define mbedtls_exit exit
34 #define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS
35 #define MBEDTLS_EXIT_FAILURE EXIT_FAILURE
36 #endif /* MBEDTLS_PLATFORM_C */
37
38 #if !defined(MBEDTLS_NET_C)
main(void)39 int main(void)
40 {
41 mbedtls_printf("MBEDTLS_NET_C not defined.\n");
42 mbedtls_exit(0);
43 }
44 #else
45
46 #include "mbedtls/net_sockets.h"
47 #include "mbedtls/error.h"
48 #include "mbedtls/ssl.h"
49 #include "mbedtls/timing.h"
50
51 #include <string.h>
52
53 /* For select() */
54 #if (defined(_WIN32) || defined(_WIN32_WCE)) && !defined(EFIX64) && \
55 !defined(EFI32)
56 #include <winsock2.h>
57 #include <windows.h>
58 #if defined(_MSC_VER)
59 #if defined(_WIN32_WCE)
60 #pragma comment( lib, "ws2.lib" )
61 #else
62 #pragma comment( lib, "ws2_32.lib" )
63 #endif
64 #endif /* _MSC_VER */
65 #else /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */
66 #if defined(MBEDTLS_HAVE_TIME)
67 #include <sys/time.h>
68 #endif
69 #include <sys/types.h>
70 #include <unistd.h>
71 #endif /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */
72
73 #define MAX_MSG_SIZE 16384 + 2048 /* max record/datagram size */
74
75 #define DFL_SERVER_ADDR "localhost"
76 #define DFL_SERVER_PORT "4433"
77 #define DFL_LISTEN_ADDR "localhost"
78 #define DFL_LISTEN_PORT "5556"
79 #define DFL_PACK 0
80
81 #if defined(MBEDTLS_TIMING_C)
82 #define USAGE_PACK \
83 " pack=%%d default: 0 (don't pack)\n" \
84 " options: t > 0 (pack for t milliseconds)\n"
85 #else
86 #define USAGE_PACK
87 #endif
88
89 #define USAGE \
90 "\n usage: udp_proxy param=<>...\n" \
91 "\n acceptable parameters:\n" \
92 " server_addr=%%s default: localhost\n" \
93 " server_port=%%d default: 4433\n" \
94 " listen_addr=%%s default: localhost\n" \
95 " listen_port=%%d default: 4433\n" \
96 "\n" \
97 " duplicate=%%d default: 0 (no duplication)\n" \
98 " duplicate about 1:N packets randomly\n" \
99 " delay=%%d default: 0 (no delayed packets)\n" \
100 " delay about 1:N packets randomly\n" \
101 " delay_ccs=0/1 default: 0 (don't delay ChangeCipherSpec)\n" \
102 " delay_cli=%%s Handshake message from client that should be\n" \
103 " delayed. Possible values are 'ClientHello',\n" \
104 " 'Certificate', 'CertificateVerify', and\n" \
105 " 'ClientKeyExchange'.\n" \
106 " May be used multiple times, even for the same\n" \
107 " message, in which case the respective message\n" \
108 " gets delayed multiple times.\n" \
109 " delay_srv=%%s Handshake message from server that should be\n" \
110 " delayed. Possible values are 'HelloRequest',\n" \
111 " 'ServerHello', 'ServerHelloDone', 'Certificate'\n" \
112 " 'ServerKeyExchange', 'NewSessionTicket',\n" \
113 " 'HelloVerifyRequest' and ''CertificateRequest'.\n" \
114 " May be used multiple times, even for the same\n" \
115 " message, in which case the respective message\n" \
116 " gets delayed multiple times.\n" \
117 " drop=%%d default: 0 (no dropped packets)\n" \
118 " drop about 1:N packets randomly\n" \
119 " mtu=%%d default: 0 (unlimited)\n" \
120 " drop packets larger than N bytes\n" \
121 " bad_ad=0/1 default: 0 (don't add bad ApplicationData)\n" \
122 " bad_cid=%%d default: 0 (don't corrupt Connection IDs)\n" \
123 " duplicate 1:N packets containing a CID,\n" \
124 " modifying CID in first instance of the packet.\n" \
125 " protect_hvr=0/1 default: 0 (don't protect HelloVerifyRequest)\n" \
126 " protect_len=%%d default: (don't protect packets of this size)\n" \
127 " inject_clihlo=0/1 default: 0 (don't inject fake ClientHello)\n" \
128 "\n" \
129 " seed=%%d default: (use current time)\n" \
130 USAGE_PACK \
131 "\n"
132
133 /*
134 * global options
135 */
136
137 #define MAX_DELAYED_HS 10
138
139 static struct options {
140 const char *server_addr; /* address to forward packets to */
141 const char *server_port; /* port to forward packets to */
142 const char *listen_addr; /* address for accepting client connections */
143 const char *listen_port; /* port for accepting client connections */
144
145 int duplicate; /* duplicate 1 in N packets (none if 0) */
146 int delay; /* delay 1 packet in N (none if 0) */
147 int delay_ccs; /* delay ChangeCipherSpec */
148 char *delay_cli[MAX_DELAYED_HS]; /* handshake types of messages from
149 * client that should be delayed. */
150 uint8_t delay_cli_cnt; /* Number of entries in delay_cli. */
151 char *delay_srv[MAX_DELAYED_HS]; /* handshake types of messages from
152 * server that should be delayed. */
153 uint8_t delay_srv_cnt; /* Number of entries in delay_srv. */
154 int drop; /* drop 1 packet in N (none if 0) */
155 int mtu; /* drop packets larger than this */
156 int bad_ad; /* inject corrupted ApplicationData record */
157 unsigned bad_cid; /* inject corrupted CID record */
158 int protect_hvr; /* never drop or delay HelloVerifyRequest */
159 int protect_len; /* never drop/delay packet of the given size*/
160 int inject_clihlo; /* inject fake ClientHello after handshake */
161 unsigned pack; /* merge packets into single datagram for
162 * at most \c merge milliseconds if > 0 */
163 unsigned int seed; /* seed for "random" events */
164 } opt;
165
exit_usage(const char * name,const char * value)166 static void exit_usage(const char *name, const char *value)
167 {
168 if (value == NULL) {
169 mbedtls_printf(" unknown option or missing value: %s\n", name);
170 } else {
171 mbedtls_printf(" option %s: illegal value: %s\n", name, value);
172 }
173
174 mbedtls_printf(USAGE);
175 mbedtls_exit(1);
176 }
177
get_options(int argc,char * argv[])178 static void get_options(int argc, char *argv[])
179 {
180 int i;
181 char *p, *q;
182
183 opt.server_addr = DFL_SERVER_ADDR;
184 opt.server_port = DFL_SERVER_PORT;
185 opt.listen_addr = DFL_LISTEN_ADDR;
186 opt.listen_port = DFL_LISTEN_PORT;
187 opt.pack = DFL_PACK;
188 /* Other members default to 0 */
189
190 opt.delay_cli_cnt = 0;
191 opt.delay_srv_cnt = 0;
192 memset(opt.delay_cli, 0, sizeof(opt.delay_cli));
193 memset(opt.delay_srv, 0, sizeof(opt.delay_srv));
194
195 for (i = 1; i < argc; i++) {
196 p = argv[i];
197 if ((q = strchr(p, '=')) == NULL) {
198 exit_usage(p, NULL);
199 }
200 *q++ = '\0';
201
202 if (strcmp(p, "server_addr") == 0) {
203 opt.server_addr = q;
204 } else if (strcmp(p, "server_port") == 0) {
205 opt.server_port = q;
206 } else if (strcmp(p, "listen_addr") == 0) {
207 opt.listen_addr = q;
208 } else if (strcmp(p, "listen_port") == 0) {
209 opt.listen_port = q;
210 } else if (strcmp(p, "duplicate") == 0) {
211 opt.duplicate = atoi(q);
212 if (opt.duplicate < 0 || opt.duplicate > 20) {
213 exit_usage(p, q);
214 }
215 } else if (strcmp(p, "delay") == 0) {
216 opt.delay = atoi(q);
217 if (opt.delay < 0 || opt.delay > 20 || opt.delay == 1) {
218 exit_usage(p, q);
219 }
220 } else if (strcmp(p, "delay_ccs") == 0) {
221 opt.delay_ccs = atoi(q);
222 if (opt.delay_ccs < 0 || opt.delay_ccs > 1) {
223 exit_usage(p, q);
224 }
225 } else if (strcmp(p, "delay_cli") == 0 ||
226 strcmp(p, "delay_srv") == 0) {
227 uint8_t *delay_cnt;
228 char **delay_list;
229 size_t len;
230 char *buf;
231
232 if (strcmp(p, "delay_cli") == 0) {
233 delay_cnt = &opt.delay_cli_cnt;
234 delay_list = opt.delay_cli;
235 } else {
236 delay_cnt = &opt.delay_srv_cnt;
237 delay_list = opt.delay_srv;
238 }
239
240 if (*delay_cnt == MAX_DELAYED_HS) {
241 mbedtls_printf(" too many uses of %s: only %d allowed\n",
242 p, MAX_DELAYED_HS);
243 exit_usage(p, NULL);
244 }
245
246 len = strlen(q);
247 buf = mbedtls_calloc(1, len + 1);
248 if (buf == NULL) {
249 mbedtls_printf(" Allocation failure\n");
250 exit(1);
251 }
252 memcpy(buf, q, len + 1);
253
254 delay_list[(*delay_cnt)++] = buf;
255 } else if (strcmp(p, "drop") == 0) {
256 opt.drop = atoi(q);
257 if (opt.drop < 0 || opt.drop > 20 || opt.drop == 1) {
258 exit_usage(p, q);
259 }
260 } else if (strcmp(p, "pack") == 0) {
261 #if defined(MBEDTLS_TIMING_C)
262 opt.pack = (unsigned) atoi(q);
263 #else
264 mbedtls_printf(" option pack only defined if MBEDTLS_TIMING_C is enabled\n");
265 exit(1);
266 #endif
267 } else if (strcmp(p, "mtu") == 0) {
268 opt.mtu = atoi(q);
269 if (opt.mtu < 0 || opt.mtu > MAX_MSG_SIZE) {
270 exit_usage(p, q);
271 }
272 } else if (strcmp(p, "bad_ad") == 0) {
273 opt.bad_ad = atoi(q);
274 if (opt.bad_ad < 0 || opt.bad_ad > 1) {
275 exit_usage(p, q);
276 }
277 }
278 #if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
279 else if (strcmp(p, "bad_cid") == 0) {
280 opt.bad_cid = (unsigned) atoi(q);
281 }
282 #endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
283 else if (strcmp(p, "protect_hvr") == 0) {
284 opt.protect_hvr = atoi(q);
285 if (opt.protect_hvr < 0 || opt.protect_hvr > 1) {
286 exit_usage(p, q);
287 }
288 } else if (strcmp(p, "protect_len") == 0) {
289 opt.protect_len = atoi(q);
290 if (opt.protect_len < 0) {
291 exit_usage(p, q);
292 }
293 } else if (strcmp(p, "inject_clihlo") == 0) {
294 opt.inject_clihlo = atoi(q);
295 if (opt.inject_clihlo < 0 || opt.inject_clihlo > 1) {
296 exit_usage(p, q);
297 }
298 } else if (strcmp(p, "seed") == 0) {
299 opt.seed = atoi(q);
300 if (opt.seed == 0) {
301 exit_usage(p, q);
302 }
303 } else {
304 exit_usage(p, NULL);
305 }
306 }
307 }
308
msg_type(unsigned char * msg,size_t len)309 static const char *msg_type(unsigned char *msg, size_t len)
310 {
311 if (len < 1) {
312 return "Invalid";
313 }
314 switch (msg[0]) {
315 case MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC: return "ChangeCipherSpec";
316 case MBEDTLS_SSL_MSG_ALERT: return "Alert";
317 case MBEDTLS_SSL_MSG_APPLICATION_DATA: return "ApplicationData";
318 case MBEDTLS_SSL_MSG_CID: return "CID";
319 case MBEDTLS_SSL_MSG_HANDSHAKE: break; /* See below */
320 default: return "Unknown";
321 }
322
323 if (len < 13 + 12) {
324 return "Invalid handshake";
325 }
326
327 /*
328 * Our handshake message are less than 2^16 bytes long, so they should
329 * have 0 as the first byte of length, frag_offset and frag_length.
330 * Otherwise, assume they are encrypted.
331 */
332 if (msg[14] || msg[19] || msg[22]) {
333 return "Encrypted handshake";
334 }
335
336 switch (msg[13]) {
337 case MBEDTLS_SSL_HS_HELLO_REQUEST: return "HelloRequest";
338 case MBEDTLS_SSL_HS_CLIENT_HELLO: return "ClientHello";
339 case MBEDTLS_SSL_HS_SERVER_HELLO: return "ServerHello";
340 case MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST: return "HelloVerifyRequest";
341 case MBEDTLS_SSL_HS_NEW_SESSION_TICKET: return "NewSessionTicket";
342 case MBEDTLS_SSL_HS_CERTIFICATE: return "Certificate";
343 case MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE: return "ServerKeyExchange";
344 case MBEDTLS_SSL_HS_CERTIFICATE_REQUEST: return "CertificateRequest";
345 case MBEDTLS_SSL_HS_SERVER_HELLO_DONE: return "ServerHelloDone";
346 case MBEDTLS_SSL_HS_CERTIFICATE_VERIFY: return "CertificateVerify";
347 case MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE: return "ClientKeyExchange";
348 case MBEDTLS_SSL_HS_FINISHED: return "Finished";
349 default: return "Unknown handshake";
350 }
351 }
352
353 #if defined(MBEDTLS_TIMING_C)
354 /* Return elapsed time in milliseconds since the first call */
elapsed_time(void)355 static unsigned elapsed_time(void)
356 {
357 static int initialized = 0;
358 static struct mbedtls_timing_hr_time hires;
359
360 if (initialized == 0) {
361 (void) mbedtls_timing_get_timer(&hires, 1);
362 initialized = 1;
363 return 0;
364 }
365
366 return mbedtls_timing_get_timer(&hires, 0);
367 }
368
369 typedef struct {
370 mbedtls_net_context *ctx;
371
372 const char *description;
373
374 unsigned packet_lifetime;
375 unsigned num_datagrams;
376
377 unsigned char data[MAX_MSG_SIZE];
378 size_t len;
379
380 } ctx_buffer;
381
382 static ctx_buffer outbuf[2];
383
ctx_buffer_flush(ctx_buffer * buf)384 static int ctx_buffer_flush(ctx_buffer *buf)
385 {
386 int ret;
387
388 mbedtls_printf(" %05u flush %s: %u bytes, %u datagrams, last %u ms\n",
389 elapsed_time(), buf->description,
390 (unsigned) buf->len, buf->num_datagrams,
391 elapsed_time() - buf->packet_lifetime);
392
393 ret = mbedtls_net_send(buf->ctx, buf->data, buf->len);
394
395 buf->len = 0;
396 buf->num_datagrams = 0;
397
398 return ret;
399 }
400
ctx_buffer_time_remaining(ctx_buffer * buf)401 static unsigned ctx_buffer_time_remaining(ctx_buffer *buf)
402 {
403 unsigned const cur_time = elapsed_time();
404
405 if (buf->num_datagrams == 0) {
406 return (unsigned) -1;
407 }
408
409 if (cur_time - buf->packet_lifetime >= opt.pack) {
410 return 0;
411 }
412
413 return opt.pack - (cur_time - buf->packet_lifetime);
414 }
415
ctx_buffer_append(ctx_buffer * buf,const unsigned char * data,size_t len)416 static int ctx_buffer_append(ctx_buffer *buf,
417 const unsigned char *data,
418 size_t len)
419 {
420 int ret;
421
422 if (len > (size_t) INT_MAX) {
423 return -1;
424 }
425
426 if (len > sizeof(buf->data)) {
427 mbedtls_printf(" ! buffer size %u too large (max %u)\n",
428 (unsigned) len, (unsigned) sizeof(buf->data));
429 return -1;
430 }
431
432 if (sizeof(buf->data) - buf->len < len) {
433 if ((ret = ctx_buffer_flush(buf)) <= 0) {
434 mbedtls_printf("ctx_buffer_flush failed with -%#04x", (unsigned int) -ret);
435 return ret;
436 }
437 }
438
439 memcpy(buf->data + buf->len, data, len);
440
441 buf->len += len;
442 if (++buf->num_datagrams == 1) {
443 buf->packet_lifetime = elapsed_time();
444 }
445
446 return (int) len;
447 }
448 #endif /* MBEDTLS_TIMING_C */
449
dispatch_data(mbedtls_net_context * ctx,const unsigned char * data,size_t len)450 static int dispatch_data(mbedtls_net_context *ctx,
451 const unsigned char *data,
452 size_t len)
453 {
454 int ret;
455 #if defined(MBEDTLS_TIMING_C)
456 ctx_buffer *buf = NULL;
457 if (opt.pack > 0) {
458 if (outbuf[0].ctx == ctx) {
459 buf = &outbuf[0];
460 } else if (outbuf[1].ctx == ctx) {
461 buf = &outbuf[1];
462 }
463
464 if (buf == NULL) {
465 return -1;
466 }
467
468 return ctx_buffer_append(buf, data, len);
469 }
470 #endif /* MBEDTLS_TIMING_C */
471
472 ret = mbedtls_net_send(ctx, data, len);
473 if (ret < 0) {
474 mbedtls_printf("net_send returned -%#04x\n", (unsigned int) -ret);
475 }
476 return ret;
477 }
478
479 typedef struct {
480 mbedtls_net_context *dst;
481 const char *way;
482 const char *type;
483 unsigned len;
484 unsigned char buf[MAX_MSG_SIZE];
485 } packet;
486
487 /* Print packet. Outgoing packets come with a reason (forward, dupl, etc.) */
print_packet(const packet * p,const char * why)488 void print_packet(const packet *p, const char *why)
489 {
490 #if defined(MBEDTLS_TIMING_C)
491 if (why == NULL) {
492 mbedtls_printf(" %05u dispatch %s %s (%u bytes)\n",
493 elapsed_time(), p->way, p->type, p->len);
494 } else {
495 mbedtls_printf(" %05u dispatch %s %s (%u bytes): %s\n",
496 elapsed_time(), p->way, p->type, p->len, why);
497 }
498 #else
499 if (why == NULL) {
500 mbedtls_printf(" dispatch %s %s (%u bytes)\n",
501 p->way, p->type, p->len);
502 } else {
503 mbedtls_printf(" dispatch %s %s (%u bytes): %s\n",
504 p->way, p->type, p->len, why);
505 }
506 #endif
507
508 fflush(stdout);
509 }
510
511 /*
512 * In order to test the server's behaviour when receiving a ClientHello after
513 * the connection is established (this could be a hard reset from the client,
514 * but the server must not drop the existing connection before establishing
515 * client reachability, see RFC 6347 Section 4.2.8), we memorize the first
516 * ClientHello we see (which can't have a cookie), then replay it after the
517 * first ApplicationData record - then we're done.
518 *
519 * This is controlled by the inject_clihlo option.
520 *
521 * We want an explicit state and a place to store the packet.
522 */
523 typedef enum {
524 ICH_INIT, /* haven't seen the first ClientHello yet */
525 ICH_CACHED, /* cached the initial ClientHello */
526 ICH_INJECTED, /* ClientHello already injected, done */
527 } inject_clihlo_state_t;
528
529 static inject_clihlo_state_t inject_clihlo_state;
530 static packet initial_clihlo;
531
send_packet(const packet * p,const char * why)532 int send_packet(const packet *p, const char *why)
533 {
534 int ret;
535 mbedtls_net_context *dst = p->dst;
536
537 /* save initial ClientHello? */
538 if (opt.inject_clihlo != 0 &&
539 inject_clihlo_state == ICH_INIT &&
540 strcmp(p->type, "ClientHello") == 0) {
541 memcpy(&initial_clihlo, p, sizeof(packet));
542 inject_clihlo_state = ICH_CACHED;
543 }
544
545 /* insert corrupted CID record? */
546 if (opt.bad_cid != 0 &&
547 strcmp(p->type, "CID") == 0 &&
548 (rand() % opt.bad_cid) == 0) {
549 unsigned char buf[MAX_MSG_SIZE];
550 memcpy(buf, p->buf, p->len);
551
552 /* The CID resides at offset 11 in the DTLS record header. */
553 buf[11] ^= 1;
554 print_packet(p, "modified CID");
555
556 if ((ret = dispatch_data(dst, buf, p->len)) <= 0) {
557 mbedtls_printf(" ! dispatch returned %d\n", ret);
558 return ret;
559 }
560 }
561
562 /* insert corrupted ApplicationData record? */
563 if (opt.bad_ad &&
564 strcmp(p->type, "ApplicationData") == 0) {
565 unsigned char buf[MAX_MSG_SIZE];
566 memcpy(buf, p->buf, p->len);
567
568 if (p->len <= 13) {
569 mbedtls_printf(" ! can't corrupt empty AD record");
570 } else {
571 ++buf[13];
572 print_packet(p, "corrupted");
573 }
574
575 if ((ret = dispatch_data(dst, buf, p->len)) <= 0) {
576 mbedtls_printf(" ! dispatch returned %d\n", ret);
577 return ret;
578 }
579 }
580
581 print_packet(p, why);
582 if ((ret = dispatch_data(dst, p->buf, p->len)) <= 0) {
583 mbedtls_printf(" ! dispatch returned %d\n", ret);
584 return ret;
585 }
586
587 /* Don't duplicate Application Data, only handshake covered */
588 if (opt.duplicate != 0 &&
589 strcmp(p->type, "ApplicationData") != 0 &&
590 rand() % opt.duplicate == 0) {
591 print_packet(p, "duplicated");
592
593 if ((ret = dispatch_data(dst, p->buf, p->len)) <= 0) {
594 mbedtls_printf(" ! dispatch returned %d\n", ret);
595 return ret;
596 }
597 }
598
599 /* Inject ClientHello after first ApplicationData */
600 if (opt.inject_clihlo != 0 &&
601 inject_clihlo_state == ICH_CACHED &&
602 strcmp(p->type, "ApplicationData") == 0) {
603 print_packet(&initial_clihlo, "injected");
604
605 if ((ret = dispatch_data(dst, initial_clihlo.buf,
606 initial_clihlo.len)) <= 0) {
607 mbedtls_printf(" ! dispatch returned %d\n", ret);
608 return ret;
609 }
610
611 inject_clihlo_state = ICH_INJECTED;
612 }
613
614 return 0;
615 }
616
617 #define MAX_DELAYED_MSG 5
618 static size_t prev_len;
619 static packet prev[MAX_DELAYED_MSG];
620
clear_pending(void)621 void clear_pending(void)
622 {
623 memset(&prev, 0, sizeof(prev));
624 prev_len = 0;
625 }
626
delay_packet(packet * delay)627 void delay_packet(packet *delay)
628 {
629 if (prev_len == MAX_DELAYED_MSG) {
630 return;
631 }
632
633 memcpy(&prev[prev_len++], delay, sizeof(packet));
634 }
635
send_delayed(void)636 int send_delayed(void)
637 {
638 uint8_t offset;
639 int ret;
640 for (offset = 0; offset < prev_len; offset++) {
641 ret = send_packet(&prev[offset], "delayed");
642 if (ret != 0) {
643 return ret;
644 }
645 }
646
647 clear_pending();
648 return 0;
649 }
650
651 /*
652 * Avoid dropping or delaying a packet that was already dropped or delayed
653 * ("held") twice: this only results in uninteresting timeouts. We can't rely
654 * on type to identify packets, since during renegotiation they're all
655 * encrypted. So, rely on size mod 2048 (which is usually just size).
656 *
657 * We only hold packets at the level of entire datagrams, not at the level
658 * of records. In particular, if the peer changes the way it packs multiple
659 * records into a single datagram, we don't necessarily count the number of
660 * times a record has been held correctly. However, the only known reason
661 * why a peer would change datagram packing is disabling the latter on
662 * retransmission, in which case we'd hold involved records at most
663 * HOLD_MAX + 1 times.
664 */
665 static unsigned char held[2048] = { 0 };
666 #define HOLD_MAX 2
667
handle_message(const char * way,mbedtls_net_context * dst,mbedtls_net_context * src)668 int handle_message(const char *way,
669 mbedtls_net_context *dst,
670 mbedtls_net_context *src)
671 {
672 int ret;
673 packet cur;
674 size_t id;
675
676 uint8_t delay_idx;
677 char **delay_list;
678 uint8_t delay_list_len;
679
680 /* receive packet */
681 if ((ret = mbedtls_net_recv(src, cur.buf, sizeof(cur.buf))) <= 0) {
682 mbedtls_printf(" ! mbedtls_net_recv returned %d\n", ret);
683 return ret;
684 }
685
686 cur.len = ret;
687 cur.type = msg_type(cur.buf, cur.len);
688 cur.way = way;
689 cur.dst = dst;
690 print_packet(&cur, NULL);
691
692 id = cur.len % sizeof(held);
693
694 if (strcmp(way, "S <- C") == 0) {
695 delay_list = opt.delay_cli;
696 delay_list_len = opt.delay_cli_cnt;
697 } else {
698 delay_list = opt.delay_srv;
699 delay_list_len = opt.delay_srv_cnt;
700 }
701
702 /* Check if message type is in the list of messages
703 * that should be delayed */
704 for (delay_idx = 0; delay_idx < delay_list_len; delay_idx++) {
705 if (delay_list[delay_idx] == NULL) {
706 continue;
707 }
708
709 if (strcmp(delay_list[delay_idx], cur.type) == 0) {
710 /* Delay message */
711 delay_packet(&cur);
712
713 /* Remove entry from list */
714 mbedtls_free(delay_list[delay_idx]);
715 delay_list[delay_idx] = NULL;
716
717 return 0;
718 }
719 }
720
721 /* do we want to drop, delay, or forward it? */
722 if ((opt.mtu != 0 &&
723 cur.len > (unsigned) opt.mtu) ||
724 (opt.drop != 0 &&
725 strcmp(cur.type, "CID") != 0 &&
726 strcmp(cur.type, "ApplicationData") != 0 &&
727 !(opt.protect_hvr &&
728 strcmp(cur.type, "HelloVerifyRequest") == 0) &&
729 cur.len != (size_t) opt.protect_len &&
730 held[id] < HOLD_MAX &&
731 rand() % opt.drop == 0)) {
732 ++held[id];
733 } else if ((opt.delay_ccs == 1 &&
734 strcmp(cur.type, "ChangeCipherSpec") == 0) ||
735 (opt.delay != 0 &&
736 strcmp(cur.type, "CID") != 0 &&
737 strcmp(cur.type, "ApplicationData") != 0 &&
738 !(opt.protect_hvr &&
739 strcmp(cur.type, "HelloVerifyRequest") == 0) &&
740 cur.len != (size_t) opt.protect_len &&
741 held[id] < HOLD_MAX &&
742 rand() % opt.delay == 0)) {
743 ++held[id];
744 delay_packet(&cur);
745 } else {
746 /* forward and possibly duplicate */
747 if ((ret = send_packet(&cur, "forwarded")) != 0) {
748 return ret;
749 }
750
751 /* send previously delayed messages if any */
752 ret = send_delayed();
753 if (ret != 0) {
754 return ret;
755 }
756 }
757
758 return 0;
759 }
760
main(int argc,char * argv[])761 int main(int argc, char *argv[])
762 {
763 int ret = 1;
764 int exit_code = MBEDTLS_EXIT_FAILURE;
765 uint8_t delay_idx;
766
767 mbedtls_net_context listen_fd, client_fd, server_fd;
768
769 #if defined(MBEDTLS_TIMING_C)
770 struct timeval tm;
771 #endif
772
773 struct timeval *tm_ptr = NULL;
774
775 int nb_fds;
776 fd_set read_fds;
777
778 mbedtls_net_init(&listen_fd);
779 mbedtls_net_init(&client_fd);
780 mbedtls_net_init(&server_fd);
781
782 get_options(argc, argv);
783
784 /*
785 * Decisions to drop/delay/duplicate packets are pseudo-random: dropping
786 * exactly 1 in N packets would lead to problems when a flight has exactly
787 * N packets: the same packet would be dropped on every resend.
788 *
789 * In order to be able to reproduce problems reliably, the seed may be
790 * specified explicitly.
791 */
792 if (opt.seed == 0) {
793 #if defined(MBEDTLS_HAVE_TIME)
794 opt.seed = (unsigned int) mbedtls_time(NULL);
795 #else
796 opt.seed = 1;
797 #endif /* MBEDTLS_HAVE_TIME */
798 mbedtls_printf(" . Pseudo-random seed: %u\n", opt.seed);
799 }
800
801 srand(opt.seed);
802
803 /*
804 * 0. "Connect" to the server
805 */
806 mbedtls_printf(" . Connect to server on UDP/%s/%s ...",
807 opt.server_addr, opt.server_port);
808 fflush(stdout);
809
810 if ((ret = mbedtls_net_connect(&server_fd, opt.server_addr, opt.server_port,
811 MBEDTLS_NET_PROTO_UDP)) != 0) {
812 mbedtls_printf(" failed\n ! mbedtls_net_connect returned %d\n\n", ret);
813 goto exit;
814 }
815
816 mbedtls_printf(" ok\n");
817
818 /*
819 * 1. Setup the "listening" UDP socket
820 */
821 mbedtls_printf(" . Bind on UDP/%s/%s ...",
822 opt.listen_addr, opt.listen_port);
823 fflush(stdout);
824
825 if ((ret = mbedtls_net_bind(&listen_fd, opt.listen_addr, opt.listen_port,
826 MBEDTLS_NET_PROTO_UDP)) != 0) {
827 mbedtls_printf(" failed\n ! mbedtls_net_bind returned %d\n\n", ret);
828 goto exit;
829 }
830
831 mbedtls_printf(" ok\n");
832
833 /*
834 * 2. Wait until a client connects
835 */
836 accept:
837 mbedtls_net_free(&client_fd);
838
839 mbedtls_printf(" . Waiting for a remote connection ...");
840 fflush(stdout);
841
842 if ((ret = mbedtls_net_accept(&listen_fd, &client_fd,
843 NULL, 0, NULL)) != 0) {
844 mbedtls_printf(" failed\n ! mbedtls_net_accept returned %d\n\n", ret);
845 goto exit;
846 }
847
848 mbedtls_printf(" ok\n");
849
850 /*
851 * 3. Forward packets forever (kill the process to terminate it)
852 */
853 clear_pending();
854 memset(held, 0, sizeof(held));
855
856 nb_fds = client_fd.fd;
857 if (nb_fds < server_fd.fd) {
858 nb_fds = server_fd.fd;
859 }
860 if (nb_fds < listen_fd.fd) {
861 nb_fds = listen_fd.fd;
862 }
863 ++nb_fds;
864
865 #if defined(MBEDTLS_TIMING_C)
866 if (opt.pack > 0) {
867 outbuf[0].ctx = &server_fd;
868 outbuf[0].description = "S <- C";
869 outbuf[0].num_datagrams = 0;
870 outbuf[0].len = 0;
871
872 outbuf[1].ctx = &client_fd;
873 outbuf[1].description = "S -> C";
874 outbuf[1].num_datagrams = 0;
875 outbuf[1].len = 0;
876 }
877 #endif /* MBEDTLS_TIMING_C */
878
879 while (1) {
880 #if defined(MBEDTLS_TIMING_C)
881 if (opt.pack > 0) {
882 unsigned max_wait_server, max_wait_client, max_wait;
883 max_wait_server = ctx_buffer_time_remaining(&outbuf[0]);
884 max_wait_client = ctx_buffer_time_remaining(&outbuf[1]);
885
886 max_wait = (unsigned) -1;
887
888 if (max_wait_server == 0) {
889 ctx_buffer_flush(&outbuf[0]);
890 } else {
891 max_wait = max_wait_server;
892 }
893
894 if (max_wait_client == 0) {
895 ctx_buffer_flush(&outbuf[1]);
896 } else {
897 if (max_wait_client < max_wait) {
898 max_wait = max_wait_client;
899 }
900 }
901
902 if (max_wait != (unsigned) -1) {
903 tm.tv_sec = max_wait / 1000;
904 tm.tv_usec = (max_wait % 1000) * 1000;
905
906 tm_ptr = &tm;
907 } else {
908 tm_ptr = NULL;
909 }
910 }
911 #endif /* MBEDTLS_TIMING_C */
912
913 FD_ZERO(&read_fds);
914 FD_SET(server_fd.fd, &read_fds);
915 FD_SET(client_fd.fd, &read_fds);
916 FD_SET(listen_fd.fd, &read_fds);
917
918 if ((ret = select(nb_fds, &read_fds, NULL, NULL, tm_ptr)) < 0) {
919 perror("select");
920 goto exit;
921 }
922
923 if (FD_ISSET(listen_fd.fd, &read_fds)) {
924 goto accept;
925 }
926
927 if (FD_ISSET(client_fd.fd, &read_fds)) {
928 if ((ret = handle_message("S <- C",
929 &server_fd, &client_fd)) != 0) {
930 goto accept;
931 }
932 }
933
934 if (FD_ISSET(server_fd.fd, &read_fds)) {
935 if ((ret = handle_message("S -> C",
936 &client_fd, &server_fd)) != 0) {
937 goto accept;
938 }
939 }
940
941 }
942
943 exit_code = MBEDTLS_EXIT_SUCCESS;
944
945 exit:
946
947 #ifdef MBEDTLS_ERROR_C
948 if (exit_code != MBEDTLS_EXIT_SUCCESS) {
949 char error_buf[100];
950 mbedtls_strerror(ret, error_buf, 100);
951 mbedtls_printf("Last error was: -0x%04X - %s\n\n", (unsigned int) -ret, error_buf);
952 fflush(stdout);
953 }
954 #endif
955
956 for (delay_idx = 0; delay_idx < MAX_DELAYED_HS; delay_idx++) {
957 mbedtls_free(opt.delay_cli[delay_idx]);
958 mbedtls_free(opt.delay_srv[delay_idx]);
959 }
960
961 mbedtls_net_free(&client_fd);
962 mbedtls_net_free(&server_fd);
963 mbedtls_net_free(&listen_fd);
964
965 #if defined(_WIN32)
966 mbedtls_printf(" Press Enter to exit this program.\n");
967 fflush(stdout); getchar();
968 #endif
969
970 mbedtls_exit(exit_code);
971 }
972
973 #endif /* MBEDTLS_NET_C */
974