1 /*
2 * UDP proxy: emulate an unreliable UDP connexion for DTLS testing
3 *
4 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
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 * This file is part of mbed TLS (https://tls.mbed.org)
20 */
21
22 /*
23 * Warning: this is an internal utility program we use for tests.
24 * It does break some abstractions from the NET layer, and is thus NOT an
25 * example of good general usage.
26 */
27
28 #if !defined(MBEDTLS_CONFIG_FILE)
29 #include "mbedtls/config.h"
30 #else
31 #include MBEDTLS_CONFIG_FILE
32 #endif
33
34 #if defined(MBEDTLS_PLATFORM_C)
35 #include "mbedtls/platform.h"
36 #else
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <time.h>
40 #define mbedtls_time time
41 #define mbedtls_time_t time_t
42 #define mbedtls_printf printf
43 #endif
44
45 #if !defined(MBEDTLS_NET_C)
main(void)46 int main( void )
47 {
48 mbedtls_printf( "MBEDTLS_NET_C not defined.\n" );
49 return( 0 );
50 }
51 #else
52
53 #include "mbedtls/net_sockets.h"
54 #include "mbedtls/error.h"
55 #include "mbedtls/ssl.h"
56
57 #include <string.h>
58
59 /* For select() */
60 #if (defined(_WIN32) || defined(_WIN32_WCE)) && !defined(EFIX64) && \
61 !defined(EFI32)
62 #include <winsock2.h>
63 #include <windows.h>
64 #if defined(_MSC_VER)
65 #if defined(_WIN32_WCE)
66 #pragma comment( lib, "ws2.lib" )
67 #else
68 #pragma comment( lib, "ws2_32.lib" )
69 #endif
70 #endif /* _MSC_VER */
71 #else /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */
72 #include <sys/time.h>
73 #include <sys/types.h>
74 #include <unistd.h>
75 #endif /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */
76
77 /* For gettimeofday() */
78 #if !defined(_WIN32)
79 #include <sys/time.h>
80 #endif
81
82 #define MAX_MSG_SIZE 16384 + 2048 /* max record/datagram size */
83
84 #define DFL_SERVER_ADDR "localhost"
85 #define DFL_SERVER_PORT "4433"
86 #define DFL_LISTEN_ADDR "localhost"
87 #define DFL_LISTEN_PORT "5556"
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 " drop=%%d default: 0 (no dropped packets)\n" \
103 " drop about 1:N packets randomly\n" \
104 " mtu=%%d default: 0 (unlimited)\n" \
105 " drop packets larger than N bytes\n" \
106 " bad_ad=0/1 default: 0 (don't add bad ApplicationData)\n" \
107 " protect_hvr=0/1 default: 0 (don't protect HelloVerifyRequest)\n" \
108 " protect_len=%%d default: (don't protect packets of this size)\n" \
109 "\n" \
110 " seed=%%d default: (use current time)\n" \
111 "\n"
112
113 /*
114 * global options
115 */
116 static struct options
117 {
118 const char *server_addr; /* address to forward packets to */
119 const char *server_port; /* port to forward packets to */
120 const char *listen_addr; /* address for accepting client connections */
121 const char *listen_port; /* port for accepting client connections */
122
123 int duplicate; /* duplicate 1 in N packets (none if 0) */
124 int delay; /* delay 1 packet in N (none if 0) */
125 int delay_ccs; /* delay ChangeCipherSpec */
126 int drop; /* drop 1 packet in N (none if 0) */
127 int mtu; /* drop packets larger than this */
128 int bad_ad; /* inject corrupted ApplicationData record */
129 int protect_hvr; /* never drop or delay HelloVerifyRequest */
130 int protect_len; /* never drop/delay packet of the given size*/
131
132 unsigned int seed; /* seed for "random" events */
133 } opt;
134
exit_usage(const char * name,const char * value)135 static void exit_usage( const char *name, const char *value )
136 {
137 if( value == NULL )
138 mbedtls_printf( " unknown option or missing value: %s\n", name );
139 else
140 mbedtls_printf( " option %s: illegal value: %s\n", name, value );
141
142 mbedtls_printf( USAGE );
143 exit( 1 );
144 }
145
get_options(int argc,char * argv[])146 static void get_options( int argc, char *argv[] )
147 {
148 int i;
149 char *p, *q;
150
151 opt.server_addr = DFL_SERVER_ADDR;
152 opt.server_port = DFL_SERVER_PORT;
153 opt.listen_addr = DFL_LISTEN_ADDR;
154 opt.listen_port = DFL_LISTEN_PORT;
155 /* Other members default to 0 */
156
157 for( i = 1; i < argc; i++ )
158 {
159 p = argv[i];
160 if( ( q = strchr( p, '=' ) ) == NULL )
161 exit_usage( p, NULL );
162 *q++ = '\0';
163
164 if( strcmp( p, "server_addr" ) == 0 )
165 opt.server_addr = q;
166 else if( strcmp( p, "server_port" ) == 0 )
167 opt.server_port = q;
168 else if( strcmp( p, "listen_addr" ) == 0 )
169 opt.listen_addr = q;
170 else if( strcmp( p, "listen_port" ) == 0 )
171 opt.listen_port = q;
172 else if( strcmp( p, "duplicate" ) == 0 )
173 {
174 opt.duplicate = atoi( q );
175 if( opt.duplicate < 0 || opt.duplicate > 20 )
176 exit_usage( p, q );
177 }
178 else if( strcmp( p, "delay" ) == 0 )
179 {
180 opt.delay = atoi( q );
181 if( opt.delay < 0 || opt.delay > 20 || opt.delay == 1 )
182 exit_usage( p, q );
183 }
184 else if( strcmp( p, "delay_ccs" ) == 0 )
185 {
186 opt.delay_ccs = atoi( q );
187 if( opt.delay_ccs < 0 || opt.delay_ccs > 1 )
188 exit_usage( p, q );
189 }
190 else if( strcmp( p, "drop" ) == 0 )
191 {
192 opt.drop = atoi( q );
193 if( opt.drop < 0 || opt.drop > 20 || opt.drop == 1 )
194 exit_usage( p, q );
195 }
196 else if( strcmp( p, "mtu" ) == 0 )
197 {
198 opt.mtu = atoi( q );
199 if( opt.mtu < 0 || opt.mtu > MAX_MSG_SIZE )
200 exit_usage( p, q );
201 }
202 else if( strcmp( p, "bad_ad" ) == 0 )
203 {
204 opt.bad_ad = atoi( q );
205 if( opt.bad_ad < 0 || opt.bad_ad > 1 )
206 exit_usage( p, q );
207 }
208 else if( strcmp( p, "protect_hvr" ) == 0 )
209 {
210 opt.protect_hvr = atoi( q );
211 if( opt.protect_hvr < 0 || opt.protect_hvr > 1 )
212 exit_usage( p, q );
213 }
214 else if( strcmp( p, "protect_len" ) == 0 )
215 {
216 opt.protect_len = atoi( q );
217 if( opt.protect_len < 0 )
218 exit_usage( p, q );
219 }
220 else if( strcmp( p, "seed" ) == 0 )
221 {
222 opt.seed = atoi( q );
223 if( opt.seed == 0 )
224 exit_usage( p, q );
225 }
226 else
227 exit_usage( p, NULL );
228 }
229 }
230
msg_type(unsigned char * msg,size_t len)231 static const char *msg_type( unsigned char *msg, size_t len )
232 {
233 if( len < 1 ) return( "Invalid" );
234 switch( msg[0] )
235 {
236 case MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC: return( "ChangeCipherSpec" );
237 case MBEDTLS_SSL_MSG_ALERT: return( "Alert" );
238 case MBEDTLS_SSL_MSG_APPLICATION_DATA: return( "ApplicationData" );
239 case MBEDTLS_SSL_MSG_HANDSHAKE: break; /* See below */
240 default: return( "Unknown" );
241 }
242
243 if( len < 13 + 12 ) return( "Invalid handshake" );
244
245 /*
246 * Our handshake message are less than 2^16 bytes long, so they should
247 * have 0 as the first byte of length, frag_offset and frag_length.
248 * Otherwise, assume they are encrypted.
249 */
250 if( msg[14] || msg[19] || msg[22] ) return( "Encrypted handshake" );
251
252 switch( msg[13] )
253 {
254 case MBEDTLS_SSL_HS_HELLO_REQUEST: return( "HelloRequest" );
255 case MBEDTLS_SSL_HS_CLIENT_HELLO: return( "ClientHello" );
256 case MBEDTLS_SSL_HS_SERVER_HELLO: return( "ServerHello" );
257 case MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST: return( "HelloVerifyRequest" );
258 case MBEDTLS_SSL_HS_NEW_SESSION_TICKET: return( "NewSessionTicket" );
259 case MBEDTLS_SSL_HS_CERTIFICATE: return( "Certificate" );
260 case MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE: return( "ServerKeyExchange" );
261 case MBEDTLS_SSL_HS_CERTIFICATE_REQUEST: return( "CertificateRequest" );
262 case MBEDTLS_SSL_HS_SERVER_HELLO_DONE: return( "ServerHelloDone" );
263 case MBEDTLS_SSL_HS_CERTIFICATE_VERIFY: return( "CertificateVerify" );
264 case MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE: return( "ClientKeyExchange" );
265 case MBEDTLS_SSL_HS_FINISHED: return( "Finished" );
266 default: return( "Unknown handshake" );
267 }
268 }
269
270 /* Return elapsed time in milliseconds since the first call */
ellapsed_time(void)271 static unsigned long ellapsed_time( void )
272 {
273 #if defined(_WIN32)
274 return( 0 );
275 #else
276 static struct timeval ref = { 0, 0 };
277 struct timeval now;
278
279 if( ref.tv_sec == 0 && ref.tv_usec == 0 )
280 {
281 gettimeofday( &ref, NULL );
282 return( 0 );
283 }
284
285 gettimeofday( &now, NULL );
286 return( 1000 * ( now.tv_sec - ref.tv_sec )
287 + ( now.tv_usec - ref.tv_usec ) / 1000 );
288 #endif
289 }
290
291 typedef struct
292 {
293 mbedtls_net_context *dst;
294 const char *way;
295 const char *type;
296 unsigned len;
297 unsigned char buf[MAX_MSG_SIZE];
298 } packet;
299
300 /* Print packet. Outgoing packets come with a reason (forward, dupl, etc.) */
print_packet(const packet * p,const char * why)301 void print_packet( const packet *p, const char *why )
302 {
303 if( why == NULL )
304 mbedtls_printf( " %05lu %s %s (%u bytes)\n",
305 ellapsed_time(), p->way, p->type, p->len );
306 else
307 mbedtls_printf( " %s %s (%u bytes): %s\n",
308 p->way, p->type, p->len, why );
309 fflush( stdout );
310 }
311
send_packet(const packet * p,const char * why)312 int send_packet( const packet *p, const char *why )
313 {
314 int ret;
315 mbedtls_net_context *dst = p->dst;
316
317 /* insert corrupted ApplicationData record? */
318 if( opt.bad_ad &&
319 strcmp( p->type, "ApplicationData" ) == 0 )
320 {
321 unsigned char buf[MAX_MSG_SIZE];
322 memcpy( buf, p->buf, p->len );
323 ++buf[p->len - 1];
324
325 print_packet( p, "corrupted" );
326 if( ( ret = mbedtls_net_send( dst, buf, p->len ) ) <= 0 )
327 {
328 mbedtls_printf( " ! mbedtls_net_send returned %d\n", ret );
329 return( ret );
330 }
331 }
332
333 print_packet( p, why );
334 if( ( ret = mbedtls_net_send( dst, p->buf, p->len ) ) <= 0 )
335 {
336 mbedtls_printf( " ! mbedtls_net_send returned %d\n", ret );
337 return( ret );
338 }
339
340 /* Don't duplicate Application Data, only handshake covered */
341 if( opt.duplicate != 0 &&
342 strcmp( p->type, "ApplicationData" ) != 0 &&
343 rand() % opt.duplicate == 0 )
344 {
345 print_packet( p, "duplicated" );
346
347 if( ( ret = mbedtls_net_send( dst, p->buf, p->len ) ) <= 0 )
348 {
349 mbedtls_printf( " ! mbedtls_net_send returned %d\n", ret );
350 return( ret );
351 }
352 }
353
354 return( 0 );
355 }
356
357 static packet prev;
358
clear_pending(void)359 void clear_pending( void )
360 {
361 memset( &prev, 0, sizeof( packet ) );
362 }
363
364 /*
365 * Avoid dropping or delaying a packet that was already dropped twice: this
366 * only results in uninteresting timeouts. We can't rely on type to identify
367 * packets, since during renegotiation they're all encrypted. So, rely on
368 * size mod 2048 (which is usually just size).
369 */
370 static unsigned char dropped[2048] = { 0 };
371 #define DROP_MAX 2
372
373 /*
374 * OpenSSL groups packets in a datagram the first time it sends them, but not
375 * when it resends them. Count every record as seen the first time.
376 */
update_dropped(const packet * p)377 void update_dropped( const packet *p )
378 {
379 size_t id = p->len % sizeof( dropped );
380 const unsigned char *end = p->buf + p->len;
381 const unsigned char *cur = p->buf;
382 size_t len = ( ( cur[11] << 8 ) | cur[12] ) + 13;
383
384 ++dropped[id];
385
386 /* Avoid counting single record twice */
387 if( len == p->len )
388 return;
389
390 while( cur < end )
391 {
392 len = ( ( cur[11] << 8 ) | cur[12] ) + 13;
393
394 id = len % sizeof( dropped );
395 ++dropped[id];
396
397 cur += len;
398 }
399 }
400
handle_message(const char * way,mbedtls_net_context * dst,mbedtls_net_context * src)401 int handle_message( const char *way,
402 mbedtls_net_context *dst,
403 mbedtls_net_context *src )
404 {
405 int ret;
406 packet cur;
407 size_t id;
408
409 /* receive packet */
410 if( ( ret = mbedtls_net_recv( src, cur.buf, sizeof( cur.buf ) ) ) <= 0 )
411 {
412 mbedtls_printf( " ! mbedtls_net_recv returned %d\n", ret );
413 return( ret );
414 }
415
416 cur.len = ret;
417 cur.type = msg_type( cur.buf, cur.len );
418 cur.way = way;
419 cur.dst = dst;
420 print_packet( &cur, NULL );
421
422 id = cur.len % sizeof( dropped );
423
424 /* do we want to drop, delay, or forward it? */
425 if( ( opt.mtu != 0 &&
426 cur.len > (unsigned) opt.mtu ) ||
427 ( opt.drop != 0 &&
428 strcmp( cur.type, "ApplicationData" ) != 0 &&
429 ! ( opt.protect_hvr &&
430 strcmp( cur.type, "HelloVerifyRequest" ) == 0 ) &&
431 cur.len != (size_t) opt.protect_len &&
432 dropped[id] < DROP_MAX &&
433 rand() % opt.drop == 0 ) )
434 {
435 update_dropped( &cur );
436 }
437 else if( ( opt.delay_ccs == 1 &&
438 strcmp( cur.type, "ChangeCipherSpec" ) == 0 ) ||
439 ( opt.delay != 0 &&
440 strcmp( cur.type, "ApplicationData" ) != 0 &&
441 ! ( opt.protect_hvr &&
442 strcmp( cur.type, "HelloVerifyRequest" ) == 0 ) &&
443 prev.dst == NULL &&
444 cur.len != (size_t) opt.protect_len &&
445 dropped[id] < DROP_MAX &&
446 rand() % opt.delay == 0 ) )
447 {
448 memcpy( &prev, &cur, sizeof( packet ) );
449 }
450 else
451 {
452 /* forward and possibly duplicate */
453 if( ( ret = send_packet( &cur, "forwarded" ) ) != 0 )
454 return( ret );
455
456 /* send previously delayed message if any */
457 if( prev.dst != NULL )
458 {
459 ret = send_packet( &prev, "delayed" );
460 memset( &prev, 0, sizeof( packet ) );
461 if( ret != 0 )
462 return( ret );
463 }
464 }
465
466 return( 0 );
467 }
468
main(int argc,char * argv[])469 int main( int argc, char *argv[] )
470 {
471 int ret;
472
473 mbedtls_net_context listen_fd, client_fd, server_fd;
474
475 int nb_fds;
476 fd_set read_fds;
477
478 mbedtls_net_init( &listen_fd );
479 mbedtls_net_init( &client_fd );
480 mbedtls_net_init( &server_fd );
481
482 get_options( argc, argv );
483
484 /*
485 * Decisions to drop/delay/duplicate packets are pseudo-random: dropping
486 * exactly 1 in N packets would lead to problems when a flight has exactly
487 * N packets: the same packet would be dropped on every resend.
488 *
489 * In order to be able to reproduce problems reliably, the seed may be
490 * specified explicitly.
491 */
492 if( opt.seed == 0 )
493 {
494 opt.seed = (unsigned int) time( NULL );
495 mbedtls_printf( " . Pseudo-random seed: %u\n", opt.seed );
496 }
497
498 srand( opt.seed );
499
500 /*
501 * 0. "Connect" to the server
502 */
503 mbedtls_printf( " . Connect to server on UDP/%s/%s ...",
504 opt.server_addr, opt.server_port );
505 fflush( stdout );
506
507 if( ( ret = mbedtls_net_connect( &server_fd, opt.server_addr, opt.server_port,
508 MBEDTLS_NET_PROTO_UDP ) ) != 0 )
509 {
510 mbedtls_printf( " failed\n ! mbedtls_net_connect returned %d\n\n", ret );
511 goto exit;
512 }
513
514 mbedtls_printf( " ok\n" );
515
516 /*
517 * 1. Setup the "listening" UDP socket
518 */
519 mbedtls_printf( " . Bind on UDP/%s/%s ...",
520 opt.listen_addr, opt.listen_port );
521 fflush( stdout );
522
523 if( ( ret = mbedtls_net_bind( &listen_fd, opt.listen_addr, opt.listen_port,
524 MBEDTLS_NET_PROTO_UDP ) ) != 0 )
525 {
526 mbedtls_printf( " failed\n ! mbedtls_net_bind returned %d\n\n", ret );
527 goto exit;
528 }
529
530 mbedtls_printf( " ok\n" );
531
532 /*
533 * 2. Wait until a client connects
534 */
535 accept:
536 mbedtls_net_free( &client_fd );
537
538 mbedtls_printf( " . Waiting for a remote connection ..." );
539 fflush( stdout );
540
541 if( ( ret = mbedtls_net_accept( &listen_fd, &client_fd,
542 NULL, 0, NULL ) ) != 0 )
543 {
544 mbedtls_printf( " failed\n ! mbedtls_net_accept returned %d\n\n", ret );
545 goto exit;
546 }
547
548 mbedtls_printf( " ok\n" );
549
550 /*
551 * 3. Forward packets forever (kill the process to terminate it)
552 */
553 clear_pending();
554 memset( dropped, 0, sizeof( dropped ) );
555
556 nb_fds = client_fd.fd;
557 if( nb_fds < server_fd.fd )
558 nb_fds = server_fd.fd;
559 if( nb_fds < listen_fd.fd )
560 nb_fds = listen_fd.fd;
561 ++nb_fds;
562
563 while( 1 )
564 {
565 FD_ZERO( &read_fds );
566 FD_SET( server_fd.fd, &read_fds );
567 FD_SET( client_fd.fd, &read_fds );
568 FD_SET( listen_fd.fd, &read_fds );
569
570 if( ( ret = select( nb_fds, &read_fds, NULL, NULL, NULL ) ) <= 0 )
571 {
572 perror( "select" );
573 goto exit;
574 }
575
576 if( FD_ISSET( listen_fd.fd, &read_fds ) )
577 goto accept;
578
579 if( FD_ISSET( client_fd.fd, &read_fds ) )
580 {
581 if( ( ret = handle_message( "S <- C",
582 &server_fd, &client_fd ) ) != 0 )
583 goto accept;
584 }
585
586 if( FD_ISSET( server_fd.fd, &read_fds ) )
587 {
588 if( ( ret = handle_message( "S -> C",
589 &client_fd, &server_fd ) ) != 0 )
590 goto accept;
591 }
592 }
593
594 exit:
595
596 #ifdef MBEDTLS_ERROR_C
597 if( ret != 0 )
598 {
599 char error_buf[100];
600 mbedtls_strerror( ret, error_buf, 100 );
601 mbedtls_printf( "Last error was: -0x%04X - %s\n\n", - ret, error_buf );
602 fflush( stdout );
603 }
604 #endif
605
606 mbedtls_net_free( &client_fd );
607 mbedtls_net_free( &server_fd );
608 mbedtls_net_free( &listen_fd );
609
610 #if defined(_WIN32)
611 mbedtls_printf( " Press Enter to exit this program.\n" );
612 fflush( stdout ); getchar();
613 #endif
614
615 return( ret != 0 );
616 }
617
618 #endif /* MBEDTLS_NET_C */
619
