src/recordHandler.cpp

   1 #include "recordHandler.h"
   2
   3 #include <sys/types.h>
   4 #include <sys/socket.h>
   5 #include <netinet/in.h>
   6 #include <arpa/inet.h>
   7 #include <termios.h>
   8 #include <unistd.h>
   9
  10 #include <iostream>
  11
  12 #include <openssl/ssl.h>
  13
  14 #include "database.h"
  15 #include "record.h"
  16 #include "opensslBIO.h"
  17 #include "simpleOpensslSigner.h"
  18 #include "slipBio.h"
  19
  20 int gencb( int a, int b, BN_GENCB* g ) {
  21     ( void ) a;
  22     ( void ) b;
  23     ( void ) g;
  24
  25     std::cout << ( a == 0 ? "." : "+" ) << std::flush;
  26
  27     return 1;
  28 }
  29
  30 int vfy( int prevfy, X509_STORE_CTX* ct ) {
  31     ( void ) ct;
  32     return prevfy;
  33 }
  34
  35 static std::shared_ptr<DH> dh_param;
  36
  37 std::shared_ptr<SSL_CTX> generateSSLContext( bool server ) {
  38     std::shared_ptr<SSL_CTX> ctx = std::shared_ptr<SSL_CTX>( SSL_CTX_new( TLSv1_2_method() ), SSL_CTX_free );
  39
  40     if( !SSL_CTX_set_cipher_list( ctx.get(), "HIGH:+CAMELLIA256:!eNull:!aNULL:!ADH:!MD5:-RSA+AES+SHA1:!RC4:!DES:!3DES:!SEED:!EXP:!AES128:!CAMELLIA128" ) ) {
  41         throw "Cannot set cipher list. Your source is broken.";
  42     }
  43
  44     SSL_CTX_set_verify( ctx.get(), SSL_VERIFY_NONE, vfy );
  45     SSL_CTX_use_certificate_file( ctx.get(), "testdata/server.crt", SSL_FILETYPE_PEM );
  46     SSL_CTX_use_PrivateKey_file( ctx.get(), "testdata/server.key", SSL_FILETYPE_PEM );
  47     std::shared_ptr<STACK_OF( X509_NAME )> cert_names(
  48         SSL_load_client_CA_file( "testdata/server.crt" ),
  49         []( STACK_OF( X509_NAME ) *st ) {
  50             std::cout << "freeing" << std::endl;
  51             sk_X509_NAME_free( st );
  52         } );
  53
  54     if( cert_names ) {
  55         SSL_CTX_set_client_CA_list( ctx.get(), cert_names.get() );
  56     }
  57
  58     if( server ) {
  59         if( !dh_param ) {
  60             FILE* paramfile = fopen( "dh_param.pem", "r" );
  61
  62             if( paramfile ) {
  63                 dh_param = std::shared_ptr<DH>( PEM_read_DHparams( paramfile, NULL, NULL, NULL ), DH_free );
  64                 fclose( paramfile );
  65             } else {
  66                 dh_param = std::shared_ptr<DH>( DH_new(), DH_free );
  67                 std::cout << "Generating DH params" << std::endl;
  68                 BN_GENCB cb;
  69                 cb.ver = 2;
  70                 cb.arg = 0;
  71                 cb.cb.cb_2 = gencb;
  72
  73                 if( !DH_generate_parameters_ex( dh_param.get(), 2048, 5, &cb ) ) {
  74                     throw "DH generation failed";
  75                 }
  76
  77                 std::cout << std::endl;
  78                 paramfile = fopen( "dh_param.pem", "w" );
  79
  80                 if( paramfile ) {
  81                     PEM_write_DHparams( paramfile, dh_param.get() );
  82                     fclose( paramfile );
  83                 }
  84             }
  85         }
  86
  87         if( !SSL_CTX_set_tmp_dh( ctx.get(), dh_param.get() ) ) {
  88             throw "Cannot set tmp dh.";
  89         }
  90     }
  91
  92     return ctx;
  93 }
  94
  95 class RecordHandlerSession {
  96 public:
  97     uint32_t sessid;
  98     uint32_t lastCommandCount;
  99
 100     std::shared_ptr<TBSCertificate> tbs;
 101     std::shared_ptr<SignedCertificate> result;
 102
 103     SSL* ssl;
 104
 105     std::shared_ptr<OpensslBIOWrapper> io;
 106     DefaultRecordHandler* parent;
 107     std::shared_ptr<Signer> signer;
 108
 109     RecordHandlerSession( DefaultRecordHandler* parent, std::shared_ptr<Signer> signer, std::shared_ptr<SSL_CTX> ctx, std::shared_ptr<BIO> output ) :
 110         tbs( new TBSCertificate() ) {
 111         this->parent = parent;
 112         this->signer = signer;
 113
 114         ssl = SSL_new( ctx.get() );
 115         std::shared_ptr<BIO> bio( BIO_new( BIO_f_ssl() ), [output]( BIO * p ) {
 116             BIO_free( p );
 117         } );
 118         SSL_set_accept_state( ssl );
 119         SSL_set_bio( ssl, output.get(), output.get() );
 120         BIO_set_ssl( bio.get(), ssl, BIO_NOCLOSE );
 121         io = std::shared_ptr<OpensslBIOWrapper>( new OpensslBIOWrapper( bio ) );
 122     }
 123
 124     void respondCommand( RecordHeader::SignerResult res, std::string payload ) {
 125         RecordHeader rh;
 126         rh.command = ( uint16_t ) res;
 127         rh.flags = 0;
 128         rh.command_count = 0; // TODO i++
 129         rh.totalLength = payload.size();
 130         sendCommand( rh, payload, io );
 131     }
 132
 133     void work() {
 134         std::cout << "done" << std::endl;
 135         std::vector<char> buffer( 2048, 0 );
 136         std::cout << "reading" << std::endl;
 137         int res = io->read( buffer.data(), buffer.capacity() );
 138         std::cout << "read" << std::endl;
 139
 140         if( res <= 0 ) {
 141             parent->reset();
 142             return;
 143         }
 144
 145         std::string content( buffer.data(), res );
 146
 147         try {
 148             RecordHeader head;
 149             std::string payload = parseCommand( head, content );
 150             execute( head, payload );
 151         } catch( const char* msg ) {
 152             std::cout << msg << std::endl;
 153             parent->reset();
 154             return;
 155         }
 156     }
 157
 158     void execute( RecordHeader& head, std::string data ) {
 159         if( head.totalLength != head.payloadLength || head.offset != 0 ) {
 160             throw "Error, chunking not supported yet";
 161         }
 162
 163         switch( ( RecordHeader::SignerCommand ) head.command ) {
 164         case RecordHeader::SignerCommand::SET_CSR: // setCSR
 165             tbs->csr_content = data;
 166             tbs->csr_type = "CSR";
 167             std::cout << "CSR read" << std::endl;
 168             break;
 169
 170         case RecordHeader::SignerCommand::SET_SIGNATURE_TYPE:
 171             tbs->md = data;
 172             break;
 173
 174         case RecordHeader::SignerCommand::SET_PROFILE:
 175             // TODO
 176             tbs->profile = data;
 177             break;
 178
 179         case RecordHeader::SignerCommand::ADD_SAN: {
 180             size_t pos = data.find( "," );
 181
 182             if( pos == std::string::npos ) {
 183             } else {
 184                 std::shared_ptr<SAN> san( new SAN() );
 185                 san->type = data.substr( 0, pos );
 186                 san->content = data.substr( pos + 1 );
 187                 tbs->SANs.push_back( san );
 188             }
 189         }
 190         break;
 191
 192         case RecordHeader::SignerCommand::ADD_AVA: {
 193             size_t pos = data.find( "," );
 194
 195             if( pos == std::string::npos ) {
 196                 // error
 197             } else {
 198                 std::shared_ptr<AVA> ava( new AVA() );
 199                 ava->name = data.substr( 0, pos );
 200                 ava->value = data.substr( pos + 1 );
 201                 tbs->AVAs.push_back( ava );
 202             }
 203         }
 204         break;
 205
 206         case RecordHeader::SignerCommand::ADD_PROOF_LINE:
 207             break;
 208
 209         case RecordHeader::SignerCommand::SIGN:
 210             result = signer->sign( tbs );
 211             std::cout << "res: " << result->certificate << std::endl;
 212             result->log = "I am a dummy log.\nI signed that thing ;-) \n";
 213             respondCommand( RecordHeader::SignerResult::SAVE_LOG, result->log );
 214             break;
 215
 216         case RecordHeader::SignerCommand::LOG_SAVED:
 217             if( result ) {
 218                 respondCommand( RecordHeader::SignerResult::CERTIFICATE, result->certificate );
 219             }
 220
 221             break;
 222
 223         default:
 224             throw "Unimplemented";
 225         }
 226     }
 227 };
 228
 229 DefaultRecordHandler::DefaultRecordHandler( std::shared_ptr<Signer> signer, std::shared_ptr<BIO> bio ) :
 230     currentSession() {
 231
 232     this->signer = signer;
 233
 234     ctx = generateSSLContext( true );
 235
 236     SSL_CTX_use_certificate_file( ctx.get(), "testdata/server.crt", SSL_FILETYPE_PEM );
 237     SSL_CTX_use_PrivateKey_file( ctx.get(), "testdata/server.key", SSL_FILETYPE_PEM );
 238
 239     this->bio = bio;
 240 }
 241
 242 void DefaultRecordHandler::reset() {
 243     currentSession = std::shared_ptr<RecordHandlerSession>();
 244 }
 245
 246 void DefaultRecordHandler::handle() {
 247     if( !currentSession ) {
 248         std::cout << "session allocated" << std::endl;
 249         currentSession = std::shared_ptr<RecordHandlerSession>( new RecordHandlerSession( this, signer, ctx, bio ) );
 250     }
 251
 252     std::cout << "really allocated: " << currentSession << ";" << std::endl;
 253     currentSession->work();
 254 }
 255
 256 void setupSerial( FILE* f ) {
 257     struct termios attr;
 258
 259     if( tcgetattr( fileno( f ), &attr ) ) {
 260         throw "failed to get attrs";
 261     }
 262
 263     attr.c_iflag &= ~( IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON );
 264     attr.c_oflag &= ~OPOST;
 265     attr.c_lflag &= ~( ECHO | ECHONL | ICANON | ISIG | IEXTEN );
 266     attr.c_cflag &= ~( CSIZE | PARENB );
 267     attr.c_cflag |= CS8;
 268
 269     if( tcsetattr( fileno( f ), TCSANOW, &attr ) ) {
 270         throw "failed to get attrs";
 271     }
 272 }
 273
 274 int handlermain( int argc, const char* argv[] ) {
 275     ( void ) argc;
 276     ( void ) argv;
 277
 278     std::shared_ptr<OpensslBIOWrapper> bio( new OpensslBIOWrapper( std::shared_ptr<BIO>( BIO_new_fd( 0, 0 ), BIO_free ) ) );
 279     std::string data =
 280         "-----BEGIN CERTIFICATE REQUEST-----\n"
 281         "MIIBSzCBtQIBADAMMQowCAYDVQQDDAFhMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB\n"
 282         "iQKBgQDerBEpIShJlx3zzl4AOS1NcwEg4iAWknQeTtI8B5dnk+l5HkOdTxqeehZn\n"
 283         "iZnuIuYXA+JWmoECg/w69+N5zw2BabelgK3cSvRqycwPEU/gceGJZTaBfkkN0hBk\n"
 284         "rpXDiLSlox5oeR150MrsHvVc+W2e+0jW1tuhz4QLzn8/uI/toQIDAQABoAAwDQYJ\n"
 285         "KoZIhvcNAQELBQADgYEATQU5VrgQAkvpCvIwRUyjj9YAa9E014tNY0jMcBdv95fy\n"
 286         "/f49zIcVtUJuZuEwY6uDZQqfAm+8CLNpOCICH/Qw7YOe+s/Yw7a8rk5VqLtgxR4M\n"
 287         "z6DUeVL0zYFoLUxIje9yDU3pWmPvyVaBPdo0DguZwFMfiWwzhkUDeQgyeaiMvQA=\n"
 288         "-----END CERTIFICATE REQUEST-----";
 289
 290     RecordHeader head;
 291     head.flags = 0;
 292     head.sessid = 13;
 293
 294     //---
 295
 296     SSL_library_init();
 297
 298     if( argc >= 2 ) {
 299         FILE* f = fopen( "/dev/ttyUSB0", "r+" );
 300
 301         if( !f ) {
 302             std::cout << "Opening /dev/ttyUSB0 bio failed" << std::endl;
 303             return -1;
 304         }
 305
 306         setupSerial( f );
 307
 308         std::shared_ptr<BIO> b( BIO_new_fd( fileno( f ), 0 ), BIO_free );
 309         std::shared_ptr<BIO> slip1( BIO_new( toBio<SlipBIO>() ), BIO_free );
 310         ( ( SlipBIO* )slip1->ptr )->setTarget( std::shared_ptr<OpensslBIO>( new OpensslBIOWrapper( b ) ) );
 311         std::cout << "Initing tlsv1_2" << std::endl;
 312         std::shared_ptr<SSL_CTX> ctx = generateSSLContext( false );
 313         std::shared_ptr<RemoteSigner> sign( new RemoteSigner( slip1, ctx ) );
 314         std::shared_ptr<TBSCertificate> cert( new TBSCertificate() );
 315         cert->csr_type = "csr";
 316         cert->csr_content = data;
 317         cert->md = "sha256";
 318         cert->profile = "1";
 319
 320         auto res = sign->sign( cert );
 321         std::cout << "sent things" << std::endl;
 322
 323         return 0;
 324     }
 325
 326     FILE* f = fopen( "/dev/ttyS0", "r+" );
 327
 328     if( !f ) {
 329         std::cout << "Opening /dev/ttyS0 bio failed" << std::endl;
 330         return -1;
 331     }
 332
 333     setupSerial( f );
 334
 335     std::shared_ptr<BIO> conn( BIO_new_fd( fileno( f ), 0 ), BIO_free );
 336     std::shared_ptr<BIO> slip1( BIO_new( toBio<SlipBIO>() ), BIO_free );
 337
 338     ( ( SlipBIO* )slip1->ptr )->setTarget( std::shared_ptr<OpensslBIO>( new OpensslBIOWrapper( conn ) ) );
 339
 340     try {
 341         DefaultRecordHandler* dh = new DefaultRecordHandler( std::shared_ptr<Signer>( new SimpleOpensslSigner() ), slip1 );
 342
 343         while( true ) {
 344             dh->handle();
 345         }
 346     } catch( char const* ch ) {
 347         std::cout << "Exception: " << ch << std::endl;
 348     }
 349
 350     return 0;
 351 }