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( uint16_t profile ) {
  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
 101     data.get()[len] = 0x0;
 102     data.get()[len + 1] = 0x0; // signer id
 103
 104     data.get()[len + 2] = profile >> 8;
 105     data.get()[len + 3] = profile & 0xFF; // profile id
 106
 107     if( !RAND_bytes( data.get() + len + 4, 16 ) || !BN_add_word( serial.get(), 1 ) ) {
 108         throw "Big number math failed while calcing serials.";
 109     }
 110
 111     char* serStr = BN_bn2hex( serial.get() );
 112     std::ofstream serialf( "serial" );
 113     serialf << serStr;
 114     serialf.close();
 115     OPENSSL_free( serStr );
 116
 117     return std::shared_ptr<BIGNUM>( BN_bin2bn( data.get(), len + 4 + 16 , 0 ), BN_free );
 118 }
 119
 120 std::shared_ptr<SignedCertificate> SimpleOpensslSigner::sign( std::shared_ptr<TBSCertificate> cert ) {
 121     if( !caKey ) {
 122         throw "CA-key not found";
 123     }
 124
 125     std::shared_ptr<X509Req> req;
 126
 127     if( cert->csr_type == "SPKAC" ) {
 128         req = X509Req::parseSPKAC( cert->csr_content );
 129     } else if( cert->csr_type == "CSR" ) {
 130         req = X509Req::parse( cert->csr_content );
 131     } else {
 132         throw "Error, unknown REQ rype " + ( cert->csr_type );
 133     }
 134
 135     int i = req->verify();
 136
 137     if( i < 0 ) {
 138         throw "Signature problems ... ";
 139     } else if( i == 0 ) {
 140         throw "Signature did not match";
 141     } else {
 142         std::cerr << "Signature ok" << std::endl;
 143     }
 144
 145     // Construct the Certificate
 146     X509Cert c = X509Cert();
 147     std::shared_ptr<X509> retsh = std::shared_ptr<X509>( X509_new(), X509_free );
 148     X509* ret = retsh.get();
 149
 150     if( !ret ) {
 151         throw "Creating X509 failed.";
 152     }
 153
 154     X509_NAME* subjectP = X509_NAME_new();
 155
 156     if( !subjectP ) {
 157         throw "malloc failure";
 158     }
 159
 160     for( std::shared_ptr<AVA> a : cert->AVAs ) {
 161         if( a->name == "CN" ) {
 162             c.addRDN( NID_commonName, a->value );
 163         } else if( a->name == "EMAIL" ) {
 164             c.addRDN( NID_pkcs9_emailAddress, a->value );
 165         } else if( a->name == "C" ) {
 166             c.addRDN( NID_countryName, a->value );
 167         } else if( a->name == "L" ) {
 168             c.addRDN( NID_localityName, a->value );
 169         } else if( a->name == "ST" ) {
 170             c.addRDN( NID_stateOrProvinceName, a->value );
 171         } else if( a->name == "O" ) {
 172             c.addRDN( NID_organizationName, a->value );
 173         } else if( a->name == "OU" ) {
 174             c.addRDN( NID_organizationalUnitName, a->value );
 175         } else {
 176             throw "unknown AVA-type";
 177         }
 178     }
 179
 180     c.setIssuerNameFrom( caCert );
 181     c.setPubkeyFrom( req );
 182     long int profile = strtol( cert->profile.c_str(), 0, 10 );
 183
 184     if( profile > 0xFFFF || profile < 0 || ( profile == 0 && cert->profile != "0" ) ) {
 185         throw "invalid profile id";
 186     }
 187
 188     std::shared_ptr<BIGNUM> ser = nextSerial( profile );
 189     c.setSerialNumber( ser.get() );
 190     c.setTimes( 0, 60 * 60 * 24 * 10 );
 191     c.setExtensions( caCert, cert->SANs );
 192
 193     std::shared_ptr<SignedCertificate> output = c.sign( caKey, cert->md );
 194
 195     return output;
 196 }