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