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