ssl_common.c

   1 /*********************************************************************
   2  *
   3  * File        :  $Source: /cvsroot/ijbswa/current/ssl_common.c,v $
   4  *
   5  * Purpose     :  File with TLS/SSL extension. Contains methods for
   6  *                creating, using and closing TLS/SSL connections that do
   7  *                not depend on particular TLS/SSL library.
   8  *
   9  * Copyright   :  Written by and Copyright (c) 2017 Vaclav Svec. FIT CVUT.
  10  *                Copyright (C) 2018-2020 by Fabian Keil <fk@fabiankeil.de>
  11  *
  12  *                This program is free software; you can redistribute it
  13  *                and/or modify it under the terms of the GNU General
  14  *                Public License as published by the Free Software
  15  *                Foundation; either version 2 of the License, or (at
  16  *                your option) any later version.
  17  *
  18  *                This program is distributed in the hope that it will
  19  *                be useful, but WITHOUT ANY WARRANTY; without even the
  20  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  21  *                PARTICULAR PURPOSE.  See the GNU General Public
  22  *                License for more details.
  23  *
  24  *                The GNU General Public License should be included with
  25  *                this file.  If not, you can view it at
  26  *                http://www.gnu.org/copyleft/gpl.html
  27  *                or write to the Free Software Foundation, Inc., 59
  28  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  29  *
  30  *********************************************************************/
  31 #include <string.h>
  32
  33 #include <ctype.h>
  34 #include "config.h"
  35 #include "project.h"
  36 #include "miscutil.h"
  37 #include "errlog.h"
  38 #include "ssl.h"
  39 #include "ssl_common.h"
  40
  41 /*
  42  * Macros for ssl_common.c
  43  */
  44 #define CERT_SERIAL_NUM_LENGTH           4                 /* Bytes of hash to be used for creating serial number of certificate. Min=2 and max=16 */
  45
  46 /*********************************************************************
  47  *
  48  * Function    :  client_use_ssl
  49  *
  50  * Description :  Tests if client in current client state structure
  51  *                should use SSL connection or standard connection.
  52  *
  53  * Parameters  :
  54  *          1  :  csp = Current client state (buffers, headers, etc...)
  55  *
  56  * Returns     :  If client should use TLS/SSL connection, 1 is returned.
  57  *                Otherwise 0 is returned.
  58  *
  59  *********************************************************************/
  60 extern int client_use_ssl(const struct client_state *csp)
  61 {
  62    return csp->http->client_ssl;
  63 }
  64
  65
  66 /*********************************************************************
  67  *
  68  * Function    :  server_use_ssl
  69  *
  70  * Description :  Tests if server in current client state structure
  71  *                should use SSL connection or standard connection.
  72  *
  73  * Parameters  :
  74  *          1  :  csp = Current client state (buffers, headers, etc...)
  75  *
  76  * Returns     :  If server should use TLS/SSL connection, 1 is returned.
  77  *                Otherwise 0 is returned.
  78  *
  79  *********************************************************************/
  80 extern int server_use_ssl(const struct client_state *csp)
  81 {
  82    return csp->http->server_ssl;
  83 }
  84
  85
  86 /*********************************************************************
  87  *
  88  * Function    :  ssl_send_data_delayed
  89  *
  90  * Description :  Sends the contents of buf (for n bytes) to given SSL
  91  *                connection, optionally delaying the operation.
  92  *
  93  * Parameters  :
  94  *          1  :  ssl_attr = SSL context to send data to
  95  *          2  :  buf = Pointer to data to be sent
  96  *          3  :  len = Length of data to be sent to the SSL context
  97  *          4  :  delay = Delay in milliseconds.
  98  *
  99  * Returns     :  0 on success (entire buffer sent).
 100  *                nonzero on error.
 101  *
 102  *********************************************************************/
 103 extern int ssl_send_data_delayed(struct ssl_attr* ssl_attr,
 104                                  const unsigned char *buf, size_t len,
 105                                  unsigned int delay)
 106 {
 107    size_t i = 0;
 108
 109    if (delay == 0)
 110    {
 111       if (ssl_send_data(ssl_attr, buf, len) < 0)
 112       {
 113          return -1;
 114       }
 115       else
 116       {
 117          return 0;
 118       }
 119    }
 120
 121    while (i < len)
 122    {
 123       size_t write_length;
 124       enum { MAX_WRITE_LENGTH = 10 };
 125
 126       if ((i + MAX_WRITE_LENGTH) > len)
 127       {
 128          write_length = len - i;
 129       }
 130       else
 131       {
 132          write_length = MAX_WRITE_LENGTH;
 133       }
 134
 135       privoxy_millisleep(delay);
 136
 137       if (ssl_send_data(ssl_attr, buf + i, write_length) < 0)
 138       {
 139          return -1;
 140       }
 141       i += write_length;
 142    }
 143
 144    return 0;
 145
 146 }
 147
 148
 149 /*********************************************************************
 150  *
 151  * Function    :  ssl_flush_socket
 152  *
 153  * Description :  Send any pending "buffered" content with given
 154  *                SSL connection. Alternative to function flush_socket.
 155  *
 156  * Parameters  :
 157  *          1  :  ssl_attr = SSL context to send buffer to
 158  *          2  :  iob = The I/O buffer to flush, usually csp->iob.
 159  *
 160  * Returns     :  On success, the number of bytes send are returned (zero
 161  *                indicates nothing was sent).  On error, -1 is returned.
 162  *
 163  *********************************************************************/
 164 extern long ssl_flush_socket(struct ssl_attr *ssl_attr, struct iob *iob)
 165 {
 166    /* Computing length of buffer part to send */
 167    long len = iob->eod - iob->cur;
 168
 169    if (len <= 0)
 170    {
 171       return(0);
 172    }
 173
 174    /* Sending data to given SSl context */
 175    if (ssl_send_data(ssl_attr, (const unsigned char *)iob->cur, (size_t)len) < 0)
 176    {
 177       return -1;
 178    }
 179    iob->eod = iob->cur = iob->buf;
 180    return(len);
 181 }
 182
 183
 184 /*********************************************************************
 185  *
 186  * Function    :  close_client_and_server_ssl_connections
 187  *
 188  * Description :  Checks if client or server should use secured
 189  *                connection over SSL and if so, closes all of them.
 190  *
 191  * Parameters  :
 192  *          1  :  csp = Current client state (buffers, headers, etc...)
 193  *
 194  * Returns     :  N/A
 195  *
 196  *********************************************************************/
 197 extern void close_client_and_server_ssl_connections(struct client_state *csp)
 198 {
 199    if (client_use_ssl(csp) == 1)
 200    {
 201       close_client_ssl_connection(csp);
 202    }
 203    if (server_use_ssl(csp) == 1)
 204    {
 205       close_server_ssl_connection(csp);
 206    }
 207 }
 208
 209
 210 /*********************************************************************
 211  *
 212  * Function    :  tunnel_established_successfully
 213  *
 214  * Description :  Check if parent proxy server response contains
 215  *                information about successfully created connection with
 216  *                destination server. (HTTP/... 2xx ...)
 217  *
 218  * Parameters  :
 219  *          1  :  server_response = Buffer with parent proxy server response
 220  *          2  :  response_len = Length of server_response
 221  *
 222  * Returns     :  1 => Connection created successfully
 223  *                0 => Connection wasn't created successfully
 224  *
 225  *********************************************************************/
 226 extern int tunnel_established_successfully(const char *server_response,
 227    unsigned int response_len)
 228 {
 229    unsigned int pos = 0;
 230
 231    if (server_response == NULL)
 232    {
 233       return 0;
 234    }
 235
 236    /* Tests if "HTTP/" string is at the begin of received response */
 237    if (strncmp(server_response, "HTTP/", 5) != 0)
 238    {
 239       return 0;
 240    }
 241
 242    for (pos = 0; pos < response_len; pos++)
 243    {
 244       if (server_response[pos] == ' ')
 245       {
 246          break;
 247       }
 248    }
 249
 250    /*
 251     * response_len -3 because of buffer end, response structure and 200 code.
 252     * There must be at least 3 chars after space.
 253     * End of buffer: ... 2xx'\0'
 254     *             pos = |
 255     */
 256    if (pos >= (response_len - 3))
 257    {
 258       return 0;
 259    }
 260
 261    /* Test HTTP status code */
 262    if (server_response[pos + 1] != '2')
 263    {
 264       return 0;
 265    }
 266
 267    return 1;
 268 }
 269
 270
 271 /*********************************************************************
 272  *
 273  * Function    :  free_certificate_chain
 274  *
 275  * Description :  Frees certificates linked list. This linked list is
 276  *                used to save information about certificates in
 277  *                trusted chain.
 278  *
 279  * Parameters  :
 280  *          1  :  csp = Current client state (buffers, headers, etc...)
 281  *
 282  * Returns     :  N/A
 283  *
 284  *********************************************************************/
 285 extern void free_certificate_chain(struct client_state *csp)
 286 {
 287    struct certs_chain *cert = csp->server_certs_chain.next;
 288
 289    /* Cleaning buffers */
 290    memset(csp->server_certs_chain.info_buf, 0,
 291       sizeof(csp->server_certs_chain.info_buf));
 292    memset(csp->server_certs_chain.file_buf, 0,
 293       sizeof(csp->server_certs_chain.file_buf));
 294    csp->server_certs_chain.next = NULL;
 295
 296    /* Freeing memory in whole linked list */
 297    while (cert != NULL)
 298    {
 299       struct certs_chain *cert_for_free = cert;
 300       cert = cert->next;
 301       freez(cert_for_free);
 302    }
 303 }
 304
 305
 306 /*********************************************************************
 307  *
 308  * Function    :  ssl_send_certificate_error
 309  *
 310  * Description :  Sends info about invalid server certificate to client.
 311  *                Sent message is including all trusted chain certificates,
 312  *                that can be downloaded in web browser.
 313  *
 314  * Parameters  :
 315  *          1  :  csp = Current client state (buffers, headers, etc...)
 316  *
 317  * Returns     :  N/A
 318  *
 319  *********************************************************************/
 320 extern void ssl_send_certificate_error(struct client_state *csp)
 321 {
 322    struct ssl_attr *ssl_attr = &csp->ssl_client_attr;
 323    size_t message_len = 0;
 324    int ret = 0;
 325    struct certs_chain *cert = NULL;
 326    const size_t head_length = 63;
 327
 328    /* Header of message with certificate information */
 329    const char message_begin[] =
 330       "HTTP/1.1 200 OK\r\n"
 331       "Content-Type: text/html\r\n"
 332       "Connection: close\r\n\r\n"
 333       "<!DOCTYPE html>\n"
 334       "<html><head><title>Server certificate verification failed</title></head>\n"
 335       "<body><h1>Server certificate verification failed</h1>\n"
 336       "<p><a href=\"https://" CGI_SITE_2_HOST "/\">Privoxy</a> was unable "
 337       "to securely connect to the destination server.</p>"
 338       "<p>Reason: ";
 339    const char message_end[] = "</body></html>\r\n\r\n";
 340    char reason[INVALID_CERT_INFO_BUF_SIZE];
 341    memset(reason, 0, sizeof(reason));
 342
 343    /* Get verification message from verification return code */
 344    ssl_crt_verify_info(reason, sizeof(reason), csp);
 345
 346    /*
 347     * Computing total length of message with all certificates inside
 348     */
 349    message_len = strlen(message_begin) + strlen(message_end)
 350                  + strlen(reason) + strlen("</p>") + 1;
 351
 352    cert = &(csp->server_certs_chain);
 353    while (cert->next != NULL)
 354    {
 355       size_t base64_len = 4 * ((strlen(cert->file_buf) + 2) / 3) + 1;
 356
 357       message_len += strlen(cert->info_buf) + strlen("<pre></pre>\n")
 358                      +  base64_len + strlen("<a href=\"data:application"
 359                         "/x-x509-ca-cert;base64,\">Download certificate</a>");
 360       cert = cert->next;
 361    }
 362
 363    /*
 364     * Joining all blocks in one long message
 365     */
 366    char message[message_len];
 367    memset(message, 0, message_len);
 368
 369    strlcpy(message, message_begin, message_len);
 370    strlcat(message, reason       , message_len);
 371    strlcat(message, "</p>"       , message_len);
 372
 373    cert = &(csp->server_certs_chain);
 374    while (cert->next != NULL)
 375    {
 376       size_t olen = 0;
 377       size_t base64_len = 4 * ((strlen(cert->file_buf) + 2) / 3) + 1; /* +1 for terminating null*/
 378       char base64_buf[base64_len];
 379       memset(base64_buf, 0, base64_len);
 380
 381       /* Encoding certificate into base64 code */
 382       ret = ssl_base64_encode((unsigned char*)base64_buf,
 383                base64_len, &olen, (const unsigned char*)cert->file_buf,
 384                strlen(cert->file_buf));
 385       if (ret != 0)
 386       {
 387          log_error(LOG_LEVEL_ERROR,
 388             "Encoding to base64 failed, buffer is to small");
 389       }
 390
 391       strlcat(message, "<pre>",        message_len);
 392       strlcat(message, cert->info_buf, message_len);
 393       strlcat(message, "</pre>\n",     message_len);
 394
 395       if (ret == 0)
 396       {
 397          strlcat(message, "<a href=\"data:application/x-x509-ca-cert;base64,",
 398             message_len);
 399          strlcat(message, base64_buf, message_len);
 400          strlcat(message, "\">Download certificate</a>", message_len);
 401       }
 402
 403       cert = cert->next;
 404    }
 405    strlcat(message, message_end, message_len);
 406
 407    /*
 408     * Sending final message to client
 409     */
 410    (void)ssl_send_data(ssl_attr, (const unsigned char *)message, strlen(message));
 411
 412    free_certificate_chain(csp);
 413
 414    log_error(LOG_LEVEL_CRUNCH, "Certificate error: %s: https://%s%s",
 415       reason, csp->http->hostport, csp->http->path);
 416    log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s https://%s%s %s\" 200 %lu",
 417       csp->ip_addr_str, csp->http->gpc, csp->http->hostport, csp->http->path,
 418       csp->http->version, message_len-head_length);
 419
 420 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
 421    csp->flags &= ~CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
 422    csp->flags |= CSP_FLAG_SERVER_SOCKET_TAINTED;
 423 #endif
 424 }
 425
 426
 427 /*********************************************************************
 428  *
 429  * Function    :  file_exists
 430  *
 431  * Description :  Tests if file exists and is readable.
 432  *
 433  * Parameters  :
 434  *          1  :  path = Path to tested file.
 435  *
 436  * Returns     :  1 => File exists and is readable.
 437  *                0 => File doesn't exist or is not readable.
 438  *
 439  *********************************************************************/
 440 extern int file_exists(const char *path)
 441 {
 442    FILE *f;
 443    if ((f = fopen(path, "r")) != NULL)
 444    {
 445       fclose(f);
 446       return 1;
 447    }
 448
 449    return 0;
 450 }
 451
 452
 453 /*********************************************************************
 454  *
 455  * Function    :  make_certs_path
 456  *
 457  * Description : Creates path to file from three pieces. This function
 458  *               takes parameters and puts them in one new mallocated
 459  *               char * in correct order. Returned variable must be freed
 460  *               by caller. This function is mainly used for creating
 461  *               paths of certificates and keys files.
 462  *
 463  * Parameters  :
 464  *          1  :  conf_dir  = Name/path of directory where is the file.
 465  *                            '.' can be used for current directory.
 466  *          2  :  file_name = Name of file in conf_dir without suffix.
 467  *          3  :  suffix    = Suffix of given file_name.
 468  *
 469  * Returns     :  path => Path was built up successfully
 470  *                NULL => Path can't be built up
 471  *
 472  *********************************************************************/
 473 extern char *make_certs_path(const char *conf_dir, const char *file_name,
 474    const char *suffix)
 475 {
 476    /* Test if all given parameters are valid */
 477    if (conf_dir == NULL || *conf_dir == '\0' || file_name == NULL ||
 478       *file_name == '\0' || suffix == NULL || *suffix == '\0')
 479    {
 480       log_error(LOG_LEVEL_ERROR,
 481          "make_certs_path failed: bad input parameters");
 482       return NULL;
 483    }
 484
 485    char *path = NULL;
 486    size_t path_size = strlen(conf_dir)
 487       + strlen(file_name) + strlen(suffix) + 2;
 488
 489    /* Setting delimiter and editing path length */
 490 #if defined(_WIN32)
 491    char delim[] = "\\";
 492    path_size += 1;
 493 #else /* ifndef _WIN32 */
 494    char delim[] = "/";
 495 #endif /* ifndef _WIN32 */
 496
 497    /*
 498     * Building up path from many parts
 499     */
 500 #if defined(unix)
 501    if (*conf_dir != '/' && basedir && *basedir)
 502    {
 503       /*
 504        * Replacing conf_dir with basedir. This new variable contains
 505        * absolute path to cwd.
 506        */
 507       path_size += strlen(basedir) + 2;
 508       path = zalloc_or_die(path_size);
 509
 510       strlcpy(path, basedir,   path_size);
 511       strlcat(path, delim,     path_size);
 512       strlcat(path, conf_dir,  path_size);
 513       strlcat(path, delim,     path_size);
 514       strlcat(path, file_name, path_size);
 515       strlcat(path, suffix,    path_size);
 516    }
 517    else
 518 #endif /* defined unix */
 519    {
 520       path = zalloc_or_die(path_size);
 521
 522       strlcpy(path, conf_dir,  path_size);
 523       strlcat(path, delim,     path_size);
 524       strlcat(path, file_name, path_size);
 525       strlcat(path, suffix,    path_size);
 526    }
 527
 528    return path;
 529 }
 530
 531
 532 /*********************************************************************
 533  *
 534  * Function    :  get_certificate_serial
 535  *
 536  * Description :  Computes serial number for new certificate from host
 537  *                name hash. This hash must be already saved in csp
 538  *                structure.
 539  *
 540  * Parameters  :
 541  *          1  :  csp = Current client state (buffers, headers, etc...)
 542  *
 543  * Returns     :  Serial number for new certificate
 544  *
 545  *********************************************************************/
 546 extern unsigned long get_certificate_serial(struct client_state *csp)
 547 {
 548    unsigned long exp    = 1;
 549    unsigned long serial = 0;
 550
 551    int i = CERT_SERIAL_NUM_LENGTH;
 552
 553    for (; i >= 0; i--)
 554    {
 555       serial += exp * (unsigned)csp->http->hash_of_host[i];
 556       exp *= 256;
 557    }
 558    return serial;
 559 }
 560
 561
 562 /*********************************************************************
 563  *
 564  * Function    :  generate_certificate_valid_date
 565  *
 566  * Description :  Turns a time_t into the format expected by mbedTLS.
 567  *
 568  * Parameters  :
 569  *          1  :  time_spec = The timestamp to convert
 570  *          2  :  buffer = The buffer to write the date to
 571  *          3  :  buffer_size = The size of the buffer
 572  *          4  :  fmt = format
 573  *
 574  * Returns     :   0 => The conversion worked
 575  *                 1 => The conversion failed
 576  *
 577  *********************************************************************/
 578 static int generate_certificate_valid_date(time_t time_spec, char *buffer,
 579                                            size_t buffer_size, const char *fmt)
 580 {
 581    struct tm valid_date;
 582    struct tm *timeptr;
 583    size_t ret;
 584
 585    timeptr = privoxy_gmtime_r(&time_spec, &valid_date);
 586    if (NULL == timeptr)
 587    {
 588       return 1;
 589    }
 590
 591    ret = strftime(buffer, buffer_size, fmt, timeptr);
 592    if (ret <= 0)
 593    {
 594       return 1;
 595    }
 596
 597    return 0;
 598
 599 }
 600
 601
 602 /*********************************************************************
 603  *
 604  * Function    :  get_certificate_valid_from_date
 605  *
 606  * Description :  Generates a "valid from" date in the format
 607  *                expected by mbedTLS.
 608  *
 609  * Parameters  :
 610  *          1  :  buffer = The buffer to write the date to
 611  *          2  :  buffer_size = The size of the buffer
 612  *          3  :  fmt = format
 613  *
 614  * Returns     :   0 => The generation worked
 615  *                 1 => The generation failed
 616  *
 617  *********************************************************************/
 618 extern int get_certificate_valid_from_date(char *buffer, size_t buffer_size, const char *fmt)
 619 {
 620    time_t time_spec;
 621
 622    time_spec = time(NULL);
 623    /* 1 month in the past */
 624    time_spec -= 30 * 24 * 60 * 60;
 625
 626    return generate_certificate_valid_date(time_spec, buffer, buffer_size, fmt);
 627
 628 }
 629
 630
 631 /*********************************************************************
 632  *
 633  * Function    :  get_certificate_valid_to_date
 634  *
 635  * Description :  Generates a "valid to" date in the format
 636  *                expected by mbedTLS.
 637  *
 638  * Parameters  :
 639  *          1  :  buffer = The buffer to write the date to
 640  *          2  :  buffer_size = The size of the buffer
 641  *          3  :  fmt = format
 642  *
 643  * Returns     :   0 => The generation worked
 644  *                 1 => The generation failed
 645  *
 646  *********************************************************************/
 647 extern int get_certificate_valid_to_date(char *buffer, size_t buffer_size, const char *fmt)
 648 {
 649    time_t time_spec;
 650
 651    time_spec = time(NULL);
 652    /* Three months in the future */
 653    time_spec += 90 * 24 * 60 * 60;
 654
 655    return generate_certificate_valid_date(time_spec, buffer, buffer_size, fmt);
 656
 657 }
 658
 659
 660 /*********************************************************************
 661  *
 662  * Function    :  host_is_ip_address
 663  *
 664  * Description :  Checks whether or not a host is specified by
 665  *                IP address. Does not actually validate the
 666  *                address.
 667  *
 668  * Parameters  :
 669  *          1  :  host = The host name to check
 670  *
 671  * Returns     :   1 => Yes
 672  *                 0 => No
 673  *
 674  *********************************************************************/
 675 extern int host_is_ip_address(const char *host)
 676 {
 677    const char *p;
 678
 679    if (NULL != strstr(host, ":"))
 680    {
 681       /* Assume an IPv6 address. */
 682       return 1;
 683    }
 684
 685    for (p = host; *p; p++)
 686    {
 687       if ((*p != '.') && !privoxy_isdigit(*p))
 688       {
 689          /* Not a dot or digit so it can't be an IPv4 address. */
 690          return 0;
 691       }
 692    }
 693
 694    /*
 695     * Host only consists of dots and digits so
 696     * assume that is an IPv4 address.
 697     */
 698    return 1;
 699
 700 }