Line data    Source code

       1             : #ifndef HEADER_fd_src_waltz_tls_test_tls_helper_h
       2             : #define HEADER_fd_src_waltz_tls_test_tls_helper_h
       3             : 
       4             : #include "fd_tls.h"
       5             : #include "fd_tls_proto.h"
       6             : #include "../../ballet/sha512/fd_sha512.h"
       7             : #include "../../ballet/ed25519/fd_ed25519.h"
       8             : 
       9             : /* Common routines for fd_tls unit tests */
      10             : 
      11             : /* fd_tls_test_rand formats mem as a ChaCha8 RNG keyed from rng and
      12             :    returns it, for use as fd_tls_t.rng.  Deliberately deterministic:
      13             :    tests and fuzz cases must be reproducible.  mem must outlive every
      14             :    handshake driven by the fd_tls_t it is installed in. */
      15             : 
      16             : static FD_FN_UNUSED fd_chacha_rng_t *
      17             : fd_tls_test_rand( fd_chacha_rng_t * mem,
      18         168 :                   fd_rng_t *        rng ) {
      19         168 :   uchar key[ 32 ];
      20        5544 :   for( ulong i=0UL; i<sizeof(key); i++ ) key[i] = fd_rng_uchar( rng );
      21         168 :   fd_chacha_rng_t * chacha = fd_chacha_rng_join( fd_chacha_rng_new( mem, FD_CHACHA_RNG_MODE_SHIFT ) );
      22         168 :   FD_TEST( chacha );
      23         168 :   return fd_chacha_rng_init( chacha, key, FD_CHACHA_RNG_ALGO_CHACHA8 );
      24         168 : }
      25             : 
      26             : struct fd_tls_test_sign_ctx {
      27             :   fd_sha512_t sha512[ 1 ];
      28             : 
      29             :   uchar public_key[ 32UL ];
      30             :   uchar private_key[ 32UL ];
      31             : };
      32             : typedef struct fd_tls_test_sign_ctx fd_tls_test_sign_ctx_t;
      33             : 
      34             : static void
      35             : fd_tls_test_sign_sign( void *        _ctx,
      36             :                        uchar *       signature,
      37       12531 :                        uchar const * payload ) {
      38       12531 :   fd_tls_test_sign_ctx_t * ctx = (fd_tls_test_sign_ctx_t *)_ctx;
      39       12531 :   fd_ed25519_sign( signature, payload, 130UL, ctx->public_key, ctx->private_key, ctx->sha512 );
      40       12531 : }
      41             : 
      42             : static FD_FN_UNUSED void
      43             : fd_tls_test_sign_ctx( fd_tls_test_sign_ctx_t * ctx,
      44         213 :                       fd_rng_t *               rng ) {
      45         213 :   FD_TEST( fd_sha512_join( fd_sha512_new( ctx->sha512 ) ) );
      46        7029 :   for( ulong b=0; b<32UL; b++ ) ctx->private_key[b] = fd_rng_uchar( rng );
      47         213 :   fd_ed25519_public_from_private( ctx->public_key, ctx->private_key, ctx->sha512 );
      48         213 : }
      49             : 
      50             : 
      51             : static FD_FN_UNUSED fd_tls_sign_t
      52         165 : fd_tls_test_sign( void * ctx ) {
      53         165 :   return (fd_tls_sign_t) {
      54         165 :     .ctx     = ctx,
      55         165 :     .sign_fn = fd_tls_test_sign_sign
      56         165 :   };
      57         165 : }
      58             : 
      59             : /* Test record transport */
      60             : 
      61             : #define TEST_RECORD_BUFSZ (4096UL)
      62             : struct test_record {
      63             :   uint  level;
      64             :   uchar buf[ TEST_RECORD_BUFSZ ];
      65             :   ulong cur;
      66             : };
      67             : 
      68             : typedef struct test_record test_record_t;
      69             : 
      70          60 : #define TEST_RECORD_BUF_CNT (8UL)
      71             : struct test_record_buf {
      72             :   test_record_t records[ TEST_RECORD_BUF_CNT ];
      73             :   ulong         recv;
      74             :   ulong         send;
      75             : };
      76             : 
      77             : typedef struct test_record_buf test_record_buf_t;
      78             : 
      79             : static FD_FN_UNUSED void
      80          24 : test_record_reset( test_record_buf_t * buf ) {
      81          24 :   buf->recv = buf->send = 0UL;
      82          24 : }
      83             : 
      84             : static FD_FN_UNUSED void
      85             : test_record_send( test_record_buf_t * buf,
      86             :                   uint                level,
      87             :                   uchar const *       record,
      88          60 :                   ulong               record_sz ) {
      89          60 :   test_record_t * r = &buf->records[ (buf->send++ % TEST_RECORD_BUF_CNT) ];
      90          60 :   r->level = level;
      91          60 :   r->cur   = record_sz;
      92          60 :   FD_TEST( record_sz<=TEST_RECORD_BUFSZ );
      93          60 :   fd_memcpy( r->buf, record, record_sz );
      94          60 : }
      95             : 
      96             : static FD_FN_UNUSED test_record_t *
      97          57 : test_record_recv( test_record_buf_t * buf ) {
      98          57 :   if( buf->recv==buf->send ) return NULL;
      99          48 :   return &buf->records[ buf->recv++ ];
     100          57 : }
     101             : 
     102             : static FD_FN_UNUSED void
     103             : test_record_log( uchar const * record,
     104             :                  ulong         record_sz,
     105          60 :                  int           from_server ) {
     106             : 
     107          60 :   FD_TEST( record_sz>=4UL );
     108             : 
     109          60 :   char buf[ 512UL ];
     110          60 :   char * str = fd_cstr_init( buf );
     111             : 
     112          60 :   char const * prefix = from_server ? "server" : "client";
     113          60 :          str = fd_cstr_append_cstr( str, prefix );
     114          60 :          str = fd_cstr_append_cstr( str, ": " );
     115             : 
     116          60 :   char const * type = NULL;
     117          60 :   switch( *(uchar const *)record ) {
     118          18 :   case FD_TLS_MSG_CLIENT_HELLO:         type = "ClientHello";         break;
     119           3 :   case FD_TLS_MSG_SERVER_HELLO:         type = "ServerHello";         break;
     120           3 :   case FD_TLS_MSG_ENCRYPTED_EXT:        type = "EncryptedExtensions"; break;
     121          12 :   case FD_TLS_MSG_CERT:                 type = "Certificate";         break;
     122           9 :   case FD_TLS_MSG_CERT_VERIFY:          type = "CertificateVerify";   break;
     123           3 :   case FD_TLS_MSG_CERT_REQ:             type = "CertificateRequest";  break;
     124          12 :   case FD_TLS_MSG_FINISHED:             type = "Finished";            break;
     125           0 :   case FD_TLS_MSG_NEW_SESSION_TICKET:   type = "NewSessionTicket";    break;
     126           0 :   default:
     127           0 :     FD_LOG_ERR(( "unknown TLS message type %u", *(uchar const *)record ));
     128          60 :   }
     129          60 :   str = fd_cstr_append_cstr( str, type );
     130          60 :   fd_cstr_fini( str );
     131             : 
     132          60 :   FD_LOG_HEXDUMP_INFO(( buf, record, record_sz ));
     133          60 : }
     134             : 
     135             : #endif /* HEADER_fd_src_waltz_tls_test_tls_helper_h */