src/simpleOpensslSigner.cpp

   1 #include "simpleOpensslSigner.h"
   2
   3 #include <iostream>
   4
   5 #include <openssl/ssl.h>
   6 #include <openssl/err.h>
   7 #include <openssl/bio.h>
   8 #include <openssl/bn.h>
   9 #include <openssl/engine.h>
  10 #include <openssl/x509v3.h>
  11
  12 #include "X509.h"
  13 #include "util.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( uint16_t profile ) {
  77     std::string res = readFile( "serial" );
  78
  79     BIGNUM* bn = 0;
  80
  81     if( res == "" ) {
  82         bn = BN_new();
  83
  84         if( !bn ) {
  85             throw "Initing serial failed";
  86         }
  87     } else {
  88         if( !BN_hex2bn( &bn, res.c_str() + 1 ) ) {
  89             throw "Parsing serial failed.";
  90         }
  91     }
  92
  93     std::shared_ptr<BIGNUM> serial = std::shared_ptr<BIGNUM>( bn, BN_free );
  94
  95     std::shared_ptr<unsigned char> data = std::shared_ptr<unsigned char>( ( unsigned char* ) malloc( BN_num_bytes( serial.get() ) + 20 ), free );
  96     int len = BN_bn2bin( serial.get(), data.get() );
  97
  98     data.get()[len] = 0x0;
  99     data.get()[len + 1] = 0x0; // signer id
 100
 101     data.get()[len + 2] = profile >> 8;
 102     data.get()[len + 3] = profile & 0xFF; // profile id
 103
 104     if( !RAND_bytes( data.get() + len + 4, 16 ) || !BN_add_word( serial.get(), 1 ) ) {
 105         throw "Big number math failed while calcing serials.";
 106     }
 107
 108     char* serStr = BN_bn2hex( serial.get() );
 109     writeFile( serStr, "serial" );
 110     OPENSSL_free( serStr );
 111
 112     return std::shared_ptr<BIGNUM>( BN_bin2bn( data.get(), len + 4 + 16 , 0 ), BN_free );
 113 }
 114
 115 std::shared_ptr<SignedCertificate> SimpleOpensslSigner::sign( std::shared_ptr<TBSCertificate> cert ) {
 116     if( !caKey ) {
 117         throw "CA-key not found";
 118     }
 119
 120     std::shared_ptr<X509Req> req;
 121
 122     if( cert->csr_type == "SPKAC" ) {
 123         req = X509Req::parseSPKAC( cert->csr_content );
 124     } else if( cert->csr_type == "CSR" ) {
 125         req = X509Req::parse( cert->csr_content );
 126     } else {
 127         throw "Error, unknown REQ rype " + ( cert->csr_type );
 128     }
 129
 130     int i = req->verify();
 131
 132     if( i < 0 ) {
 133         throw "Signature problems ... ";
 134     } else if( i == 0 ) {
 135         throw "Signature did not match";
 136     } else {
 137         std::cerr << "Signature ok" << std::endl;
 138     }
 139
 140     // Construct the Certificate
 141     X509Cert c = X509Cert();
 142     std::shared_ptr<X509> retsh = std::shared_ptr<X509>( X509_new(), X509_free );
 143     X509* ret = retsh.get();
 144
 145     if( !ret ) {
 146         throw "Creating X509 failed.";
 147     }
 148
 149     X509_NAME* subjectP = X509_NAME_new();
 150
 151     if( !subjectP ) {
 152         throw "malloc failure";
 153     }
 154
 155     for( std::shared_ptr<AVA> a : cert->AVAs ) {
 156         if( a->name == "CN" ) {
 157             c.addRDN( NID_commonName, a->value );
 158         } else if( a->name == "EMAIL" ) {
 159             c.addRDN( NID_pkcs9_emailAddress, a->value );
 160         } else if( a->name == "C" ) {
 161             c.addRDN( NID_countryName, a->value );
 162         } else if( a->name == "L" ) {
 163             c.addRDN( NID_localityName, a->value );
 164         } else if( a->name == "ST" ) {
 165             c.addRDN( NID_stateOrProvinceName, a->value );
 166         } else if( a->name == "O" ) {
 167             c.addRDN( NID_organizationName, a->value );
 168         } else if( a->name == "OU" ) {
 169             c.addRDN( NID_organizationalUnitName, a->value );
 170         } else {
 171             throw "unknown AVA-type";
 172         }
 173     }
 174
 175     c.setIssuerNameFrom( caCert );
 176     c.setPubkeyFrom( req );
 177     long int profile = strtol( cert->profile.c_str(), 0, 10 );
 178
 179     if( profile > 0xFFFF || profile < 0 || ( profile == 0 && cert->profile != "0" ) ) {
 180         throw "invalid profile id";
 181     }
 182
 183     std::shared_ptr<BIGNUM> ser = nextSerial( profile );
 184     c.setSerialNumber( ser.get() );
 185     c.setTimes( 0, 60 * 60 * 24 * 10 );
 186     c.setExtensions( caCert, cert->SANs );
 187
 188     std::shared_ptr<SignedCertificate> output = c.sign( caKey, cert->md );
 189
 190     return output;
 191 }