1 #include "recordHandler.h"
4 #include <sys/socket.h>
5 #include <netinet/in.h>
12 #include <openssl/ssl.h>
16 #include "opensslBIO.h"
17 #include "remoteSigner.h"
18 #include "simpleOpensslSigner.h"
21 int gencb( int a, int b, BN_GENCB* g ) {
26 std::cout << ( a == 0 ? "." : "+" ) << std::flush;
31 static int verify_callback( int preverify_ok, X509_STORE_CTX* ctx ) {
33 std::cout << "Verification failed: " << preverify_ok << " because " << X509_STORE_CTX_get_error( ctx ) << std::endl;
39 static std::shared_ptr<DH> dh_param;
41 std::shared_ptr<SSL_CTX> generateSSLContext( bool server ) {
42 std::shared_ptr<SSL_CTX> ctx = std::shared_ptr<SSL_CTX>(
43 SSL_CTX_new( TLSv1_2_method() ),
48 if( !SSL_CTX_set_cipher_list( ctx.get(), "HIGH:+CAMELLIA256:!eNull:!aNULL:!ADH:!MD5:-RSA+AES+SHA1:!RC4:!DES:!3DES:!SEED:!EXP:!AES128:!CAMELLIA128" ) ) {
49 throw "Cannot set cipher list. Your source is broken.";
52 SSL_CTX_set_verify( ctx.get(), SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, verify_callback );
53 SSL_CTX_use_certificate_file( ctx.get(), server ? "keys/signer_server.crt" : "keys/signer_client.crt", SSL_FILETYPE_PEM );
54 SSL_CTX_use_PrivateKey_file( ctx.get(), server ? "keys/signer_server.key" : "keys/signer_client.key", SSL_FILETYPE_PEM );
55 SSL_CTX_load_verify_locations( ctx.get(), "keys/env.crt", 0 );
58 STACK_OF( X509_NAME ) *names = SSL_load_client_CA_file( "keys/env.crt" );
61 SSL_CTX_set_client_CA_list( ctx.get(), names );
67 FILE* paramfile = fopen( "dh_param.pem", "r" );
70 dh_param = std::shared_ptr<DH>( PEM_read_DHparams( paramfile, NULL, NULL, NULL ), DH_free );
73 dh_param = std::shared_ptr<DH>( DH_new(), DH_free );
74 std::cout << "Generating DH params" << std::endl;
80 if( !DH_generate_parameters_ex( dh_param.get(), 2048, 5, &cb ) ) {
81 throw "DH generation failed";
84 std::cout << std::endl;
85 paramfile = fopen( "dh_param.pem", "w" );
88 PEM_write_DHparams( paramfile, dh_param.get() );
94 if( !SSL_CTX_set_tmp_dh( ctx.get(), dh_param.get() ) ) {
95 throw "Cannot set tmp dh.";
102 class RecordHandlerSession {
105 uint32_t lastCommandCount;
107 std::shared_ptr<TBSCertificate> tbs;
108 std::shared_ptr<SignedCertificate> result;
112 std::shared_ptr<OpensslBIOWrapper> io;
113 DefaultRecordHandler* parent;
114 std::shared_ptr<Signer> signer;
116 RecordHandlerSession( DefaultRecordHandler* parent, std::shared_ptr<Signer> signer, std::shared_ptr<SSL_CTX> ctx, std::shared_ptr<BIO> output ) :
117 tbs( new TBSCertificate() ) {
118 this->parent = parent;
119 this->signer = signer;
121 ssl = SSL_new( ctx.get() );
122 std::shared_ptr<BIO> bio( BIO_new( BIO_f_ssl() ), [output]( BIO * p ) {
125 SSL_set_accept_state( ssl );
126 SSL_set_bio( ssl, output.get(), output.get() );
127 BIO_set_ssl( bio.get(), ssl, BIO_NOCLOSE );
128 io = std::shared_ptr<OpensslBIOWrapper>( new OpensslBIOWrapper( bio ) );
131 void respondCommand( RecordHeader::SignerResult res, std::string payload ) {
133 rh.command = ( uint16_t ) res;
135 rh.command_count = 0; // TODO i++
136 rh.totalLength = payload.size();
137 sendCommand( rh, payload, io );
141 std::cout << "done" << std::endl;
142 std::vector<char> buffer( 2048, 0 );
143 std::cout << "reading" << std::endl;
144 int res = io->read( buffer.data(), buffer.capacity() );
145 std::cout << "read" << std::endl;
152 std::string content( buffer.data(), res );
156 std::string payload = parseCommand( head, content );
157 execute( head, payload );
158 } catch( const char* msg ) {
159 std::cout << msg << std::endl;
165 void execute( RecordHeader& head, std::string data ) {
166 if( head.totalLength != head.payloadLength || head.offset != 0 ) {
167 throw "Error, chunking not supported yet";
170 switch( ( RecordHeader::SignerCommand ) head.command ) {
171 case RecordHeader::SignerCommand::SET_CSR: // setCSR
172 tbs->csr_content = data;
173 tbs->csr_type = "CSR";
174 std::cout << "CSR read" << std::endl;
177 case RecordHeader::SignerCommand::SET_SIGNATURE_TYPE:
181 case RecordHeader::SignerCommand::SET_PROFILE:
186 case RecordHeader::SignerCommand::ADD_SAN: {
187 size_t pos = data.find( "," );
189 if( pos == std::string::npos ) {
191 std::shared_ptr<SAN> san( new SAN() );
192 san->type = data.substr( 0, pos );
193 san->content = data.substr( pos + 1 );
194 tbs->SANs.push_back( san );
199 case RecordHeader::SignerCommand::ADD_AVA: {
200 size_t pos = data.find( "," );
202 if( pos == std::string::npos ) {
205 std::shared_ptr<AVA> ava( new AVA() );
206 ava->name = data.substr( 0, pos );
207 ava->value = data.substr( pos + 1 );
208 tbs->AVAs.push_back( ava );
213 case RecordHeader::SignerCommand::ADD_PROOF_LINE:
216 case RecordHeader::SignerCommand::SIGN:
217 result = signer->sign( tbs );
218 std::cout << "res: " << result->certificate << std::endl;
219 result->log = "I am a dummy log.\nI signed that thing ;-) \n";
220 respondCommand( RecordHeader::SignerResult::SAVE_LOG, result->log );
223 case RecordHeader::SignerCommand::LOG_SAVED:
225 respondCommand( RecordHeader::SignerResult::CERTIFICATE, result->certificate );
231 throw "Unimplemented";
236 DefaultRecordHandler::DefaultRecordHandler( std::shared_ptr<Signer> signer, std::shared_ptr<BIO> bio ) :
239 this->signer = signer;
241 ctx = generateSSLContext( true );
246 void DefaultRecordHandler::reset() {
247 currentSession = std::shared_ptr<RecordHandlerSession>();
250 void DefaultRecordHandler::handle() {
251 if( !currentSession ) {
252 std::cout << "session allocated" << std::endl;
253 currentSession = std::shared_ptr<RecordHandlerSession>( new RecordHandlerSession( this, signer, ctx, bio ) );
256 std::cout << "really allocated: " << currentSession << ";" << std::endl;
257 currentSession->work();
260 void setupSerial( FILE* f ) {
263 if( tcgetattr( fileno( f ), &attr ) ) {
264 throw "failed to get attrs";
267 attr.c_iflag &= ~( IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON );
268 attr.c_oflag &= ~OPOST;
269 attr.c_lflag &= ~( ECHO | ECHONL | ICANON | ISIG | IEXTEN );
270 attr.c_cflag &= ~( CSIZE | PARENB );
273 cfsetispeed( &attr, B115200 );
274 cfsetospeed( &attr, B115200 );
276 if( tcsetattr( fileno( f ), TCSANOW, &attr ) ) {
277 throw "failed to get attrs";
281 int handlermain( int argc, const char* argv[] ) {
285 std::shared_ptr<OpensslBIOWrapper> bio( new OpensslBIOWrapper( std::shared_ptr<BIO>( BIO_new_fd( 0, 0 ), BIO_free ) ) );
287 "-----BEGIN CERTIFICATE REQUEST-----\n"
288 "MIIBSzCBtQIBADAMMQowCAYDVQQDDAFhMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB\n"
289 "iQKBgQDerBEpIShJlx3zzl4AOS1NcwEg4iAWknQeTtI8B5dnk+l5HkOdTxqeehZn\n"
290 "iZnuIuYXA+JWmoECg/w69+N5zw2BabelgK3cSvRqycwPEU/gceGJZTaBfkkN0hBk\n"
291 "rpXDiLSlox5oeR150MrsHvVc+W2e+0jW1tuhz4QLzn8/uI/toQIDAQABoAAwDQYJ\n"
292 "KoZIhvcNAQELBQADgYEATQU5VrgQAkvpCvIwRUyjj9YAa9E014tNY0jMcBdv95fy\n"
293 "/f49zIcVtUJuZuEwY6uDZQqfAm+8CLNpOCICH/Qw7YOe+s/Yw7a8rk5VqLtgxR4M\n"
294 "z6DUeVL0zYFoLUxIje9yDU3pWmPvyVaBPdo0DguZwFMfiWwzhkUDeQgyeaiMvQA=\n"
295 "-----END CERTIFICATE REQUEST-----";
306 FILE* f = fopen( "/dev/ttyUSB0", "r+" );
309 std::cout << "Opening /dev/ttyUSB0 bio failed" << std::endl;
315 std::shared_ptr<BIO> b( BIO_new_fd( fileno( f ), 0 ), BIO_free );
316 std::shared_ptr<BIO> slip1( BIO_new( toBio<SlipBIO>() ), BIO_free );
317 ( ( SlipBIO* )slip1->ptr )->setTarget( std::shared_ptr<OpensslBIO>( new OpensslBIOWrapper( b ) ) );
318 std::cout << "Initing tlsv1_2" << std::endl;
319 std::shared_ptr<SSL_CTX> ctx = generateSSLContext( false );
320 std::shared_ptr<RemoteSigner> sign( new RemoteSigner( slip1, ctx ) );
321 std::shared_ptr<TBSCertificate> cert( new TBSCertificate() );
322 cert->csr_type = "csr";
323 cert->csr_content = data;
326 std::shared_ptr<AVA> ava( new AVA() );
328 ava->value = "Dummy user certificates";
329 cert->AVAs.push_back( ava );
330 std::shared_ptr<SAN> san( new SAN() );
332 san->content = "n42.example.com";
333 cert->SANs.push_back( san );
335 auto res = sign->sign( cert );
336 std::cout << "log: " << res->log << std::endl;
337 std::cout << "cert things: " << res->certificate << std::endl;
341 FILE* f = fopen( "/dev/ttyS0", "r+" );
344 std::cout << "Opening /dev/ttyS0 bio failed" << std::endl;
350 std::shared_ptr<BIO> conn( BIO_new_fd( fileno( f ), 0 ), BIO_free );
351 std::shared_ptr<BIO> slip1( BIO_new( toBio<SlipBIO>() ), BIO_free );
353 ( ( SlipBIO* )slip1->ptr )->setTarget( std::shared_ptr<OpensslBIO>( new OpensslBIOWrapper( conn ) ) );
356 DefaultRecordHandler* dh = new DefaultRecordHandler( std::shared_ptr<Signer>( new SimpleOpensslSigner() ), slip1 );
361 } catch( char const* ch ) {
362 std::cout << "Exception: " << ch << std::endl;