src/simpleOpensslSigner.cpp

   1 #include "simpleOpensslSigner.h"
   2
   3 #include <iostream>
   4 #include <fstream>
   5
   6 #include <openssl/ssl.h>
   7 #include <openssl/err.h>
   8 #include <openssl/bio.h>
   9 #include <openssl/bn.h>
  10 #include <openssl/engine.h>
  11 #include <openssl/x509v3.h>
  12
  13 #include "X509.h"
  14
  15 extern std::vector<Profile> profiles;
  16
  17 std::shared_ptr<int> SimpleOpensslSigner::lib_ref(
  18     new int( SSL_library_init() ),
  19     []( int* ref ) {
  20         delete ref;
  21
  22         EVP_cleanup();
  23         CRYPTO_cleanup_all_ex_data();
  24     } );
  25
  26 std::shared_ptr<X509> loadX509FromFile( std::string filename ) {
  27     FILE* f = fopen( filename.c_str(), "r" );
  28
  29     if( !f ) {
  30         return std::shared_ptr<X509>();
  31     }
  32
  33     X509* key = PEM_read_X509( f, NULL, NULL, 0 );
  34     fclose( f );
  35
  36     if( !key ) {
  37         return std::shared_ptr<X509>();
  38     }
  39
  40     return std::shared_ptr<X509>(
  41         key,
  42         []( X509 * ref ) {
  43             X509_free( ref );
  44         } );
  45 }
  46
  47 std::shared_ptr<EVP_PKEY> loadPkeyFromFile( std::string filename ) {
  48     FILE* f = fopen( filename.c_str(), "r" );
  49
  50     if( !f ) {
  51         return std::shared_ptr<EVP_PKEY>();
  52     }
  53
  54     EVP_PKEY* key = PEM_read_PrivateKey( f, NULL, NULL, 0 );
  55     fclose( f );
  56
  57     if( !key ) {
  58         return std::shared_ptr<EVP_PKEY>();
  59     }
  60
  61     return std::shared_ptr<EVP_PKEY>(
  62         key,
  63         []( EVP_PKEY * ref ) {
  64             EVP_PKEY_free( ref );
  65         } );
  66 }
  67
  68 SimpleOpensslSigner::SimpleOpensslSigner() {
  69     caCert = loadX509FromFile( profiles[0].cert );
  70     caKey = loadPkeyFromFile( profiles[0].key );
  71 }
  72
  73 SimpleOpensslSigner::~SimpleOpensslSigner() {
  74 }
  75
  76 std::shared_ptr<BIGNUM> SimpleOpensslSigner::nextSerial() {
  77     std::ifstream serialif( "serial" );
  78     std::string res;
  79     serialif >> res;
  80     serialif.close();
  81
  82     BIGNUM* bn = 0;
  83
  84     if( res == "" ) {
  85         bn = BN_new();
  86
  87         if( !bn ) {
  88             throw "Initing serial failed";
  89         }
  90     } else {
  91         if( !BN_hex2bn( &bn, res.c_str() + 1 ) ) {
  92             throw "Parsing serial failed.";
  93         }
  94     }
  95
  96     std::shared_ptr<BIGNUM> serial = std::shared_ptr<BIGNUM>( bn, BN_free );
  97
  98     std::shared_ptr<unsigned char> data = std::shared_ptr<unsigned char>( ( unsigned char* ) malloc( BN_num_bytes( serial.get() ) + 20 ), free );
  99     int len = BN_bn2bin( serial.get(), data.get() );
 100     data.get()[len] = 0x0;
 101     data.get()[len + 1] = 0x0; // profile id
 102     data.get()[len + 2] = 0x0;
 103     data.get()[len + 3] = 0x0; // signer id
 104
 105     if( !RAND_bytes( data.get() + len + 4, 16 ) || !BN_add_word( serial.get(), 1 ) ) {
 106         throw "Big number math failed while calcing serials.";
 107     }
 108
 109     char* serStr = BN_bn2hex( serial.get() );
 110     std::ofstream serialf( "serial" );
 111     serialf << serStr;
 112     serialf.close();
 113     OPENSSL_free( serStr );
 114
 115     return std::shared_ptr<BIGNUM>( BN_bin2bn( data.get(), len + 4 + 16 , 0 ), BN_free );
 116 }
 117
 118 std::shared_ptr<SignedCertificate> SimpleOpensslSigner::sign( std::shared_ptr<TBSCertificate> cert ) {
 119     if( !caKey ) {
 120         throw "CA-key not found";
 121     }
 122
 123     std::shared_ptr<X509Req> req;
 124
 125     if( cert->csr_type == "SPKAC" ) {
 126         req = X509Req::parseSPKAC( cert->csr_content );
 127     } else if( cert->csr_type == "CSR" ) {
 128         req = X509Req::parse( cert->csr_content );
 129     } else {
 130         throw "Error, unknown REQ rype " + ( cert->csr_type );
 131     }
 132
 133     int i = req->verify();
 134
 135     if( i < 0 ) {
 136         throw "Signature problems ... ";
 137     } else if( i == 0 ) {
 138         throw "Signature did not match";
 139     } else {
 140         std::cerr << "Signature ok" << std::endl;
 141     }
 142
 143     // Construct the Certificate
 144     X509Cert c = X509Cert();
 145     std::shared_ptr<X509> retsh = std::shared_ptr<X509>( X509_new(), X509_free );
 146     X509* ret = retsh.get();
 147
 148     if( !ret ) {
 149         throw "Creating X509 failed.";
 150     }
 151
 152     X509_NAME* subjectP = X509_NAME_new();
 153
 154     if( !subjectP ) {
 155         throw "malloc failure";
 156     }
 157
 158     for( std::shared_ptr<AVA> a : cert->AVAs ) {
 159         if( a->name == "CN" ) {
 160             c.addRDN( NID_commonName, a->value );
 161         } else if( a->name == "EMAIL" ) {
 162             c.addRDN( NID_pkcs9_emailAddress, a->value );
 163         } else {
 164             throw "unknown AVA-type";
 165         }
 166     }
 167
 168     c.setIssuerNameFrom( caCert );
 169     c.setPubkeyFrom( req );
 170     std::shared_ptr<BIGNUM> ser = nextSerial();
 171     c.setSerialNumber( ser.get() );
 172     c.setTimes( 0, 60 * 60 * 24 * 10 );
 173     c.setExtensions( caCert, cert->SANs );
 174
 175     std::shared_ptr<SignedCertificate> output = c.sign( caKey, cert->md );
 176
 177     return output;
 178 }