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",
 294          len, sizeof(last->file_buf) - 1);
 295       len = sizeof(last->file_buf) - 1;
 296    }
 297
 298    strncpy(last->file_buf, bio_mem_data, (size_t)len);
 299    BIO_free(bio);
 300    bio = BIO_new(BIO_s_mem());
 301    if (!bio)
 302    {
 303       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_new_mem_buf() failed");
 304       ret = -1;
 305       goto exit;
 306    }
 307
 308    /*
 309     * Saving certificate information into buffer
 310     */
 311    l = X509_get_version(crt);
 312    if (l >= 0 && l <= 2)
 313    {
 314       if (BIO_printf(bio, "cert. version     : %ld\n", l + 1) <= 0)
 315       {
 316          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for version failed");
 317          ret = -1;
 318          goto exit;
 319       }
 320    }
 321    else
 322    {
 323       if (BIO_printf(bio, "cert. version     : Unknown (%ld)\n", l) <= 0)
 324       {
 325          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for version failed");
 326          ret = -1;
 327          goto exit;
 328       }
 329    }
 330
 331    if (BIO_puts(bio, "serial number     : ") <= 0)
 332    {
 333       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_write() for serial failed");
 334       ret = -1;
 335       goto exit;
 336    }
 337    bs = X509_get0_serialNumber(crt);
 338    if (bs->length <= (int)sizeof(long))
 339    {
 340       ERR_set_mark();
 341       l = ASN1_INTEGER_get(bs);
 342       ERR_pop_to_mark();
 343    }
 344    else
 345    {
 346       l = -1;
 347    }
 348    if (l != -1)
 349    {
 350       unsigned long ul;
 351       const char *neg;
 352       if (bs->type == V_ASN1_NEG_INTEGER)
 353       {
 354          ul = 0 - (unsigned long)l;
 355          neg = "-";
 356       }
 357       else
 358       {
 359          ul = (unsigned long)l;
 360          neg = "";
 361       }
 362       if (BIO_printf(bio, " %s%lu (%s0x%lx)\n", neg, ul, neg, ul) <= 0)
 363       {
 364          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for serial failed");
 365          ret = -1;
 366          goto exit;
 367       }
 368    }
 369    else
 370    {
 371       if (bs->type == V_ASN1_NEG_INTEGER)
 372       {
 373          if (BIO_puts(bio, " (Negative)") < 0)
 374          {
 375             log_ssl_errors(LOG_LEVEL_ERROR, "BIO_puts() for serial failed");
 376             ret = -1;
 377             goto exit;
 378          }
 379       }
 380       for (int i = 0; i < bs->length; i++)
 381       {
 382          if (BIO_printf(bio, "%02x%c", bs->data[i],
 383                ((i + 1 == bs->length) ? '\n' : ':')) <= 0)
 384          {
 385             log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for serial failed");
 386             ret = -1;
 387             goto exit;
 388          }
 389       }
 390    }
 391
 392    if (BIO_puts(bio, "issuer name       : ") <= 0)
 393    {
 394       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_puts() for issuer failed");
 395       ret = -1;
 396       goto exit;
 397    }
 398    if (X509_NAME_print_ex(bio, X509_get_issuer_name(crt), 0, 0) < 0)
 399    {
 400       log_ssl_errors(LOG_LEVEL_ERROR, "X509_NAME_print_ex() for issuer failed");
 401       ret = -1;
 402       goto exit;
 403    }
 404
 405    if (BIO_puts(bio, "\nsubject name      : ") <= 0)
 406    {
 407       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_puts() for sublect failed");
 408       ret = -1;
 409       goto exit;
 410    }
 411    if (X509_NAME_print_ex(bio, X509_get_subject_name(crt), 0, 0) < 0) {
 412       log_ssl_errors(LOG_LEVEL_ERROR, "X509_NAME_print_ex() for subject failed");
 413       ret = -1;
 414       goto exit;
 415    }
 416
 417    if (BIO_puts(bio, "\nissued  on        : ") <= 0)
 418    {
 419       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_puts() for issued on failed");
 420       ret = -1;
 421       goto exit;
 422    }
 423    if (!ASN1_TIME_print(bio, X509_get0_notBefore(crt)))
 424    {
 425       log_ssl_errors(LOG_LEVEL_ERROR, "ASN1_TIME_print() for issued on failed");
 426       ret = -1;
 427       goto exit;
 428    }
 429
 430    if (BIO_puts(bio, "\nexpires on        : ") <= 0)
 431    {
 432       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_puts() for expires on failed");
 433       ret = -1;
 434       goto exit;
 435    }
 436    if (!ASN1_TIME_print(bio, X509_get0_notAfter(crt)))
 437    {
 438       log_ssl_errors(LOG_LEVEL_ERROR, "ASN1_TIME_print() for expires on failed");
 439       ret = -1;
 440       goto exit;
 441    }
 442
 443    if (BIO_puts(bio, "\nsigned using      : ") <= 0)
 444    {
 445       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_puts() for signed using failed");
 446       ret = -1;
 447       goto exit;
 448    }
 449    tsig_alg = X509_get0_tbs_sigalg(crt);
 450    if (!i2a_ASN1_OBJECT(bio, tsig_alg->algorithm))
 451    {
 452       log_ssl_errors(LOG_LEVEL_ERROR, "i2a_ASN1_OBJECT() for signed using on failed");
 453       ret = -1;
 454       goto exit;
 455    }
 456    pkey = X509_get_pubkey(crt);
 457    if (!pkey)
 458    {
 459       log_ssl_errors(LOG_LEVEL_ERROR, "X509_get_pubkey() failed");
 460       ret = -1;
 461       goto exit;
 462    }
 463 #define BC              "18"
 464    switch (EVP_PKEY_base_id(pkey))
 465    {
 466       case EVP_PKEY_RSA:
 467          ret = BIO_printf(bio, "\n%-" BC "s: %d bits", "RSA key size", EVP_PKEY_bits(pkey));
 468          break;
 469       case EVP_PKEY_DSA:
 470          ret = BIO_printf(bio, "\n%-" BC "s: %d bits", "DSA key size", EVP_PKEY_bits(pkey));
 471          break;
 472       default:
 473          ret = BIO_printf(bio, "\n%-" BC "s: %d bits", "non-RSA/DSA key size", EVP_PKEY_bits(pkey));
 474          break;
 475    }
 476    if (ret <= 0)
 477    {
 478       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for key size failed");
 479       ret = -1;
 480       goto exit;
 481    }
 482
 483    loc = X509_get_ext_by_NID(crt, NID_basic_constraints, -1);
 484    if (loc != -1)
 485    {
 486       X509_EXTENSION *ex = X509_get_ext(crt, loc);
 487       if (BIO_puts(bio, "\nbasic constraints : ") <= 0)
 488       {
 489          log_ssl_errors(LOG_LEVEL_ERROR,
 490             "BIO_printf() for basic constraints failed");
 491          ret = -1;
 492          goto exit;
 493       }
 494       if (!X509V3_EXT_print(bio, ex, 0, 0))
 495       {
 496          if (!ASN1_STRING_print_ex(bio, X509_EXTENSION_get_data(ex), ASN1_STRFLGS_RFC2253))
 497          {
 498             log_ssl_errors(LOG_LEVEL_ERROR,
 499                "ASN1_STRING_print_ex() for basic constraints failed");
 500             ret = -1;
 501             goto exit;
 502          }
 503       }
 504    }
 505
 506    loc = X509_get_ext_by_NID(crt, NID_subject_alt_name, -1);
 507    if (loc != -1)
 508    {
 509       X509_EXTENSION *ex = X509_get_ext(crt, loc);
 510       if (BIO_puts(bio, "\nsubject alt name  : ") <= 0)
 511       {
 512          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for alt name failed");
 513          ret = -1;
 514          goto exit;
 515       }
 516       if (!X509V3_EXT_print(bio, ex, 0, 0))
 517       {
 518          if (!ASN1_STRING_print_ex(bio, X509_EXTENSION_get_data(ex),
 519                ASN1_STRFLGS_RFC2253))
 520          {
 521             log_ssl_errors(LOG_LEVEL_ERROR,
 522                "ASN1_STRING_print_ex() for alt name failed");
 523             ret = -1;
 524             goto exit;
 525          }
 526       }
 527    }
 528
 529    loc = X509_get_ext_by_NID(crt, NID_netscape_cert_type, -1);
 530    if (loc != -1)
 531    {
 532       X509_EXTENSION *ex = X509_get_ext(crt, loc);
 533       if (BIO_puts(bio, "\ncert. type        : ") <= 0)
 534       {
 535          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for cert type failed");
 536          ret = -1;
 537          goto exit;
 538       }
 539       if (!X509V3_EXT_print(bio, ex, 0, 0))
 540       {
 541          if (!ASN1_STRING_print_ex(bio, X509_EXTENSION_get_data(ex),
 542                ASN1_STRFLGS_RFC2253))
 543          {
 544             log_ssl_errors(LOG_LEVEL_ERROR,
 545                "ASN1_STRING_print_ex() for cert type failed");
 546             ret = -1;
 547             goto exit;
 548          }
 549       }
 550    }
 551
 552    loc = X509_get_ext_by_NID(crt, NID_key_usage, -1);
 553    if (loc != -1)
 554    {
 555       X509_EXTENSION *ex = X509_get_ext(crt, loc);
 556       if (BIO_puts(bio, "\nkey usage         : ") <= 0)
 557       {
 558          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for key usage failed");
 559          ret = -1;
 560          goto exit;
 561       }
 562       if (!X509V3_EXT_print(bio, ex, 0, 0))
 563       {
 564          if (!ASN1_STRING_print_ex(bio, X509_EXTENSION_get_data(ex),
 565                ASN1_STRFLGS_RFC2253))
 566          {
 567             log_ssl_errors(LOG_LEVEL_ERROR,
 568                "ASN1_STRING_print_ex() for key usage failed");
 569             ret = -1;
 570             goto exit;
 571          }
 572       }
 573    }
 574
 575    loc = X509_get_ext_by_NID(crt, NID_ext_key_usage, -1);
 576    if (loc != -1) {
 577       X509_EXTENSION *ex = X509_get_ext(crt, loc);
 578       if (BIO_puts(bio, "\next key usage     : ") <= 0)
 579       {
 580          log_ssl_errors(LOG_LEVEL_ERROR,
 581             "BIO_printf() for ext key usage failed");
 582          ret = -1;
 583          goto exit;
 584       }
 585       if (!X509V3_EXT_print(bio, ex, 0, 0))
 586       {
 587          if (!ASN1_STRING_print_ex(bio, X509_EXTENSION_get_data(ex),
 588                ASN1_STRFLGS_RFC2253))
 589          {
 590             log_ssl_errors(LOG_LEVEL_ERROR,
 591                "ASN1_STRING_print_ex() for ext key usage failed");
 592             ret = -1;
 593             goto exit;
 594          }
 595       }
 596    }
 597
 598    loc = X509_get_ext_by_NID(crt, NID_certificate_policies, -1);
 599    if (loc != -1)
 600    {
 601       X509_EXTENSION *ex = X509_get_ext(crt, loc);
 602       if (BIO_puts(bio, "\ncertificate policies : ") <= 0)
 603       {
 604          log_ssl_errors(LOG_LEVEL_ERROR, "BIO_printf() for certificate policies failed");
 605          ret = -1;
 606          goto exit;
 607       }
 608       if (!X509V3_EXT_print(bio, ex, 0, 0))
 609       {
 610          if (!ASN1_STRING_print_ex(bio, X509_EXTENSION_get_data(ex),
 611                ASN1_STRFLGS_RFC2253))
 612          {
 613             log_ssl_errors(LOG_LEVEL_ERROR,
 614                "ASN1_STRING_print_ex() for certificate policies failed");
 615             ret = -1;
 616             goto exit;
 617          }
 618       }
 619    }
 620
 621    /* make valgrind happy */
 622    static const char zero = 0;
 623    BIO_write(bio, &zero, 1);
 624
 625    len = BIO_get_mem_data(bio, &bio_mem_data);
 626    encoded_text = html_encode(bio_mem_data);
 627    strlcpy(last->info_buf, encoded_text, sizeof(last->info_buf));
 628    freez(encoded_text);
 629    ret = 0;
 630
 631 exit:
 632    if (bio)
 633    {
 634       BIO_free(bio);
 635    }
 636    if (pkey)
 637    {
 638       EVP_PKEY_free(pkey);
 639    }
 640    return ret;
 641 }
 642
 643
 644 /*********************************************************************
 645  *
 646  * Function    :  host_to_hash
 647  *
 648  * Description :  Creates MD5 hash from host name. Host name is loaded
 649  *                from structure csp and saved again into it.
 650  *
 651  * Parameters  :
 652  *          1  :  csp = Current client state (buffers, headers, etc...)
 653  *
 654  * Returns     :  1 => Error while creating hash
 655  *                0 => Hash created successfully
 656  *
 657  *********************************************************************/
 658 static int host_to_hash(struct client_state *csp)
 659 {
 660    int ret = 0;
 661
 662    memset(csp->http->hash_of_host, 0, sizeof(csp->http->hash_of_host));
 663    MD5((unsigned char *)csp->http->host, strlen(csp->http->host),
 664       csp->http->hash_of_host);
 665
 666    /* Converting hash into string with hex */
 667    size_t i = 0;
 668    for (; i < 16; i++)
 669    {
 670       if ((ret = sprintf((char *)csp->http->hash_of_host_hex + 2 * i, "%02x",
 671          csp->http->hash_of_host[i])) < 0)
 672       {
 673          log_error(LOG_LEVEL_ERROR, "Sprintf return value: %d", ret);
 674          return -1;
 675       }
 676    }
 677
 678    return 0;
 679 }
 680
 681
 682 /*********************************************************************
 683  *
 684  * Function    :  create_client_ssl_connection
 685  *
 686  * Description :  Creates TLS/SSL secured connection with client
 687  *
 688  * Parameters  :
 689  *          1  :  csp = Current client state (buffers, headers, etc...)
 690  *
 691  * Returns     :  0 on success, negative value if connection wasn't created
 692  *                successfully.
 693  *
 694  *********************************************************************/
 695 extern int create_client_ssl_connection(struct client_state *csp)
 696 {
 697    struct ssl_attr *ssl_attr = &csp->ssl_client_attr;
 698    /* Paths to certificates file and key file */
 699    char *key_file  = NULL;
 700    char *ca_file   = NULL;
 701    char *cert_file = NULL;
 702    int ret = 0;
 703    SSL* ssl;
 704
 705    /*
 706     * Initializing OpenSSL structures for TLS/SSL connection
 707     */
 708    openssl_init();
 709
 710    /*
 711     * Preparing hash of host for creating certificates
 712     */
 713    ret = host_to_hash(csp);
 714    if (ret != 0)
 715    {
 716       log_error(LOG_LEVEL_ERROR, "Generating hash of host failed: %d", ret);
 717       ret = -1;
 718       goto exit;
 719    }
 720
 721    /*
 722     * Preparing paths to certificates files and key file
 723     */
 724    ca_file   = csp->config->ca_cert_file;
 725    cert_file = make_certs_path(csp->config->certificate_directory,
 726       (const char *)csp->http->hash_of_host_hex, CERT_FILE_TYPE);
 727    key_file  = make_certs_path(csp->config->certificate_directory,
 728       (const char *)csp->http->hash_of_host_hex, KEY_FILE_TYPE);
 729
 730    if (cert_file == NULL || key_file == NULL)
 731    {
 732       ret = -1;
 733       goto exit;
 734    }
 735
 736    /*
 737     * Generating certificate for requested host. Mutex to prevent
 738     * certificate and key inconsistence must be locked.
 739     */
 740    privoxy_mutex_lock(&certificate_mutex);
 741
 742    ret = generate_webpage_certificate(csp);
 743    if (ret < 0)
 744    {
 745       log_error(LOG_LEVEL_ERROR,
 746          "Generate_webpage_certificate failed: %d", ret);
 747       privoxy_mutex_unlock(&certificate_mutex);
 748       ret = -1;
 749       goto exit;
 750    }
 751    privoxy_mutex_unlock(&certificate_mutex);
 752
 753    if (!(ssl_attr->openssl_attr.ctx = SSL_CTX_new(SSLv23_server_method())))
 754    {
 755       log_ssl_errors(LOG_LEVEL_ERROR, "Unable to create SSL context");
 756       ret = -1;
 757       goto exit;
 758    }
 759
 760    /* Set the key and cert */
 761    if (SSL_CTX_use_certificate_file(ssl_attr->openssl_attr.ctx,
 762          cert_file, SSL_FILETYPE_PEM) != 1)
 763    {
 764       log_ssl_errors(LOG_LEVEL_ERROR,
 765          "Loading webpage certificate %s failed", cert_file);
 766       ret = -1;
 767       goto exit;
 768    }
 769
 770    if (SSL_CTX_use_PrivateKey_file(ssl_attr->openssl_attr.ctx,
 771          key_file, SSL_FILETYPE_PEM) != 1)
 772    {
 773       log_ssl_errors(LOG_LEVEL_ERROR,
 774          "Loading webpage certificate private key %s failed", key_file);
 775       ret = -1;
 776       goto exit;
 777    }
 778
 779    SSL_CTX_set_options(ssl_attr->openssl_attr.ctx, SSL_OP_NO_SSLv3);
 780
 781    if (!(ssl_attr->openssl_attr.bio = BIO_new_ssl(ssl_attr->openssl_attr.ctx, 0)))
 782    {
 783       log_ssl_errors(LOG_LEVEL_ERROR, "Unable to create BIO structure");
 784       ret = -1;
 785       goto exit;
 786    }
 787
 788    if (BIO_get_ssl(ssl_attr->openssl_attr.bio, &ssl) != 1)
 789    {
 790       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_get_ssl failed");
 791       ret = -1;
 792       goto exit;
 793    }
 794
 795    if (!SSL_set_fd(ssl, csp->cfd))
 796    {
 797       log_ssl_errors(LOG_LEVEL_ERROR, "SSL_set_fd failed");
 798       ret = -1;
 799       goto exit;
 800    }
 801
 802    /*
 803     *  Handshake with client
 804     */
 805    log_error(LOG_LEVEL_CONNECT,
 806       "Performing the TLS/SSL handshake with client. Hash of host: %s",
 807       csp->http->hash_of_host_hex);
 808    if (BIO_do_handshake(ssl_attr->openssl_attr.bio) != 1)
 809    {
 810        log_ssl_errors(LOG_LEVEL_ERROR, "BIO_do_handshake failed");
 811        ret = -1;
 812        goto exit;
 813    }
 814
 815    log_error(LOG_LEVEL_CONNECT, "Client successfully connected over TLS/SSL");
 816    csp->ssl_with_client_is_opened = 1;
 817    ret = 0;
 818
 819 exit:
 820    /*
 821     * Freeing allocated paths to files
 822     */
 823    freez(cert_file);
 824    freez(key_file);
 825
 826    /* Freeing structures if connection wasn't created successfully */
 827    if (ret < 0)
 828    {
 829       free_client_ssl_structures(csp);
 830    }
 831    return ret;
 832 }
 833
 834
 835 /*********************************************************************
 836  *
 837  * Function    :  close_client_ssl_connection
 838  *
 839  * Description :  Closes TLS/SSL connection with client. This function
 840  *                checks if this connection is already created.
 841  *
 842  * Parameters  :
 843  *          1  :  csp = Current client state (buffers, headers, etc...)
 844  *
 845  * Returns     :  N/A
 846  *
 847  *********************************************************************/
 848 extern void close_client_ssl_connection(struct client_state *csp)
 849 {
 850    struct ssl_attr *ssl_attr = &csp->ssl_client_attr;
 851
 852    if (csp->ssl_with_client_is_opened == 0)
 853    {
 854       return;
 855    }
 856
 857    /*
 858     * Notifying the peer that the connection is being closed.
 859     */
 860    BIO_ssl_shutdown(ssl_attr->openssl_attr.bio);
 861    free_client_ssl_structures(csp);
 862    csp->ssl_with_client_is_opened = 0;
 863 }
 864
 865
 866 /*********************************************************************
 867  *
 868  * Function    :  free_client_ssl_structures
 869  *
 870  * Description :  Frees structures used for SSL communication with
 871  *                client.
 872  *
 873  * Parameters  :
 874  *          1  :  csp = Current client state (buffers, headers, etc...)
 875  *
 876  * Returns     :  N/A
 877  *
 878  *********************************************************************/
 879 static void free_client_ssl_structures(struct client_state *csp)
 880 {
 881    struct ssl_attr *ssl_attr = &csp->ssl_client_attr;
 882
 883    if (ssl_attr->openssl_attr.bio)
 884    {
 885       BIO_free_all(ssl_attr->openssl_attr.bio);
 886    }
 887    if (ssl_attr->openssl_attr.ctx)
 888    {
 889       SSL_CTX_free(ssl_attr->openssl_attr.ctx);
 890    }
 891 }
 892
 893
 894 /*********************************************************************
 895  *
 896  * Function    :  close_server_ssl_connection
 897  *
 898  * Description :  Closes TLS/SSL connection with server. This function
 899  *                checks if this connection is already opened.
 900  *
 901  * Parameters  :
 902  *          1  :  csp = Current client state (buffers, headers, etc...)
 903  *
 904  * Returns     :  N/A
 905  *
 906  *********************************************************************/
 907 extern void close_server_ssl_connection(struct client_state *csp)
 908 {
 909    struct ssl_attr *ssl_attr = &csp->ssl_server_attr;
 910
 911    if (csp->ssl_with_server_is_opened == 0)
 912    {
 913       return;
 914    }
 915
 916    /*
 917    * Notifying the peer that the connection is being closed.
 918    */
 919    BIO_ssl_shutdown(ssl_attr->openssl_attr.bio);
 920    free_server_ssl_structures(csp);
 921    csp->ssl_with_server_is_opened = 0;
 922 }
 923
 924
 925 /*********************************************************************
 926  *
 927  * Function    :  create_server_ssl_connection
 928  *
 929  * Description :  Creates TLS/SSL secured connection with server.
 930  *
 931  * Parameters  :
 932  *          1  :  csp = Current client state (buffers, headers, etc...)
 933  *
 934  * Returns     :  0 on success, negative value if connection wasn't created
 935  *                successfully.
 936  *
 937  *********************************************************************/
 938 extern int create_server_ssl_connection(struct client_state *csp)
 939 {
 940    openssl_connection_attr *ssl_attrs = &csp->ssl_server_attr.openssl_attr;
 941    int ret = 0;
 942    char *trusted_cas_file = NULL;
 943    STACK_OF(X509) *chain;
 944    SSL *ssl;
 945
 946    csp->server_cert_verification_result = SSL_CERT_NOT_VERIFIED;
 947    csp->server_certs_chain.next = NULL;
 948
 949    /* Setting path to file with trusted CAs */
 950    trusted_cas_file = csp->config->trusted_cas_file;
 951
 952    ssl_attrs->ctx = SSL_CTX_new(SSLv23_method());
 953    if (!ssl_attrs->ctx)
 954    {
 955       log_ssl_errors(LOG_LEVEL_ERROR, "SSL context creation failed");
 956       ret = -1;
 957       goto exit;
 958    }
 959
 960    /*
 961     * Loading file with trusted CAs
 962     */
 963    if (!SSL_CTX_load_verify_locations(ssl_attrs->ctx, trusted_cas_file, NULL))
 964    {
 965       log_ssl_errors(LOG_LEVEL_ERROR, "Loading trusted CAs file %s failed",
 966          trusted_cas_file);
 967       ret = -1;
 968       goto exit;
 969    }
 970
 971    SSL_CTX_set_verify(ssl_attrs->ctx, SSL_VERIFY_NONE, NULL);
 972    SSL_CTX_set_options(ssl_attrs->ctx, SSL_OP_NO_SSLv3);
 973
 974    if (!(ssl_attrs->bio = BIO_new_ssl(ssl_attrs->ctx, 1)))
 975    {
 976       log_ssl_errors(LOG_LEVEL_ERROR, "Unable to create BIO structure");
 977       ret = -1;
 978       goto exit;
 979    }
 980
 981    if (BIO_get_ssl(ssl_attrs->bio, &ssl) != 1)
 982    {
 983       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_get_ssl failed");
 984       ret = -1;
 985       goto exit;
 986    }
 987
 988    if (!SSL_set_fd(ssl, csp->server_connection.sfd))
 989    {
 990       log_ssl_errors(LOG_LEVEL_ERROR, "SSL_set_fd failed");
 991       ret = -1;
 992       goto exit;
 993    }
 994
 995    /*
 996     * Set the hostname to check against the received server certificate
 997     */
 998    if (!SSL_set1_host(ssl, csp->http->host))
 999    {
1000       log_ssl_errors(LOG_LEVEL_ERROR, "SSL_set1_host failed");
1001       ret = -1;
1002       goto exit;
1003    }
1004
1005    /* SNI extension */
1006    if (!SSL_set_tlsext_host_name(ssl, csp->http->host))
1007    {
1008       log_ssl_errors(LOG_LEVEL_ERROR, "SSL_set_tlsext_host_name failed");
1009       ret = -1;
1010       goto exit;
1011    }
1012
1013    /*
1014     * Handshake with server
1015     */
1016    log_error(LOG_LEVEL_CONNECT,
1017       "Performing the TLS/SSL handshake with the server");
1018
1019    if (BIO_do_handshake(ssl_attrs->bio) != 1)
1020    {
1021       log_ssl_errors(LOG_LEVEL_ERROR, "BIO_do_handshake failed");
1022       ret = -1;
1023       goto exit;
1024    }
1025
1026    chain = SSL_get_peer_cert_chain(ssl);
1027    if (chain)
1028    {
1029       for (int i = 0; i < sk_X509_num(chain); i++)
1030       {
1031          if (ssl_store_cert(csp, sk_X509_value(chain, i)) != 0)
1032          {
1033             log_error(LOG_LEVEL_ERROR, "ssl_store_cert failed");
1034             ret = -1;
1035             goto exit;
1036          }
1037       }
1038    }
1039
1040    if (!csp->dont_verify_certificate)
1041    {
1042       long verify_result = SSL_get_verify_result(ssl);
1043       if (verify_result == X509_V_OK)
1044       {
1045          ret = 0;
1046          csp->server_cert_verification_result = SSL_CERT_VALID;
1047       }
1048       else
1049       {
1050          csp->server_cert_verification_result = verify_result;
1051          log_error(LOG_LEVEL_ERROR, "SSL_get_verify_result failed: %s",
1052             X509_verify_cert_error_string(verify_result));
1053          ret = -1;
1054          goto exit;
1055       }
1056    }
1057
1058    log_error(LOG_LEVEL_CONNECT, "Server successfully connected over TLS/SSL");
1059
1060    /*
1061     * Server certificate chain is valid, so we can clean
1062     * chain, because we will not send it to client.
1063     */
1064    free_certificate_chain(csp);
1065
1066    csp->ssl_with_server_is_opened = 1;
1067 exit:
1068    /* Freeing structures if connection wasn't created successfully */
1069    if (ret < 0)
1070    {
1071       free_server_ssl_structures(csp);
1072    }
1073
1074    return ret;
1075 }
1076
1077
1078 /*********************************************************************
1079  *
1080  * Function    :  free_server_ssl_structures
1081  *
1082  * Description :  Frees structures used for SSL communication with server
1083  *
1084  * Parameters  :
1085  *          1  :  csp = Current client state (buffers, headers, etc...)
1086  *
1087  * Returns     :  N/A
1088  *
1089  *********************************************************************/
1090 static void free_server_ssl_structures(struct client_state *csp)
1091 {
1092    struct ssl_attr *ssl_attr = &csp->ssl_server_attr;
1093
1094    if (ssl_attr->openssl_attr.bio)
1095    {
1096       BIO_free_all(ssl_attr->openssl_attr.bio);
1097    }
1098    if (ssl_attr->openssl_attr.ctx)
1099    {
1100       SSL_CTX_free(ssl_attr->openssl_attr.ctx);
1101    }
1102 }
1103
1104
1105 /*********************************************************************
1106  *
1107  * Function    :  log_ssl_errors
1108  *
1109  * Description :  Log SSL errors
1110  *
1111  * Parameters  :
1112  *          1  :  debuglevel = Debug level
1113  *          2  :  desc = Error description
1114  *
1115  * Returns     :  N/A
1116  *
1117  *********************************************************************/
1118 static void log_ssl_errors(int debuglevel, const char* fmt, ...)
1119 {
1120    unsigned long err_code;
1121    char prefix[ERROR_BUF_SIZE];
1122    va_list args;
1123    va_start(args, fmt);
1124    vsnprintf(prefix, sizeof(prefix), fmt, args);
1125    int reported = 0;
1126
1127    while ((err_code = ERR_get_error()))
1128    {
1129       char err_buf[ERROR_BUF_SIZE];
1130       reported = 1;
1131       ERR_error_string_n(err_code, err_buf, sizeof(err_buf));
1132       log_error(debuglevel, "%s: %s", prefix, err_buf);
1133    }
1134    va_end(args);
1135    /*
1136     * In case if called by mistake and there were
1137     * no SSL errors let's report it to the log.
1138     */
1139    if (!reported)
1140    {
1141       log_error(debuglevel, "%s: no ssl errors detected", prefix);
1142    }
1143 }
1144
1145
1146 /*********************************************************************
1147  *
1148  * Function    :  ssl_base64_encode
1149  *
1150  * Description :  Encode a buffer into base64 format.
1151  *
1152  * Parameters  :
1153  *          1  :  dst = Destination buffer
1154  *          2  :  dlen = Destination buffer length
1155  *          3  :  olen = Number of bytes written
1156  *          4  :  src = Source buffer
1157  *          5  :  slen = Amount of data to be encoded
1158  *
1159  * Returns     :  0 on success, error code othervise
1160  *
1161  *********************************************************************/
1162 extern int ssl_base64_encode(unsigned char *dst, size_t dlen, size_t *olen,
1163                              const unsigned char *src, size_t slen)
1164 {
1165    *olen = 4 * ((slen/3)  + ((slen%3) ? 1 : 0)) + 1;
1166    if (*olen < dlen)
1167    {
1168       return ENOBUFS;
1169    }
1170    *olen = (size_t)EVP_EncodeBlock(dst, src, (int)slen) + 1;
1171    return 0;
1172 }
1173
1174
1175 /*********************************************************************
1176  *
1177  * Function    :  close_file_stream
1178  *
1179  * Description :  Close file stream, report error on close error
1180  *
1181  * Parameters  :
1182  *          1  :  f = file stream to close
1183  *          2  :  path = path for error report
1184  *
1185  * Returns     :  N/A
1186  *
1187  *********************************************************************/
1188 static void close_file_stream(FILE *f, const char *path)
1189 {
1190    if (fclose(f) != 0)
1191    {
1192       log_error(LOG_LEVEL_ERROR,
1193          "Error closing file %s: %s", path, strerror(errno));
1194    }
1195 }
1196
1197
1198 /*********************************************************************
1199  *
1200  * Function    :  write_certificate
1201  *
1202  * Description :  Writes certificate into file.
1203  *
1204  * Parameters  :
1205  *          1  :  crt = certificate to write into file
1206  *          2  :  output_file = path to save certificate file
1207  *
1208  *                on error
1209  * Returns     :  1 on success success or negative value
1210  *
1211  *********************************************************************/
1212 static int write_certificate(X509 *crt, const char *output_file)
1213 {
1214    FILE *f = NULL;
1215    int ret = -1;
1216
1217    /*
1218     * Saving certificate into file
1219     */
1220    if ((f = fopen(output_file, "w")) == NULL)
1221    {
1222       log_error(LOG_LEVEL_ERROR, "Opening file %s to save certificate failed",
1223          output_file);
1224       return ret;
1225    }
1226
1227    ret = PEM_write_X509(f, crt);
1228    if (!ret)
1229    {
1230       log_ssl_errors(LOG_LEVEL_ERROR,
1231          "Writing certificate into file %s failed", output_file);
1232       ret = -1;
1233    }
1234
1235    close_file_stream(f, output_file);
1236
1237    return ret;
1238 }
1239
1240 /*********************************************************************
1241  *
1242  * Function    :  write_private_key
1243  *
1244  * Description :  Writes private key into file and copies saved
1245  *                content into given pointer to string. If function
1246  *                returns 0 for success, this copy must be freed by
1247  *                caller.
1248  *
1249  * Parameters  :
1250  *          1  :  key = key to write into file
1251  *          2  :  ret_buf = pointer to string with created key file content
1252  *          3  :  key_file_path = path where to save key file
1253  *
1254  * Returns     :  Length of written private key on success or negative value
1255  *                on error
1256  *
1257  *********************************************************************/
1258 static int write_private_key(EVP_PKEY *key, char **ret_buf,
1259                              const char *key_file_path)
1260 {
1261    size_t len = 0;                /* Length of created key    */
1262    FILE *f = NULL;                /* File to save certificate */
1263    int ret = 0;
1264    BIO *bio_mem = BIO_new(BIO_s_mem());
1265    char *bio_mem_data = 0;
1266
1267    if (bio_mem == NULL)
1268    {
1269       log_ssl_errors(LOG_LEVEL_ERROR, "write_private_key memory allocation failure");
1270       return -1;
1271    }
1272
1273    /*
1274     * Writing private key into PEM string
1275     */
1276    if (!PEM_write_bio_PrivateKey(bio_mem, key, NULL, NULL, 0, NULL, NULL))
1277    {
1278       log_ssl_errors(LOG_LEVEL_ERROR,
1279          "Writing private key into PEM string failed");
1280       ret = -1;
1281       goto exit;
1282    }
1283
1284    len = (size_t)BIO_get_mem_data(bio_mem, &bio_mem_data);
1285
1286    /* Initializing buffer for key file content */
1287    *ret_buf = zalloc_or_die(len + 1);
1288    (*ret_buf)[len] = 0;
1289
1290    strncpy(*ret_buf, bio_mem_data, len);
1291
1292    /*
1293     * Saving key into file
1294     */
1295    if ((f = fopen(key_file_path, "wb")) == NULL)
1296    {
1297       log_error(LOG_LEVEL_ERROR,
1298          "Opening file %s to save private key failed: %E",
1299          key_file_path);
1300       ret = -1;
1301       goto exit;
1302    }
1303
1304    if (fwrite(*ret_buf, 1, len, f) != len)
1305    {
1306       log_error(LOG_LEVEL_ERROR,
1307          "Writing private key into file %s failed",
1308          key_file_path);
1309       close_file_stream(f, key_file_path);
1310       ret = -1;
1311       goto exit;
1312    }
1313
1314    close_file_stream(f, key_file_path);
1315
1316 exit:
1317    BIO_free(bio_mem);
1318    if (ret < 0)
1319    {
1320       freez(*ret_buf);
1321       *ret_buf = NULL;
1322       return ret;
1323    }
1324    return (int)len;
1325 }
1326
1327
1328 /*********************************************************************
1329  *
1330  * Function    :  generate_key
1331  *
1332  * Description : Tests if private key for host saved in csp already
1333  *               exists.  If this file doesn't exists, a new key is
1334  *               generated and saved in a file. The generated key is also
1335  *               copied into given parameter key_buf, which must be then
1336  *               freed by caller. If file with key exists, key_buf
1337  *               contain NULL and no private key is generated.
1338  *
1339  * Parameters  :
1340  *          1  :  csp = Current client state (buffers, headers, etc...)
1341  *          2  :  key_buf = buffer to save new generated key
1342  *
1343  * Returns     :  -1 => Error while generating private key
1344  *                 0 => Key already exists
1345  *                >0 => Length of generated private key
1346  *
1347  *********************************************************************/
1348 static int generate_key(struct client_state *csp, char **key_buf)
1349 {
1350    int ret = 0;
1351    char* key_file_path = NULL;
1352    BIGNUM *exp = BN_new();
1353    RSA *rsa = RSA_new();
1354    EVP_PKEY *key = EVP_PKEY_new();
1355
1356    if (exp == NULL || rsa == NULL || key == NULL)
1357    {
1358       log_ssl_errors(LOG_LEVEL_ERROR, "RSA key memory allocation failure");
1359       ret = -1;
1360       goto exit;
1361    }
1362
1363    BN_set_word(exp, RSA_KEY_PUBLIC_EXPONENT);
1364
1365    key_file_path = make_certs_path(csp->config->certificate_directory,
1366       (char *)csp->http->hash_of_host_hex, KEY_FILE_TYPE);
1367    if (key_file_path == NULL)
1368    {
1369       ret = -1;
1370       goto exit;
1371    }
1372
1373    /*
1374     * Test if key already exists. If so, we don't have to create it again.
1375     */
1376    if (file_exists(key_file_path) == 1)
1377    {
1378       ret = 0;
1379       goto exit;
1380    }
1381
1382    ret = RSA_generate_key_ex(rsa, RSA_KEYSIZE, exp, NULL);
1383    if (ret == 0)
1384    {
1385       log_ssl_errors(LOG_LEVEL_ERROR, "RSA key generation failure");
1386       ret = -1;
1387       goto exit;
1388    }
1389
1390    if (!EVP_PKEY_set1_RSA(key, rsa))
1391    {
1392       log_ssl_errors(LOG_LEVEL_ERROR,
1393          "Error assigning RSA key pair to PKEY structure");
1394       ret = -1;
1395       goto exit;
1396    }
1397
1398    /*
1399     * Exporting private key into file
1400     */
1401    if ((ret = write_private_key(key, key_buf, key_file_path)) < 0)
1402    {
1403       log_error(LOG_LEVEL_ERROR,
1404          "Writing private key into file %s failed", key_file_path);
1405       ret = -1;
1406       goto exit;
1407    }
1408
1409 exit:
1410    /*
1411     * Freeing used variables
1412     */
1413    if (exp)
1414    {
1415       BN_free(exp);
1416    }
1417    if (rsa)
1418    {
1419       RSA_free(rsa);
1420    }
1421    if (key)
1422    {
1423       EVP_PKEY_free(key);
1424    }
1425    freez(key_file_path);
1426
1427    return ret;
1428 }
1429
1430
1431 /*********************************************************************
1432  *
1433  * Function    :  ssl_certificate_load
1434  *
1435  * Description :  Loads certificate from file.
1436  *
1437  * Parameters  :
1438  *          1  :  cert_path = The certificate path to load
1439  *
1440  * Returns     :   NULL => error loading certificate,
1441  *                   pointer to certificate instance otherwise
1442  *
1443  *********************************************************************/
1444 static X509* ssl_certificate_load(const char *cert_path)
1445 {
1446    X509 *cert = NULL;
1447    FILE *cert_f = NULL;
1448
1449    if (!(cert_f = fopen(cert_path, "r")))
1450    {
1451       log_error(LOG_LEVEL_ERROR,
1452          "Error opening certificate file %s: %s", cert_path, strerror(errno));
1453       return NULL;
1454    }
1455
1456    if (!(cert = PEM_read_X509(cert_f, NULL, NULL, NULL)))
1457    {
1458       log_ssl_errors(LOG_LEVEL_ERROR,
1459          "Error reading certificate file %s", cert_path);
1460    }
1461
1462    close_file_stream(cert_f, cert_path);
1463    return cert;
1464 }
1465
1466
1467 /*********************************************************************
1468  *
1469  * Function    :  ssl_certificate_is_invalid
1470  *
1471  * Description :  Checks whether or not a certificate is valid.
1472  *                Currently only checks that the certificate can be
1473  *                parsed and that the "valid to" date is in the future.
1474  *
1475  * Parameters  :
1476  *          1  :  cert_file = The certificate to check
1477  *
1478  * Returns     :   0 => The certificate is valid.
1479  *                 1 => The certificate is invalid
1480  *
1481  *********************************************************************/
1482 static int ssl_certificate_is_invalid(const char *cert_file)
1483 {
1484    int ret;
1485
1486    X509 *cert = NULL;
1487
1488    if (!(cert = ssl_certificate_load(cert_file)))
1489    {
1490       log_ssl_errors(LOG_LEVEL_ERROR,
1491          "Error reading certificate file %s", cert_file);
1492       return 1;
1493    }
1494
1495    ret = X509_cmp_current_time(X509_get_notAfter(cert));
1496    if (ret == 0)
1497    {
1498       log_ssl_errors(LOG_LEVEL_ERROR,
1499          "Error checking certificate %s validity", cert_file);
1500    }
1501
1502    X509_free(cert);
1503
1504    return ret == -1 ? 1 : 0;
1505 }
1506
1507
1508 /*********************************************************************
1509  *
1510  * Function    :  set_x509_ext
1511  *
1512  * Description :  Sets the X509V3 extension data
1513  *
1514  * Parameters  :
1515  *          1  :  cert = The certificate to modify
1516  *          2  :  issuer = Issuer certificate
1517  *          3  :  nid = OpenSSL NID
1518  *          2  :  data = extension value
1519  *
1520  * Returns     :   0 => Error while setting extensuon data
1521  *                 1 => It worked
1522  *
1523  *********************************************************************/
1524 static int set_x509_ext(X509 *cert, X509 *issuer, int nid, const char *value)
1525 {
1526    X509_EXTENSION *ext = NULL;
1527    X509V3_CTX ctx;
1528    int ret = 0;
1529
1530    X509V3_set_ctx(&ctx, issuer, cert, NULL, NULL, 0);
1531    ext = X509V3_EXT_conf_nid(NULL, &ctx, nid, value);
1532    if (!ext)
1533    {
1534       log_ssl_errors(LOG_LEVEL_ERROR, "X509V3_EXT_conf_nid failure");
1535       goto exit;
1536    }
1537
1538    if (!X509_add_ext(cert, ext, -1))
1539    {
1540       log_ssl_errors(LOG_LEVEL_ERROR, "X509_add_ext failure");
1541       goto exit;
1542    }
1543
1544    ret = 1;
1545 exit:
1546    if (ext)
1547    {
1548       X509_EXTENSION_free(ext);
1549    }
1550    return ret;
1551 }
1552
1553
1554 /*********************************************************************
1555  *
1556  * Function    :  set_subject_alternative_name
1557  *
1558  * Description :  Sets the Subject Alternative Name extension to a cert
1559  *
1560  * Parameters  :
1561  *          1  :  cert = The certificate to modify
1562  *          2  :  issuer = Issuer certificate
1563  *          2  :  hostname = The hostname to add
1564  *
1565  * Returns     :   0 => Error while creating certificate.
1566  *                 1 => It worked
1567  *
1568  *********************************************************************/
1569 static int set_subject_alternative_name(X509 *cert, X509 *issuer, const char *hostname)
1570 {
1571    size_t altname_len = strlen(hostname) + sizeof(CERTIFICATE_ALT_NAME_PREFIX);
1572    char alt_name_buf[altname_len];
1573
1574    snprintf(alt_name_buf, sizeof(alt_name_buf),
1575       CERTIFICATE_ALT_NAME_PREFIX"%s", hostname);
1576    return set_x509_ext(cert, issuer, NID_subject_alt_name, alt_name_buf);
1577 }
1578
1579
1580 /*********************************************************************
1581  *
1582  * Function    :  generate_webpage_certificate
1583  *
1584  * Description :  Creates certificate file in presetted directory.
1585  *                If certificate already exists, no other certificate
1586  *                will be created. Subject of certificate is named
1587  *                by csp->http->host from parameter. This function also
1588  *                triggers generating of private key for new certificate.
1589  *
1590  * Parameters  :
1591  *          1  :  csp = Current client state (buffers, headers, etc...)
1592  *
1593  * Returns     :  -1 => Error while creating certificate.
1594  *                 0 => Certificate already exists.
1595  *                 1 => Certificate created
1596  *
1597  *********************************************************************/
1598 static int generate_webpage_certificate(struct client_state *csp)
1599 {
1600    char *key_buf = NULL;    /* Buffer for created key */
1601    X509 *issuer_cert = NULL;
1602    X509 *cert = NULL;
1603    BIO *pk_bio = NULL;
1604    EVP_PKEY *loaded_subject_key = NULL;
1605    EVP_PKEY *loaded_issuer_key = NULL;
1606    X509_NAME *issuer_name;
1607    X509_NAME *subject_name = NULL;
1608    ASN1_TIME *asn_time = NULL;
1609    ASN1_INTEGER *serial = NULL;
1610    BIGNUM *serial_num = NULL;
1611
1612    int ret = 0;
1613    cert_options cert_opt;
1614    char cert_valid_from[VALID_DATETIME_BUFLEN];
1615    char cert_valid_to[VALID_DATETIME_BUFLEN];
1616
1617    /* Paths to keys and certificates needed to create certificate */
1618    cert_opt.issuer_key  = NULL;
1619    cert_opt.subject_key = NULL;
1620    cert_opt.issuer_crt  = NULL;
1621
1622    cert_opt.output_file = make_certs_path(csp->config->certificate_directory,
1623       (const char *)csp->http->hash_of_host_hex, CERT_FILE_TYPE);
1624    if (cert_opt.output_file == NULL)
1625    {
1626       return -1;
1627    }
1628
1629    cert_opt.subject_key = make_certs_path(csp->config->certificate_directory,
1630       (const char *)csp->http->hash_of_host_hex, KEY_FILE_TYPE);
1631    if (cert_opt.subject_key == NULL)
1632    {
1633       freez(cert_opt.output_file);
1634       return -1;
1635    }
1636
1637    if (file_exists(cert_opt.output_file) == 1)
1638    {
1639       /* The file exists, but is it valid? */
1640       if (ssl_certificate_is_invalid(cert_opt.output_file))
1641       {
1642          log_error(LOG_LEVEL_CONNECT,
1643             "Certificate %s is no longer valid. Removing it.",
1644             cert_opt.output_file);
1645          if (unlink(cert_opt.output_file))
1646          {
1647             log_error(LOG_LEVEL_ERROR, "Failed to unlink %s: %E",
1648                cert_opt.output_file);
1649
1650             freez(cert_opt.output_file);
1651             freez(cert_opt.subject_key);
1652
1653             return -1;
1654          }
1655          if (unlink(cert_opt.subject_key))
1656          {
1657             log_error(LOG_LEVEL_ERROR, "Failed to unlink %s: %E",
1658                cert_opt.subject_key);
1659
1660             freez(cert_opt.output_file);
1661             freez(cert_opt.subject_key);
1662
1663             return -1;
1664          }
1665       }
1666       else
1667       {
1668          freez(cert_opt.output_file);
1669          freez(cert_opt.subject_key);
1670
1671          return 0;
1672       }
1673    }
1674
1675    /*
1676     * Create key for requested host
1677     */
1678    int subject_key_len = generate_key(csp, &key_buf);
1679    if (subject_key_len < 0)
1680    {
1681       freez(cert_opt.output_file);
1682       freez(cert_opt.subject_key);
1683       log_error(LOG_LEVEL_ERROR, "Key generating failed");
1684       return -1;
1685    }
1686
1687    /*
1688     * Converting unsigned long serial number to char * serial number.
1689     * We must compute length of serial number in string + terminating null.
1690     */
1691    unsigned long certificate_serial = get_certificate_serial(csp);
1692    unsigned long certificate_serial_time = (unsigned long)time(NULL);
1693    int serial_num_size = snprintf(NULL, 0, "%lu%lu",
1694       certificate_serial_time, certificate_serial) + 1;
1695    if (serial_num_size <= 0)
1696    {
1697       serial_num_size = 1;
1698    }
1699
1700    char serial_num_text[serial_num_size];  /* Buffer for serial number */
1701    ret = snprintf(serial_num_text, (size_t)serial_num_size, "%lu%lu",
1702       certificate_serial_time, certificate_serial);
1703    if (ret < 0 || ret >= serial_num_size)
1704    {
1705       log_error(LOG_LEVEL_ERROR,
1706          "Converting certificate serial number into string failed");
1707       ret = -1;
1708       goto exit;
1709    }
1710
1711    /*
1712     * Preparing parameters for certificate
1713     */
1714    subject_name = X509_NAME_new();
1715    if (!subject_name)
1716    {
1717       log_ssl_errors(LOG_LEVEL_ERROR, "RSA key memory allocation failure");
1718       ret = -1;
1719       goto exit;
1720    }
1721
1722    if (!X509_NAME_add_entry_by_txt(subject_name, CERT_PARAM_COMMON_NAME_FCODE,
1723          MBSTRING_ASC, (void *)csp->http->host, -1, -1, 0))
1724    {
1725       log_ssl_errors(LOG_LEVEL_ERROR,
1726          "X509 subject name (code: %s, val: %s) error",
1727          CERT_PARAM_COMMON_NAME_FCODE, csp->http->host);
1728       ret = -1;
1729       goto exit;
1730    }
1731    if (!X509_NAME_add_entry_by_txt(subject_name, CERT_PARAM_ORGANIZATION_FCODE,
1732          MBSTRING_ASC, (void *)csp->http->host, -1, -1, 0))
1733    {
1734       log_ssl_errors(LOG_LEVEL_ERROR,
1735          "X509 subject name (code: %s, val: %s) error",
1736          CERT_PARAM_COMMON_NAME_FCODE, csp->http->host);
1737       ret = -1;
1738       goto exit;
1739    }
1740    if (!X509_NAME_add_entry_by_txt(subject_name, CERT_PARAM_ORG_UNIT_FCODE,
1741          MBSTRING_ASC, (void *)csp->http->host, -1, -1, 0))
1742    {
1743       log_ssl_errors(LOG_LEVEL_ERROR,
1744          "X509 subject name (code: %s, val: %s) error",
1745          CERT_PARAM_COMMON_NAME_FCODE, csp->http->host);
1746       ret = -1;
1747       goto exit;
1748    }
1749    if (!X509_NAME_add_entry_by_txt(subject_name, CERT_PARAM_COUNTRY_FCODE,
1750          MBSTRING_ASC, (void *)CERT_PARAM_COUNTRY_CODE, -1, -1, 0))
1751    {
1752       log_ssl_errors(LOG_LEVEL_ERROR,
1753          "X509 subject name (code: %s, val: %s) error",
1754          CERT_PARAM_COMMON_NAME_FCODE, csp->http->host);
1755       ret = -1;
1756       goto exit;
1757    }
1758
1759    cert_opt.issuer_crt = csp->config->ca_cert_file;
1760    cert_opt.issuer_key = csp->config->ca_key_file;
1761
1762    if (get_certificate_valid_from_date(cert_valid_from,
1763          sizeof(cert_valid_from), VALID_DATETIME_FMT)
1764     || get_certificate_valid_to_date(cert_valid_to,
1765          sizeof(cert_valid_to), VALID_DATETIME_FMT))
1766    {
1767       log_error(LOG_LEVEL_ERROR, "Generating one of the validity dates failed");
1768       ret = -1;
1769       goto exit;
1770    }
1771
1772    cert_opt.subject_pwd = CERT_SUBJECT_PASSWORD;
1773    cert_opt.issuer_pwd  = csp->config->ca_password;
1774    cert_opt.not_before  = cert_valid_from;
1775    cert_opt.not_after   = cert_valid_to;
1776    cert_opt.serial      = serial_num_text;
1777    cert_opt.max_pathlen = -1;
1778
1779    /*
1780     * Test if the private key was already created.
1781     * XXX: Can this still happen?
1782     */
1783    if (subject_key_len == 0)
1784    {
1785       log_error(LOG_LEVEL_ERROR, "Subject key was already created");
1786       ret = 0;
1787       goto exit;
1788    }
1789
1790    /*
1791     * Parse serial to MPI
1792     */
1793    serial_num = BN_new();
1794    if (!serial_num)
1795    {
1796       log_error(LOG_LEVEL_ERROR, "generate_webpage_certificate: memory error");
1797       ret = -1;
1798       goto exit;
1799    }
1800    if (!BN_dec2bn(&serial_num, cert_opt.serial))
1801    {
1802       log_ssl_errors(LOG_LEVEL_ERROR, "Failed to parse serial %s", cert_opt.serial);
1803       ret = -1;
1804       goto exit;
1805    }
1806
1807    if (!(serial = BN_to_ASN1_INTEGER(serial_num, NULL)))
1808    {
1809       log_ssl_errors(LOG_LEVEL_ERROR, "Failed to generate serial ASN1 representation");
1810       ret = -1;
1811       goto exit;
1812    }
1813
1814    /*
1815     * Loading certificates
1816     */
1817    if (!(issuer_cert = ssl_certificate_load(cert_opt.issuer_crt)))
1818    {
1819       log_error(LOG_LEVEL_ERROR, "Loading issuer certificate %s failed",
1820          cert_opt.issuer_crt);
1821       ret = -1;
1822       goto exit;
1823    }
1824
1825    issuer_name = X509_get_issuer_name(issuer_cert);
1826
1827    /*
1828     * Loading keys from file or from buffer
1829     */
1830    if (key_buf != NULL && subject_key_len > 0)
1831    {
1832       pk_bio = BIO_new_mem_buf(key_buf, subject_key_len);
1833    }
1834    else if (!(pk_bio = BIO_new_file(cert_opt.subject_key, "r")))
1835    {
1836       log_ssl_errors(LOG_LEVEL_ERROR,
1837          "Failure opening subject key %s BIO", cert_opt.subject_key);
1838       ret = -1;
1839       goto exit;
1840    }
1841
1842    loaded_subject_key = PEM_read_bio_PrivateKey(pk_bio, NULL, NULL,
1843       (void *)cert_opt.subject_pwd);
1844    if (!loaded_subject_key)
1845    {
1846       log_ssl_errors(LOG_LEVEL_ERROR, "Parsing subject key %s failed",
1847          cert_opt.subject_key);
1848       ret = -1;
1849       goto exit;
1850    }
1851
1852    if (!BIO_free(pk_bio))
1853    {
1854       log_ssl_errors(LOG_LEVEL_ERROR, "Error closing subject key BIO");
1855    }
1856
1857    if (!(pk_bio = BIO_new_file(cert_opt.issuer_key, "r")))
1858    {
1859       log_ssl_errors(LOG_LEVEL_ERROR, "Failure opening issuer key %s BIO",
1860          cert_opt.issuer_key);
1861       ret = -1;
1862       goto exit;
1863    }
1864
1865    loaded_issuer_key = PEM_read_bio_PrivateKey(pk_bio, NULL, NULL,
1866       (void *)cert_opt.issuer_pwd);
1867    if (!loaded_issuer_key)
1868    {
1869       log_ssl_errors(LOG_LEVEL_ERROR, "Parsing issuer key %s failed",
1870          cert_opt.subject_key);
1871       ret = -1;
1872       goto exit;
1873    }
1874
1875    cert = X509_new();
1876    if (!cert)
1877    {
1878       log_ssl_errors(LOG_LEVEL_ERROR, "Certificate allocation error");
1879       ret = -1;
1880       goto exit;
1881    }
1882
1883    if (!X509_set_version(cert, CERTIFICATE_VERSION))
1884    {
1885       log_ssl_errors(LOG_LEVEL_ERROR, "X509_set_version failed");
1886       ret = -1;
1887       goto exit;
1888    }
1889
1890    /*
1891     * Setting parameters of signed certificate
1892     */
1893    if (!X509_set_pubkey(cert, loaded_subject_key))
1894    {
1895       log_ssl_errors(LOG_LEVEL_ERROR,
1896          "Setting issuer name in signed certificate failed");
1897       ret = -1;
1898       goto exit;
1899    }
1900
1901    if (!X509_set_subject_name(cert, subject_name))
1902    {
1903       log_ssl_errors(LOG_LEVEL_ERROR,
1904          "Setting issuer name in signed certificate failed");
1905       ret = -1;
1906       goto exit;
1907    }
1908
1909    if (!X509_set_issuer_name(cert, issuer_name))
1910    {
1911       log_ssl_errors(LOG_LEVEL_ERROR,
1912          "Setting issuer name in signed certificate failed");
1913       ret = -1;
1914       goto exit;
1915    }
1916
1917    if (!X509_set_serialNumber(cert, serial))
1918    {
1919       log_ssl_errors(LOG_LEVEL_ERROR,
1920          "Setting serial number in signed certificate failed");
1921       ret = -1;
1922       goto exit;
1923    }
1924
1925    asn_time = ASN1_TIME_new();
1926    if (!asn_time)
1927    {
1928       log_ssl_errors(LOG_LEVEL_ERROR, "ASN1 time memory allocation failure");
1929       ret = -1;
1930       goto exit;
1931    }
1932
1933    if (!ASN1_TIME_set_string(asn_time, cert_opt.not_after))
1934    {
1935       log_ssl_errors(LOG_LEVEL_ERROR, "ASN1 time [%s] encode error", cert_opt.not_after);
1936       ret = -1;
1937       goto exit;
1938    }
1939
1940    if (!X509_set1_notAfter(cert, asn_time))
1941    {
1942       log_ssl_errors(LOG_LEVEL_ERROR,
1943          "Setting valid not after in signed certificate failed");
1944       ret = -1;
1945       goto exit;
1946    }
1947
1948    if (!ASN1_TIME_set_string(asn_time, cert_opt.not_before))
1949    {
1950       log_ssl_errors(LOG_LEVEL_ERROR, "ASN1 time encode error");
1951       ret = -1;
1952       goto exit;
1953    }
1954
1955    if (!X509_set1_notBefore(cert, asn_time))
1956    {
1957       log_ssl_errors(LOG_LEVEL_ERROR,
1958          "Setting valid not befre in signed certificate failed");
1959       ret = -1;
1960       goto exit;
1961    }
1962
1963    if (!set_x509_ext(cert, issuer_cert, NID_basic_constraints, CERTIFICATE_BASIC_CONSTRAINTS))
1964    {
1965       log_ssl_errors(LOG_LEVEL_ERROR, "Setting the basicConstraints extension "
1966          "in signed certificate failed");
1967       ret = -1;
1968       goto exit;
1969    }
1970
1971    if (!set_x509_ext(cert, issuer_cert, NID_subject_key_identifier, CERTIFICATE_SUBJECT_KEY))
1972    {
1973       log_ssl_errors(LOG_LEVEL_ERROR,
1974          "Setting the Subject Key Identifie extension failed");
1975       ret = -1;
1976       goto exit;
1977    }
1978
1979    if (!set_x509_ext(cert, issuer_cert, NID_authority_key_identifier, CERTIFICATE_AUTHORITY_KEY))
1980    {
1981       log_ssl_errors(LOG_LEVEL_ERROR,
1982          "Setting the Authority Key Identifier extension failed");
1983       ret = -1;
1984       goto exit;
1985    }
1986
1987    if (!host_is_ip_address(csp->http->host) &&
1988        !set_subject_alternative_name(cert, issuer_cert, csp->http->host))
1989    {
1990       log_ssl_errors(LOG_LEVEL_ERROR, "Setting the Subject Alt Nameextension failed");
1991       ret = -1;
1992       goto exit;
1993    }
1994
1995    if (!X509_sign(cert, loaded_issuer_key, EVP_sha256()))
1996    {
1997       log_ssl_errors(LOG_LEVEL_ERROR, "Signing certificate failed");
1998       ret = -1;
1999       goto exit;
2000    }
2001
2002    /*
2003     * Writing certificate into file
2004     */
2005    if (write_certificate(cert, cert_opt.output_file) < 0)
2006    {
2007       log_error(LOG_LEVEL_ERROR, "Writing certificate into file failed");
2008       ret = -1;
2009       goto exit;
2010    }
2011
2012    ret = 1;
2013
2014 exit:
2015    /*
2016     * Freeing used structures
2017     */
2018    if (issuer_cert)
2019    {
2020       X509_free(issuer_cert);
2021    }
2022    if (cert)
2023    {
2024       X509_free(cert);
2025    }
2026    if (pk_bio && !BIO_free(pk_bio))
2027    {
2028       log_ssl_errors(LOG_LEVEL_ERROR, "Error closing pk BIO");
2029    }
2030    if (loaded_subject_key)
2031    {
2032       EVP_PKEY_free(loaded_subject_key);
2033    }
2034    if (loaded_issuer_key)
2035    {
2036       EVP_PKEY_free(loaded_issuer_key);
2037    }
2038    if (subject_name)
2039    {
2040       X509_NAME_free(subject_name);
2041    }
2042    if (asn_time)
2043    {
2044       ASN1_TIME_free(asn_time);
2045    }
2046    if (serial_num)
2047    {
2048       BN_free(serial_num);
2049    }
2050    if (serial)
2051    {
2052       ASN1_INTEGER_free(serial);
2053    }
2054    freez(cert_opt.subject_key);
2055    freez(cert_opt.output_file);
2056    freez(key_buf);
2057
2058    return ret;
2059 }
2060
2061
2062 /*********************************************************************
2063  *
2064  * Function    :  ssl_crt_verify_info
2065  *
2066  * Description :  Returns an informational string about the verification
2067  *                status of a certificate.
2068  *
2069  * Parameters  :
2070  *          1  :  buf = Buffer to write to
2071  *          2  :  size = Maximum size of buffer
2072  *          3  :  csp = client state
2073  *
2074  * Returns     :  N/A
2075  *
2076  *********************************************************************/
2077 extern void ssl_crt_verify_info(char *buf, size_t size, struct client_state *csp)
2078 {
2079    strncpy(buf, X509_verify_cert_error_string(csp->server_cert_verification_result), size);
2080    buf[size - 1] = 0;
2081 }
2082
2083
2084 /*********************************************************************
2085  *
2086  * Function    :  ssl_release
2087  *
2088  * Description :  Release all SSL resources
2089  *
2090  * Parameters  :
2091  *
2092  * Returns     :  N/A
2093  *
2094  *********************************************************************/
2095 extern void ssl_release(void)
2096 {
2097    if (ssl_inited == 1)
2098    {
2099       SSL_COMP_free_compression_methods();
2100
2101       CONF_modules_free();
2102       CONF_modules_unload(1);
2103
2104       COMP_zlib_cleanup();
2105
2106       ERR_free_strings();
2107       EVP_cleanup();
2108
2109       CRYPTO_cleanup_all_ex_data();
2110    }
2111 }
2112