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