openssl.c

   1 /*********************************************************************
   2  *
   3  * File        :  $Source: $
   4  *
   5  * Purpose     :  File with TLS/SSL extension. Contains methods for
   6  *                creating, using and closing TLS/SSL connections.
   7  *
   8  * Copyright   :  Written by and Copyright (c) 2020 Maxim Antonov <mantonov@gmail.com>
   9  *
  10  *                This program is free software; you can redistribute it
  11  *                and/or modify it under the terms of the GNU General
  12  *                Public License as published by the Free Software
  13  *                Foundation; either version 2 of the License, or (at
  14  *                your option) any later version.
  15  *
  16  *                This program is distributed in the hope that it will
  17  *                be useful, but WITHOUT ANY WARRANTY; without even the
  18  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  19  *                PARTICULAR PURPOSE.  See the GNU General Public
  20  *                License for more details.
  21  *
  22  *                The GNU General Public License should be included with
  23  *                this file.  If not, you can view it at
  24  *                http://www.gnu.org/copyleft/gpl.html
  25  *                or write to the Free Software Foundation, Inc., 59
  26  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  27  *
  28  *********************************************************************/
  29
  30 #include <string.h>
  31 #include <unistd.h>
  32
  33 #include <openssl/bn.h>
  34 #include <openssl/opensslv.h>
  35 #include <openssl/pem.h>
  36 #include <openssl/md5.h>
  37 #include <openssl/x509v3.h>
  38
  39 #include "config.h"
  40 #include "project.h"
  41 #include "miscutil.h"
  42 #include "errlog.h"
  43 #include "encode.h"
  44 #include "jcc.h"
  45 #include "ssl.h"
  46 #include "ssl_common.h"
  47
  48 /*
  49  * Macros for openssl.c
  50  */
  51 #define CERTIFICATE_BASIC_CONSTRAINTS            "CA:FALSE"
  52 #define CERTIFICATE_SUBJECT_KEY                  "hash"
  53 #define CERTIFICATE_AUTHORITY_KEY                "keyid:always"
  54 #define CERTIFICATE_ALT_NAME_PREFIX              "DNS:"
  55 #define CERTIFICATE_VERSION                      2
  56 #define VALID_DATETIME_FMT                       "%Y%m%d%H%M%SZ"
  57 #define VALID_DATETIME_BUFLEN                    16
  58
  59 static int generate_webpage_certificate(struct client_state *csp);
  60 static void free_client_ssl_structures(struct client_state *csp);
  61 static void free_server_ssl_structures(struct client_state *csp);
  62 static int ssl_store_cert(struct client_state *csp, X509* crt);
  63 static void log_ssl_errors(int debuglevel, const char* fmt, ...) __attribute__((format(printf, 2, 3)));
  64
  65 static int ssl_inited = 0;
  66
  67 /*********************************************************************
  68  *
  69  * Function    :  openssl_init
  70  *
  71  * Description :  INitializes OpenSSL library once
  72  *
  73  * Parameters  :  N/A
  74  *
  75  * Returns     :  N/A
  76  *
  77  *********************************************************************/
  78 static void openssl_init(void)
  79 {
  80    if (ssl_inited == 0)
  81    {
  82       privoxy_mutex_lock(&ssl_init_mutex);
  83       if (ssl_inited == 0)
  84       {
  85 #if OPENSSL_VERSION_NUMBER < 0x10100000L
  86          SSL_library_init();
  87 #else
  88          OPENSSL_init_ssl(0, NULL);
  89 #endif
  90          SSL_load_error_strings();
  91          OpenSSL_add_ssl_algorithms();
  92          ssl_inited = 1;
  93       }
  94       privoxy_mutex_unlock(&ssl_init_mutex);
  95    }
  96 }
  97
  98
  99 /*********************************************************************
 100  *
 101  * Function    :  is_ssl_pending
 102  *
 103  * Description :  Tests if there are some waiting data on ssl connection.
 104  *                Only considers data that has actually been received
 105  *                locally and ignores data that is still on the fly
 106  *                or has not yet been sent by the remote end.
 107  *
 108  * Parameters  :
 109  *          1  :  ssl = SSL context to test
 110  *
 111  * Returns     :   0 => No data are pending
 112  *                >0 => Pending data length
 113  *
 114  *********************************************************************/
 115 extern size_t is_ssl_pending(struct ssl_attr *ssl_attr)
 116 {
 117    BIO *bio = ssl_attr->openssl_attr.bio;
 118    if (bio == NULL)
 119    {
 120       return 0;
 121    }
 122
 123    return (size_t)BIO_pending(bio);
 124 }
 125
 126
 127 /*********************************************************************
 128  *
 129  * Function    :  ssl_send_data
 130  *
 131  * Description :  Sends the content of buf (for n bytes) to given SSL
 132  *                connection context.
 133  *
 134  * Parameters  :
 135  *          1  :  ssl = SSL context to send data to
 136  *          2  :  buf = Pointer to data to be sent
 137  *          3  :  len = Length of data to be sent to the SSL context
 138  *
 139  * Returns     :  Length of sent data or negative value on error.
 140  *
 141  *********************************************************************/
 142 extern int ssl_send_data(struct ssl_attr *ssl_attr, const unsigned char *buf, size_t len)
 143 {
 144    BIO *bio = ssl_attr->openssl_attr.bio;
 145    int ret = 0;
 146    int pos                  = 0;  /* Position of unsent part in buffer */
 147
 148    if (len == 0)
 149    {
 150       return 0;
 151    }
 152
 153    while (pos < len)
 154    {
 155       int send_len = (int)len - pos;
 156
 157       log_error(LOG_LEVEL_WRITING, "TLS: %N", send_len, buf+pos);
 158
 159       /*
 160        * Sending one part of the buffer
 161        */
 162       while ((ret = BIO_write(bio,
 163          (const unsigned char *)(buf + pos),
 164          send_len)) < 0)
 165       {
 166          if (!BIO_should_retry(bio))
 167          {
 168             log_ssl_errors(LOG_LEVEL_ERROR,
 169                "Sending data over TLS/SSL failed");
 170             return -1;
 171          }
 172       }
 173       /* Adding count of sent bytes to position in buffer */
 174       pos = pos + ret;
 175    }
 176
 177    return (int)len;
 178 }
 179
 180
 181 /*********************************************************************
 182  *
 183  * Function    :  ssl_recv_data
 184  *
 185  * Description :  Receives data from given SSL context and puts
 186  *                it into buffer.
 187  *
 188  * Parameters  :
 189  *          1  :  ssl = SSL context to receive data from
 190  *          2  :  buf = Pointer to buffer where data will be written
 191  *          3  :  max_length = Maximum number of bytes to read
 192  *
 193  * Returns     :  Number of bytes read, 0 for EOF, or -1
 194  *                on error.
 195  *
 196  *********************************************************************/
 197 extern int ssl_recv_data(struct ssl_attr *ssl_attr, unsigned char *buf, size_t max_length)
 198 {
 199    BIO *bio = ssl_attr->openssl_attr.bio;
 200    int ret = 0;
 201    memset(buf, 0, max_length);
 202
 203    /*
 204     * Receiving data from SSL context into buffer
 205     */
 206    do
 207    {
 208       ret = BIO_read(bio, buf, (int)max_length);
 209    } while (ret <= 0 && BIO_should_retry(bio));
 210
 211    if (ret < 0)
 212    {
 213       log_ssl_errors(LOG_LEVEL_ERROR,
 214          "Receiving data over TLS/SSL failed");
 215
 216       return -1;
 217    }
 218
 219    log_error(LOG_LEVEL_RECEIVED, "TLS: %N", ret, buf);
 220
 221    return ret;
 222 }
 223
 224
 225 /*********************************************************************
 226  *
 227  * Function    :  ssl_store_cert
 228  *
 229  * Description :  This is a callback function for certificate verification.
 230  *                It's called once for each certificate in the server's
 231  *                certificate trusted chain and prepares information about
 232  *                the certificate. The information can be used to inform
 233  *                the user about invalid certificates.
 234  *
 235  * Parameters  :
 236  *          1  :  csp = Current client state (buffers, headers, etc...)
 237  *          2  :  crt   = certificate from trusted chain
 238  *
 239  * Returns     :  0 on success and negative value on error
 240  *
 241  *********************************************************************/
 242 static int ssl_store_cert(struct client_state *csp, X509* crt)
 243 {
 244    long len = 0;
 245    struct certs_chain  *last = &(csp->server_certs_chain);
 246    int ret = 0;
 247    BIO *bio = BIO_new(BIO_s_mem());
 248    EVP_PKEY *pkey = NULL;
 249    char *bio_mem_data = 0;
 250    char *encoded_text;
 251    long l;
 252    const ASN1_INTEGER *bs;
 253    const X509_ALGOR *tsig_alg;
 254    int loc;
 255
 256    if (!bio)
 257    {
 258       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_new_mem_buf() failed");
 259       return -1;
 260    }
 261
 262    /*
 263     * Searching for last item in certificates linked list
 264     */
 265    while (last->next != NULL)
 266    {
 267       last = last->next;
 268    }
 269
 270    /*
 271     * Preparing next item in linked list for next certificate
 272     */
 273    last->next = malloc_or_die(sizeof(struct certs_chain));
 274    last->next->next = NULL;
 275    memset(last->next->info_buf, 0, sizeof(last->next->info_buf));
 276    memset(last->next->file_buf, 0, sizeof(last->next->file_buf));
 277
 278    /*
 279     * Saving certificate file into buffer
 280     */
 281    if (!PEM_write_bio_X509(bio, crt))
 282    {
 283       log_ssl_errors(LOG_LEVEL_ERROR, "PEM_write_X509() failed");
 284       ret = -1;
 285       goto exit;
 286    }
 287
 288    len = BIO_get_mem_data(bio, &bio_mem_data);
 289
 290    if (len > (sizeof(last->file_buf) - 1))
 291    {
 292       log_error(LOG_LEVEL_ERROR,
 293                 "X509 PEM cert len %d is larger then buffer len %s", len, sizeof(last->file_buf) - 1);
 294       len = sizeof(last->file_buf) - 1;
 295    }
 296
 297    strncpy(last->file_buf, bio_mem_data, (size_t)len);
 298    BIO_free(bio);
 299    bio = BIO_new(BIO_s_mem());
 300    if (!bio)
 301    {
 302       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_new_mem_buf() failed");
 303       ret = -1;
 304       goto exit;
 305    }
 306
 307    /*
 308     * Saving certificate information into buffer
 309     */
 310    l = X509_get_version(crt);
 311    if (l >= 0 && l <= 2) {
 312       if (BIO_printf(bio, "cert. version     : %ld\n", l + 1) <= 0) {
 313          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for version failed");
 314          ret = -1;
 315          goto exit;
 316       }
 317    } else {
 318       if (BIO_printf(bio, "cert. version     : Unknown (%ld)\n", l) <= 0) {
 319          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for version failed");
 320          ret = -1;
 321          goto exit;
 322       }
 323    }
 324
 325    if (BIO_puts(bio, "serial number     : ") <= 0) {
 326       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_write() for serial failed");
 327       ret = -1;
 328       goto exit;
 329    }
 330    bs = X509_get0_serialNumber(crt);
 331    if (bs->length <= (int)sizeof(long)) {
 332       ERR_set_mark();
 333       l = ASN1_INTEGER_get(bs);
 334       ERR_pop_to_mark();
 335    } else {
 336       l = -1;
 337    }
 338    if (l != -1) {
 339       unsigned long ul;
 340       const char *neg;
 341       if (bs->type == V_ASN1_NEG_INTEGER) {
 342          ul = 0 - (unsigned long)l;
 343          neg = "-";
 344       } else {
 345          ul = (unsigned long)l;
 346          neg = "";
 347       }
 348       if (BIO_printf(bio, " %s%lu (%s0x%lx)\n", neg, ul, neg, ul) <= 0) {
 349          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for serial failed");
 350          ret = -1;
 351          goto exit;
 352       }
 353    } else {
 354       if (bs->type == V_ASN1_NEG_INTEGER) {
 355          if (BIO_puts(bio, " (Negative)") < 0) {
 356             log_ssl_errors(LOG_LEVEL_ERROR, "BIO_puts() for serial failed");
 357             ret = -1;
 358             goto exit;
 359          }
 360       }
 361       for (int i = 0; i < bs->length; i++) {
 362          if (BIO_printf(bio, "%02x%c", bs->data[i],
 363                         ((i + 1 == bs->length) ? '\n' : ':')) <= 0) {
 364             log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for serial failed");
 365             ret = -1;
 366             goto exit;
 367          }
 368       }
 369    }
 370
 371    if (BIO_puts(bio, "issuer name       : ") <= 0) {
 372       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_puts() for issuer failed");
 373       ret = -1;
 374       goto exit;
 375    }
 376    if (X509_NAME_print_ex(bio, X509_get_issuer_name(crt), 0, 0) < 0) {
 377       log_ssl_errors(LOG_LEVEL_ERROR, "X509_NAME_print_ex() for issuer failed");
 378       ret = -1;
 379       goto exit;
 380    }
 381
 382    if (BIO_puts(bio, "\nsubject name      : ") <= 0) {
 383       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_puts() for sublect failed");
 384       ret = -1;
 385       goto exit;
 386    }
 387    if (X509_NAME_print_ex(bio, X509_get_subject_name(crt), 0, 0) < 0) {
 388       log_ssl_errors(LOG_LEVEL_ERROR, "X509_NAME_print_ex() for subject failed");
 389       ret = -1;
 390       goto exit;
 391    }
 392
 393    if (BIO_puts(bio, "\nissued  on        : ") <= 0) {
 394       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_puts() for issued on failed");
 395       ret = -1;
 396       goto exit;
 397    }
 398    if (!ASN1_TIME_print(bio, X509_get0_notBefore(crt))) {
 399       log_ssl_errors(LOG_LEVEL_ERROR, "ASN1_TIME_print() for issued on failed");
 400       ret = -1;
 401       goto exit;
 402    }
 403
 404    if (BIO_puts(bio, "\nexpires on        : ") <= 0) {
 405       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_puts() for expires on failed");
 406       ret = -1;
 407       goto exit;
 408    }
 409    if (!ASN1_TIME_print(bio, X509_get0_notAfter(crt))) {
 410       log_ssl_errors(LOG_LEVEL_ERROR, "ASN1_TIME_print() for expires on failed");
 411       ret = -1;
 412       goto exit;
 413    }
 414
 415    if (BIO_puts(bio, "\nsigned using      : ") <= 0) {
 416       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_puts() for signed using failed");
 417       ret = -1;
 418       goto exit;
 419    }
 420    tsig_alg = X509_get0_tbs_sigalg(crt);
 421    if (!i2a_ASN1_OBJECT(bio, tsig_alg->algorithm)) {
 422       log_ssl_errors(LOG_LEVEL_ERROR, "i2a_ASN1_OBJECT() for signed using on failed");
 423       ret = -1;
 424       goto exit;
 425    }
 426    pkey = X509_get_pubkey(crt);
 427    if (!pkey) {
 428       log_ssl_errors(LOG_LEVEL_ERROR, "X509_get_pubkey() failed");
 429       ret = -1;
 430       goto exit;
 431    }
 432 #define BC              "18"
 433    switch (EVP_PKEY_base_id(pkey)) {
 434    case EVP_PKEY_RSA:
 435       ret = BIO_printf(bio, "\n%-" BC "s: %d bits", "RSA key size", EVP_PKEY_bits(pkey));
 436       break;
 437    case EVP_PKEY_DSA:
 438       ret = BIO_printf(bio, "\n%-" BC "s: %d bits", "DSA key size", EVP_PKEY_bits(pkey));
 439       break;
 440    default:
 441       ret = BIO_printf(bio, "\n%-" BC "s: %d bits", "non-RSA/DSA key size", EVP_PKEY_bits(pkey));
 442       break;
 443    }
 444    if (ret <= 0) {
 445       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for key size failed");
 446       ret = -1;
 447       goto exit;
 448    }
 449
 450    loc = X509_get_ext_by_NID(crt, NID_basic_constraints, -1);
 451    if (loc != -1) {
 452       X509_EXTENSION *ex = X509_get_ext(crt, loc);
 453       if (BIO_puts(bio, "\nbasic constraints : ") <= 0) {
 454          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for basic constraints failed");
 455          ret = -1;
 456          goto exit;
 457       }
 458       if (!X509V3_EXT_print(bio, ex, 0, 0)) {
 459          if (!ASN1_STRING_print_ex(bio, X509_EXTENSION_get_data(ex), ASN1_STRFLGS_RFC2253)) {
 460             log_ssl_errors(LOG_LEVEL_ERROR, "ASN1_STRING_print_ex() for basic constraints failed");
 461             ret = -1;
 462             goto exit;
 463          }
 464       }
 465    }
 466
 467    loc = X509_get_ext_by_NID(crt, NID_subject_alt_name, -1);
 468    if (loc != -1) {
 469       X509_EXTENSION *ex = X509_get_ext(crt, loc);
 470       if (BIO_puts(bio, "\nsubject alt name  : ") <= 0) {
 471          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for alt name failed");
 472          ret = -1;
 473          goto exit;
 474       }
 475       if (!X509V3_EXT_print(bio, ex, 0, 0)) {
 476          if (!ASN1_STRING_print_ex(bio, X509_EXTENSION_get_data(ex), ASN1_STRFLGS_RFC2253)) {
 477             log_ssl_errors(LOG_LEVEL_ERROR, "ASN1_STRING_print_ex() for alt name failed");
 478             ret = -1;
 479             goto exit;
 480          }
 481       }
 482    }
 483
 484    loc = X509_get_ext_by_NID(crt, NID_netscape_cert_type, -1);
 485    if (loc != -1) {
 486       X509_EXTENSION *ex = X509_get_ext(crt, loc);
 487       if (BIO_puts(bio, "\ncert. type        : ") <= 0) {
 488          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for cert type failed");
 489          ret = -1;
 490          goto exit;
 491       }
 492       if (!X509V3_EXT_print(bio, ex, 0, 0)) {
 493          if (!ASN1_STRING_print_ex(bio, X509_EXTENSION_get_data(ex), ASN1_STRFLGS_RFC2253)) {
 494             log_ssl_errors(LOG_LEVEL_ERROR, "ASN1_STRING_print_ex() for cert type failed");
 495             ret = -1;
 496             goto exit;
 497          }
 498       }
 499    }
 500
 501    loc = X509_get_ext_by_NID(crt, NID_key_usage, -1);
 502    if (loc != -1) {
 503       X509_EXTENSION *ex = X509_get_ext(crt, loc);
 504       if (BIO_puts(bio, "\nkey usage         : ") <= 0) {
 505          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for key usage failed");
 506          ret = -1;
 507          goto exit;
 508       }
 509       if (!X509V3_EXT_print(bio, ex, 0, 0)) {
 510          if (!ASN1_STRING_print_ex(bio, X509_EXTENSION_get_data(ex), ASN1_STRFLGS_RFC2253)) {
 511             log_ssl_errors(LOG_LEVEL_ERROR, "ASN1_STRING_print_ex() for key usage failed");
 512             ret = -1;
 513             goto exit;
 514          }
 515       }
 516    }
 517
 518    loc = X509_get_ext_by_NID(crt, NID_ext_key_usage, -1);
 519    if (loc != -1) {
 520       X509_EXTENSION *ex = X509_get_ext(crt, loc);
 521       if (BIO_puts(bio, "\next key usage     : ") <= 0) {
 522          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for ext key usage failed");
 523          ret = -1;
 524          goto exit;
 525       }
 526       if (!X509V3_EXT_print(bio, ex, 0, 0)) {
 527          if (!ASN1_STRING_print_ex(bio, X509_EXTENSION_get_data(ex), ASN1_STRFLGS_RFC2253)) {
 528             log_ssl_errors(LOG_LEVEL_ERROR, "ASN1_STRING_print_ex() for ext key usage failed");
 529             ret = -1;
 530             goto exit;
 531          }
 532       }
 533    }
 534
 535    loc = X509_get_ext_by_NID(crt, NID_certificate_policies, -1);
 536    if (loc != -1) {
 537       X509_EXTENSION *ex = X509_get_ext(crt, loc);
 538       if (BIO_puts(bio, "\ncertificate policies : ") <= 0) {
 539          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for certificate policies failed");
 540          ret = -1;
 541          goto exit;
 542       }
 543       if (!X509V3_EXT_print(bio, ex, 0, 0)) {
 544          if (!ASN1_STRING_print_ex(bio, X509_EXTENSION_get_data(ex), ASN1_STRFLGS_RFC2253)) {
 545             log_ssl_errors(LOG_LEVEL_ERROR, "ASN1_STRING_print_ex() for certificate policies failed");
 546             ret = -1;
 547             goto exit;
 548          }
 549       }
 550    }
 551
 552    /* make valgrind happy */
 553    static const char zero = 0;
 554    BIO_write(bio, &zero, 1);
 555
 556    len = BIO_get_mem_data(bio, &bio_mem_data);
 557    encoded_text = html_encode(bio_mem_data);
 558    strlcpy(last->info_buf, encoded_text, sizeof(last->info_buf));
 559    freez(encoded_text);
 560    ret = 0;
 561
 562 exit:
 563    if (bio) BIO_free(bio);
 564    if (pkey) EVP_PKEY_free(pkey);
 565    return ret;
 566 }
 567
 568 /*********************************************************************
 569  *
 570  * Function    :  host_to_hash
 571  *
 572  * Description :  Creates MD5 hash from host name. Host name is loaded
 573  *                from structure csp and saved again into it.
 574  *
 575  * Parameters  :
 576  *          1  :  csp = Current client state (buffers, headers, etc...)
 577  *
 578  * Returns     :  1 => Error while creating hash
 579  *                0 => Hash created successfully
 580  *
 581  *********************************************************************/
 582 static int host_to_hash(struct client_state *csp)
 583 {
 584    int ret = 0;
 585
 586    memset(csp->http->hash_of_host, 0, sizeof(csp->http->hash_of_host));
 587    MD5((unsigned char *)csp->http->host, strlen(csp->http->host),
 588       csp->http->hash_of_host);
 589
 590    /* Converting hash into string with hex */
 591    size_t i = 0;
 592    for (; i < 16; i++)
 593    {
 594       if ((ret = sprintf((char *)csp->http->hash_of_host_hex + 2 * i, "%02x",
 595          csp->http->hash_of_host[i])) < 0)
 596       {
 597          log_error(LOG_LEVEL_ERROR, "Sprintf return value: %d", ret);
 598          return -1;
 599       }
 600    }
 601
 602    return 0;
 603 }
 604
 605 /*********************************************************************
 606  *
 607  * Function    :  create_client_ssl_connection
 608  *
 609  * Description :  Creates TLS/SSL secured connection with client
 610  *
 611  * Parameters  :
 612  *          1  :  csp = Current client state (buffers, headers, etc...)
 613  *
 614  * Returns     :  0 on success, negative value if connection wasn't created
 615  *                successfully.
 616  *
 617  *********************************************************************/
 618 extern int create_client_ssl_connection(struct client_state *csp)
 619 {
 620    struct ssl_attr *ssl_attr = &csp->ssl_client_attr;
 621    /* Paths to certificates file and key file */
 622    char *key_file  = NULL;
 623    char *ca_file   = NULL;
 624    char *cert_file = NULL;
 625    int ret = 0;
 626    SSL* ssl;
 627
 628    /*
 629     * Initializing OpenSSL structures for TLS/SSL connection
 630     */
 631    openssl_init();
 632
 633    /*
 634     * Preparing hash of host for creating certificates
 635     */
 636    ret = host_to_hash(csp);
 637    if (ret != 0)
 638    {
 639       log_error(LOG_LEVEL_ERROR, "Generating hash of host failed: %d", ret);
 640       ret = -1;
 641       goto exit;
 642    }
 643
 644    /*
 645     * Preparing paths to certificates files and key file
 646     */
 647    ca_file   = csp->config->ca_cert_file;
 648    cert_file = make_certs_path(csp->config->certificate_directory,
 649       (const char *)csp->http->hash_of_host_hex, CERT_FILE_TYPE);
 650    key_file  = make_certs_path(csp->config->certificate_directory,
 651       (const char *)csp->http->hash_of_host_hex, KEY_FILE_TYPE);
 652
 653    if (cert_file == NULL || key_file == NULL)
 654    {
 655       ret = -1;
 656       goto exit;
 657    }
 658
 659    /*
 660     * Generating certificate for requested host. Mutex to prevent
 661     * certificate and key inconsistence must be locked.
 662     */
 663    privoxy_mutex_lock(&certificate_mutex);
 664
 665    ret = generate_webpage_certificate(csp);
 666    if (ret < 0)
 667    {
 668       log_error(LOG_LEVEL_ERROR,
 669          "Generate_webpage_certificate failed: %d", ret);
 670       privoxy_mutex_unlock(&certificate_mutex);
 671       ret = -1;
 672       goto exit;
 673    }
 674    privoxy_mutex_unlock(&certificate_mutex);
 675
 676    if (!(ssl_attr->openssl_attr.ctx = SSL_CTX_new(SSLv23_server_method()))) {
 677       log_ssl_errors(LOG_LEVEL_ERROR, "Unable to create SSL context");
 678       ret = -1;
 679       goto exit;
 680    }
 681
 682       /* Set the key and cert */
 683    if (SSL_CTX_use_certificate_file(ssl_attr->openssl_attr.ctx,
 684                                     cert_file, SSL_FILETYPE_PEM) != 1) {
 685       log_ssl_errors(LOG_LEVEL_ERROR, "Loading webpage certificate %s failed", cert_file);
 686       ret = -1;
 687       goto exit;
 688    }
 689
 690    if (SSL_CTX_use_PrivateKey_file(ssl_attr->openssl_attr.ctx, key_file, SSL_FILETYPE_PEM) != 1) {
 691       log_ssl_errors(LOG_LEVEL_ERROR, "Loading webpage certificate private key %s failed", key_file);
 692       ret = -1;
 693       goto exit;
 694    }
 695
 696    SSL_CTX_set_options(ssl_attr->openssl_attr.ctx, SSL_OP_NO_SSLv3);
 697
 698    if (!(ssl_attr->openssl_attr.bio = BIO_new_ssl(ssl_attr->openssl_attr.ctx, 0))) {
 699       log_ssl_errors(LOG_LEVEL_ERROR, "Unable to create BIO structure");
 700       ret = -1;
 701       goto exit;
 702    }
 703
 704    if (BIO_get_ssl(ssl_attr->openssl_attr.bio, &ssl) != 1)
 705    {
 706       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_get_ssl failed");
 707       ret = -1;
 708       goto exit;
 709    }
 710
 711    if(!SSL_set_fd(ssl, csp->cfd))
 712    {
 713       log_ssl_errors(LOG_LEVEL_ERROR, "SSL_set_fd failed");
 714       ret = -1;
 715       goto exit;
 716    }
 717
 718    /*
 719     *  Handshake with client
 720     */
 721    log_error(LOG_LEVEL_CONNECT,
 722       "Performing the TLS/SSL handshake with client. Hash of host: %s",
 723       csp->http->hash_of_host_hex);
 724    if (BIO_do_handshake(ssl_attr->openssl_attr.bio) != 1) {
 725        log_ssl_errors(LOG_LEVEL_ERROR, "BIO_do_handshake failed");
 726        ret = -1;
 727        goto exit;
 728    }
 729
 730    log_error(LOG_LEVEL_CONNECT, "Client successfully connected over TLS/SSL");
 731    csp->ssl_with_client_is_opened = 1;
 732    ret = 0;
 733
 734 exit:
 735    /*
 736     * Freeing allocated paths to files
 737     */
 738    freez(cert_file);
 739    freez(key_file);
 740
 741    /* Freeing structures if connection wasn't created successfully */
 742    if (ret < 0)
 743    {
 744       free_client_ssl_structures(csp);
 745    }
 746    return ret;
 747 }
 748
 749
 750 /*********************************************************************
 751  *
 752  * Function    :  close_client_ssl_connection
 753  *
 754  * Description :  Closes TLS/SSL connection with client. This function
 755  *                checks if this connection is already created.
 756  *
 757  * Parameters  :
 758  *          1  :  csp = Current client state (buffers, headers, etc...)
 759  *
 760  * Returns     :  N/A
 761  *
 762  *********************************************************************/
 763 extern void close_client_ssl_connection(struct client_state *csp)
 764 {
 765    struct ssl_attr *ssl_attr = &csp->ssl_client_attr;
 766
 767    if (csp->ssl_with_client_is_opened == 0)
 768    {
 769       return;
 770    }
 771
 772    /*
 773     * Notifying the peer that the connection is being closed.
 774     */
 775    BIO_ssl_shutdown(ssl_attr->openssl_attr.bio);
 776    free_client_ssl_structures(csp);
 777    csp->ssl_with_client_is_opened = 0;
 778 }
 779
 780
 781 /*********************************************************************
 782  *
 783  * Function    :  free_client_ssl_structures
 784  *
 785  * Description :  Frees structures used for SSL communication with
 786  *                client.
 787  *
 788  * Parameters  :
 789  *          1  :  csp = Current client state (buffers, headers, etc...)
 790  *
 791  * Returns     :  N/A
 792  *
 793  *********************************************************************/
 794 static void free_client_ssl_structures(struct client_state *csp)
 795 {
 796    struct ssl_attr *ssl_attr = &csp->ssl_client_attr;
 797
 798    if (ssl_attr->openssl_attr.bio) BIO_free_all(ssl_attr->openssl_attr.bio);
 799    if (ssl_attr->openssl_attr.ctx) SSL_CTX_free(ssl_attr->openssl_attr.ctx);
 800 }
 801
 802
 803 /*********************************************************************
 804  *
 805  * Function    :  close_server_ssl_connection
 806  *
 807  * Description :  Closes TLS/SSL connection with server. This function
 808  *                checks if this connection is already opened.
 809  *
 810  * Parameters  :
 811  *          1  :  csp = Current client state (buffers, headers, etc...)
 812  *
 813  * Returns     :  N/A
 814  *
 815  *********************************************************************/
 816 extern void close_server_ssl_connection(struct client_state *csp)
 817 {
 818    struct ssl_attr *ssl_attr = &csp->ssl_server_attr;
 819
 820    if (csp->ssl_with_server_is_opened == 0)
 821    {
 822       return;
 823    }
 824
 825    /*
 826    * Notifying the peer that the connection is being closed.
 827    */
 828    BIO_ssl_shutdown(ssl_attr->openssl_attr.bio);
 829    free_server_ssl_structures(csp);
 830    csp->ssl_with_server_is_opened = 0;
 831 }
 832
 833
 834 /*********************************************************************
 835  *
 836  * Function    :  create_server_ssl_connection
 837  *
 838  * Description :  Creates TLS/SSL secured connection with server.
 839  *
 840  * Parameters  :
 841  *          1  :  csp = Current client state (buffers, headers, etc...)
 842  *
 843  * Returns     :  0 on success, negative value if connection wasn't created
 844  *                successfully.
 845  *
 846  *********************************************************************/
 847 extern int create_server_ssl_connection(struct client_state *csp)
 848 {
 849    openssl_connection_attr *ssl_attrs = &csp->ssl_server_attr.openssl_attr;
 850    int ret = 0;
 851    char *trusted_cas_file = NULL;
 852    STACK_OF(X509) *chain;
 853    SSL *ssl;
 854
 855    csp->server_cert_verification_result = SSL_CERT_NOT_VERIFIED;
 856    csp->server_certs_chain.next = NULL;
 857
 858    /* Setting path to file with trusted CAs */
 859    trusted_cas_file = csp->config->trusted_cas_file;
 860
 861
 862    ssl_attrs->ctx = SSL_CTX_new(SSLv23_method());
 863    if (!ssl_attrs->ctx)
 864    {
 865       log_ssl_errors(LOG_LEVEL_ERROR, "SSL context creation failed");
 866       ret = -1;
 867       goto exit;
 868    }
 869
 870    /*
 871     * Loading file with trusted CAs
 872     */
 873    if(!SSL_CTX_load_verify_locations(ssl_attrs->ctx, trusted_cas_file, NULL))
 874    {
 875       log_ssl_errors(LOG_LEVEL_ERROR, "Loading trusted CAs file %s failed",
 876          trusted_cas_file);
 877       ret = -1;
 878       goto exit;
 879    }
 880
 881    SSL_CTX_set_verify(ssl_attrs->ctx, SSL_VERIFY_NONE, NULL);
 882    SSL_CTX_set_options(ssl_attrs->ctx, SSL_OP_NO_SSLv3);
 883
 884    if (!(ssl_attrs->bio = BIO_new_ssl(ssl_attrs->ctx, 1))) {
 885       log_ssl_errors(LOG_LEVEL_ERROR, "Unable to create BIO structure");
 886       ret = -1;
 887       goto exit;
 888    }
 889
 890    if (BIO_get_ssl(ssl_attrs->bio, &ssl) != 1)
 891    {
 892       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_get_ssl failed");
 893       ret = -1;
 894       goto exit;
 895    }
 896
 897    if (!SSL_set_fd(ssl, csp->server_connection.sfd))
 898    {
 899       log_ssl_errors(LOG_LEVEL_ERROR, "SSL_set_fd failed");
 900       ret = -1;
 901       goto exit;
 902    }
 903
 904    /*
 905     * Set the hostname to check against the received server certificate
 906     */
 907    if (!SSL_set1_host(ssl, csp->http->host))
 908    {
 909       log_ssl_errors(LOG_LEVEL_ERROR, "SSL_set1_host failed");
 910       ret = -1;
 911       goto exit;
 912    }
 913
 914    /* SNI extension */
 915    if (!SSL_set_tlsext_host_name(ssl, csp->http->host))
 916    {
 917       log_ssl_errors(LOG_LEVEL_ERROR, "SSL_set_tlsext_host_name failed");
 918       ret = -1;
 919       goto exit;
 920    }
 921
 922    /*
 923     * Handshake with server
 924     */
 925    log_error(LOG_LEVEL_CONNECT,
 926       "Performing the TLS/SSL handshake with the server");
 927
 928    if (BIO_do_handshake(ssl_attrs->bio) != 1)
 929    {
 930       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_do_handshake failed");
 931       ret = -1;
 932       goto exit;
 933    }
 934
 935    chain = SSL_get_peer_cert_chain(ssl);
 936    if (chain) {
 937       for (int i = 0; i < sk_X509_num(chain); i++) {
 938          if (ssl_store_cert(csp, sk_X509_value(chain, i)) != 0) {
 939             log_error(LOG_LEVEL_ERROR, "ssl_store_cert failed");
 940             ret = -1;
 941             goto exit;
 942          }
 943       }
 944    }
 945
 946    if (!csp->dont_verify_certificate)
 947    {
 948       long verify_result = SSL_get_verify_result(ssl);
 949       if (verify_result == X509_V_OK)
 950       {
 951          ret = 0;
 952          csp->server_cert_verification_result = SSL_CERT_VALID;
 953       } else {
 954          csp->server_cert_verification_result = verify_result;
 955          log_error(LOG_LEVEL_ERROR, "SSL_get_verify_result failed: %s",
 956                     X509_verify_cert_error_string(verify_result));
 957          ret = -1;
 958          goto exit;
 959       }
 960    }
 961
 962    log_error(LOG_LEVEL_CONNECT, "Server successfully connected over TLS/SSL");
 963
 964    /*
 965     * Server certificate chain is valid, so we can clean
 966     * chain, because we will not send it to client.
 967     */
 968    free_certificate_chain(csp);
 969
 970    csp->ssl_with_server_is_opened = 1;
 971 exit:
 972    /* Freeing structures if connection wasn't created successfully */
 973    if (ret < 0)
 974    {
 975       free_server_ssl_structures(csp);
 976    }
 977
 978    return ret;
 979 }
 980
 981
 982 /*********************************************************************
 983  *
 984  * Function    :  free_server_ssl_structures
 985  *
 986  * Description :  Frees structures used for SSL communication with server
 987  *
 988  * Parameters  :
 989  *          1  :  csp = Current client state (buffers, headers, etc...)
 990  *
 991  * Returns     :  N/A
 992  *
 993  *********************************************************************/
 994 static void free_server_ssl_structures(struct client_state *csp)
 995 {
 996    struct ssl_attr *ssl_attr = &csp->ssl_server_attr;
 997
 998    if (ssl_attr->openssl_attr.bio) BIO_free_all(ssl_attr->openssl_attr.bio);
 999    if (ssl_attr->openssl_attr.ctx) SSL_CTX_free(ssl_attr->openssl_attr.ctx);
1000 }
1001
1002
1003 /*********************************************************************
1004  *
1005  * Function    :  log_ssl_errors
1006  *
1007  * Description :  Log SSL errors
1008  *
1009  * Parameters  :
1010  *          1  :  debuglevel = Debug level
1011  *          2  :  desc = Error description
1012  *
1013  * Returns     :  N/A
1014  *
1015  *********************************************************************/
1016 static void log_ssl_errors(int debuglevel, const char* fmt, ...)
1017 {
1018    unsigned long err_code;
1019    char prefix[ERROR_BUF_SIZE];
1020    va_list args;
1021    va_start(args, fmt);
1022    vsnprintf(prefix, sizeof(prefix), fmt, args);
1023    int reported = 0;
1024
1025    while ((err_code = ERR_get_error())) {
1026       char err_buf[ERROR_BUF_SIZE];
1027       reported = 1;
1028       ERR_error_string_n(err_code, err_buf, sizeof(err_buf));
1029       log_error(debuglevel, "%s: %s", prefix, err_buf);
1030    }
1031    va_end(args);
1032    /* in case if called by mistake and there were no SSL errors let's report it to the log */
1033    if (!reported)
1034       log_error(debuglevel, "%s: no ssl errors detected", prefix);
1035 }
1036
1037
1038 /*********************************************************************
1039  *
1040  * Function    :  ssl_base64_encode
1041  *
1042  * Description :  Encode a buffer into base64 format.
1043  *
1044  * Parameters  :
1045  *          1  :  dst = Destination buffer
1046  *          2  :  dlen = Destination buffer length
1047  *          3  :  olen = Number of bytes written
1048  *          4  :  src = Source buffer
1049  *          5  :  slen = Amount of data to be encoded
1050  *
1051  * Returns     :  0 on success, error code othervise
1052  *
1053  *********************************************************************/
1054 extern int ssl_base64_encode(unsigned char *dst, size_t dlen, size_t *olen,
1055                               const unsigned char *src, size_t slen )
1056 {
1057    *olen = 4 * ((slen/3)  + ((slen%3) ? 1 : 0)) + 1;
1058    if (*olen < dlen)
1059       return ENOBUFS;
1060    *olen = (size_t)EVP_EncodeBlock(dst, src, (int)slen) + 1;
1061    return 0;
1062 }
1063
1064
1065 /*********************************************************************
1066  *
1067  * Function    :  close_file_stream
1068  *
1069  * Description :  Close file stream, report error on close error
1070  *
1071  * Parameters  :
1072  *          1  :  f = file stream to close
1073  *          2  :  path = path for error report
1074  *
1075  * Returns     :  N/A
1076  *
1077  *********************************************************************/
1078 static void close_file_stream(FILE *f, const char* path) {
1079    if (fclose(f) != 0) {
1080       log_error(LOG_LEVEL_ERROR, "Error closing file %s: %s", path, strerror(errno));
1081    }
1082 }
1083
1084
1085 /*********************************************************************
1086  *
1087  * Function    :  write_certificate
1088  *
1089  * Description :  Writes certificate into file.
1090  *
1091  * Parameters  :
1092  *          1  :  crt = certificate to write into file
1093  *          2  :  output_file = path to save certificate file
1094  *
1095  *                on error
1096  * Returns     :  1 on success success or negative value
1097  *
1098  *********************************************************************/
1099 static int write_certificate(X509 *crt, const char *output_file)
1100 {
1101    FILE *f = NULL;
1102    int ret = -1;
1103
1104    /*
1105     * Saving certificate into file
1106     */
1107    if ((f = fopen(output_file, "w")) == NULL)
1108    {
1109       log_error(LOG_LEVEL_ERROR, "Opening file %s to save certificate failed",
1110          output_file);
1111       return ret;
1112    }
1113
1114    ret = PEM_write_X509(f, crt);
1115    if (!ret)
1116    {
1117       log_ssl_errors(LOG_LEVEL_ERROR,
1118          "Writing certificate into file %s failed", output_file);
1119       ret = -1;
1120    }
1121
1122    close_file_stream(f, output_file);
1123
1124    return ret;
1125 }
1126
1127 /*********************************************************************
1128  *
1129  * Function    :  write_private_key
1130  *
1131  * Description :  Writes private key into file and copies saved
1132  *                content into given pointer to string. If function
1133  *                returns 0 for success, this copy must be freed by
1134  *                caller.
1135  *
1136  * Parameters  :
1137  *          1  :  key = key to write into file
1138  *          2  :  ret_buf = pointer to string with created key file content
1139  *          3  :  key_file_path = path where to save key file
1140  *
1141  * Returns     :  Length of written private key on success or negative value
1142  *                on error
1143  *
1144  *********************************************************************/
1145 static int write_private_key(EVP_PKEY *key, char **ret_buf,
1146    const char *key_file_path)
1147 {
1148    size_t len = 0;                /* Length of created key    */
1149    FILE *f = NULL;                /* File to save certificate */
1150    int ret = 0;
1151    BIO *bio_mem = BIO_new(BIO_s_mem());
1152    char *bio_mem_data = 0;
1153
1154    if (bio_mem == NULL) {
1155       log_ssl_errors(LOG_LEVEL_ERROR, "write_private_key memory allocation failure");
1156       return -1;
1157    }
1158
1159    /*
1160     * Writing private key into PEM string
1161     */
1162    if (!PEM_write_bio_PrivateKey(bio_mem, key, NULL, NULL, 0, NULL, NULL)) {
1163       log_ssl_errors(LOG_LEVEL_ERROR, "Writing private key into PEM string failed");
1164       ret = -1;
1165       goto exit;
1166    }
1167
1168    len = (size_t)BIO_get_mem_data(bio_mem, &bio_mem_data);
1169
1170    /* Initializing buffer for key file content */
1171    *ret_buf = zalloc_or_die(len + 1);
1172    (*ret_buf)[len] = 0;
1173
1174    strncpy(*ret_buf, bio_mem_data, len);
1175
1176    /*
1177     * Saving key into file
1178     */
1179    if ((f = fopen(key_file_path, "wb")) == NULL)
1180    {
1181       log_error(LOG_LEVEL_ERROR,
1182          "Opening file %s to save private key failed: %E",
1183          key_file_path);
1184       ret = -1;
1185       goto exit;
1186    }
1187
1188    if (fwrite(*ret_buf, 1, len, f) != len)
1189    {
1190       log_error(LOG_LEVEL_ERROR,
1191          "Writing private key into file %s failed",
1192          key_file_path);
1193       close_file_stream(f, key_file_path);
1194       ret = -1;
1195       goto exit;
1196    }
1197
1198    close_file_stream(f, key_file_path);
1199
1200 exit:
1201    BIO_free(bio_mem);
1202    if (ret < 0)
1203    {
1204       freez(*ret_buf);
1205       *ret_buf = NULL;
1206       return ret;
1207    }
1208    return (int)len;
1209 }
1210
1211
1212 /*********************************************************************
1213  *
1214  * Function    :  generate_key
1215  *
1216  * Description : Tests if private key for host saved in csp already
1217  *               exists.  If this file doesn't exists, a new key is
1218  *               generated and saved in a file. The generated key is also
1219  *               copied into given parameter key_buf, which must be then
1220  *               freed by caller. If file with key exists, key_buf
1221  *               contain NULL and no private key is generated.
1222  *
1223  * Parameters  :
1224  *          1  :  csp = Current client state (buffers, headers, etc...)
1225  *          2  :  key_buf = buffer to save new generated key
1226  *
1227  * Returns     :  -1 => Error while generating private key
1228  *                 0 => Key already exists
1229  *                >0 => Length of generated private key
1230  *
1231  *********************************************************************/
1232 static int generate_key(struct client_state *csp, char **key_buf)
1233 {
1234    int ret = 0;
1235    char* key_file_path = NULL;
1236    BIGNUM *exp = BN_new();
1237    RSA *rsa = RSA_new();
1238    EVP_PKEY *key = EVP_PKEY_new();
1239
1240    if (exp == NULL || rsa == NULL || key == NULL) {
1241       log_ssl_errors(LOG_LEVEL_ERROR, "RSA key memory allocation failure");
1242       ret = -1;
1243       goto exit;
1244    }
1245
1246    BN_set_word(exp, RSA_KEY_PUBLIC_EXPONENT);
1247
1248    key_file_path = make_certs_path(csp->config->certificate_directory,
1249       (char *)csp->http->hash_of_host_hex, KEY_FILE_TYPE);
1250    if (key_file_path == NULL)
1251    {
1252       ret = -1;
1253       goto exit;
1254    }
1255
1256    /*
1257     * Test if key already exists. If so, we don't have to create it again.
1258     */
1259    if (file_exists(key_file_path) == 1)
1260    {
1261       ret = 0;
1262       goto exit;
1263    }
1264
1265    ret = RSA_generate_key_ex(rsa, RSA_KEYSIZE, exp, NULL);
1266    if (ret == 0) {
1267       log_ssl_errors(LOG_LEVEL_ERROR, "RSA key generation failure");
1268       ret = -1;
1269       goto exit;
1270    }
1271
1272    if (!EVP_PKEY_set1_RSA(key, rsa)) {
1273       log_ssl_errors(LOG_LEVEL_ERROR, "Error assigning RSA key pair to PKEY structure");
1274       ret = -1;
1275       goto exit;
1276    }
1277
1278    /*
1279     * Exporting private key into file
1280     */
1281    if ((ret = write_private_key(key, key_buf, key_file_path)) < 0)
1282    {
1283       log_error(LOG_LEVEL_ERROR,
1284          "Writing private key into file %s failed", key_file_path);
1285       ret = -1;
1286       goto exit;
1287    }
1288
1289 exit:
1290    /*
1291     * Freeing used variables
1292     */
1293    if (exp) BN_free(exp);
1294    if (rsa) RSA_free(rsa);
1295    if (key) EVP_PKEY_free(key);
1296    freez(key_file_path);
1297
1298    return ret;
1299 }
1300
1301 /*********************************************************************
1302  *
1303  * Function    :  ssl_certificate_load
1304  *
1305  * Description :  Loads certificate from file.
1306  *
1307  * Parameters  :
1308  *          1  :  cert_path = The certificate path to load
1309  *
1310  * Returns     :   NULL => error loading certificate,
1311  *                   pointer to certificate instance otherwise
1312  *
1313  *********************************************************************/
1314 static X509* ssl_certificate_load(const char *cert_path)
1315 {
1316    X509 *cert = NULL;
1317    FILE *cert_f = NULL;
1318
1319    if (!(cert_f = fopen(cert_path, "r"))) {
1320       log_error(LOG_LEVEL_ERROR, "Error opening certificate file %s: %s", cert_path, strerror(errno));
1321       return NULL;
1322    }
1323
1324    if (!(cert = PEM_read_X509(cert_f, NULL, NULL, NULL))) {
1325       log_ssl_errors(LOG_LEVEL_ERROR, "Error reading certificate file %s", cert_path);
1326    }
1327
1328    close_file_stream(cert_f, cert_path);
1329    return cert;
1330 }
1331
1332
1333 /*********************************************************************
1334  *
1335  * Function    :  ssl_certificate_is_invalid
1336  *
1337  * Description :  Checks whether or not a certificate is valid.
1338  *                Currently only checks that the certificate can be
1339  *                parsed and that the "valid to" date is in the future.
1340  *
1341  * Parameters  :
1342  *          1  :  cert_file = The certificate to check
1343  *
1344  * Returns     :   0 => The certificate is valid.
1345  *                 1 => The certificate is invalid
1346  *
1347  *********************************************************************/
1348 static int ssl_certificate_is_invalid(const char *cert_file)
1349 {
1350    int ret;
1351
1352    X509 *cert = NULL;
1353
1354    if (!(cert = ssl_certificate_load(cert_file))) {
1355       log_ssl_errors(LOG_LEVEL_ERROR, "Error reading certificate file %s", cert_file);
1356       return 1;
1357    }
1358
1359    ret = X509_cmp_current_time(X509_get_notAfter(cert));
1360    if (ret == 0) {
1361       log_ssl_errors(LOG_LEVEL_ERROR, "Error checking certificate %s validity", cert_file);
1362    }
1363
1364    X509_free(cert);
1365
1366    return ret == -1 ? 1 : 0;
1367 }
1368
1369 /*********************************************************************
1370  *
1371  * Function    :  set_x509_ext
1372  *
1373  * Description :  Sets the X509V3 extension data
1374  *
1375  * Parameters  :
1376  *          1  :  cert = The certificate to modify
1377  *          2  :  issuer = Issuer certificate
1378  *          3  :  nid = OpenSSL NID
1379  *          2  :  data = extension value
1380  *
1381  * Returns     :   0 => Error while setting extensuon data
1382  *                 1 => It worked
1383  *
1384  *********************************************************************/
1385 static int set_x509_ext(X509 *cert, X509 *issuer, int nid, const char *value)
1386 {
1387    X509_EXTENSION * ext = NULL;
1388    X509V3_CTX ctx;
1389    int ret = 0;
1390
1391    X509V3_set_ctx(&ctx, issuer, cert, NULL, NULL, 0);
1392    ext = X509V3_EXT_conf_nid(NULL, &ctx, nid, value);
1393    if (!ext)
1394    {
1395       log_ssl_errors(LOG_LEVEL_ERROR, "X509V3_EXT_conf_nid failure");
1396       goto exit;
1397    }
1398
1399    if (!X509_add_ext(cert, ext, -1))
1400    {
1401       log_ssl_errors(LOG_LEVEL_ERROR, "X509_add_ext failure");
1402       goto exit;
1403    }
1404
1405    ret = 1;
1406 exit:
1407    if (ext) X509_EXTENSION_free(ext);
1408    return ret;
1409 }
1410
1411
1412 /*********************************************************************
1413  *
1414  * Function    :  set_subject_alternative_name
1415  *
1416  * Description :  Sets the Subject Alternative Name extension to a cert
1417  *
1418  * Parameters  :
1419  *          1  :  cert = The certificate to modify
1420  *          2  :  issuer = Issuer certificate
1421  *          2  :  hostname = The hostname to add
1422  *
1423  * Returns     :   0 => Error while creating certificate.
1424  *                 1 => It worked
1425  *
1426  *********************************************************************/
1427 static int set_subject_alternative_name(X509 *cert, X509 *issuer, const char *hostname)
1428 {
1429    size_t altname_len = strlen(hostname) + sizeof(CERTIFICATE_ALT_NAME_PREFIX);
1430    char alt_name_buf[altname_len];
1431
1432    snprintf(alt_name_buf, sizeof(alt_name_buf), CERTIFICATE_ALT_NAME_PREFIX"%s", hostname);
1433    return set_x509_ext(cert, issuer, NID_subject_alt_name, alt_name_buf);
1434 }
1435
1436
1437 /*********************************************************************
1438  *
1439  * Function    :  generate_webpage_certificate
1440  *
1441  * Description :  Creates certificate file in presetted directory.
1442  *                If certificate already exists, no other certificate
1443  *                will be created. Subject of certificate is named
1444  *                by csp->http->host from parameter. This function also
1445  *                triggers generating of private key for new certificate.
1446  *
1447  * Parameters  :
1448  *          1  :  csp = Current client state (buffers, headers, etc...)
1449  *
1450  * Returns     :  -1 => Error while creating certificate.
1451  *                 0 => Certificate already exists.
1452  *                 1 => Certificate created
1453  *
1454  *********************************************************************/
1455 static int generate_webpage_certificate(struct client_state *csp)
1456 {
1457    char *key_buf = NULL;    /* Buffer for created key */
1458    X509* issuer_cert = NULL;
1459    X509* cert = NULL;
1460    BIO* pk_bio = NULL;
1461    EVP_PKEY *loaded_subject_key = NULL;
1462    EVP_PKEY *loaded_issuer_key = NULL;
1463    X509_NAME* issuer_name;
1464    X509_NAME* subject_name = NULL;
1465    ASN1_TIME* asn_time = NULL;
1466    ASN1_INTEGER *serial = NULL;
1467    BIGNUM *serial_num = NULL;
1468
1469    int ret = 0;
1470    cert_options cert_opt;
1471    char cert_valid_from[VALID_DATETIME_BUFLEN];
1472    char cert_valid_to[VALID_DATETIME_BUFLEN];
1473
1474    /* Paths to keys and certificates needed to create certificate */
1475    cert_opt.issuer_key  = NULL;
1476    cert_opt.subject_key = NULL;
1477    cert_opt.issuer_crt  = NULL;
1478
1479    cert_opt.output_file = make_certs_path(csp->config->certificate_directory,
1480       (const char *)csp->http->hash_of_host_hex, CERT_FILE_TYPE);
1481    if (cert_opt.output_file == NULL)
1482    {
1483       return -1;
1484    }
1485
1486    cert_opt.subject_key = make_certs_path(csp->config->certificate_directory,
1487       (const char *)csp->http->hash_of_host_hex, KEY_FILE_TYPE);
1488    if (cert_opt.subject_key == NULL)
1489    {
1490       freez(cert_opt.output_file);
1491       return -1;
1492    }
1493
1494    if (file_exists(cert_opt.output_file) == 1)
1495    {
1496       /* The file exists, but is it valid? */
1497       if (ssl_certificate_is_invalid(cert_opt.output_file))
1498       {
1499          log_error(LOG_LEVEL_CONNECT,
1500             "Certificate %s is no longer valid. Removing it.",
1501             cert_opt.output_file);
1502          if (unlink(cert_opt.output_file))
1503          {
1504             log_error(LOG_LEVEL_ERROR, "Failed to unlink %s: %E",
1505                cert_opt.output_file);
1506
1507             freez(cert_opt.output_file);
1508             freez(cert_opt.subject_key);
1509
1510             return -1;
1511          }
1512          if (unlink(cert_opt.subject_key))
1513          {
1514             log_error(LOG_LEVEL_ERROR, "Failed to unlink %s: %E",
1515                cert_opt.subject_key);
1516
1517             freez(cert_opt.output_file);
1518             freez(cert_opt.subject_key);
1519
1520             return -1;
1521          }
1522       }
1523       else
1524       {
1525          freez(cert_opt.output_file);
1526          freez(cert_opt.subject_key);
1527
1528          return 0;
1529       }
1530    }
1531
1532    /*
1533     * Create key for requested host
1534     */
1535    int subject_key_len = generate_key(csp, &key_buf);
1536    if (subject_key_len < 0)
1537    {
1538       freez(cert_opt.output_file);
1539       freez(cert_opt.subject_key);
1540       log_error(LOG_LEVEL_ERROR, "Key generating failed");
1541       return -1;
1542    }
1543
1544    /*
1545     * Converting unsigned long serial number to char * serial number.
1546     * We must compute length of serial number in string + terminating null.
1547     */
1548    unsigned long certificate_serial = get_certificate_serial(csp);
1549    unsigned long certificate_serial_time = (unsigned long)time(NULL);
1550    int serial_num_size = snprintf(NULL, 0, "%lu%lu",
1551       certificate_serial_time, certificate_serial) + 1;
1552    if (serial_num_size <= 0)
1553    {
1554       serial_num_size = 1;
1555    }
1556
1557    char serial_num_text[serial_num_size];  /* Buffer for serial number */
1558    ret = snprintf(serial_num_text, (size_t)serial_num_size, "%lu%lu",
1559       certificate_serial_time, certificate_serial);
1560    if (ret < 0 || ret >= serial_num_size)
1561    {
1562       log_error(LOG_LEVEL_ERROR,
1563          "Converting certificate serial number into string failed");
1564       ret = -1;
1565       goto exit;
1566    }
1567
1568    /*
1569     * Preparing parameters for certificate
1570     */
1571    subject_name = X509_NAME_new();
1572    if (!subject_name)
1573    {
1574       log_ssl_errors(LOG_LEVEL_ERROR, "RSA key memory allocation failure");
1575       ret = -1;
1576       goto exit;
1577    }
1578
1579    if (!X509_NAME_add_entry_by_txt(subject_name, CERT_PARAM_COMMON_NAME_FCODE, MBSTRING_ASC,
1580                                     (void*)csp->http->host, -1, -1, 0))
1581    {
1582       log_ssl_errors(LOG_LEVEL_ERROR, "X509 subject name (code: %s, val: %s) error",
1583                      CERT_PARAM_COMMON_NAME_FCODE, csp->http->host);
1584       ret = -1;
1585       goto exit;
1586    }
1587    if (!X509_NAME_add_entry_by_txt(subject_name, CERT_PARAM_ORGANIZATION_FCODE, MBSTRING_ASC,
1588                                     (void*)csp->http->host, -1, -1, 0))
1589    {
1590       log_ssl_errors(LOG_LEVEL_ERROR, "X509 subject name (code: %s, val: %s) error",
1591                      CERT_PARAM_COMMON_NAME_FCODE, csp->http->host);
1592       ret = -1;
1593       goto exit;
1594    }
1595    if (!X509_NAME_add_entry_by_txt(subject_name, CERT_PARAM_ORG_UNIT_FCODE, MBSTRING_ASC,
1596                                     (void*)csp->http->host, -1, -1, 0))
1597    {
1598       log_ssl_errors(LOG_LEVEL_ERROR, "X509 subject name (code: %s, val: %s) error",
1599                      CERT_PARAM_COMMON_NAME_FCODE, csp->http->host);
1600       ret = -1;
1601       goto exit;
1602    }
1603    if (!X509_NAME_add_entry_by_txt(subject_name, CERT_PARAM_COUNTRY_FCODE, MBSTRING_ASC,
1604                                     (void*)CERT_PARAM_COUNTRY_CODE, -1, -1, 0))
1605    {
1606       log_ssl_errors(LOG_LEVEL_ERROR, "X509 subject name (code: %s, val: %s) error",
1607                      CERT_PARAM_COMMON_NAME_FCODE, csp->http->host);
1608       ret = -1;
1609       goto exit;
1610    }
1611
1612    cert_opt.issuer_crt = csp->config->ca_cert_file;
1613    cert_opt.issuer_key = csp->config->ca_key_file;
1614
1615    if (get_certificate_valid_from_date(cert_valid_from, sizeof(cert_valid_from), VALID_DATETIME_FMT)
1616     || get_certificate_valid_to_date(cert_valid_to, sizeof(cert_valid_to), VALID_DATETIME_FMT))
1617    {
1618       log_error(LOG_LEVEL_ERROR, "Generating one of the validity dates failed");
1619       ret = -1;
1620       goto exit;
1621    }
1622
1623    cert_opt.subject_pwd   = CERT_SUBJECT_PASSWORD;
1624    cert_opt.issuer_pwd    = csp->config->ca_password;
1625    cert_opt.not_before    = cert_valid_from;
1626    cert_opt.not_after     = cert_valid_to;
1627    cert_opt.serial        = serial_num_text;
1628    cert_opt.max_pathlen   = -1;
1629
1630    /*
1631     * Test if the private key was already created.
1632     * XXX: Can this still happen?
1633     */
1634    if (subject_key_len == 0)
1635    {
1636       log_error(LOG_LEVEL_ERROR, "Subject key was already created");
1637       ret = 0;
1638       goto exit;
1639    }
1640
1641    /*
1642     * Parse serial to MPI
1643     */
1644    serial_num = BN_new();
1645    if (!serial_num)
1646    {
1647       log_error(LOG_LEVEL_ERROR, "generate_webpage_certificate: memory error");
1648       ret = -1;
1649       goto exit;
1650    }
1651    if (!BN_dec2bn(&serial_num, cert_opt.serial))
1652    {
1653       log_ssl_errors(LOG_LEVEL_ERROR, "Failed to parse serial %s", cert_opt.serial);
1654       ret = -1;
1655       goto exit;
1656    }
1657
1658    if (!(serial = BN_to_ASN1_INTEGER(serial_num, NULL)))
1659    {
1660       log_ssl_errors(LOG_LEVEL_ERROR, "Failed to generate serial ASN1 representation");
1661       ret = -1;
1662       goto exit;
1663    }
1664
1665    /*
1666     * Loading certificates
1667     */
1668    if (!(issuer_cert = ssl_certificate_load(cert_opt.issuer_crt)))
1669    {
1670       log_error(LOG_LEVEL_ERROR, "Loading issuer certificate %s failed", cert_opt.issuer_crt);
1671       ret = -1;
1672       goto exit;
1673    }
1674
1675    issuer_name = X509_get_issuer_name(issuer_cert);
1676
1677    /*
1678     * Loading keys from file or from buffer
1679     */
1680    if (key_buf != NULL && subject_key_len > 0)
1681    {
1682       pk_bio = BIO_new_mem_buf(key_buf, subject_key_len);
1683    }
1684    else if (!(pk_bio = BIO_new_file(cert_opt.subject_key, "r")))
1685    {
1686          log_ssl_errors(LOG_LEVEL_ERROR, "Failure opening subject key %s BIO", cert_opt.subject_key);
1687          ret = -1;
1688          goto exit;
1689    }
1690
1691    loaded_subject_key = PEM_read_bio_PrivateKey(pk_bio, NULL, NULL, (void*)cert_opt.subject_pwd);
1692    if (!loaded_subject_key)
1693    {
1694       log_ssl_errors(LOG_LEVEL_ERROR, "Parsing subject key %s failed", cert_opt.subject_key);
1695       ret = -1;
1696       goto exit;
1697    }
1698
1699    if (!BIO_free(pk_bio)) {
1700       log_ssl_errors(LOG_LEVEL_ERROR, "Error closing subject key BIO");
1701    }
1702
1703    if (!(pk_bio = BIO_new_file(cert_opt.issuer_key, "r")))
1704    {
1705          log_ssl_errors(LOG_LEVEL_ERROR, "Failure opening issuer key %s BIO", cert_opt.issuer_key);
1706          ret = -1;
1707          goto exit;
1708    }
1709
1710    loaded_issuer_key = PEM_read_bio_PrivateKey(pk_bio, NULL, NULL, (void*)cert_opt.issuer_pwd);
1711    if (!loaded_issuer_key)
1712    {
1713       log_ssl_errors(LOG_LEVEL_ERROR, "Parsing issuer key %s failed", cert_opt.subject_key);
1714       ret = -1;
1715       goto exit;
1716    }
1717
1718    cert = X509_new();
1719    if (!cert)
1720    {
1721       log_ssl_errors(LOG_LEVEL_ERROR, "Certificate allocation error");
1722       ret = -1;
1723       goto exit;
1724    }
1725
1726    if (!X509_set_version(cert, CERTIFICATE_VERSION))
1727    {
1728       log_ssl_errors(LOG_LEVEL_ERROR, "X509_set_version failed");
1729       ret = -1;
1730       goto exit;
1731    }
1732
1733    /*
1734     * Setting parameters of signed certificate
1735     */
1736    if (!X509_set_pubkey(cert, loaded_subject_key)) {
1737       log_ssl_errors(LOG_LEVEL_ERROR, "Setting issuer name in signed certificate failed");
1738       ret = -1;
1739       goto exit;
1740    }
1741
1742    if (!X509_set_subject_name(cert, subject_name))
1743    {
1744       log_ssl_errors(LOG_LEVEL_ERROR, "Setting issuer name in signed certificate failed");
1745       ret = -1;
1746       goto exit;
1747    }
1748
1749    if (!X509_set_issuer_name(cert, issuer_name))
1750    {
1751       log_ssl_errors(LOG_LEVEL_ERROR, "Setting issuer name in signed certificate failed");
1752       ret = -1;
1753       goto exit;
1754    }
1755
1756    if (!X509_set_serialNumber(cert, serial))
1757    {
1758       log_ssl_errors(LOG_LEVEL_ERROR, "Setting serial number in signed certificate failed");
1759       ret = -1;
1760       goto exit;
1761    }
1762
1763    asn_time = ASN1_TIME_new();
1764    if (!asn_time) {
1765       log_ssl_errors(LOG_LEVEL_ERROR, "ASN1 time memory allocation failure");
1766       ret = -1;
1767       goto exit;
1768    }
1769
1770    if (!ASN1_TIME_set_string(asn_time, cert_opt.not_after)) {
1771       log_ssl_errors(LOG_LEVEL_ERROR, "ASN1 time [%s] encode error", cert_opt.not_after);
1772       ret = -1;
1773       goto exit;
1774    }
1775
1776    if (!X509_set1_notAfter(cert, asn_time))
1777    {
1778       log_ssl_errors(LOG_LEVEL_ERROR, "Setting valid not after in signed certificate failed");
1779       ret = -1;
1780       goto exit;
1781    }
1782
1783    if (!ASN1_TIME_set_string(asn_time, cert_opt.not_before)) {
1784       log_ssl_errors(LOG_LEVEL_ERROR, "ASN1 time encode error");
1785       ret = -1;
1786       goto exit;
1787    }
1788
1789    if (!X509_set1_notBefore(cert, asn_time))
1790    {
1791       log_ssl_errors(LOG_LEVEL_ERROR, "Setting valid not befre in signed certificate failed");
1792       ret = -1;
1793       goto exit;
1794    }
1795
1796    if(!set_x509_ext(cert, issuer_cert, NID_basic_constraints, CERTIFICATE_BASIC_CONSTRAINTS))
1797    {
1798       log_ssl_errors(LOG_LEVEL_ERROR, "Setting the basicConstraints extension "
1799          "in signed certificate failed");
1800       ret = -1;
1801       goto exit;
1802    }
1803
1804    if (!set_x509_ext(cert, issuer_cert, NID_subject_key_identifier, CERTIFICATE_SUBJECT_KEY))
1805    {
1806       log_ssl_errors(LOG_LEVEL_ERROR, "Setting the Subject Key Identifie extension failed");
1807       ret = -1;
1808       goto exit;
1809    }
1810
1811    if (!set_x509_ext(cert, issuer_cert, NID_authority_key_identifier, CERTIFICATE_AUTHORITY_KEY))
1812    {
1813       log_ssl_errors(LOG_LEVEL_ERROR, "Setting the Authority Key Identifier extension failed");
1814       ret = -1;
1815       goto exit;
1816    }
1817
1818    if (!host_is_ip_address(csp->http->host) &&
1819        !set_subject_alternative_name(cert, issuer_cert, csp->http->host))
1820    {
1821       log_ssl_errors(LOG_LEVEL_ERROR, "Setting the Subject Alt Nameextension failed");
1822       ret = -1;
1823       goto exit;
1824    }
1825
1826    if (!X509_sign(cert, loaded_issuer_key, EVP_sha256()))
1827    {
1828       log_ssl_errors(LOG_LEVEL_ERROR, "Signing certificate failed");
1829       ret = -1;
1830       goto exit;
1831    }
1832
1833    /*
1834     * Writing certificate into file
1835     */
1836    if (write_certificate(cert, cert_opt.output_file) < 0)
1837    {
1838       log_error(LOG_LEVEL_ERROR, "Writing certificate into file failed");
1839       ret = -1;
1840       goto exit;
1841    }
1842
1843    ret = 1;
1844
1845 exit:
1846    /*
1847     * Freeing used structures
1848     */
1849    if (issuer_cert) X509_free(issuer_cert);
1850    if (cert) X509_free(cert);
1851    if (pk_bio && !BIO_free(pk_bio)) {
1852       log_ssl_errors(LOG_LEVEL_ERROR, "Error closing pk BIO");
1853    }
1854    if (loaded_subject_key) EVP_PKEY_free(loaded_subject_key);
1855    if (loaded_issuer_key) EVP_PKEY_free(loaded_issuer_key);
1856    if (subject_name) X509_NAME_free(subject_name);
1857    if (asn_time) ASN1_TIME_free(asn_time);
1858    if (serial_num) BN_free(serial_num);
1859    if (serial) ASN1_INTEGER_free(serial);
1860    freez(cert_opt.subject_key);
1861    freez(cert_opt.output_file);
1862    freez(key_buf);
1863
1864    return ret;
1865 }
1866
1867
1868 /*********************************************************************
1869  *
1870  * Function    :  ssl_crt_verify_info
1871  *
1872  * Description :  Returns an informational string about the verification
1873  *                status of a certificate.
1874  *
1875  * Parameters  :
1876  *          1  :  buf = Buffer to write to
1877  *          2  :  size = Maximum size of buffer
1878  *          3  :  csp = client state
1879  *
1880  * Returns     :  N/A
1881  *
1882  *********************************************************************/
1883 extern void ssl_crt_verify_info(char *buf, size_t size, struct client_state *csp)
1884 {
1885    strncpy(buf, X509_verify_cert_error_string(csp->server_cert_verification_result), size);
1886    buf[size - 1] = 0;
1887 }
1888
1889
1890 /*********************************************************************
1891  *
1892  * Function    :  ssl_release
1893  *
1894  * Description :  Release all SSL resources
1895  *
1896  * Parameters  :
1897  *
1898  * Returns     :  N/A
1899  *
1900  *********************************************************************/
1901 extern void ssl_release(void)
1902 {
1903    if (ssl_inited == 1)
1904    {
1905       SSL_COMP_free_compression_methods();
1906
1907       CONF_modules_free();
1908       CONF_modules_unload(1);
1909
1910       COMP_zlib_cleanup();
1911
1912       ERR_free_strings();
1913       EVP_cleanup();
1914
1915       CRYPTO_cleanup_all_ex_data();
1916    }
1917 }
1918