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 "ssl.h"
  37
  38 /*
  39  * OpenSSL interface
  40  */
  41
  42 #include <openssl/x509v3.h>
  43 #include <openssl/ssl.h>
  44 #include <openssl/err.h>
  45 #include <openssl/safestack.h>
  46 static X509 *x509;
  47 static RSA *rsa;
  48 static SSL_CTX *context;
  49 static EVP_PKEY *pkey;
  50
  51 static int verify_callback(int preverify_ok, X509_STORE_CTX *ctx);
  52
  53 static int SSL_add_ext(X509 * crt, int nid, char *value) {
  54         X509_EXTENSION *ex;
  55         X509V3_CTX ctx;
  56         X509V3_set_ctx_nodb(&ctx);
  57         X509V3_set_ctx(&ctx, crt, crt, NULL, NULL, 0);
  58         ex = X509V3_EXT_conf_nid(NULL, &ctx, nid, value);
  59         if (!ex)
  60                 return 0;
  61
  62         X509_add_ext(crt, ex, -1);
  63         X509_EXTENSION_free(ex);
  64         return 1;
  65 }
  66
  67 static X509 *SSL_readcert(char *certfile)
  68 {
  69         FILE *fp;
  70         X509 *x509;
  71
  72         /* open the certificate file */
  73         fp = fopen(certfile, "r");
  74         if (fp == NULL) {
  75                 Log_warn("Unable to open the X509 file %s for reading.", certfile);
  76                 return NULL;
  77         }
  78
  79         /* allocate memory for the cert structure */
  80         x509 = X509_new();
  81
  82         if (PEM_read_X509(fp, &x509, NULL, NULL) == 0) {
  83                 /* error reading the x509 information - check the error stack */
  84                 Log_warn("Error trying to read X509 info.");
  85                 fclose(fp);
  86                 X509_free(x509);
  87                 return NULL;
  88         }
  89         fclose(fp);
  90         return x509;
  91 }
  92
  93 static RSA *SSL_readprivatekey(char *keyfile)
  94 {
  95         FILE *fp;
  96         RSA *rsa;
  97
  98 /* open the private key file for reading */
  99         fp = fopen(keyfile, "r");
 100         if (fp == NULL) {
 101                 Log_warn("Unable to open the private key file %s for reading.", keyfile);
 102                 return NULL;
 103         }
 104
 105 /* allocate memory for the RSA structure */
 106         rsa = RSA_new();
 107
 108         /* assign a callback function for the password */
 109
 110         /* read a private key from file */
 111         if (PEM_read_RSAPrivateKey(fp, &rsa, NULL, NULL) <= 0) {
 112                 /* error reading the key - check the error stack */
 113                 Log_warn("Error trying to read private key.");
 114                 RSA_free(rsa);
 115                 fclose(fp);
 116                 return NULL;
 117         }
 118         fclose(fp);
 119         return rsa;
 120 }
 121
 122 static void SSL_writecert(char *certfile, X509 *x509)
 123 {
 124         FILE *fp;
 125
 126         /* open the private key file */
 127         fp = fopen(certfile, "w");
 128         if (fp == NULL) {
 129                 Log_warn("Unable to open the X509 file %s for writing", certfile);
 130                 return;
 131         }
 132         if (PEM_write_X509(fp, x509) == 0) {
 133                 Log_warn("Error trying to write X509 info.");
 134         }
 135         fclose(fp);
 136 }
 137
 138 static void SSL_writekey(char *keyfile, RSA *rsa)
 139 {
 140         FILE *fp;
 141
 142         /* open the private key file for reading */
 143         fp = fopen(keyfile, "w");
 144         if (fp == NULL) {
 145                 Log_warn("Unable to open the private key file %s for writing.", keyfile);
 146                 return;
 147         }
 148
 149         if (PEM_write_RSAPrivateKey(fp, rsa, NULL, NULL, 0, NULL, NULL) == 0) {
 150                 Log_warn("Error trying to write private key");
 151         }
 152         fclose(fp);
 153 }
 154
 155 static void SSL_initializeCert() {
 156
 157         char *crt = (char *)getStrConf(CERTIFICATE);
 158         char *key = (char *)getStrConf(KEY);
 159
 160         if (context) {
 161                 bool did_load_cert = SSL_CTX_use_certificate_chain_file(context, crt);
 162                 rsa = SSL_readprivatekey(key);
 163
 164                 if (!rsa || !did_load_cert) {
 165                         Log_info("Generating new server certificate.");
 166
 167
 168                         CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
 169
 170                         x509 = X509_new();
 171                         pkey = EVP_PKEY_new();
 172                         rsa = RSA_generate_key(4096,RSA_F4,NULL,NULL);
 173                         EVP_PKEY_assign_RSA(pkey, rsa);
 174
 175                         X509_set_version(x509, 2);
 176                         ASN1_INTEGER_set(X509_get_serialNumber(x509),1);
 177                         X509_gmtime_adj(X509_get_notBefore(x509),0);
 178                         X509_gmtime_adj(X509_get_notAfter(x509),60*60*24*365);
 179                         X509_set_pubkey(x509, pkey);
 180
 181                         X509_NAME *name=X509_get_subject_name(x509);
 182
 183                         X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC, (const uint8_t *)"Murmur Autogenerated Certificate v2", -1, -1, 0);
 184                         X509_set_issuer_name(x509, name);
 185                         SSL_add_ext(x509, NID_basic_constraints, "critical,CA:FALSE");
 186                         SSL_add_ext(x509, NID_ext_key_usage, "serverAuth,clientAuth");
 187                         SSL_add_ext(x509, NID_subject_key_identifier, "hash");
 188                         SSL_add_ext(x509, NID_netscape_comment, "Generated from umurmur");
 189
 190                         X509_sign(x509, pkey, EVP_md5());
 191
 192                         SSL_writecert(crt, x509);
 193                         SSL_writekey(key, rsa);
 194
 195                         SSL_CTX_use_certificate(context, x509);
 196                 } else {
 197                   pkey = EVP_PKEY_new();
 198                   EVP_PKEY_assign_RSA(pkey, rsa);
 199                 }
 200
 201                 SSL_CTX_use_PrivateKey(context, pkey);
 202
 203         } else {
 204                 Log_fatal("Failed to initialize TLS context.");
 205         }
 206
 207 }
 208
 209 void SSLi_init(void)
 210 {
 211         SSL *ssl;
 212         int i, offset = 0, cipherstringlen = 0;
 213         STACK_OF(SSL_CIPHER) *cipherlist = NULL, *cipherlist_new = NULL;
 214         SSL_CIPHER *cipher;
 215         char *cipherstring;
 216
 217         SSL_library_init();
 218         OpenSSL_add_all_algorithms();
 219         SSL_load_error_strings();
 220         ERR_load_crypto_strings();
 221
 222         context = SSL_CTX_new(SSLv23_server_method());
 223         if (context == NULL)
 224         {
 225                 ERR_print_errors_fp(stderr);
 226                 abort();
 227         }
 228
 229         char const * sslCAPath = getStrConf(CAPATH);
 230         if(sslCAPath != NULL)
 231         {
 232                 SSL_CTX_load_verify_locations(context, NULL, sslCAPath);
 233         }
 234
 235         SSL_initializeCert();
 236
 237         /* Set cipher list */
 238         ssl = SSL_new(context);
 239         cipherlist = (STACK_OF(SSL_CIPHER) *) SSL_get_ciphers(ssl);
 240         cipherlist_new = (STACK_OF(SSL_CIPHER) *) sk_SSL_CIPHER_new_null();
 241
 242         for ( i = 0; (cipher = sk_SSL_CIPHER_value(cipherlist, i)) != NULL; i++) {
 243                 if (SSL_CIPHER_get_bits(cipher, NULL) >= 128) {
 244                         sk_SSL_CIPHER_push(cipherlist_new, cipher);
 245                 }
 246         }
 247         Log_debug("List of ciphers:");
 248         if (cipherlist_new) {
 249                 for (i = 0; (cipher = sk_SSL_CIPHER_value(cipherlist_new, i)) != NULL; i++) {
 250                         Log_debug("%s", SSL_CIPHER_get_name(cipher));
 251                         cipherstringlen += strlen(SSL_CIPHER_get_name(cipher)) + 1;
 252                 }
 253                 cipherstring = malloc(cipherstringlen + 1);
 254                 if (cipherstring == NULL)
 255                         Log_fatal("Out of memory");
 256                 for (i = 0; (cipher = sk_SSL_CIPHER_value(cipherlist_new, i)) != NULL; i++) {
 257                         offset += sprintf(cipherstring + offset, "%s:", SSL_CIPHER_get_name(cipher));
 258                 }
 259         }
 260
 261         if (cipherlist_new)
 262                 sk_SSL_CIPHER_free(cipherlist_new);
 263
 264         if (strlen(cipherstring) == 0)
 265                 Log_fatal("No suitable ciphers found!");
 266
 267         if (SSL_CTX_set_cipher_list(context, cipherstring) == 0)
 268                 Log_fatal("Failed to set cipher list!");
 269
 270         free(cipherstring);
 271
 272         SSL_CTX_set_verify(context, SSL_VERIFY_PEER|SSL_VERIFY_CLIENT_ONCE,
 273                            verify_callback);
 274
 275         SSL_free(ssl);
 276         Log_info("OpenSSL library initialized");
 277
 278 }
 279
 280 void SSLi_deinit(void)
 281 {
 282         SSL_CTX_free(context);
 283         EVP_cleanup();
 284 }
 285
 286 int SSLi_nonblockaccept(SSL_handle_t *ssl, bool_t *SSLready)
 287 {
 288         int rc;
 289         rc = SSL_accept(ssl);
 290         if (rc < 0) {
 291                 if (SSL_get_error(ssl, rc) == SSL_ERROR_WANT_READ ||
 292                         SSL_get_error(ssl, rc) == SSL_ERROR_WANT_WRITE) {
 293                         Log_debug("SSL not ready");
 294                         return 0;
 295                 } else {
 296                         Log_warn("SSL error: %s", ERR_error_string(SSL_get_error(ssl, rc), NULL));
 297                         return -1;
 298                 }
 299         }
 300         *SSLready = true;
 301         return 0;
 302 }
 303
 304 SSL_handle_t *SSLi_newconnection(int *fd, bool_t *SSLready)
 305 {
 306         SSL *ssl;
 307
 308         *SSLready = false;
 309         ssl = SSL_new(context);
 310         SSL_set_fd(ssl, *fd);
 311         if (SSLi_nonblockaccept(ssl, SSLready) < 0) {
 312                 SSL_free(ssl);
 313                 return NULL;
 314         }
 315         return ssl;
 316 }
 317
 318 /* Create SHA1 of last certificate in the peer's chain. */
 319 bool_t SSLi_getSHA1Hash(SSL_handle_t *ssl, uint8_t *hash)
 320 {
 321         X509 *x509;
 322         uint8_t *buf, *p;
 323         int len;
 324
 325         x509 = SSL_get_peer_certificate(ssl);
 326         if (!x509) {
 327                 return false;
 328         }
 329
 330         len = i2d_X509(x509, NULL);
 331         buf = malloc(len);
 332         if (buf == NULL) {
 333                 Log_fatal("malloc");
 334         }
 335
 336         p = buf;
 337         i2d_X509(x509, &p);
 338
 339         SHA1(buf, len, hash);
 340         free(buf);
 341         return true;
 342 }
 343
 344 void SSLi_closeconnection(SSL_handle_t *ssl)
 345 {
 346         SSL_free(ssl);
 347 }
 348
 349 void SSLi_shutdown(SSL_handle_t *ssl)
 350 {
 351         SSL_shutdown(ssl);
 352 }
 353
 354 int SSLi_read(SSL_handle_t *ssl, uint8_t *buf, int len)
 355 {
 356         return SSL_read(ssl, buf, len);
 357 }
 358
 359 int SSLi_write(SSL_handle_t *ssl, uint8_t *buf, int len)
 360 {
 361         return SSL_write(ssl, buf, len);
 362 }
 363
 364 int SSLi_get_error(SSL_handle_t *ssl, int code)
 365 {
 366         return SSL_get_error(ssl, code);
 367 }
 368
 369 bool_t SSLi_data_pending(SSL_handle_t *ssl)
 370 {
 371         return SSL_pending(ssl);
 372 }
 373
 374 void SSLi_free(SSL_handle_t *ssl)
 375 {
 376         SSL_free(ssl);
 377 }
 378
 379 static int verify_callback(int preverify_ok, X509_STORE_CTX *ctx)
 380 {
 381         char    buf[256];
 382         X509   *err_cert;
 383         int     err, depth;
 384         SSL    *ssl;
 385
 386     err_cert = X509_STORE_CTX_get_current_cert(ctx);
 387     err = X509_STORE_CTX_get_error(ctx);
 388     depth = X509_STORE_CTX_get_error_depth(ctx);
 389
 390     ssl = X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
 391     X509_NAME_oneline(X509_get_subject_name(err_cert), buf, 256);
 392
 393     if (depth > 5) {
 394         preverify_ok = 0;
 395         err = X509_V_ERR_CERT_CHAIN_TOO_LONG;
 396         X509_STORE_CTX_set_error(ctx, err);
 397     }
 398     if (!preverify_ok) {
 399             Log_warn("SSL: verify error:num=%d:%s:depth=%d:%s\n", err,
 400                      X509_verify_cert_error_string(err), depth, buf);
 401     }
 402     /*
 403      * At this point, err contains the last verification error. We can use
 404      * it for something special
 405      */
 406     if (!preverify_ok && (err == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT)) {
 407             X509_NAME_oneline(X509_get_issuer_name(ctx->current_cert), buf, 256);
 408             Log_warn("issuer= %s", buf);
 409     }
 410     return 1;
 411 }