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 creates an fd_tls provider from an fd_rng_t.
      12             :    This is a deliberately insecure, deterministic RNG intended for tests. */
      13             : 
      14             : static void *
      15             : fd_tls_test_rand_read( void * ctx,
      16             :                        void * buf,
      17          21 :                        ulong  bufsz ) {
      18             : 
      19          21 :   if( FD_UNLIKELY( !ctx ) ) return NULL;
      20             : 
      21          21 :   fd_rng_t * rng  = (fd_rng_t *)ctx;
      22          21 :   uchar *    buf_ = (uchar *)buf;
      23         693 :   for( ulong i=0UL; i<bufsz; i++ )
      24         672 :     buf_[i] = (uchar)fd_rng_uchar( rng );
      25          21 :   return buf_;
      26          21 : }
      27             : 
      28             : static FD_FN_UNUSED fd_tls_rand_t
      29          36 : fd_tls_test_rand( fd_rng_t * rng ) {
      30          36 :   return (fd_tls_rand_t) {
      31          36 :     .ctx     = rng,
      32          36 :     .rand_fn = fd_tls_test_rand_read
      33          36 :   };
      34          36 : }
      35             : 
      36             : struct fd_tls_test_sign_ctx {
      37             :   fd_sha512_t sha512[ 1 ];
      38             : 
      39             :   uchar public_key[ 32UL ];
      40             :   uchar private_key[ 32UL ];
      41             : };
      42             : typedef struct fd_tls_test_sign_ctx fd_tls_test_sign_ctx_t;
      43             : 
      44             : static void
      45             : fd_tls_test_sign_sign( void *        _ctx,
      46             :                        uchar *       signature,
      47       12159 :                        uchar const * payload ) {
      48       12159 :   fd_tls_test_sign_ctx_t * ctx = (fd_tls_test_sign_ctx_t *)_ctx;
      49       12159 :   fd_ed25519_sign( signature, payload, 130UL, ctx->public_key, ctx->private_key, ctx->sha512 );
      50       12159 : }
      51             : 
      52             : static FD_FN_UNUSED void
      53             : fd_tls_test_sign_ctx( fd_tls_test_sign_ctx_t * ctx,
      54          87 :                       fd_rng_t *               rng ) {
      55          87 :   FD_TEST( fd_sha512_join( fd_sha512_new( ctx->sha512 ) ) );
      56        2871 :   for( ulong b=0; b<32UL; b++ ) ctx->private_key[b] = fd_rng_uchar( rng );
      57          87 :   fd_ed25519_public_from_private( ctx->public_key, ctx->private_key, ctx->sha512 );
      58          87 : }
      59             : 
      60             : 
      61             : static FD_FN_UNUSED fd_tls_sign_t
      62          39 : fd_tls_test_sign( void * ctx ) {
      63          39 :   return (fd_tls_sign_t) {
      64          39 :     .ctx     = ctx,
      65          39 :     .sign_fn = fd_tls_test_sign_sign
      66          39 :   };
      67          39 : }
      68             : 
      69             : /* Test record transport */
      70             : 
      71             : #define TEST_RECORD_BUFSZ (4096UL)
      72             : struct test_record {
      73             :   uint  level;
      74             :   uchar buf[ TEST_RECORD_BUFSZ ];
      75             :   ulong cur;
      76             : };
      77             : 
      78             : typedef struct test_record test_record_t;
      79             : 
      80         162 : #define TEST_RECORD_BUF_CNT (8UL)
      81             : struct test_record_buf {
      82             :   test_record_t records[ TEST_RECORD_BUF_CNT ];
      83             :   ulong         recv;
      84             :   ulong         send;
      85             : };
      86             : 
      87             : typedef struct test_record_buf test_record_buf_t;
      88             : 
      89             : static FD_FN_UNUSED void
      90          24 : test_record_reset( test_record_buf_t * buf ) {
      91          24 :   buf->recv = buf->send = 0UL;
      92          24 : }
      93             : 
      94             : static FD_FN_UNUSED void
      95             : test_record_send( test_record_buf_t * buf,
      96             :                   uint                level,
      97             :                   uchar const *       record,
      98         162 :                   ulong               record_sz ) {
      99         162 :   test_record_t * r = &buf->records[ (buf->send++ % TEST_RECORD_BUF_CNT) ];
     100         162 :   r->level = level;
     101         162 :   r->cur   = record_sz;
     102         162 :   FD_TEST( record_sz<=TEST_RECORD_BUFSZ );
     103         162 :   fd_memcpy( r->buf, record, record_sz );
     104         162 : }
     105             : 
     106             : static FD_FN_UNUSED test_record_t *
     107         192 : test_record_recv( test_record_buf_t * buf ) {
     108         192 :   if( buf->recv==buf->send ) return NULL;
     109         147 :   return &buf->records[ buf->recv++ ];
     110         192 : }
     111             : 
     112             : static FD_FN_UNUSED void
     113             : test_record_log( uchar const * record,
     114             :                  ulong         record_sz,
     115         162 :                  int           from_server ) {
     116             : 
     117         162 :   FD_TEST( record_sz>=4UL );
     118             : 
     119         162 :   char buf[ 512UL ];
     120         162 :   char * str = fd_cstr_init( buf );
     121             : 
     122         162 :   char const * prefix = from_server ? "server" : "client";
     123         162 :          str = fd_cstr_append_cstr( str, prefix );
     124         162 :          str = fd_cstr_append_cstr( str, ": " );
     125             : 
     126         162 :   char const * type = NULL;
     127         162 :   switch( *(uchar const *)record ) {
     128          21 :   case FD_TLS_MSG_CLIENT_HELLO:       type = "ClientHello";         break;
     129          18 :   case FD_TLS_MSG_SERVER_HELLO:       type = "ServerHello";         break;
     130          15 :   case FD_TLS_MSG_ENCRYPTED_EXT:      type = "EncryptedExtensions"; break;
     131          27 :   case FD_TLS_MSG_CERT:               type = "Certificate";         break;
     132          27 :   case FD_TLS_MSG_CERT_VERIFY:        type = "CertificateVerify";   break;
     133          12 :   case FD_TLS_MSG_CERT_REQ:           type = "CertificateRequest";  break;
     134          30 :   case FD_TLS_MSG_FINISHED:           type = "Finished";            break;
     135          12 :   case FD_TLS_MSG_NEW_SESSION_TICKET: type = "NewSessionTicket";    break;
     136           0 :   default:
     137           0 :     FD_LOG_ERR(( "unknown TLS message type %u", *(uchar const *)record ));
     138         162 :   }
     139         162 :   str = fd_cstr_append_cstr( str, type );
     140         162 :   fd_cstr_fini( str );
     141             : 
     142         162 :   FD_LOG_HEXDUMP_INFO(( buf, record, record_sz ));
     143         162 : }
     144             : 
     145             : #endif /* HEADER_fd_src_waltz_tls_test_tls_helper_h */