ssl.c

   1 /*********************************************************************
   2  *
   3  * File        :  $Source: /cvsroot/ijbswa/current/ssl.c,v $
   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) 2017-2020 Vaclav Svec. FIT CVUT.
   9  *                Copyright (C) 2018-2020 by Fabian Keil <fk@fabiankeil.de>
  10  *
  11  *                This program is free software; you can redistribute it
  12  *                and/or modify it under the terms of the GNU General
  13  *                Public License as published by the Free Software
  14  *                Foundation; either version 2 of the License, or (at
  15  *                your option) any later version.
  16  *
  17  *                This program is distributed in the hope that it will
  18  *                be useful, but WITHOUT ANY WARRANTY; without even the
  19  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  20  *                PARTICULAR PURPOSE.  See the GNU General Public
  21  *                License for more details.
  22  *
  23  *                The GNU General Public License should be included with
  24  *                this file.  If not, you can view it at
  25  *                http://www.gnu.org/copyleft/gpl.html
  26  *                or write to the Free Software Foundation, Inc., 59
  27  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  28  *
  29  *********************************************************************/
  30
  31 #include <string.h>
  32 #include <unistd.h>
  33
  34 #if !defined(MBEDTLS_CONFIG_FILE)
  35 #  include "mbedtls/config.h"
  36 #else
  37 #  include MBEDTLS_CONFIG_FILE
  38 #endif
  39
  40 #include "mbedtls/md5.h"
  41 #include "mbedtls/pem.h"
  42 #include "mbedtls/base64.h"
  43 #include "mbedtls/error.h"
  44 #include "mbedtls/oid.h"
  45 #include "mbedtls/asn1write.h"
  46
  47 #include "config.h"
  48 #include "project.h"
  49 #include "miscutil.h"
  50 #include "errlog.h"
  51 #include "jcc.h"
  52 #include "ssl.h"
  53 #include "ssl_common.h"
  54 #include "encode.h"
  55
  56
  57 /*
  58  * Macros for searching begin and end of certificates.
  59  * Necessary to convert structure mbedtls_x509_crt to crt file.
  60  */
  61 #define PEM_BEGIN_CRT     "-----BEGIN CERTIFICATE-----\n"
  62 #define PEM_END_CRT       "-----END CERTIFICATE-----\n"
  63 #define VALID_DATETIME_FMT    "%Y%m%d%H%M%S"
  64 #define VALID_DATETIME_BUFLEN 15
  65
  66 /*
  67  * Macros for ssl.c
  68  */
  69 #define CERTIFICATE_BUF_SIZE             16384             /* Size of buffer to save certificate. Value 4096 is mbedtls library buffer size for certificate in DER form */
  70 #define PRIVATE_KEY_BUF_SIZE             16000             /* Size of buffer to save private key. Value 16000 is taken from mbed TLS library examples. */
  71 #define CERT_SIGNATURE_ALGORITHM         MBEDTLS_MD_SHA256 /* The MD algorithm to use for the signature */
  72 #define CERT_PARAM_COMMON_NAME           CERT_PARAM_COMMON_NAME_FCODE"="
  73 #define CERT_PARAM_ORGANIZATION          ","CERT_PARAM_ORGANIZATION_FCODE"="
  74 #define CERT_PARAM_ORG_UNIT              ","CERT_PARAM_ORG_UNIT_FCODE"="
  75 #define CERT_PARAM_COUNTRY               ","CERT_PARAM_COUNTRY_FCODE"="CERT_PARAM_COUNTRY_CODE
  76
  77 /*
  78  * Properties of key for generating
  79  */
  80 typedef struct {
  81    mbedtls_pk_type_t type;   /* type of key to generate  */
  82    int  rsa_keysize;         /* length of key in bits    */
  83    char *key_file_path;      /* filename of the key file */
  84 } key_options;
  85
  86 /* Variables for one common RNG for all SSL use */
  87 static mbedtls_ctr_drbg_context ctr_drbg;
  88 static mbedtls_entropy_context  entropy;
  89 static int rng_seeded;
  90
  91 static int generate_host_certificate(struct client_state *csp);
  92 static int host_to_hash(struct client_state *csp);
  93 static int ssl_verify_callback(void *data, mbedtls_x509_crt *crt, int depth, uint32_t *flags);
  94 static void free_client_ssl_structures(struct client_state *csp);
  95 static void free_server_ssl_structures(struct client_state *csp);
  96 static int seed_rng(struct client_state *csp);
  97 static int *get_ciphersuites_from_string(const char *ciphersuites_string);
  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_attr = 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    mbedtls_ssl_context *ssl = &ssl_attr->mbedtls_attr.ssl;
 118    if (ssl == NULL)
 119    {
 120       return 0;
 121    }
 122
 123    return mbedtls_ssl_get_bytes_avail(ssl);
 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_attr = 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    mbedtls_ssl_context *ssl = &ssl_attr->mbedtls_attr.ssl;
 145    int ret = 0;
 146    size_t max_fragment_size = 0;  /* Maximal length of data in one SSL fragment*/
 147    int send_len             = 0;  /* length of one data part to send */
 148    int pos                  = 0;  /* Position of unsent part in buffer */
 149
 150    if (len == 0)
 151    {
 152       return 0;
 153    }
 154
 155    /* Getting maximal length of data sent in one fragment */
 156    max_fragment_size = mbedtls_ssl_get_max_frag_len(ssl);
 157
 158    /*
 159     * Whole buffer must be sent in many fragments, because each fragment
 160     * has its maximal length.
 161     */
 162    while (pos < len)
 163    {
 164       /* Compute length of data, that can be send in next fragment */
 165       if ((pos + (int)max_fragment_size) > len)
 166       {
 167          send_len = (int)len - pos;
 168       }
 169       else
 170       {
 171          send_len = (int)max_fragment_size;
 172       }
 173
 174       log_error(LOG_LEVEL_WRITING, "TLS on socket %d: %N",
 175          ssl_attr->mbedtls_attr.socket_fd.fd, send_len, buf+pos);
 176
 177       /*
 178        * Sending one part of the buffer
 179        */
 180       while ((ret = mbedtls_ssl_write(ssl,
 181          (const unsigned char *)(buf + pos),
 182          (size_t)send_len)) < 0)
 183       {
 184          if (ret != MBEDTLS_ERR_SSL_WANT_READ &&
 185              ret != MBEDTLS_ERR_SSL_WANT_WRITE)
 186          {
 187             char err_buf[ERROR_BUF_SIZE];
 188
 189             mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 190             log_error(LOG_LEVEL_ERROR,
 191                "Sending data on socket %d over TLS/SSL failed: %s",
 192                ssl_attr->mbedtls_attr.socket_fd.fd, err_buf);
 193             return -1;
 194          }
 195       }
 196       /* Adding count of sent bytes to position in buffer */
 197       pos = pos + send_len;
 198    }
 199
 200    return (int)len;
 201 }
 202
 203
 204 /*********************************************************************
 205  *
 206  * Function    :  ssl_recv_data
 207  *
 208  * Description :  Receives data from given SSL context and puts
 209  *                it into buffer.
 210  *
 211  * Parameters  :
 212  *          1  :  ssl_attr = SSL context to receive data from
 213  *          2  :  buf = Pointer to buffer where data will be written
 214  *          3  :  max_length = Maximum number of bytes to read
 215  *
 216  * Returns     :  Number of bytes read, 0 for EOF, or -1
 217  *                on error.
 218  *
 219  *********************************************************************/
 220 extern int ssl_recv_data(struct ssl_attr *ssl_attr, unsigned char *buf, size_t max_length)
 221 {
 222    mbedtls_ssl_context *ssl = &ssl_attr->mbedtls_attr.ssl;
 223    int ret = 0;
 224    memset(buf, 0, max_length);
 225
 226    /*
 227     * Receiving data from SSL context into buffer
 228     */
 229    do
 230    {
 231       ret = mbedtls_ssl_read(ssl, buf, max_length);
 232    } while (ret == MBEDTLS_ERR_SSL_WANT_READ
 233       || ret == MBEDTLS_ERR_SSL_WANT_WRITE);
 234
 235    if (ret < 0)
 236    {
 237       char err_buf[ERROR_BUF_SIZE];
 238
 239       if (ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY)
 240       {
 241          log_error(LOG_LEVEL_CONNECT, "The peer notified us that "
 242             "the connection on socket %d is going to be closed",
 243             ssl_attr->mbedtls_attr.socket_fd.fd);
 244          return 0;
 245       }
 246       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 247       log_error(LOG_LEVEL_ERROR,
 248          "Receiving data on socket %d over TLS/SSL failed: %s",
 249          ssl_attr->mbedtls_attr.socket_fd.fd, err_buf);
 250
 251       return -1;
 252    }
 253
 254    log_error(LOG_LEVEL_RECEIVED, "TLS from socket %d: %N",
 255       ssl_attr->mbedtls_attr.socket_fd.fd, ret, buf);
 256
 257    return ret;
 258 }
 259
 260
 261 /*********************************************************************
 262  *
 263  * Function    :  create_client_ssl_connection
 264  *
 265  * Description :  Creates TLS/SSL secured connection with client
 266  *
 267  * Parameters  :
 268  *          1  :  csp = Current client state (buffers, headers, etc...)
 269  *
 270  * Returns     :  0 on success, negative value if connection wasn't created
 271  *                successfully.
 272  *
 273  *********************************************************************/
 274 extern int create_client_ssl_connection(struct client_state *csp)
 275 {
 276    struct ssl_attr *ssl_attr = &csp->ssl_client_attr;
 277    /* Paths to certificates file and key file */
 278    char *key_file  = NULL;
 279    char *ca_file   = NULL;
 280    char *cert_file = NULL;
 281    int ret = 0;
 282    char err_buf[ERROR_BUF_SIZE];
 283
 284    /*
 285     * Initializing mbedtls structures for TLS/SSL connection
 286     */
 287    mbedtls_net_init(&(ssl_attr->mbedtls_attr.socket_fd));
 288    mbedtls_ssl_init(&(ssl_attr->mbedtls_attr.ssl));
 289    mbedtls_ssl_config_init(&(ssl_attr->mbedtls_attr.conf));
 290    mbedtls_x509_crt_init(&(ssl_attr->mbedtls_attr.server_cert));
 291    mbedtls_pk_init(&(ssl_attr->mbedtls_attr.prim_key));
 292 #if defined(MBEDTLS_SSL_CACHE_C)
 293    mbedtls_ssl_cache_init(&(ssl_attr->mbedtls_attr.cache));
 294 #endif
 295
 296    /*
 297     * Preparing hash of host for creating certificates
 298     */
 299    ret = host_to_hash(csp);
 300    if (ret != 0)
 301    {
 302       log_error(LOG_LEVEL_ERROR, "Generating hash of host failed: %d", ret);
 303       ret = -1;
 304       goto exit;
 305    }
 306
 307    /*
 308     * Preparing paths to certificates files and key file
 309     */
 310    ca_file   = csp->config->ca_cert_file;
 311    cert_file = make_certs_path(csp->config->certificate_directory,
 312       (const char *)csp->http->hash_of_host_hex, CERT_FILE_TYPE);
 313    key_file  = make_certs_path(csp->config->certificate_directory,
 314       (const char *)csp->http->hash_of_host_hex, KEY_FILE_TYPE);
 315
 316    if (cert_file == NULL || key_file == NULL)
 317    {
 318       ret = -1;
 319       goto exit;
 320    }
 321
 322    /*
 323     * Generating certificate for requested host. Mutex to prevent
 324     * certificate and key inconsistence must be locked.
 325     */
 326    privoxy_mutex_lock(&certificate_mutex);
 327
 328    ret = generate_host_certificate(csp);
 329    if (ret < 0)
 330    {
 331       log_error(LOG_LEVEL_ERROR,
 332          "generate_host_certificate failed: %d", ret);
 333       privoxy_mutex_unlock(&certificate_mutex);
 334       ret = -1;
 335       goto exit;
 336    }
 337    privoxy_mutex_unlock(&certificate_mutex);
 338
 339    /*
 340     * Seed the RNG
 341     */
 342    ret = seed_rng(csp);
 343    if (ret != 0)
 344    {
 345       ret = -1;
 346       goto exit;
 347    }
 348
 349    /*
 350     * Loading CA file, webpage certificate and key files
 351     */
 352    ret = mbedtls_x509_crt_parse_file(&(ssl_attr->mbedtls_attr.server_cert),
 353       cert_file);
 354    if (ret != 0)
 355    {
 356       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 357       log_error(LOG_LEVEL_ERROR,
 358          "Loading webpage certificate %s failed: %s", cert_file, err_buf);
 359       ret = -1;
 360       goto exit;
 361    }
 362
 363    ret = mbedtls_x509_crt_parse_file(&(ssl_attr->mbedtls_attr.server_cert),
 364       ca_file);
 365    if (ret != 0)
 366    {
 367       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 368       log_error(LOG_LEVEL_ERROR,
 369          "Loading CA certificate %s failed: %s", ca_file, err_buf);
 370       ret = -1;
 371       goto exit;
 372    }
 373
 374    ret = mbedtls_pk_parse_keyfile(&(ssl_attr->mbedtls_attr.prim_key),
 375       key_file, NULL);
 376    if (ret != 0)
 377    {
 378       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 379       log_error(LOG_LEVEL_ERROR,
 380          "Loading and parsing webpage certificate private key %s failed: %s",
 381          key_file, err_buf);
 382       ret = -1;
 383       goto exit;
 384    }
 385
 386    /*
 387     * Setting SSL parameters
 388     */
 389    ret = mbedtls_ssl_config_defaults(&(ssl_attr->mbedtls_attr.conf),
 390       MBEDTLS_SSL_IS_SERVER, MBEDTLS_SSL_TRANSPORT_STREAM,
 391       MBEDTLS_SSL_PRESET_DEFAULT);
 392    if (ret != 0)
 393    {
 394       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 395       log_error(LOG_LEVEL_ERROR,
 396          "mbedtls_ssl_config_defaults failed: %s", err_buf);
 397       ret = -1;
 398       goto exit;
 399    }
 400
 401    mbedtls_ssl_conf_rng(&(ssl_attr->mbedtls_attr.conf),
 402       mbedtls_ctr_drbg_random, &ctr_drbg);
 403
 404 #if defined(MBEDTLS_SSL_CACHE_C)
 405    mbedtls_ssl_conf_session_cache(&(ssl_attr->mbedtls_attr.conf),
 406       &(ssl_attr->mbedtls_attr.cache), mbedtls_ssl_cache_get,
 407       mbedtls_ssl_cache_set);
 408 #endif
 409
 410    /*
 411     * Setting certificates
 412     */
 413    ret = mbedtls_ssl_conf_own_cert(&(ssl_attr->mbedtls_attr.conf),
 414       &(ssl_attr->mbedtls_attr.server_cert),
 415       &(ssl_attr->mbedtls_attr.prim_key));
 416    if (ret != 0)
 417    {
 418       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 419       log_error(LOG_LEVEL_ERROR,
 420          "mbedtls_ssl_conf_own_cert failed: %s", err_buf);
 421       ret = -1;
 422       goto exit;
 423    }
 424
 425    if (csp->config->cipher_list != NULL)
 426    {
 427       ssl_attr->mbedtls_attr.ciphersuites_list =
 428          get_ciphersuites_from_string(csp->config->cipher_list);
 429       if (ssl_attr->mbedtls_attr.ciphersuites_list == NULL)
 430       {
 431          log_error(LOG_LEVEL_ERROR,
 432             "Setting the cipher list '%s' for the client connection failed",
 433             csp->config->cipher_list);
 434          ret = -1;
 435          goto exit;
 436       }
 437       mbedtls_ssl_conf_ciphersuites(&(ssl_attr->mbedtls_attr.conf),
 438          ssl_attr->mbedtls_attr.ciphersuites_list);
 439    }
 440
 441    ret = mbedtls_ssl_setup(&(ssl_attr->mbedtls_attr.ssl),
 442       &(ssl_attr->mbedtls_attr.conf));
 443    if (ret != 0)
 444    {
 445       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 446       log_error(LOG_LEVEL_ERROR, "mbedtls_ssl_setup failed: %s", err_buf);
 447       ret = -1;
 448       goto exit;
 449    }
 450
 451    mbedtls_ssl_set_bio(&(ssl_attr->mbedtls_attr.ssl),
 452       &(ssl_attr->mbedtls_attr.socket_fd), mbedtls_net_send,
 453       mbedtls_net_recv, NULL);
 454    mbedtls_ssl_session_reset(&(ssl_attr->mbedtls_attr.ssl));
 455
 456    /*
 457     * Setting socket fd in mbedtls_net_context structure. This structure
 458     * can't be set by mbedtls functions, because we already have created
 459     * a TCP connection when this function is called.
 460     */
 461    ssl_attr->mbedtls_attr.socket_fd.fd = csp->cfd;
 462
 463    /*
 464     *  Handshake with client
 465     */
 466    log_error(LOG_LEVEL_CONNECT,
 467       "Performing the TLS/SSL handshake with client. Hash of host: %s",
 468       csp->http->hash_of_host_hex);
 469    while ((ret = mbedtls_ssl_handshake(&(ssl_attr->mbedtls_attr.ssl))) != 0)
 470    {
 471       if (ret != MBEDTLS_ERR_SSL_WANT_READ &&
 472           ret != MBEDTLS_ERR_SSL_WANT_WRITE)
 473       {
 474          mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 475          log_error(LOG_LEVEL_ERROR,
 476             "medtls_ssl_handshake with client failed: %s", err_buf);
 477          ret = -1;
 478          goto exit;
 479       }
 480    }
 481
 482    log_error(LOG_LEVEL_CONNECT, "Client successfully connected over TLS/SSL");
 483    csp->ssl_with_client_is_opened = 1;
 484
 485 exit:
 486    /*
 487     * Freeing allocated paths to files
 488     */
 489    freez(cert_file);
 490    freez(key_file);
 491
 492    /* Freeing structures if connection wasn't created successfully */
 493    if (ret < 0)
 494    {
 495       free_client_ssl_structures(csp);
 496    }
 497    return ret;
 498 }
 499
 500
 501 /*********************************************************************
 502  *
 503  * Function    :  close_client_ssl_connection
 504  *
 505  * Description :  Closes TLS/SSL connection with client. This function
 506  *                checks if this connection is already created.
 507  *
 508  * Parameters  :
 509  *          1  :  csp = Current client state (buffers, headers, etc...)
 510  *
 511  * Returns     :  N/A
 512  *
 513  *********************************************************************/
 514 extern void close_client_ssl_connection(struct client_state *csp)
 515 {
 516    struct ssl_attr *ssl_attr = &csp->ssl_client_attr;
 517    int ret = 0;
 518
 519    if (csp->ssl_with_client_is_opened == 0)
 520    {
 521       return;
 522    }
 523
 524    /*
 525     * Notifying the peer that the connection is being closed.
 526     */
 527    do {
 528       ret = mbedtls_ssl_close_notify(&(ssl_attr->mbedtls_attr.ssl));
 529    } while (ret == MBEDTLS_ERR_SSL_WANT_WRITE);
 530
 531    free_client_ssl_structures(csp);
 532    csp->ssl_with_client_is_opened = 0;
 533 }
 534
 535
 536 /*********************************************************************
 537  *
 538  * Function    :  free_client_ssl_structures
 539  *
 540  * Description :  Frees structures used for SSL communication with
 541  *                client.
 542  *
 543  * Parameters  :
 544  *          1  :  csp = Current client state (buffers, headers, etc...)
 545  *
 546  * Returns     :  N/A
 547  *
 548  *********************************************************************/
 549 static void free_client_ssl_structures(struct client_state *csp)
 550 {
 551    struct ssl_attr *ssl_attr = &csp->ssl_client_attr;
 552    /*
 553    * We can't use function mbedtls_net_free, because this function
 554    * inter alia close TCP connection on set fd. Instead of this
 555    * function, we change fd to -1, which is the same what does
 556    * rest of mbedtls_net_free function.
 557    */
 558    ssl_attr->mbedtls_attr.socket_fd.fd = -1;
 559
 560    /* Freeing mbedtls structures */
 561    mbedtls_x509_crt_free(&(ssl_attr->mbedtls_attr.server_cert));
 562    mbedtls_pk_free(&(ssl_attr->mbedtls_attr.prim_key));
 563    mbedtls_ssl_free(&(ssl_attr->mbedtls_attr.ssl));
 564    freez(ssl_attr->mbedtls_attr.ciphersuites_list);
 565    mbedtls_ssl_config_free(&(ssl_attr->mbedtls_attr.conf));
 566 #if defined(MBEDTLS_SSL_CACHE_C)
 567    mbedtls_ssl_cache_free(&(ssl_attr->mbedtls_attr.cache));
 568 #endif
 569 }
 570
 571
 572 /*********************************************************************
 573  *
 574  * Function    :  create_server_ssl_connection
 575  *
 576  * Description :  Creates TLS/SSL secured connection with server.
 577  *
 578  * Parameters  :
 579  *          1  :  csp = Current client state (buffers, headers, etc...)
 580  *
 581  * Returns     :  0 on success, negative value if connection wasn't created
 582  *                successfully.
 583  *
 584  *********************************************************************/
 585 extern int create_server_ssl_connection(struct client_state *csp)
 586 {
 587    struct ssl_attr *ssl_attr = &csp->ssl_server_attr;
 588    int ret = 0;
 589    char err_buf[ERROR_BUF_SIZE];
 590    char *trusted_cas_file = NULL;
 591    int auth_mode = MBEDTLS_SSL_VERIFY_REQUIRED;
 592
 593    csp->server_cert_verification_result = SSL_CERT_NOT_VERIFIED;
 594    csp->server_certs_chain.next = NULL;
 595
 596    /* Setting path to file with trusted CAs */
 597    trusted_cas_file = csp->config->trusted_cas_file;
 598
 599    /*
 600     * Initializing mbedtls structures for TLS/SSL connection
 601     */
 602    mbedtls_net_init(&(ssl_attr->mbedtls_attr.socket_fd));
 603    mbedtls_ssl_init(&(ssl_attr->mbedtls_attr.ssl));
 604    mbedtls_ssl_config_init(&(ssl_attr->mbedtls_attr.conf));
 605    mbedtls_x509_crt_init(&(ssl_attr->mbedtls_attr.ca_cert));
 606
 607    /*
 608    * Setting socket fd in mbedtls_net_context structure. This structure
 609    * can't be set by mbedtls functions, because we already have created
 610    * TCP connection when calling this function.
 611    */
 612    ssl_attr->mbedtls_attr.socket_fd.fd = csp->server_connection.sfd;
 613
 614    /*
 615     * Seed the RNG
 616     */
 617    ret = seed_rng(csp);
 618    if (ret != 0)
 619    {
 620       ret = -1;
 621       goto exit;
 622    }
 623
 624    /*
 625     * Loading file with trusted CAs
 626     */
 627    ret = mbedtls_x509_crt_parse_file(&(ssl_attr->mbedtls_attr.ca_cert),
 628       trusted_cas_file);
 629    if (ret < 0)
 630    {
 631       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 632       log_error(LOG_LEVEL_ERROR, "Loading trusted CAs file %s failed: %s",
 633          trusted_cas_file, err_buf);
 634       ret = -1;
 635       goto exit;
 636    }
 637
 638    /*
 639     * Set TLS/SSL options
 640     */
 641    ret = mbedtls_ssl_config_defaults(&(ssl_attr->mbedtls_attr.conf),
 642       MBEDTLS_SSL_IS_CLIENT,
 643       MBEDTLS_SSL_TRANSPORT_STREAM,
 644       MBEDTLS_SSL_PRESET_DEFAULT);
 645    if (ret != 0)
 646    {
 647       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 648       log_error(LOG_LEVEL_ERROR, "mbedtls_ssl_config_defaults failed: %s",
 649          err_buf);
 650       ret = -1;
 651       goto exit;
 652    }
 653
 654    /*
 655     * Setting how strict should certificate verification be and other
 656     * parameters for certificate verification
 657     */
 658    if (csp->dont_verify_certificate)
 659    {
 660       auth_mode = MBEDTLS_SSL_VERIFY_NONE;
 661    }
 662
 663    mbedtls_ssl_conf_authmode(&(ssl_attr->mbedtls_attr.conf), auth_mode);
 664    mbedtls_ssl_conf_ca_chain(&(ssl_attr->mbedtls_attr.conf),
 665       &(ssl_attr->mbedtls_attr.ca_cert), NULL);
 666
 667    /* Setting callback function for certificates verification */
 668    mbedtls_ssl_conf_verify(&(ssl_attr->mbedtls_attr.conf),
 669       ssl_verify_callback, (void *)csp);
 670
 671    mbedtls_ssl_conf_rng(&(ssl_attr->mbedtls_attr.conf),
 672       mbedtls_ctr_drbg_random, &ctr_drbg);
 673
 674    if (csp->config->cipher_list != NULL)
 675    {
 676       ssl_attr->mbedtls_attr.ciphersuites_list =
 677          get_ciphersuites_from_string(csp->config->cipher_list);
 678       if (ssl_attr->mbedtls_attr.ciphersuites_list == NULL)
 679       {
 680          log_error(LOG_LEVEL_ERROR,
 681             "Setting the cipher list '%s' for the server connection failed",
 682             csp->config->cipher_list);
 683          ret = -1;
 684          goto exit;
 685       }
 686       mbedtls_ssl_conf_ciphersuites(&(ssl_attr->mbedtls_attr.conf),
 687          ssl_attr->mbedtls_attr.ciphersuites_list);
 688    }
 689
 690    ret = mbedtls_ssl_setup(&(ssl_attr->mbedtls_attr.ssl),
 691       &(ssl_attr->mbedtls_attr.conf));
 692    if (ret != 0)
 693    {
 694       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 695       log_error(LOG_LEVEL_ERROR, "mbedtls_ssl_setup failed: %s", err_buf);
 696       ret = -1;
 697       goto exit;
 698    }
 699
 700    /*
 701     * Set the hostname to check against the received server certificate
 702     */
 703    ret = mbedtls_ssl_set_hostname(&(ssl_attr->mbedtls_attr.ssl),
 704       csp->http->host);
 705    if (ret != 0)
 706    {
 707       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 708       log_error(LOG_LEVEL_ERROR, "mbedtls_ssl_set_hostname failed: %s",
 709          err_buf);
 710       ret = -1;
 711       goto exit;
 712    }
 713
 714    mbedtls_ssl_set_bio(&(ssl_attr->mbedtls_attr.ssl),
 715       &(ssl_attr->mbedtls_attr.socket_fd), mbedtls_net_send,
 716       mbedtls_net_recv, NULL);
 717
 718    /*
 719     * Handshake with server
 720     */
 721    log_error(LOG_LEVEL_CONNECT,
 722       "Performing the TLS/SSL handshake with the server");
 723
 724    while ((ret = mbedtls_ssl_handshake(&(ssl_attr->mbedtls_attr.ssl))) != 0)
 725    {
 726       if (ret != MBEDTLS_ERR_SSL_WANT_READ
 727        && ret != MBEDTLS_ERR_SSL_WANT_WRITE)
 728       {
 729          mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 730
 731          if (ret == MBEDTLS_ERR_X509_CERT_VERIFY_FAILED)
 732          {
 733             char reason[INVALID_CERT_INFO_BUF_SIZE];
 734
 735             csp->server_cert_verification_result =
 736                mbedtls_ssl_get_verify_result(&(ssl_attr->mbedtls_attr.ssl));
 737             mbedtls_x509_crt_verify_info(reason, sizeof(reason), "",
 738                csp->server_cert_verification_result);
 739
 740             /* Log the reason without the trailing new line */
 741             log_error(LOG_LEVEL_ERROR,
 742                "X509 certificate verification for %s failed: %N",
 743                csp->http->hostport, strlen(reason)-1, reason);
 744             ret = -1;
 745          }
 746          else
 747          {
 748             log_error(LOG_LEVEL_ERROR,
 749                "mbedtls_ssl_handshake with server failed: %s", err_buf);
 750             free_certificate_chain(csp);
 751             ret = -1;
 752          }
 753          goto exit;
 754       }
 755    }
 756
 757    log_error(LOG_LEVEL_CONNECT, "Server successfully connected over TLS/SSL");
 758
 759    /*
 760     * Server certificate chain is valid, so we can clean
 761     * chain, because we will not send it to client.
 762     */
 763    free_certificate_chain(csp);
 764
 765    csp->ssl_with_server_is_opened = 1;
 766    csp->server_cert_verification_result =
 767       mbedtls_ssl_get_verify_result(&(ssl_attr->mbedtls_attr.ssl));
 768
 769 exit:
 770    /* Freeing structures if connection wasn't created successfully */
 771    if (ret < 0)
 772    {
 773       free_server_ssl_structures(csp);
 774    }
 775
 776    return ret;
 777 }
 778
 779
 780 /*********************************************************************
 781  *
 782  * Function    :  close_server_ssl_connection
 783  *
 784  * Description :  Closes TLS/SSL connection with server. This function
 785  *                checks if this connection is already opened.
 786  *
 787  * Parameters  :
 788  *          1  :  csp = Current client state (buffers, headers, etc...)
 789  *
 790  * Returns     :  N/A
 791  *
 792  *********************************************************************/
 793 extern void close_server_ssl_connection(struct client_state *csp)
 794 {
 795    struct ssl_attr *ssl_attr = &csp->ssl_server_attr;
 796    int ret = 0;
 797
 798    if (csp->ssl_with_server_is_opened == 0)
 799    {
 800       return;
 801    }
 802
 803    /*
 804    * Notifying the peer that the connection is being closed.
 805    */
 806    do {
 807       ret = mbedtls_ssl_close_notify(&(ssl_attr->mbedtls_attr.ssl));
 808    } while (ret == MBEDTLS_ERR_SSL_WANT_WRITE);
 809
 810    free_server_ssl_structures(csp);
 811    csp->ssl_with_server_is_opened = 0;
 812 }
 813
 814
 815 /*********************************************************************
 816  *
 817  * Function    :  free_server_ssl_structures
 818  *
 819  * Description :  Frees structures used for SSL communication with server
 820  *
 821  * Parameters  :
 822  *          1  :  csp = Current client state (buffers, headers, etc...)
 823  *
 824  * Returns     :  N/A
 825  *
 826  *********************************************************************/
 827 static void free_server_ssl_structures(struct client_state *csp)
 828 {
 829    struct ssl_attr *ssl_attr = &csp->ssl_server_attr;
 830    /*
 831    * We can't use function mbedtls_net_free, because this function
 832    * inter alia close TCP connection on set fd. Instead of this
 833    * function, we change fd to -1, which is the same what does
 834    * rest of mbedtls_net_free function.
 835    */
 836    ssl_attr->mbedtls_attr.socket_fd.fd = -1;
 837
 838    mbedtls_x509_crt_free(&(ssl_attr->mbedtls_attr.ca_cert));
 839    mbedtls_ssl_free(&(ssl_attr->mbedtls_attr.ssl));
 840    freez(ssl_attr->mbedtls_attr.ciphersuites_list);
 841    mbedtls_ssl_config_free(&(ssl_attr->mbedtls_attr.conf));
 842 }
 843
 844
 845 /*====================== Certificates ======================*/
 846
 847 /*********************************************************************
 848  *
 849  * Function    :  write_certificate
 850  *
 851  * Description :  Writes certificate into file.
 852  *
 853  * Parameters  :
 854  *          1  :  crt = certificate to write into file
 855  *          2  :  output_file = path to save certificate file
 856  *          3  :  f_rng = mbedtls_ctr_drbg_random
 857  *          4  :  p_rng = mbedtls_ctr_drbg_context
 858  *
 859  * Returns     :  Length of written certificate on success or negative value
 860  *                on error
 861  *
 862  *********************************************************************/
 863 static int write_certificate(mbedtls_x509write_cert *crt, const char *output_file,
 864    int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
 865 {
 866    FILE *f = NULL;
 867    size_t len = 0;
 868    unsigned char cert_buf[CERTIFICATE_BUF_SIZE + 1]; /* Buffer for certificate in PEM format + terminating NULL */
 869    int ret = 0;
 870    char err_buf[ERROR_BUF_SIZE];
 871
 872    memset(cert_buf, 0, sizeof(cert_buf));
 873
 874    /*
 875     * Writing certificate into PEM string. If buffer is too small, function
 876     * returns specific error and no buffer overflow can happen.
 877     */
 878    if ((ret = mbedtls_x509write_crt_pem(crt, cert_buf,
 879       sizeof(cert_buf) - 1, f_rng, p_rng)) != 0)
 880    {
 881       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 882       log_error(LOG_LEVEL_ERROR,
 883          "Writing certificate into buffer failed: %s", err_buf);
 884       return -1;
 885    }
 886
 887    len = strlen((char *)cert_buf);
 888
 889    /*
 890     * Saving certificate into file
 891     */
 892    if ((f = fopen(output_file, "w")) == NULL)
 893    {
 894       log_error(LOG_LEVEL_ERROR, "Opening file %s to save certificate failed",
 895          output_file);
 896       return -1;
 897    }
 898
 899    if (fwrite(cert_buf, 1, len, f) != len)
 900    {
 901       log_error(LOG_LEVEL_ERROR,
 902          "Writing certificate into file %s failed", output_file);
 903       fclose(f);
 904       return -1;
 905    }
 906
 907    fclose(f);
 908
 909    return (int)len;
 910 }
 911
 912
 913 /*********************************************************************
 914  *
 915  * Function    :  write_private_key
 916  *
 917  * Description :  Writes private key into file and copies saved
 918  *                content into given pointer to string. If function
 919  *                returns 0 for success, this copy must be freed by
 920  *                caller.
 921  *
 922  * Parameters  :
 923  *          1  :  key = key to write into file
 924  *          2  :  ret_buf = pointer to string with created key file content
 925  *          3  :  key_file_path = path where to save key file
 926  *
 927  * Returns     :  Length of written private key on success or negative value
 928  *                on error
 929  *
 930  *********************************************************************/
 931 static int write_private_key(mbedtls_pk_context *key, unsigned char **ret_buf,
 932    const char *key_file_path)
 933 {
 934    size_t len = 0;                /* Length of created key    */
 935    FILE *f = NULL;                /* File to save certificate */
 936    int ret = 0;
 937    char err_buf[ERROR_BUF_SIZE];
 938
 939    /* Initializing buffer for key file content */
 940    *ret_buf = zalloc_or_die(PRIVATE_KEY_BUF_SIZE + 1);
 941
 942    /*
 943     * Writing private key into PEM string
 944     */
 945    if ((ret = mbedtls_pk_write_key_pem(key, *ret_buf, PRIVATE_KEY_BUF_SIZE)) != 0)
 946    {
 947       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
 948       log_error(LOG_LEVEL_ERROR,
 949          "Writing private key into PEM string failed: %s", err_buf);
 950       ret = -1;
 951       goto exit;
 952    }
 953    len = strlen((char *)*ret_buf);
 954
 955    /*
 956     * Saving key into file
 957     */
 958    if ((f = fopen(key_file_path, "wb")) == NULL)
 959    {
 960       log_error(LOG_LEVEL_ERROR,
 961          "Opening file %s to save private key failed: %E",
 962          key_file_path);
 963       ret = -1;
 964       goto exit;
 965    }
 966
 967    if (fwrite(*ret_buf, 1, len, f) != len)
 968    {
 969       fclose(f);
 970       log_error(LOG_LEVEL_ERROR,
 971          "Writing private key into file %s failed",
 972          key_file_path);
 973       ret = -1;
 974       goto exit;
 975    }
 976
 977    fclose(f);
 978
 979 exit:
 980    if (ret < 0)
 981    {
 982       freez(*ret_buf);
 983       *ret_buf = NULL;
 984       return ret;
 985    }
 986    return (int)len;
 987 }
 988
 989
 990 /*********************************************************************
 991  *
 992  * Function    :  generate_key
 993  *
 994  * Description : Tests if private key for host saved in csp already
 995  *               exists.  If this file doesn't exists, a new key is
 996  *               generated and saved in a file. The generated key is also
 997  *               copied into given parameter key_buf, which must be then
 998  *               freed by caller. If file with key exists, key_buf
 999  *               contain NULL and no private key is generated.
1000  *
1001  * Parameters  :
1002  *          1  :  csp = Current client state (buffers, headers, etc...)
1003  *          2  :  key_buf = buffer to save new generated key
1004  *
1005  * Returns     :  -1 => Error while generating private key
1006  *                 0 => Key already exists
1007  *                >0 => Length of generated private key
1008  *
1009  *********************************************************************/
1010 static int generate_key(struct client_state *csp, unsigned char **key_buf)
1011 {
1012    mbedtls_pk_context key;
1013    key_options key_opt;
1014    int ret = 0;
1015    char err_buf[ERROR_BUF_SIZE];
1016
1017    key_opt.key_file_path = NULL;
1018
1019    /*
1020     * Initializing structures for key generating
1021     */
1022    mbedtls_pk_init(&key);
1023
1024    /*
1025     * Preparing path for key file and other properties for generating key
1026     */
1027    key_opt.type        = MBEDTLS_PK_RSA;
1028    key_opt.rsa_keysize = RSA_KEYSIZE;
1029
1030    key_opt.key_file_path = make_certs_path(csp->config->certificate_directory,
1031       (char *)csp->http->hash_of_host_hex, KEY_FILE_TYPE);
1032    if (key_opt.key_file_path == NULL)
1033    {
1034       ret = -1;
1035       goto exit;
1036    }
1037
1038    /*
1039     * Test if key already exists. If so, we don't have to create it again.
1040     */
1041    if (file_exists(key_opt.key_file_path) == 1)
1042    {
1043       ret = 0;
1044       goto exit;
1045    }
1046
1047    /*
1048     * Seed the RNG
1049     */
1050    ret = seed_rng(csp);
1051    if (ret != 0)
1052    {
1053       ret = -1;
1054       goto exit;
1055    }
1056
1057    /*
1058     * Setting attributes of private key and generating it
1059     */
1060    if ((ret = mbedtls_pk_setup(&key,
1061       mbedtls_pk_info_from_type(key_opt.type))) != 0)
1062    {
1063       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1064       log_error(LOG_LEVEL_ERROR, "mbedtls_pk_setup failed: %s", err_buf);
1065       ret = -1;
1066       goto exit;
1067    }
1068
1069    ret = mbedtls_rsa_gen_key(mbedtls_pk_rsa(key), mbedtls_ctr_drbg_random,
1070       &ctr_drbg, (unsigned)key_opt.rsa_keysize, RSA_KEY_PUBLIC_EXPONENT);
1071    if (ret != 0)
1072    {
1073       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1074       log_error(LOG_LEVEL_ERROR, "Key generating failed: %s", err_buf);
1075       ret = -1;
1076       goto exit;
1077    }
1078
1079    /*
1080     * Exporting private key into file
1081     */
1082    if ((ret = write_private_key(&key, key_buf, key_opt.key_file_path)) < 0)
1083    {
1084       log_error(LOG_LEVEL_ERROR,
1085          "Writing private key into file %s failed", key_opt.key_file_path);
1086       ret = -1;
1087       goto exit;
1088    }
1089
1090 exit:
1091    /*
1092     * Freeing used variables
1093     */
1094    freez(key_opt.key_file_path);
1095
1096    mbedtls_pk_free(&key);
1097
1098    return ret;
1099 }
1100
1101
1102 /*********************************************************************
1103  *
1104  * Function    :  ssl_certificate_is_invalid
1105  *
1106  * Description :  Checks whether or not a certificate is valid.
1107  *                Currently only checks that the certificate can be
1108  *                parsed and that the "valid to" date is in the future.
1109  *
1110  * Parameters  :
1111  *          1  :  cert_file = The certificate to check
1112  *
1113  * Returns     :   0 => The certificate is valid.
1114  *                 1 => The certificate is invalid
1115  *
1116  *********************************************************************/
1117 static int ssl_certificate_is_invalid(const char *cert_file)
1118 {
1119    mbedtls_x509_crt cert;
1120    int ret;
1121
1122    mbedtls_x509_crt_init(&cert);
1123
1124    ret = mbedtls_x509_crt_parse_file(&cert, cert_file);
1125    if (ret != 0)
1126    {
1127       char err_buf[ERROR_BUF_SIZE];
1128
1129       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1130       log_error(LOG_LEVEL_ERROR,
1131          "Loading certificate %s to check validity failed: %s",
1132          cert_file, err_buf);
1133       mbedtls_x509_crt_free(&cert);
1134
1135       return 1;
1136    }
1137    if (mbedtls_x509_time_is_past(&cert.valid_to))
1138    {
1139       mbedtls_x509_crt_free(&cert);
1140
1141       return 1;
1142    }
1143
1144    mbedtls_x509_crt_free(&cert);
1145
1146    return 0;
1147
1148 }
1149
1150
1151 /*********************************************************************
1152  *
1153  * Function    :  set_subject_alternative_name
1154  *
1155  * Description :  Sets the Subject Alternative Name extension to a cert
1156  *
1157  * Parameters  :
1158  *          1  :  cert = The certificate to modify
1159  *          2  :  hostname = The hostname to add
1160  *
1161  * Returns     :  <0 => Error while creating certificate.
1162  *                 0 => It worked
1163  *
1164  *********************************************************************/
1165 static int set_subject_alternative_name(mbedtls_x509write_cert *cert, const char *hostname)
1166 {
1167    char err_buf[ERROR_BUF_SIZE];
1168    int ret;
1169    char *subject_alternative_name;
1170    size_t subject_alternative_name_len;
1171 #define MBEDTLS_SUBJECT_ALTERNATIVE_NAME_MAX_LEN 255
1172    unsigned char san_buf[MBEDTLS_SUBJECT_ALTERNATIVE_NAME_MAX_LEN + 1];
1173    unsigned char *c;
1174    int len;
1175
1176    subject_alternative_name_len = strlen(hostname) + 1;
1177    subject_alternative_name = zalloc_or_die(subject_alternative_name_len);
1178
1179    strlcpy(subject_alternative_name, hostname, subject_alternative_name_len);
1180
1181    memset(san_buf, 0, sizeof(san_buf));
1182
1183    c = san_buf + sizeof(san_buf);
1184    len = 0;
1185
1186    ret = mbedtls_asn1_write_raw_buffer(&c, san_buf,
1187       (const unsigned char *)subject_alternative_name,
1188       strlen(subject_alternative_name));
1189    if (ret < 0)
1190    {
1191       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1192       log_error(LOG_LEVEL_ERROR,
1193          "mbedtls_asn1_write_raw_buffer() failed: %s", err_buf);
1194       goto exit;
1195    }
1196    len += ret;
1197
1198    ret = mbedtls_asn1_write_len(&c, san_buf, strlen(subject_alternative_name));
1199    if (ret < 0)
1200    {
1201       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1202       log_error(LOG_LEVEL_ERROR,
1203          "mbedtls_asn1_write_len() failed: %s", err_buf);
1204       goto exit;
1205    }
1206    len += ret;
1207
1208    ret = mbedtls_asn1_write_tag(&c, san_buf, MBEDTLS_ASN1_CONTEXT_SPECIFIC | 2);
1209    if (ret < 0)
1210    {
1211       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1212       log_error(LOG_LEVEL_ERROR,
1213          "mbedtls_asn1_write_tag() failed: %s", err_buf);
1214       goto exit;
1215    }
1216    len += ret;
1217
1218    ret = mbedtls_asn1_write_len(&c, san_buf, (size_t)len);
1219    if (ret < 0)
1220    {
1221       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1222       log_error(LOG_LEVEL_ERROR,
1223          "mbedtls_asn1_write_len() failed: %s", err_buf);
1224       goto exit;
1225    }
1226    len += ret;
1227
1228    ret = mbedtls_asn1_write_tag(&c, san_buf,
1229       MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE);
1230    if (ret < 0)
1231    {
1232       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1233       log_error(LOG_LEVEL_ERROR,
1234          "mbedtls_asn1_write_tag() failed: %s", err_buf);
1235       goto exit;
1236    }
1237    len += ret;
1238
1239    ret = mbedtls_x509write_crt_set_extension(cert,
1240       MBEDTLS_OID_SUBJECT_ALT_NAME,
1241       MBEDTLS_OID_SIZE(MBEDTLS_OID_SUBJECT_ALT_NAME),
1242       0, san_buf + sizeof(san_buf) - len, (size_t)len);
1243    if (ret < 0)
1244    {
1245       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1246       log_error(LOG_LEVEL_ERROR,
1247          "mbedtls_x509write_crt_set_extension() failed: %s", err_buf);
1248    }
1249
1250 exit:
1251    freez(subject_alternative_name);
1252
1253    return ret;
1254
1255 }
1256
1257
1258 /*********************************************************************
1259  *
1260  * Function    :  generate_host_certificate
1261  *
1262  * Description :  Creates certificate file in presetted directory.
1263  *                If certificate already exists, no other certificate
1264  *                will be created. Subject of certificate is named
1265  *                by csp->http->host from parameter. This function also
1266  *                triggers generating of private key for new certificate.
1267  *
1268  * Parameters  :
1269  *          1  :  csp = Current client state (buffers, headers, etc...)
1270  *
1271  * Returns     :  -1 => Error while creating certificate.
1272  *                 0 => Certificate already exists.
1273  *                >0 => Length of created certificate.
1274  *
1275  *********************************************************************/
1276 static int generate_host_certificate(struct client_state *csp)
1277 {
1278    mbedtls_x509_crt issuer_cert;
1279    mbedtls_pk_context loaded_issuer_key, loaded_subject_key;
1280    mbedtls_pk_context *issuer_key  = &loaded_issuer_key;
1281    mbedtls_pk_context *subject_key = &loaded_subject_key;
1282    mbedtls_x509write_cert cert;
1283    mbedtls_mpi serial;
1284
1285    unsigned char *key_buf = NULL;    /* Buffer for created key */
1286
1287    int ret = 0;
1288    char err_buf[ERROR_BUF_SIZE];
1289    cert_options cert_opt;
1290    char cert_valid_from[VALID_DATETIME_BUFLEN];
1291    char cert_valid_to[VALID_DATETIME_BUFLEN];
1292
1293    /* Paths to keys and certificates needed to create certificate */
1294    cert_opt.issuer_key  = NULL;
1295    cert_opt.subject_key = NULL;
1296    cert_opt.issuer_crt  = NULL;
1297
1298    cert_opt.output_file = make_certs_path(csp->config->certificate_directory,
1299       (const char *)csp->http->hash_of_host_hex, CERT_FILE_TYPE);
1300    if (cert_opt.output_file == NULL)
1301    {
1302       return -1;
1303    }
1304
1305    cert_opt.subject_key = make_certs_path(csp->config->certificate_directory,
1306       (const char *)csp->http->hash_of_host_hex, KEY_FILE_TYPE);
1307    if (cert_opt.subject_key == NULL)
1308    {
1309       freez(cert_opt.output_file);
1310       return -1;
1311    }
1312
1313    if (enforce_sane_certificate_state(cert_opt.output_file,
1314          cert_opt.subject_key))
1315    {
1316       freez(cert_opt.output_file);
1317       freez(cert_opt.subject_key);
1318
1319       return -1;
1320    }
1321
1322    if (file_exists(cert_opt.output_file) == 1)
1323    {
1324       /* The file exists, but is it valid? */
1325       if (ssl_certificate_is_invalid(cert_opt.output_file))
1326       {
1327          log_error(LOG_LEVEL_CONNECT,
1328             "Certificate %s is no longer valid. Removing it.",
1329             cert_opt.output_file);
1330          if (unlink(cert_opt.output_file))
1331          {
1332             log_error(LOG_LEVEL_ERROR, "Failed to unlink %s: %E",
1333                cert_opt.output_file);
1334
1335             freez(cert_opt.output_file);
1336             freez(cert_opt.subject_key);
1337
1338             return -1;
1339          }
1340          if (unlink(cert_opt.subject_key))
1341          {
1342             log_error(LOG_LEVEL_ERROR, "Failed to unlink %s: %E",
1343                cert_opt.subject_key);
1344
1345             freez(cert_opt.output_file);
1346             freez(cert_opt.subject_key);
1347
1348             return -1;
1349          }
1350       }
1351       else
1352       {
1353          freez(cert_opt.output_file);
1354          freez(cert_opt.subject_key);
1355
1356          return 0;
1357       }
1358    }
1359
1360    /*
1361     * Create key for requested host
1362     */
1363    int subject_key_len = generate_key(csp, &key_buf);
1364    if (subject_key_len < 0)
1365    {
1366       freez(cert_opt.output_file);
1367       freez(cert_opt.subject_key);
1368       log_error(LOG_LEVEL_ERROR, "Key generating failed");
1369       return -1;
1370    }
1371
1372    /*
1373     * Initializing structures for certificate generating
1374     */
1375    mbedtls_x509write_crt_init(&cert);
1376    mbedtls_x509write_crt_set_md_alg(&cert, CERT_SIGNATURE_ALGORITHM);
1377    mbedtls_pk_init(&loaded_issuer_key);
1378    mbedtls_pk_init(&loaded_subject_key);
1379    mbedtls_mpi_init(&serial);
1380    mbedtls_x509_crt_init(&issuer_cert);
1381
1382    /*
1383     * Presetting parameters for certificate. We must compute total length
1384     * of parameters.
1385     */
1386    size_t cert_params_len = strlen(CERT_PARAM_COMMON_NAME) +
1387       strlen(CERT_PARAM_ORGANIZATION) + strlen(CERT_PARAM_COUNTRY) +
1388       strlen(CERT_PARAM_ORG_UNIT) +
1389       3 * strlen(csp->http->host) + 1;
1390    char cert_params[cert_params_len];
1391    memset(cert_params, 0, cert_params_len);
1392
1393    /*
1394     * Converting unsigned long serial number to char * serial number.
1395     * We must compute length of serial number in string + terminating null.
1396     */
1397    unsigned long certificate_serial = get_certificate_serial(csp);
1398    unsigned long certificate_serial_time = (unsigned long)time(NULL);
1399    int serial_num_size = snprintf(NULL, 0, "%lu%lu",
1400       certificate_serial_time, certificate_serial) + 1;
1401    if (serial_num_size <= 0)
1402    {
1403       serial_num_size = 1;
1404    }
1405
1406    char serial_num_text[serial_num_size];  /* Buffer for serial number */
1407    ret = snprintf(serial_num_text, (size_t)serial_num_size, "%lu%lu",
1408       certificate_serial_time, certificate_serial);
1409    if (ret < 0 || ret >= serial_num_size)
1410    {
1411       log_error(LOG_LEVEL_ERROR,
1412          "Converting certificate serial number into string failed");
1413       ret = -1;
1414       goto exit;
1415    }
1416
1417    /*
1418     * Preparing parameters for certificate
1419     */
1420    strlcpy(cert_params, CERT_PARAM_COMMON_NAME,  cert_params_len);
1421    strlcat(cert_params, csp->http->host,         cert_params_len);
1422    strlcat(cert_params, CERT_PARAM_ORGANIZATION, cert_params_len);
1423    strlcat(cert_params, csp->http->host,         cert_params_len);
1424    strlcat(cert_params, CERT_PARAM_ORG_UNIT,     cert_params_len);
1425    strlcat(cert_params, csp->http->host,         cert_params_len);
1426    strlcat(cert_params, CERT_PARAM_COUNTRY,      cert_params_len);
1427
1428    cert_opt.issuer_crt = csp->config->ca_cert_file;
1429    cert_opt.issuer_key = csp->config->ca_key_file;
1430
1431    if (get_certificate_valid_from_date(cert_valid_from, sizeof(cert_valid_from), VALID_DATETIME_FMT)
1432     || get_certificate_valid_to_date(cert_valid_to, sizeof(cert_valid_to), VALID_DATETIME_FMT))
1433    {
1434       log_error(LOG_LEVEL_ERROR, "Generating one of the validity dates failed");
1435       ret = -1;
1436       goto exit;
1437    }
1438
1439    cert_opt.subject_pwd   = CERT_SUBJECT_PASSWORD;
1440    cert_opt.issuer_pwd    = csp->config->ca_password;
1441    cert_opt.subject_name  = cert_params;
1442    cert_opt.not_before    = cert_valid_from;
1443    cert_opt.not_after     = cert_valid_to;
1444    cert_opt.serial        = serial_num_text;
1445    cert_opt.is_ca         = 0;
1446    cert_opt.max_pathlen   = -1;
1447
1448    /*
1449     * Test if the private key was already created.
1450     * XXX: Can this still happen?
1451     */
1452    if (subject_key_len == 0)
1453    {
1454       log_error(LOG_LEVEL_ERROR, "Subject key was already created");
1455       ret = 0;
1456       goto exit;
1457    }
1458
1459    /*
1460     * Seed the PRNG
1461     */
1462    ret = seed_rng(csp);
1463    if (ret != 0)
1464    {
1465       ret = -1;
1466       goto exit;
1467    }
1468
1469    /*
1470     * Parse serial to MPI
1471     */
1472    ret = mbedtls_mpi_read_string(&serial, 10, cert_opt.serial);
1473    if (ret != 0)
1474    {
1475       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1476       log_error(LOG_LEVEL_ERROR,
1477          "mbedtls_mpi_read_string failed: %s", err_buf);
1478       ret = -1;
1479       goto exit;
1480    }
1481
1482    /*
1483     * Loading certificates
1484     */
1485    ret = mbedtls_x509_crt_parse_file(&issuer_cert, cert_opt.issuer_crt);
1486    if (ret != 0)
1487    {
1488       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1489       log_error(LOG_LEVEL_ERROR, "Loading issuer certificate %s failed: %s",
1490          cert_opt.issuer_crt, err_buf);
1491       ret = -1;
1492       goto exit;
1493    }
1494
1495    ret = mbedtls_x509_dn_gets(cert_opt.issuer_name,
1496       sizeof(cert_opt.issuer_name), &issuer_cert.subject);
1497    if (ret < 0)
1498    {
1499       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1500       log_error(LOG_LEVEL_ERROR, "mbedtls_x509_dn_gets failed: %s", err_buf);
1501       ret = -1;
1502       goto exit;
1503    }
1504
1505    /*
1506     * Loading keys from file or from buffer
1507     */
1508    if (key_buf != NULL && subject_key_len > 0)
1509    {
1510       /* Key was created in this function and is stored in buffer */
1511       ret = mbedtls_pk_parse_key(&loaded_subject_key, key_buf,
1512          (size_t)(subject_key_len + 1), (unsigned const char *)
1513          cert_opt.subject_pwd, strlen(cert_opt.subject_pwd));
1514    }
1515    else
1516    {
1517       /* Key wasn't created in this function, because it already existed */
1518       ret = mbedtls_pk_parse_keyfile(&loaded_subject_key,
1519          cert_opt.subject_key, cert_opt.subject_pwd);
1520    }
1521
1522    if (ret != 0)
1523    {
1524       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1525       log_error(LOG_LEVEL_ERROR, "Parsing subject key %s failed: %s",
1526          cert_opt.subject_key, err_buf);
1527       ret = -1;
1528       goto exit;
1529    }
1530
1531    ret = mbedtls_pk_parse_keyfile(&loaded_issuer_key, cert_opt.issuer_key,
1532       cert_opt.issuer_pwd);
1533    if (ret != 0)
1534    {
1535       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1536       log_error(LOG_LEVEL_ERROR,
1537          "Parsing issuer key %s failed: %s", cert_opt.issuer_key, err_buf);
1538       ret = -1;
1539       goto exit;
1540    }
1541
1542    /*
1543     * Check if key and issuer certificate match
1544     */
1545    if (!mbedtls_pk_can_do(&issuer_cert.pk, MBEDTLS_PK_RSA) ||
1546       mbedtls_mpi_cmp_mpi(&mbedtls_pk_rsa(issuer_cert.pk)->N,
1547          &mbedtls_pk_rsa(*issuer_key)->N) != 0 ||
1548       mbedtls_mpi_cmp_mpi(&mbedtls_pk_rsa(issuer_cert.pk)->E,
1549          &mbedtls_pk_rsa(*issuer_key)->E) != 0)
1550    {
1551       log_error(LOG_LEVEL_ERROR,
1552          "Issuer key doesn't match issuer certificate");
1553       ret = -1;
1554       goto exit;
1555    }
1556
1557    mbedtls_x509write_crt_set_subject_key(&cert, subject_key);
1558    mbedtls_x509write_crt_set_issuer_key(&cert, issuer_key);
1559
1560    /*
1561     * Setting parameters of signed certificate
1562     */
1563    ret = mbedtls_x509write_crt_set_subject_name(&cert, cert_opt.subject_name);
1564    if (ret != 0)
1565    {
1566       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1567       log_error(LOG_LEVEL_ERROR,
1568          "Setting subject name in signed certificate failed: %s", err_buf);
1569       ret = -1;
1570       goto exit;
1571    }
1572
1573    ret = mbedtls_x509write_crt_set_issuer_name(&cert, cert_opt.issuer_name);
1574    if (ret != 0)
1575    {
1576       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1577       log_error(LOG_LEVEL_ERROR,
1578          "Setting issuer name in signed certificate failed: %s", err_buf);
1579       ret = -1;
1580       goto exit;
1581    }
1582
1583    ret = mbedtls_x509write_crt_set_serial(&cert, &serial);
1584    if (ret != 0)
1585    {
1586       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1587       log_error(LOG_LEVEL_ERROR,
1588          "Setting serial number in signed certificate failed: %s", err_buf);
1589       ret = -1;
1590       goto exit;
1591    }
1592
1593    ret = mbedtls_x509write_crt_set_validity(&cert, cert_opt.not_before,
1594       cert_opt.not_after);
1595    if (ret != 0)
1596    {
1597       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1598       log_error(LOG_LEVEL_ERROR,
1599          "Setting validity in signed certificate failed: %s", err_buf);
1600       ret = -1;
1601       goto exit;
1602    }
1603
1604    /*
1605     * Setting the basicConstraints extension for certificate
1606     */
1607    ret = mbedtls_x509write_crt_set_basic_constraints(&cert, cert_opt.is_ca,
1608       cert_opt.max_pathlen);
1609    if (ret != 0)
1610    {
1611       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1612       log_error(LOG_LEVEL_ERROR, "Setting the basicConstraints extension "
1613          "in signed certificate failed: %s", err_buf);
1614       ret = -1;
1615       goto exit;
1616    }
1617
1618 #if defined(MBEDTLS_SHA1_C)
1619    /* Setting the subjectKeyIdentifier extension for certificate */
1620    ret = mbedtls_x509write_crt_set_subject_key_identifier(&cert);
1621    if (ret != 0)
1622    {
1623       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1624       log_error(LOG_LEVEL_ERROR, "mbedtls_x509write_crt_set_subject_key_"
1625          "identifier failed: %s", err_buf);
1626       ret = -1;
1627       goto exit;
1628    }
1629
1630    /* Setting the authorityKeyIdentifier extension for certificate */
1631    ret = mbedtls_x509write_crt_set_authority_key_identifier(&cert);
1632    if (ret != 0)
1633    {
1634       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1635       log_error(LOG_LEVEL_ERROR, "mbedtls_x509write_crt_set_authority_key_"
1636          "identifier failed: %s", err_buf);
1637       ret = -1;
1638       goto exit;
1639    }
1640 #endif /* MBEDTLS_SHA1_C */
1641
1642    if (!host_is_ip_address(csp->http->host) &&
1643       set_subject_alternative_name(&cert, csp->http->host))
1644    {
1645       /* Errors are already logged by set_subject_alternative_name() */
1646       ret = -1;
1647       goto exit;
1648    }
1649
1650    /*
1651     * Writing certificate into file
1652     */
1653    ret = write_certificate(&cert, cert_opt.output_file,
1654       mbedtls_ctr_drbg_random, &ctr_drbg);
1655    if (ret < 0)
1656    {
1657       log_error(LOG_LEVEL_ERROR, "Writing certificate into file failed");
1658       goto exit;
1659    }
1660
1661 exit:
1662    /*
1663     * Freeing used structures
1664     */
1665    mbedtls_x509write_crt_free(&cert);
1666    mbedtls_pk_free(&loaded_subject_key);
1667    mbedtls_pk_free(&loaded_issuer_key);
1668    mbedtls_mpi_free(&serial);
1669    mbedtls_x509_crt_free(&issuer_cert);
1670
1671    freez(cert_opt.subject_key);
1672    freez(cert_opt.output_file);
1673    freez(key_buf);
1674
1675    return ret;
1676 }
1677
1678 /*********************************************************************
1679  *
1680  * Function    :  ssl_verify_callback
1681  *
1682  * Description :  This is a callback function for certificate verification.
1683  *                It's called once for each certificate in the server's
1684  *                certificate trusted chain and prepares information about
1685  *                the certificate. The information can be used to inform
1686  *                the user about invalid certificates.
1687  *
1688  * Parameters  :
1689  *          1  :  csp_void = Current client state (buffers, headers, etc...)
1690  *          2  :  crt   = certificate from trusted chain
1691  *          3  :  depth = depth in trusted chain
1692  *          4  :  flags = certificate flags
1693  *
1694  * Returns     :  0 on success and negative value on error
1695  *
1696  *********************************************************************/
1697 static int ssl_verify_callback(void *csp_void, mbedtls_x509_crt *crt,
1698    int depth, uint32_t *flags)
1699 {
1700    struct client_state *csp  = (struct client_state *)csp_void;
1701    struct certs_chain  *last = &(csp->server_certs_chain);
1702    size_t olen = 0;
1703    int ret = 0;
1704
1705    /*
1706     * Searching for last item in certificates linked list
1707     */
1708    while (last->next != NULL)
1709    {
1710       last = last->next;
1711    }
1712
1713    /*
1714     * Preparing next item in linked list for next certificate
1715     */
1716    last->next = malloc_or_die(sizeof(struct certs_chain));
1717    last->next->next = NULL;
1718    memset(last->next->info_buf, 0, sizeof(last->next->info_buf));
1719    memset(last->next->file_buf, 0, sizeof(last->next->file_buf));
1720
1721    /*
1722     * Saving certificate file into buffer
1723     */
1724    if ((ret = mbedtls_pem_write_buffer(PEM_BEGIN_CRT, PEM_END_CRT,
1725       crt->raw.p, crt->raw.len, (unsigned char *)last->file_buf,
1726       sizeof(last->file_buf)-1, &olen)) != 0)
1727    {
1728       char err_buf[ERROR_BUF_SIZE];
1729
1730       mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1731       log_error(LOG_LEVEL_ERROR, "mbedtls_pem_write_buffer() failed: %s",
1732          err_buf);
1733
1734       return(ret);
1735    }
1736
1737    /*
1738     * Saving certificate information into buffer
1739     */
1740    {
1741       char buf[CERT_INFO_BUF_SIZE];
1742       char *encoded_text;
1743 #define CERT_INFO_PREFIX                 ""
1744
1745       mbedtls_x509_crt_info(buf, sizeof(buf), CERT_INFO_PREFIX, crt);
1746       encoded_text = html_encode(buf);
1747       if (encoded_text == NULL)
1748       {
1749          log_error(LOG_LEVEL_ERROR,
1750             "Failed to HTML-encode the certificate information");
1751          return -1;
1752       }
1753       strlcpy(last->info_buf, encoded_text, sizeof(last->info_buf));
1754       freez(encoded_text);
1755    }
1756
1757    return 0;
1758 }
1759
1760
1761 /*********************************************************************
1762  *
1763  * Function    :  host_to_hash
1764  *
1765  * Description :  Creates MD5 hash from host name. Host name is loaded
1766  *                from structure csp and saved again into it.
1767  *
1768  * Parameters  :
1769  *          1  :  csp = Current client state (buffers, headers, etc...)
1770  *
1771  * Returns     :  1 => Error while creating hash
1772  *                0 => Hash created successfully
1773  *
1774  *********************************************************************/
1775 static int host_to_hash(struct client_state *csp)
1776 {
1777    int ret = 0;
1778
1779 #if !defined(MBEDTLS_MD5_C)
1780 #error mbedTLS needs to be compiled with md5 support
1781 #else
1782    memset(csp->http->hash_of_host, 0, sizeof(csp->http->hash_of_host));
1783    ret = mbedtls_md5_ret((unsigned char *)csp->http->host,
1784       strlen(csp->http->host), csp->http->hash_of_host);
1785    if (ret != 0)
1786    {
1787       log_error(LOG_LEVEL_ERROR,
1788          "Failed to generate md5 hash of host %s: %d",
1789          csp->http->host, ret);
1790       return -1;
1791    }
1792
1793    /* Converting hash into string with hex */
1794    size_t i = 0;
1795    for (; i < 16; i++)
1796    {
1797       if ((ret = sprintf((char *)csp->http->hash_of_host_hex + 2 * i, "%02x",
1798          csp->http->hash_of_host[i])) < 0)
1799       {
1800          log_error(LOG_LEVEL_ERROR, "Sprintf return value: %d", ret);
1801          return -1;
1802       }
1803    }
1804
1805    return 0;
1806 #endif /* MBEDTLS_MD5_C */
1807 }
1808
1809 /*********************************************************************
1810  *
1811  * Function    :  seed_rng
1812  *
1813  * Description :  Seeding the RNG for all SSL uses
1814  *
1815  * Parameters  :
1816  *          1  :  csp = Current client state (buffers, headers, etc...)
1817  *
1818  * Returns     : -1 => RNG wasn't seed successfully
1819  *                0 => RNG is seeded successfully
1820  *
1821  *********************************************************************/
1822 static int seed_rng(struct client_state *csp)
1823 {
1824    int ret = 0;
1825    char err_buf[ERROR_BUF_SIZE];
1826
1827    if (rng_seeded == 0)
1828    {
1829       privoxy_mutex_lock(&ssl_init_mutex);
1830       if (rng_seeded == 0)
1831       {
1832          mbedtls_ctr_drbg_init(&ctr_drbg);
1833          mbedtls_entropy_init(&entropy);
1834          ret = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func,
1835             &entropy, NULL, 0);
1836          if (ret != 0)
1837          {
1838             mbedtls_strerror(ret, err_buf, sizeof(err_buf));
1839             log_error(LOG_LEVEL_ERROR,
1840                "mbedtls_ctr_drbg_seed failed: %s", err_buf);
1841             privoxy_mutex_unlock(&ssl_init_mutex);
1842             return -1;
1843          }
1844          rng_seeded = 1;
1845       }
1846       privoxy_mutex_unlock(&ssl_init_mutex);
1847    }
1848    return 0;
1849 }
1850
1851
1852 /*********************************************************************
1853  *
1854  * Function    :  ssl_base64_encode
1855  *
1856  * Description :  Encode a buffer into base64 format.
1857  *
1858  * Parameters  :
1859  *          1  :  dst = Destination buffer
1860  *          2  :  dlen = Destination buffer length
1861  *          3  :  olen = Number of bytes written
1862  *          4  :  src = Source buffer
1863  *          5  :  slen = Amount of data to be encoded
1864  *
1865  * Returns     :  0 on success, error code othervise
1866  *
1867  *********************************************************************/
1868 extern int ssl_base64_encode(unsigned char *dst, size_t dlen, size_t *olen,
1869                              const unsigned char *src, size_t slen)
1870 {
1871    return mbedtls_base64_encode(dst, dlen, olen, src, slen);
1872 }
1873
1874
1875 /*********************************************************************
1876  *
1877  * Function    :  ssl_crt_verify_info
1878  *
1879  * Description :  Returns an informational string about the verification
1880  *                status of a certificate.
1881  *
1882  * Parameters  :
1883  *          1  :  buf = Buffer to write to
1884  *          2  :  size = Maximum size of buffer
1885  *          3  :  csp = client state
1886  *
1887  * Returns     :  N/A
1888  *
1889  *********************************************************************/
1890 extern void ssl_crt_verify_info(char *buf, size_t size, struct client_state *csp)
1891 {
1892    char *last_byte;
1893
1894    mbedtls_x509_crt_verify_info(buf, size, "",
1895       csp->server_cert_verification_result);
1896    last_byte = buf + strlen(buf)-1;
1897    if (*last_byte == '\n')
1898    {
1899       /* Overwrite trailing new line character */
1900       *last_byte = '\0';
1901    }
1902 }
1903
1904
1905 /*********************************************************************
1906  *
1907  * Function    :  ssl_release
1908  *
1909  * Description :  Release all SSL resources
1910  *
1911  * Parameters  :
1912  *
1913  * Returns     :  N/A
1914  *
1915  *********************************************************************/
1916 extern void ssl_release(void)
1917 {
1918    if (rng_seeded == 1)
1919    {
1920       mbedtls_ctr_drbg_free(&ctr_drbg);
1921       mbedtls_entropy_free(&entropy);
1922    }
1923 }
1924
1925
1926 /*********************************************************************
1927  *
1928  * Function    :  get_ciphersuites_from_string
1929  *
1930  * Description :  Converts a string of ciphersuite names to
1931  *                an array of ciphersuite ids.
1932  *
1933  * Parameters  :
1934  *          1  :  ciphersuites_string = String containing allowed
1935  *                ciphersuites.
1936  *
1937  * Returns     :  Array of ciphersuite ids
1938  *
1939  *********************************************************************/
1940 static int *get_ciphersuites_from_string(const char *parameter_string)
1941 {
1942    char *ciphersuites_index;
1943    char *item_end;
1944    char *ciphersuites_string;
1945    int *ciphersuite_ids;
1946    size_t count = 2;
1947    int index = 0;
1948    const char separator = ':';
1949    size_t parameter_len = strlen(parameter_string);
1950
1951    ciphersuites_string = zalloc_or_die(parameter_len + 1);
1952    strncpy(ciphersuites_string, parameter_string, parameter_len);
1953    ciphersuites_index = ciphersuites_string;
1954
1955    while (*ciphersuites_index)
1956    {
1957       if (*ciphersuites_index++ == separator)
1958       {
1959          ++count;
1960       }
1961    }
1962
1963    ciphersuite_ids = zalloc_or_die(count * sizeof(int));
1964
1965    ciphersuites_index = ciphersuites_string;
1966    do
1967    {
1968       item_end = strchr(ciphersuites_index, separator);
1969       if (item_end != NULL)
1970       {
1971          *item_end = '\0';
1972       }
1973
1974       ciphersuite_ids[index] =
1975          mbedtls_ssl_get_ciphersuite_id(ciphersuites_index);
1976       if (ciphersuite_ids[index] == 0)
1977       {
1978          log_error(LOG_LEVEL_ERROR,
1979             "Failed to get ciphersuite id for %s", ciphersuites_index);
1980          freez(ciphersuite_ids);
1981          freez(ciphersuites_string);
1982          return NULL;
1983       }
1984       ciphersuites_index = item_end + 1;
1985       index++;
1986    } while (item_end != NULL);
1987
1988    ciphersuite_ids[index] = 0;
1989    freez(ciphersuites_string);
1990
1991    return ciphersuite_ids;
1992
1993 }