openssl.c

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