third_party/mbedtls/repo/programs/test/udp_proxy.c

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