Line data    Source code

       1             : #include "fd_quic_sandbox.h"
       2             : #include "../fd_quic_private.h"
       3             : #include "../templ/fd_quic_parse_util.h"
       4             : 
       5             : /* fd_quic_sandbox_capture_pkt captures a single outgoing packet sent by
       6             :    fd_quic. */
       7             : 
       8             : static void
       9             : fd_quic_sandbox_capture_pkt( fd_quic_sandbox_t *       sandbox,
      10           0 :                              fd_aio_pkt_info_t const * pkt ) {
      11             : 
      12           0 :   ulong            seq    = sandbox->pkt_seq_w;
      13           0 :   fd_frag_meta_t * mcache = sandbox->pkt_mcache;
      14           0 :   void *           dcache = sandbox->pkt_dcache;
      15           0 :   ulong            mtu    = sandbox->pkt_mtu;
      16           0 :   ulong            chunk  = sandbox->pkt_chunk;
      17           0 :   ulong            chunk0 = fd_dcache_compact_chunk0( sandbox, dcache );
      18           0 :   ulong            wmark  = fd_dcache_compact_wmark ( sandbox, dcache, mtu );
      19           0 :   ulong            depth  = fd_mcache_depth( mcache );
      20           0 :   ulong            sz     = pkt->buf_sz;
      21           0 :   uchar *          data   = fd_chunk_to_laddr( sandbox, chunk );
      22           0 :   ulong            ctl    = fd_frag_meta_ctl( /* orig */ 0, /* som */ 1, /* eom */ 1, /* err */ 0 );
      23           0 :   ulong            ts     = sandbox->wallclock;
      24             : 
      25           0 :   fd_memcpy( data, pkt->buf, sz );
      26           0 :   fd_mcache_publish( mcache, depth, seq, 0UL, chunk, sz, ctl, ts, ts );
      27             : 
      28           0 :   sandbox->pkt_seq_w = fd_seq_inc( seq, 1UL );
      29           0 :   sandbox->pkt_chunk = fd_dcache_compact_next( chunk, pkt->buf_sz, chunk0, wmark );
      30           0 : }
      31             : 
      32             : /* fd_quic_sandbox_aio_send implements fd_aio_send_func_t.  Called by
      33             :    the sandbox fd_quic to capture response packets into the sandbox
      34             :    capture ring. */
      35             : 
      36             : static int
      37             : fd_quic_sandbox_aio_send( void *                    ctx,
      38             :                           fd_aio_pkt_info_t const * batch,
      39             :                           ulong                     batch_cnt,
      40             :                           ulong *                   opt_batch_idx,
      41           0 :                           int                       flush ) {
      42             : 
      43           0 :   fd_quic_sandbox_t * sandbox = (fd_quic_sandbox_t *)ctx;
      44             : 
      45           0 :   for( ulong j=0UL; j<batch_cnt; j++ ) {
      46           0 :     fd_quic_sandbox_capture_pkt( sandbox, batch + j );
      47           0 :   }
      48             : 
      49           0 :   ulong _batch_idx[1];
      50           0 :   opt_batch_idx = opt_batch_idx ? opt_batch_idx : _batch_idx;
      51           0 :   *opt_batch_idx = batch_cnt;
      52             : 
      53           0 :   (void)flush;
      54           0 :   return FD_AIO_SUCCESS;
      55           0 : }
      56             : 
      57             : fd_frag_meta_t const *
      58           0 : fd_quic_sandbox_next_packet( fd_quic_sandbox_t * sandbox ) {
      59           0 :   fd_frag_meta_t * mcache = sandbox->pkt_mcache;
      60             : 
      61           0 :   ulong depth = fd_mcache_depth( mcache );
      62           0 :   ulong seq   = sandbox->pkt_seq_r;
      63           0 :   ulong mline = fd_mcache_line_idx( seq, depth );
      64             : 
      65           0 :   fd_frag_meta_t * frag = mcache + mline;
      66           0 :   if( FD_UNLIKELY( fd_seq_lt( frag->seq, seq ) ) ) return NULL;
      67           0 :   if( FD_UNLIKELY( fd_seq_gt( frag->seq, seq ) ) ) {
      68             :     /* Occurs if the fd_quic published 'depth' packets in succession
      69             :        without any reads via this function. */
      70           0 :     FD_LOG_WARNING(( "overrun detected, some captured packets were lost" ));
      71           0 :     seq = frag->seq;
      72           0 :   }
      73             : 
      74           0 :   sandbox->pkt_seq_r = fd_seq_inc( seq, 1UL );
      75             : 
      76           0 :   return frag;
      77           0 : }
      78             : 
      79             : uchar const fd_quic_sandbox_self_ed25519_keypair[64] =
      80             :   { /* private key */
      81             :     0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
      82             :     0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
      83             :     0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
      84             :     0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
      85             :     /* public key */
      86             :     0xdb, 0x99, 0x5f, 0xe2, 0x51, 0x69, 0xd1, 0x41,
      87             :     0xca, 0xb9, 0xbb, 0xba, 0x92, 0xba, 0xa0, 0x1f,
      88             :     0x9f, 0x2e, 0x1e, 0xce, 0x7d, 0xf4, 0xcb, 0x2a,
      89             :     0xc0, 0x51, 0x90, 0xf3, 0x7f, 0xcc, 0x1f, 0x9d };
      90             : 
      91             : 
      92             : uchar const fd_quic_sandbox_peer_ed25519_keypair[64] =
      93             :   { /* private key */
      94             :     0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
      95             :     0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
      96             :     0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
      97             :     0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
      98             :     /* public key */
      99             :     0x21, 0x52, 0xf8, 0xd1, 0x9b, 0x79, 0x1d, 0x24,
     100             :     0x45, 0x32, 0x42, 0xe1, 0x5f, 0x2e, 0xab, 0x6c,
     101             :     0xb7, 0xcf, 0xfa, 0x7b, 0x6a, 0x5e, 0xd3, 0x00,
     102             :     0x97, 0x96, 0x0e, 0x06, 0x98, 0x81, 0xdb, 0x12 };
     103             : 
     104             : uchar const fd_quic_sandbox_aes128_key[16] =
     105             :   { 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43,
     106             :     0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43 };
     107             : 
     108             : uchar const fd_quic_sandbox_aes128_iv[12] =
     109             :   { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     110             :     0x00, 0x00, 0x00, 0x00 };
     111             : 
     112             : static ulong
     113    79319451 : fd_quic_sandbox_now_cb( void * context ) {
     114    79319451 :   fd_quic_sandbox_t * sandbox = context;
     115    79319451 :   return sandbox->wallclock;
     116    79319451 : }
     117             : 
     118             : ulong
     119          15 : fd_quic_sandbox_align( void ) {
     120          15 :   return fd_ulong_max( fd_ulong_max( fd_ulong_max( fd_ulong_max(
     121          15 :       alignof(fd_quic_sandbox_t),
     122          15 :       fd_quic_align() ),
     123          15 :       fd_mcache_align() ),
     124          15 :       fd_dcache_align() ),
     125          15 :       FD_CHUNK_ALIGN );
     126          15 : }
     127             : 
     128             : ulong
     129             : fd_quic_sandbox_footprint( fd_quic_limits_t const * quic_limits,
     130             :                            ulong                    pkt_cnt,
     131           6 :                            ulong                    mtu ) {
     132             : 
     133           6 :   ulong root_align = fd_quic_sandbox_align();
     134           6 :   ulong quic_fp    = fd_quic_footprint( quic_limits );
     135           6 :   ulong mcache_fp  = fd_mcache_footprint( pkt_cnt, 0UL );
     136           6 :   ulong dcache_fp  = fd_dcache_footprint( fd_dcache_req_data_sz( mtu, pkt_cnt, 1UL, 1 ), 0UL );
     137             : 
     138           6 :   if( FD_UNLIKELY( !quic_fp   ) ) return 0UL;
     139           6 :   if( FD_UNLIKELY( !mcache_fp ) ) return 0UL;
     140           6 :   if( FD_UNLIKELY( !dcache_fp ) ) return 0UL;
     141             : 
     142           6 :   ulong l = FD_LAYOUT_INIT;
     143           6 :   l = FD_LAYOUT_APPEND( l, root_align,        sizeof(fd_quic_sandbox_t) );
     144           6 :   l = FD_LAYOUT_APPEND( l, fd_quic_align(),   quic_fp                   );
     145           6 :   l = FD_LAYOUT_APPEND( l, fd_mcache_align(), mcache_fp                 );
     146           6 :   l = FD_LAYOUT_APPEND( l, fd_dcache_align(), dcache_fp                 );
     147           6 :   return FD_LAYOUT_FINI( l, root_align );
     148           6 : }
     149             : 
     150             : fd_quic_sandbox_t *
     151             : fd_quic_sandbox_new( void *                   mem,
     152             :                      fd_quic_limits_t const * quic_limits,
     153             :                      ulong                    pkt_cnt,
     154           3 :                      ulong                    mtu ) {
     155             : 
     156           3 :   if( FD_UNLIKELY( !mem ) ) {
     157           0 :     FD_LOG_WARNING(( "NULL mem" ));
     158           0 :     return NULL;
     159           0 :   }
     160             : 
     161           3 :   if( FD_UNLIKELY( !fd_ulong_is_aligned( (ulong)mem, fd_quic_sandbox_align() ) ) ) {
     162           0 :     FD_LOG_WARNING(( "misaligned mem" ));
     163           0 :     return NULL;
     164           0 :   }
     165             : 
     166           3 :   ulong fp = fd_quic_sandbox_footprint( quic_limits, pkt_cnt, mtu );
     167           3 :   if( FD_UNLIKELY( !fp ) ) {
     168           0 :     FD_LOG_WARNING(( "invalid params" ));
     169           0 :     return NULL;
     170           0 :   }
     171             : 
     172           3 :   ulong root_align     = fd_quic_sandbox_align();
     173           3 :   ulong quic_fp        = fd_quic_footprint( quic_limits );
     174           3 :   ulong mcache_fp      = fd_mcache_footprint( pkt_cnt, 0UL );
     175           3 :   ulong dcache_data_sz = fd_dcache_req_data_sz( mtu, pkt_cnt, 1UL, 1 );
     176           3 :   ulong dcache_fp      = fd_dcache_footprint( dcache_data_sz, 0UL );
     177             : 
     178           3 :   FD_SCRATCH_ALLOC_INIT( l, mem );
     179           3 :   fd_quic_sandbox_t * sandbox    = FD_SCRATCH_ALLOC_APPEND( l, root_align,        sizeof(fd_quic_sandbox_t) );
     180           3 :   void *              quic_mem   = FD_SCRATCH_ALLOC_APPEND( l, fd_quic_align(),   quic_fp                   );
     181           3 :   void *              mcache_mem = FD_SCRATCH_ALLOC_APPEND( l, fd_mcache_align(), mcache_fp                 );
     182           3 :   void *              dcache_mem = FD_SCRATCH_ALLOC_APPEND( l, fd_dcache_align(), dcache_fp                 );
     183           3 :   FD_SCRATCH_ALLOC_FINI( l, root_align );
     184             : 
     185           3 :   ulong seq0 = 0UL;  /* the first packet in the capture always has sequence number 0 */
     186             : 
     187           3 :   *sandbox = (fd_quic_sandbox_t) {
     188           3 :     .quic       = fd_quic_join  ( fd_quic_new( quic_mem, quic_limits ) ),
     189           3 :     .pkt_mcache = fd_mcache_join( fd_mcache_new( mcache_mem, pkt_cnt, 0UL, seq0 ) ),
     190           3 :     .pkt_dcache = fd_dcache_join( fd_dcache_new( dcache_mem, dcache_data_sz, 0UL ) ),
     191           3 :     .pkt_seq_r  = seq0,
     192           3 :     .pkt_mtu    = mtu
     193           3 :   };
     194           3 :   void * shmlog = (void *)( (ulong)sandbox->quic + sandbox->quic->layout.log_off );
     195           3 :   if( FD_UNLIKELY( !fd_quic_log_rx_join( sandbox->log_rx, shmlog ) ) ) {
     196           0 :     FD_LOG_CRIT(( "Failed to join the log of a newly created quic" ));
     197           0 :   }
     198             : 
     199           3 :   FD_COMPILER_MFENCE();
     200           3 :   sandbox->magic = FD_QUIC_SANDBOX_MAGIC;
     201           3 :   FD_COMPILER_MFENCE();
     202             : 
     203           3 :   return sandbox;
     204           3 : }
     205             : 
     206             : fd_quic_sandbox_t *
     207             : fd_quic_sandbox_init( fd_quic_sandbox_t * sandbox,
     208           3 :                       int                 role ) {
     209             : 
     210           3 :   fd_quic_t *        quic     = sandbox->quic;
     211           3 :   fd_quic_config_t * quic_cfg = &quic->config;
     212             : 
     213           3 :   quic_cfg->role                  = role;
     214           3 :   quic_cfg->idle_timeout          = FD_QUIC_SANDBOX_IDLE_TIMEOUT;
     215           3 :   quic_cfg->net.ip_addr           = FD_QUIC_SANDBOX_SELF_IP4;
     216           3 :   quic_cfg->net.listen_udp_port   = FD_QUIC_SANDBOX_SELF_PORT;
     217           3 :   quic_cfg->net.ephem_udp_port.lo = FD_QUIC_SANDBOX_SELF_PORT;
     218           3 :   quic_cfg->net.ephem_udp_port.hi = FD_QUIC_SANDBOX_SELF_PORT + 1;
     219           3 :   quic_cfg->initial_rx_max_stream_data = 512UL; /* arbitrary */
     220           3 :   memcpy( quic_cfg->identity_public_key, fd_quic_sandbox_self_ed25519_keypair + 32, 32 );
     221           3 :   memset( &quic->metrics, 0, sizeof(fd_quic_metrics_t) );
     222             : 
     223           3 :   fd_aio_t aio_tx = {
     224           3 :     .send_func = fd_quic_sandbox_aio_send,
     225           3 :     .ctx       = sandbox
     226           3 :   };
     227           3 :   fd_quic_set_aio_net_tx( quic, &aio_tx );
     228             : 
     229           3 :   quic->cb.now_ctx = sandbox;
     230           3 :   quic->cb.now     = fd_quic_sandbox_now_cb;
     231             : 
     232           3 :   if( FD_UNLIKELY( !fd_quic_init( quic ) ) ) {
     233           0 :     FD_LOG_WARNING(( "fd_quic_init failed" ));
     234           0 :     return NULL;
     235           0 :   }
     236             : 
     237           3 :   sandbox->wallclock = 0UL;
     238           3 :   sandbox->pkt_seq_r = 0UL;
     239           3 :   sandbox->pkt_seq_w = 0UL;
     240           3 :   sandbox->pkt_mcache[0].seq = ULONG_MAX;  /* mark first entry as unpublished */
     241           3 :   sandbox->pkt_chunk = fd_dcache_compact_chunk0( sandbox, sandbox->pkt_dcache );
     242             : 
     243             :   /* skip ahead the log seq no */
     244           3 :   fd_quic_log_tx_t * log_tx = fd_quic_get_state( quic )->log_tx;
     245           3 :   log_tx->seq += 4093; /* prime */
     246             : 
     247           3 :   return sandbox;
     248           3 : }
     249             : 
     250             : void *
     251           3 : fd_quic_sandbox_delete( fd_quic_sandbox_t * mem ) {
     252             : 
     253           3 :   if( FD_UNLIKELY( !mem ) ) {
     254           0 :     FD_LOG_WARNING(( "NULL mem" ));
     255           0 :     return NULL;
     256           0 :   }
     257             : 
     258           3 :   fd_quic_sandbox_t * sandbox = (fd_quic_sandbox_t *)mem;
     259           3 :   if( FD_UNLIKELY( sandbox->magic != FD_QUIC_SANDBOX_MAGIC ) ) {
     260           0 :     FD_LOG_WARNING(( "invalid magic" ));
     261           0 :     return NULL;
     262           0 :   }
     263             : 
     264           3 :   FD_COMPILER_MFENCE();
     265           3 :   sandbox->magic = 0UL;
     266           3 :   FD_COMPILER_MFENCE();
     267             : 
     268           3 :   fd_quic_delete  ( fd_quic_leave  ( sandbox->quic       ) );
     269           3 :   fd_mcache_delete( fd_mcache_leave( sandbox->pkt_mcache ) );
     270           3 :   fd_dcache_delete( fd_dcache_leave( sandbox->pkt_dcache ) );
     271             : 
     272           3 :   return mem;
     273           3 : }
     274             : 
     275             : fd_quic_conn_t *
     276             : fd_quic_sandbox_new_conn_established( fd_quic_sandbox_t * sandbox,
     277      300000 :                                       fd_rng_t *          rng ) {
     278             : 
     279      300000 :   fd_quic_t * quic = sandbox->quic;
     280             : 
     281             :   /* fd_quic_t conn IDs are always 8 bytes */
     282      300000 :   ulong             our_conn_id_u64 = fd_rng_ulong( rng );
     283             : 
     284             :   /* the peer may choose a conn ID size 1 to 16 bytes
     285             :      For now, pick 8 bytes too */
     286      300000 :   ulong             peer_conn_id_u64 = fd_rng_ulong( rng );
     287      300000 :   fd_quic_conn_id_t peer_conn_id     = fd_quic_conn_id_new( &peer_conn_id_u64, 8UL );
     288             : 
     289      300000 :   fd_quic_conn_t * conn = fd_quic_conn_create(
     290      300000 :       /* quic         */ quic,
     291      300000 :       /* our_conn_id  */ our_conn_id_u64,
     292      300000 :       /* peer_conn_id */ &peer_conn_id,
     293             :       /* dst_ip_addr  */ FD_QUIC_SANDBOX_PEER_IP4,
     294             :       /* dst_udp_addr */ FD_QUIC_SANDBOX_PEER_PORT,
     295      300000 :       /* server       */ quic->config.role == FD_QUIC_ROLE_SERVER );
     296      300000 :   if( FD_UNLIKELY( !conn ) ) {
     297           0 :     FD_LOG_WARNING(( "fd_quic_conn_create failed" ));
     298           0 :     return NULL;
     299           0 :   }
     300             : 
     301      300000 :   conn->state       = FD_QUIC_CONN_STATE_ACTIVE;
     302      300000 :   conn->established = 1;
     303             : 
     304             :   /* Mock a completed handshake */
     305      300000 :   conn->handshake_complete = 1;
     306      300000 :   conn->peer_enc_level     = fd_quic_enc_level_appdata_id;
     307      300000 :   conn->keys_avail         = 1U<<fd_quic_enc_level_appdata_id;
     308             : 
     309      300000 :   conn->idle_timeout  = FD_QUIC_SANDBOX_IDLE_TIMEOUT;
     310      300000 :   conn->last_activity = sandbox->wallclock;
     311             : 
     312             :   /* Reset flow control limits */
     313      300000 :   conn->tx_max_data           = 0UL;
     314      300000 :   conn->tx_tot_data           = 0UL;
     315      300000 :   conn->srx->rx_max_data      = 0UL;
     316      300000 :   conn->srx->rx_tot_data      = 0UL;
     317      300000 :   conn->srx->rx_max_data_ackd = 0UL;
     318      300000 :   conn->tx_initial_max_stream_data_uni = 0UL;
     319             : 
     320             :   /* TODO set a realistic packet number */
     321             : 
     322      300000 :   return conn;
     323      300000 : }
     324             : 
     325             : void
     326             : fd_quic_sandbox_send_frame( fd_quic_sandbox_t * sandbox,
     327             :                             fd_quic_conn_t *    conn,
     328             :                             fd_quic_pkt_t *     pkt_meta,
     329             :                             uchar const *       frame_ptr,
     330    79319448 :                             ulong               frame_sz ) {
     331             : 
     332             :   /* TODO consider crafting a real app packet instead of bypassing
     333             :           packet processing checks */
     334             : 
     335    79319448 :   fd_quic_t * quic = sandbox->quic;
     336             : 
     337             :   /* set pkt_type to FD_QUIC_PKT_TYPE_ONE_RTT as it allows all
     338             :    * frame types */
     339    79319448 :   uint pkt_type = FD_QUIC_PKT_TYPE_ONE_RTT;
     340             : 
     341    79319448 :   ulong rc = fd_quic_handle_v1_frame( quic, conn, pkt_meta, pkt_type, frame_ptr, frame_sz );
     342    79319448 :   if( FD_UNLIKELY( rc==FD_QUIC_PARSE_FAIL ) ) return;
     343    79319448 :   if( FD_UNLIKELY( rc==0UL || rc>frame_sz ) ) {
     344           0 :     FD_LOG_CRIT(( "Invalid fd_quic_handle_v1_frame return value (rc=%#lx frame_sz=%#lx)", rc, frame_sz ));
     345           0 :   }
     346             : 
     347    79319448 : }
     348             : 
     349             : void
     350             : fd_quic_sandbox_send_lone_frame( fd_quic_sandbox_t * sandbox,
     351             :                                  fd_quic_conn_t *    conn,
     352             :                                  uchar const *       frame,
     353    79319448 :                                  ulong               frame_sz ) {
     354             : 
     355    79319448 :   FD_TEST( frame_sz <= sandbox->pkt_mtu );
     356             : 
     357    79319448 :   ulong pkt_num = conn->exp_pkt_number[2]++;
     358             : 
     359    79319448 :   ulong quic_pkt_sz = frame_sz;  /* TODO mock some QUIC packetization overhead */
     360             : 
     361    79319448 :   fd_quic_pkt_t pkt_meta = {
     362    79319448 :     .ip4 = {{
     363    79319448 :       .verihl       = FD_IP4_VERIHL(4,5),
     364    79319448 :       .net_tot_len  = (ushort)( 20 + 8 + quic_pkt_sz ),
     365    79319448 :       .net_frag_off = 0x4000u, /* don't fragment */
     366    79319448 :       .ttl          = 64,
     367    79319448 :       .protocol     = FD_IP4_HDR_PROTOCOL_UDP,
     368    79319448 :     }},
     369    79319448 :     .udp = {{
     370    79319448 :       .net_sport = FD_QUIC_SANDBOX_PEER_PORT,
     371    79319448 :       .net_dport = FD_QUIC_SANDBOX_SELF_PORT,
     372    79319448 :       .net_len   = (ushort)( 8 + quic_pkt_sz ),
     373    79319448 :     }},
     374    79319448 :     .pkt_number = pkt_num,
     375    79319448 :     .rcv_time   = sandbox->wallclock,
     376    79319448 :     .enc_level  = fd_quic_enc_level_appdata_id,
     377    79319448 :   };
     378             : 
     379    79319448 :   fd_quic_sandbox_send_frame( sandbox, conn, &pkt_meta, frame, frame_sz );
     380             : 
     381    79319448 :   fd_quic_lazy_ack_pkt( sandbox->quic, conn, &pkt_meta );
     382             : 
     383             :   /* Synchronize log seq[0] from tx to rx */
     384    79319448 :   fd_quic_log_tx_seq_update( fd_quic_get_state( sandbox->quic )->log_tx );
     385    79319448 : }
     386             : 
     387             : void
     388             : fd_quic_sandbox_send_ping_pkt( fd_quic_sandbox_t * sandbox,
     389             :                                fd_quic_conn_t *    conn,
     390           0 :                                ulong               pktnum ) {
     391             : 
     392           0 :   uchar pkt_buf[ 256 ];
     393           0 :   pkt_buf[0] = fd_quic_one_rtt_h0( /* spin */         0,
     394           0 :                                    /* key_phase */    !!conn->key_phase,
     395           0 :                                    /* pktnum_len-1 */ 3 );
     396           0 :   memcpy( pkt_buf+1, &conn->our_conn_id, FD_QUIC_CONN_ID_SZ );
     397           0 :   uint pktnum_comp = fd_uint_bswap( (uint)( pktnum & UINT_MAX ) );
     398           0 :   memcpy( pkt_buf+9, &pktnum_comp, 4 );
     399           0 :   pkt_buf[13] = 0x01;  /* PING frame */
     400           0 :   memset( pkt_buf+14, 0, 18UL );
     401             : 
     402           0 :   fd_quic_crypto_keys_t * keys = &conn->keys[fd_quic_enc_level_appdata_id][0];
     403           0 :   ulong out_sz = 48UL;
     404           0 :   int crypt_res = fd_quic_crypto_encrypt( pkt_buf, &out_sz, pkt_buf, 13UL, pkt_buf+13, 19UL, keys, keys, pktnum );
     405           0 :   FD_TEST( crypt_res==FD_QUIC_SUCCESS );
     406             : 
     407           0 :   fd_quic_pkt_t pkt_meta = {
     408           0 :     .ip4 = {{
     409           0 :       .verihl       = FD_IP4_VERIHL(4,5),
     410           0 :       .net_tot_len  = 28,
     411           0 :       .net_frag_off = 0x4000u, /* don't fragment */
     412           0 :       .ttl          = 64,
     413           0 :       .protocol     = FD_IP4_HDR_PROTOCOL_UDP,
     414           0 :     }},
     415           0 :     .udp = {{
     416           0 :       .net_sport = FD_QUIC_SANDBOX_PEER_PORT,
     417           0 :       .net_dport = FD_QUIC_SANDBOX_SELF_PORT,
     418           0 :       .net_len   = 8,
     419           0 :     }},
     420           0 :     .pkt_number = pktnum,
     421           0 :     .rcv_time   = sandbox->wallclock,
     422           0 :     .enc_level  = fd_quic_enc_level_appdata_id,
     423           0 :   };
     424             : 
     425           0 :   fd_quic_process_quic_packet_v1( sandbox->quic, &pkt_meta, pkt_buf, out_sz );
     426           0 : }