src/ssli_openssl.c

   1 /* Copyright (C) 2009-2014, Martin Johansson <martin@fatbob.nu>
   2    Copyright (C) 2005-2014, Thorvald Natvig <thorvald@natvig.com>
   3
   4    All rights reserved.
   5
   6    Redistribution and use in source and binary forms, with or without
   7    modification, are permitted provided that the following conditions
   8    are met:
   9
  10    - Redistributions of source code must retain the above copyright notice,
  11      this list of conditions and the following disclaimer.
  12    - Redistributions in binary form must reproduce the above copyright notice,
  13      this list of conditions and the following disclaimer in the documentation
  14      and/or other materials provided with the distribution.
  15    - Neither the name of the Developers nor the names of its contributors may
  16      be used to endorse or promote products derived from this software without
  17      specific prior written permission.
  18
  19    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
  23    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  24    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  26    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  27    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  28    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  29    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30 */
  31 #include <stdlib.h>
  32 #include <fcntl.h>
  33
  34 #include "conf.h"
  35 #include "log.h"
  36 #include "memory.h"
  37 #include "ssl.h"
  38
  39 /*
  40  * OpenSSL interface
  41  */
  42
  43 #include <openssl/x509v3.h>
  44 #include <openssl/ssl.h>
  45 #include <openssl/err.h>
  46 #include <openssl/safestack.h>
  47 static X509 *x509;
  48 static RSA *rsa;
  49 static SSL_CTX *context;
  50 static EVP_PKEY *pkey;
  51
  52 static char const * ciphers = "EECDH+CHACHA20:EECDH+AESGCM:EECDH+AES+TLSv1.2:EECDH+AES:AESGCM:AES:!aNULL:!DHE:!kECDH";
  53
  54 static int verify_callback(int preverify_ok, X509_STORE_CTX *ctx);
  55
  56 static int SSL_add_ext(X509 * crt, int nid, char *value) {
  57         X509_EXTENSION *ex;
  58         X509V3_CTX ctx;
  59         X509V3_set_ctx_nodb(&ctx);
  60         X509V3_set_ctx(&ctx, crt, crt, NULL, NULL, 0);
  61         ex = X509V3_EXT_conf_nid(NULL, &ctx, nid, value);
  62         if (!ex)
  63                 return 0;
  64
  65         X509_add_ext(crt, ex, -1);
  66         X509_EXTENSION_free(ex);
  67         return 1;
  68 }
  69
  70 static X509 *SSL_readcert(char *certfile)
  71 {
  72         FILE *fp;
  73         X509 *x509;
  74
  75         /* open the certificate file */
  76         fp = fopen(certfile, "r");
  77         if (fp == NULL) {
  78                 Log_warn("Unable to open the X509 file %s for reading.", certfile);
  79                 return NULL;
  80         }
  81
  82         /* allocate memory for the cert structure */
  83         x509 = X509_new();
  84
  85         if (PEM_read_X509(fp, &x509, NULL, NULL) == 0) {
  86                 /* error reading the x509 information - check the error stack */
  87                 Log_warn("Error trying to read X509 info.");
  88                 fclose(fp);
  89                 X509_free(x509);
  90                 return NULL;
  91         }
  92         fclose(fp);
  93         return x509;
  94 }
  95
  96 static RSA *SSL_readprivatekey(char *keyfile)
  97 {
  98         FILE *fp;
  99         RSA *rsa;
 100
 101 /* open the private key file for reading */
 102         fp = fopen(keyfile, "r");
 103         if (fp == NULL) {
 104                 Log_warn("Unable to open the private key file %s for reading.", keyfile);
 105                 return NULL;
 106         }
 107
 108 /* allocate memory for the RSA structure */
 109         rsa = RSA_new();
 110
 111         /* assign a callback function for the password */
 112
 113         /* read a private key from file */
 114         if (PEM_read_RSAPrivateKey(fp, &rsa, NULL, NULL) <= 0) {
 115                 /* error reading the key - check the error stack */
 116                 Log_warn("Error trying to read private key.");
 117                 RSA_free(rsa);
 118                 fclose(fp);
 119                 return NULL;
 120         }
 121         fclose(fp);
 122         return rsa;
 123 }
 124
 125 static void SSL_writecert(char *certfile, X509 *x509)
 126 {
 127         FILE *fp;
 128
 129         /* open the private key file */
 130         fp = fopen(certfile, "w");
 131         if (fp == NULL) {
 132                 Log_warn("Unable to open the X509 file %s for writing", certfile);
 133                 return;
 134         }
 135         if (PEM_write_X509(fp, x509) == 0) {
 136                 Log_warn("Error trying to write X509 info.");
 137         }
 138         fclose(fp);
 139 }
 140
 141 static void SSL_writekey(char *keyfile, RSA *rsa)
 142 {
 143         FILE *fp;
 144
 145         /* open the private key file for reading */
 146         fp = fopen(keyfile, "w");
 147         if (fp == NULL) {
 148                 Log_warn("Unable to open the private key file %s for writing.", keyfile);
 149                 return;
 150         }
 151
 152         if (PEM_write_RSAPrivateKey(fp, rsa, NULL, NULL, 0, NULL, NULL) == 0) {
 153                 Log_warn("Error trying to write private key");
 154         }
 155         fclose(fp);
 156 }
 157
 158 static void SSL_initializeCert() {
 159
 160         char *crt = (char *)getStrConf(CERTIFICATE);
 161         char *key = (char *)getStrConf(KEY);
 162
 163         if (context) {
 164                 bool_t did_load_cert = SSL_CTX_use_certificate_chain_file(context, crt);
 165                 rsa = SSL_readprivatekey(key);
 166
 167                 if (!rsa || !did_load_cert) {
 168                         Log_info("Generating new server certificate.");
 169
 170
 171                         CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
 172
 173                         x509 = X509_new();
 174                         pkey = EVP_PKEY_new();
 175                         rsa = RSA_generate_key(4096,RSA_F4,NULL,NULL);
 176                         EVP_PKEY_assign_RSA(pkey, rsa);
 177
 178                         X509_set_version(x509, 2);
 179                         ASN1_INTEGER_set(X509_get_serialNumber(x509),1);
 180                         X509_gmtime_adj(X509_get_notBefore(x509),0);
 181                         X509_gmtime_adj(X509_get_notAfter(x509),60*60*24*365);
 182                         X509_set_pubkey(x509, pkey);
 183
 184                         X509_NAME *name=X509_get_subject_name(x509);
 185
 186                         X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC, (const uint8_t *)"Murmur Autogenerated Certificate v2", -1, -1, 0);
 187                         X509_set_issuer_name(x509, name);
 188                         SSL_add_ext(x509, NID_basic_constraints, "critical,CA:FALSE");
 189                         SSL_add_ext(x509, NID_ext_key_usage, "serverAuth,clientAuth");
 190                         SSL_add_ext(x509, NID_subject_key_identifier, "hash");
 191                         SSL_add_ext(x509, NID_netscape_comment, "Generated from umurmur");
 192
 193                         X509_sign(x509, pkey, EVP_md5());
 194
 195                         SSL_writecert(crt, x509);
 196                         SSL_writekey(key, rsa);
 197
 198                         SSL_CTX_use_certificate(context, x509);
 199                 } else {
 200                   pkey = EVP_PKEY_new();
 201                   EVP_PKEY_assign_RSA(pkey, rsa);
 202                 }
 203
 204                 SSL_CTX_use_PrivateKey(context, pkey);
 205
 206         } else {
 207                 Log_fatal("Failed to initialize TLS context.");
 208         }
 209
 210 }
 211
 212 void SSLi_init(void)
 213 {
 214         SSL *ssl;
 215         int i, offset = 0, cipherstringlen = 0;
 216         STACK_OF(SSL_CIPHER) *cipherlist = NULL, *cipherlist_new = NULL;
 217         SSL_CIPHER *cipher;
 218         char *cipherstring = NULL;
 219
 220         SSL_library_init();
 221         OpenSSL_add_all_algorithms();
 222         SSL_load_error_strings();
 223         ERR_load_crypto_strings();
 224
 225         context = SSL_CTX_new(SSLv23_server_method());
 226         SSL_CTX_set_options(context, SSL_OP_NO_SSLv2);
 227         SSL_CTX_set_options(context, SSL_OP_NO_SSLv3);
 228         SSL_CTX_set_options(context, SSL_OP_CIPHER_SERVER_PREFERENCE);
 229         if (context == NULL)
 230         {
 231                 ERR_print_errors_fp(stderr);
 232                 abort();
 233         }
 234
 235         SSL_CTX_set_cipher_list(context, ciphers);
 236
 237         EC_KEY *ecdhkey = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
 238         SSL_CTX_set_tmp_ecdh(context, ecdhkey);
 239         EC_KEY_free(ecdhkey);
 240
 241         char const * sslCAPath = getStrConf(CAPATH);
 242         if(sslCAPath != NULL)
 243         {
 244                 SSL_CTX_load_verify_locations(context, NULL, sslCAPath);
 245         }
 246
 247         SSL_initializeCert();
 248
 249         /* Set cipher list */
 250         ssl = SSL_new(context);
 251         cipherlist = (STACK_OF(SSL_CIPHER) *) SSL_get_ciphers(ssl);
 252         cipherlist_new = (STACK_OF(SSL_CIPHER) *) sk_SSL_CIPHER_new_null();
 253
 254         for ( i = 0; (cipher = sk_SSL_CIPHER_value(cipherlist, i)) != NULL; i++) {
 255                 if (SSL_CIPHER_get_bits(cipher, NULL) >= 128) {
 256                         sk_SSL_CIPHER_push(cipherlist_new, cipher);
 257                 }
 258         }
 259         Log_debug("List of ciphers:");
 260         if (cipherlist_new) {
 261                 for (i = 0; (cipher = sk_SSL_CIPHER_value(cipherlist_new, i)) != NULL; i++) {
 262                         Log_debug("%s", SSL_CIPHER_get_name(cipher));
 263                         cipherstringlen += strlen(SSL_CIPHER_get_name(cipher)) + 1;
 264                 }
 265                 cipherstring = Memory_safeMalloc(1, cipherstringlen + 1);
 266                 for (i = 0; (cipher = sk_SSL_CIPHER_value(cipherlist_new, i)) != NULL; i++) {
 267                         offset += sprintf(cipherstring + offset, "%s:", SSL_CIPHER_get_name(cipher));
 268                 }
 269         }
 270
 271         if (cipherlist_new)
 272                 sk_SSL_CIPHER_free(cipherlist_new);
 273
 274         if (!cipherstring || !*cipherstring)
 275                 Log_fatal("No suitable ciphers found!");
 276
 277         if (SSL_CTX_set_cipher_list(context, cipherstring) == 0)
 278                 Log_fatal("Failed to set cipher list!");
 279
 280         free(cipherstring);
 281
 282         SSL_CTX_set_verify(context, SSL_VERIFY_PEER|SSL_VERIFY_CLIENT_ONCE,
 283                            verify_callback);
 284
 285         SSL_free(ssl);
 286         Log_info("OpenSSL library initialized");
 287
 288 }
 289
 290 void SSLi_deinit(void)
 291 {
 292         SSL_CTX_free(context);
 293         EVP_cleanup();
 294 }
 295
 296 int SSLi_nonblockaccept(SSL_handle_t *ssl, bool_t *SSLready)
 297 {
 298         int rc;
 299         rc = SSL_accept(ssl);
 300         if (rc < 0) {
 301                 if (SSL_get_error(ssl, rc) == SSL_ERROR_WANT_READ ||
 302                         SSL_get_error(ssl, rc) == SSL_ERROR_WANT_WRITE) {
 303                         Log_debug("SSL not ready");
 304                         return 0;
 305                 } else {
 306                         Log_warn("SSL error: %s", ERR_error_string(SSL_get_error(ssl, rc), NULL));
 307                         return -1;
 308                 }
 309         }
 310         *SSLready = true;
 311         return 0;
 312 }
 313
 314 SSL_handle_t *SSLi_newconnection(int *fd, bool_t *SSLready)
 315 {
 316         SSL *ssl;
 317
 318         *SSLready = false;
 319         ssl = SSL_new(context);
 320         SSL_set_fd(ssl, *fd);
 321         if (SSLi_nonblockaccept(ssl, SSLready) < 0) {
 322                 SSL_free(ssl);
 323                 return NULL;
 324         }
 325         return ssl;
 326 }
 327
 328 /* Create SHA1 of last certificate in the peer's chain. */
 329 bool_t SSLi_getSHA1Hash(SSL_handle_t *ssl, uint8_t *hash)
 330 {
 331         X509 *x509;
 332         uint8_t *buf, *p;
 333         int len;
 334
 335         x509 = SSL_get_peer_certificate(ssl);
 336         if (!x509) {
 337                 return false;
 338         }
 339
 340         len = i2d_X509(x509, NULL);
 341         buf = Memory_safeMalloc(1, len);
 342
 343         p = buf;
 344         i2d_X509(x509, &p);
 345
 346         SHA1(buf, len, hash);
 347         free(buf);
 348         return true;
 349 }
 350
 351 void SSLi_closeconnection(SSL_handle_t *ssl)
 352 {
 353         SSL_free(ssl);
 354 }
 355
 356 void SSLi_shutdown(SSL_handle_t *ssl)
 357 {
 358         SSL_shutdown(ssl);
 359 }
 360
 361 int SSLi_read(SSL_handle_t *ssl, uint8_t *buf, int len)
 362 {
 363         return SSL_read(ssl, buf, len);
 364 }
 365
 366 int SSLi_write(SSL_handle_t *ssl, uint8_t *buf, int len)
 367 {
 368         return SSL_write(ssl, buf, len);
 369 }
 370
 371 int SSLi_get_error(SSL_handle_t *ssl, int code)
 372 {
 373         return SSL_get_error(ssl, code);
 374 }
 375
 376 bool_t SSLi_data_pending(SSL_handle_t *ssl)
 377 {
 378         return SSL_pending(ssl);
 379 }
 380
 381 void SSLi_free(SSL_handle_t *ssl)
 382 {
 383         SSL_free(ssl);
 384 }
 385
 386 static int verify_callback(int preverify_ok, X509_STORE_CTX *ctx)
 387 {
 388         char    buf[256];
 389         X509   *err_cert;
 390         int     err, depth;
 391         SSL    *ssl;
 392
 393     err_cert = X509_STORE_CTX_get_current_cert(ctx);
 394     err = X509_STORE_CTX_get_error(ctx);
 395     depth = X509_STORE_CTX_get_error_depth(ctx);
 396
 397     ssl = X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
 398     X509_NAME_oneline(X509_get_subject_name(err_cert), buf, 256);
 399
 400     if (depth > 5) {
 401         preverify_ok = 0;
 402         err = X509_V_ERR_CERT_CHAIN_TOO_LONG;
 403         X509_STORE_CTX_set_error(ctx, err);
 404     }
 405     if (!preverify_ok) {
 406             Log_warn("SSL: verify error:num=%d:%s:depth=%d:%s\n", err,
 407                      X509_verify_cert_error_string(err), depth, buf);
 408     }
 409     /*
 410      * At this point, err contains the last verification error. We can use
 411      * it for something special
 412      */
 413     if (!preverify_ok && (err == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT)) {
 414             X509_NAME_oneline(X509_get_issuer_name(err_cert), buf, 256);
 415             Log_warn("issuer= %s", buf);
 416     }
 417     return 1;
 418 }