gnutls: remove client certificate support
[vlc.git] / modules / misc / gnutls.c
1 /*****************************************************************************
2  * gnutls.c
3  *****************************************************************************
4  * Copyright (C) 2004-2012 Rémi Denis-Courmont
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser General Public License as published by
8  * the Free Software Foundation; either version 2.1 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Öesser General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
19  *****************************************************************************/
20
21 /*****************************************************************************
22  * Preamble
23  *****************************************************************************/
24
25 #ifdef HAVE_CONFIG_H
26 # include "config.h"
27 #endif
28
29 #include <time.h>
30 #include <errno.h>
31 #include <assert.h>
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_tls.h>
36 #include <vlc_block.h>
37 #include <vlc_dialog.h>
38
39 #include <gnutls/gnutls.h>
40 #include <gnutls/x509.h>
41 #include "dhparams.h"
42
43 /*****************************************************************************
44  * Module descriptor
45  *****************************************************************************/
46 static int  OpenClient  (vlc_tls_creds_t *);
47 static void CloseClient (vlc_tls_creds_t *);
48 static int  OpenServer  (vlc_tls_creds_t *, const char *, const char *);
49 static void CloseServer (vlc_tls_creds_t *);
50
51 #define PRIORITIES_TEXT N_("TLS cipher priorities")
52 #define PRIORITIES_LONGTEXT N_("Ciphers, key exchange methods, " \
53     "hash functions and compression methods can be selected. " \
54     "Refer to GNU TLS documentation for detailed syntax.")
55 static const char *const priorities_values[] = {
56     "PERFORMANCE",
57     "NORMAL",
58     "SECURE128",
59     "SECURE256",
60     "EXPORT",
61 };
62 static const char *const priorities_text[] = {
63     N_("Performance (prioritize faster ciphers)"),
64     N_("Normal"),
65     N_("Secure 128-bits (exclude 256-bits ciphers)"),
66     N_("Secure 256-bits (prioritize 256-bits ciphers)"),
67     N_("Export (include insecure ciphers)"),
68 };
69
70 vlc_module_begin ()
71     set_shortname( "GNU TLS" )
72     set_description( N_("GNU TLS transport layer security") )
73     set_capability( "tls client", 1 )
74     set_callbacks( OpenClient, CloseClient )
75     set_category( CAT_ADVANCED )
76     set_subcategory( SUBCAT_ADVANCED_NETWORK )
77
78     add_submodule ()
79         set_description( N_("GNU TLS server") )
80         set_capability( "tls server", 1 )
81         set_category( CAT_ADVANCED )
82         set_subcategory( SUBCAT_ADVANCED_NETWORK )
83         set_callbacks( OpenServer, CloseServer )
84
85         add_string ("gnutls-priorities", "NORMAL", PRIORITIES_TEXT,
86                     PRIORITIES_LONGTEXT, false)
87             change_string_list (priorities_values, priorities_text)
88 vlc_module_end ()
89
90 static vlc_mutex_t gnutls_mutex = VLC_STATIC_MUTEX;
91
92 /**
93  * Initializes GnuTLS with proper locking.
94  * @return VLC_SUCCESS on success, a VLC error code otherwise.
95  */
96 static int gnutls_Init (vlc_object_t *p_this)
97 {
98     int ret = VLC_EGENERIC;
99
100     vlc_mutex_lock (&gnutls_mutex);
101     if (gnutls_global_init ())
102     {
103         msg_Err (p_this, "cannot initialize GnuTLS");
104         goto error;
105     }
106
107     const char *psz_version = gnutls_check_version ("3.1.4");
108     if (psz_version == NULL)
109     {
110         msg_Err (p_this, "unsupported GnuTLS version");
111         gnutls_global_deinit ();
112         goto error;
113     }
114
115     msg_Dbg (p_this, "GnuTLS v%s initialized", psz_version);
116     ret = VLC_SUCCESS;
117
118 error:
119     vlc_mutex_unlock (&gnutls_mutex);
120     return ret;
121 }
122
123
124 /**
125  * Deinitializes GnuTLS.
126  */
127 static void gnutls_Deinit (vlc_object_t *p_this)
128 {
129     vlc_mutex_lock (&gnutls_mutex);
130
131     gnutls_global_deinit ();
132     msg_Dbg (p_this, "GnuTLS deinitialized");
133     vlc_mutex_unlock (&gnutls_mutex);
134 }
135
136
137 static int gnutls_Error (vlc_object_t *obj, int val)
138 {
139     switch (val)
140     {
141         case GNUTLS_E_AGAIN:
142 #ifdef _WIN32
143             WSASetLastError (WSAEWOULDBLOCK);
144 #else
145             errno = EAGAIN;
146 #endif
147             break;
148
149         case GNUTLS_E_INTERRUPTED:
150 #ifdef _WIN32
151             WSASetLastError (WSAEINTR);
152 #else
153             errno = EINTR;
154 #endif
155             break;
156
157         default:
158             msg_Err (obj, "%s", gnutls_strerror (val));
159 #ifndef NDEBUG
160             if (!gnutls_error_is_fatal (val))
161                 msg_Err (obj, "Error above should be handled");
162 #endif
163 #ifdef _WIN32
164             WSASetLastError (WSAECONNRESET);
165 #else
166             errno = ECONNRESET;
167 #endif
168     }
169     return -1;
170 }
171 #define gnutls_Error(o, val) gnutls_Error(VLC_OBJECT(o), val)
172
173 struct vlc_tls_sys
174 {
175     gnutls_session_t session;
176     bool handshaked;
177 };
178
179
180 /**
181  * Sends data through a TLS session.
182  */
183 static int gnutls_Send (void *opaque, const void *buf, size_t length)
184 {
185     vlc_tls_t *session = opaque;
186     vlc_tls_sys_t *sys = session->sys;
187
188     int val = gnutls_record_send (sys->session, buf, length);
189     return (val < 0) ? gnutls_Error (session, val) : val;
190 }
191
192
193 /**
194  * Receives data through a TLS session.
195  */
196 static int gnutls_Recv (void *opaque, void *buf, size_t length)
197 {
198     vlc_tls_t *session = opaque;
199     vlc_tls_sys_t *sys = session->sys;
200
201     int val = gnutls_record_recv (sys->session, buf, length);
202     return (val < 0) ? gnutls_Error (session, val) : val;
203 }
204
205
206 /**
207  * Starts or continues the TLS handshake.
208  *
209  * @return -1 on fatal error, 0 on successful handshake completion,
210  * 1 if more would-be blocking recv is needed,
211  * 2 if more would-be blocking send is required.
212  */
213 static int gnutls_ContinueHandshake (vlc_tls_t *session, const char *host,
214                                      const char *service)
215 {
216     vlc_tls_sys_t *sys = session->sys;
217     int val;
218
219 #ifdef _WIN32
220     WSASetLastError (0);
221 #endif
222     do
223     {
224         val = gnutls_handshake (sys->session);
225         msg_Dbg (session, "TLS handshake: %s", gnutls_strerror (val));
226
227         if ((val == GNUTLS_E_AGAIN) || (val == GNUTLS_E_INTERRUPTED))
228             /* I/O event: return to caller's poll() loop */
229             return 1 + gnutls_record_get_direction (sys->session);
230     }
231     while (val < 0 && !gnutls_error_is_fatal (val));
232
233     if (val < 0)
234     {
235 #ifdef _WIN32
236         msg_Dbg (session, "Winsock error %d", WSAGetLastError ());
237 #endif
238         msg_Err (session, "TLS handshake error: %s", gnutls_strerror (val));
239         return -1;
240     }
241
242     sys->handshaked = true;
243     (void) host; (void) service;
244     return 0;
245 }
246
247
248 /**
249  * Looks up certificate in known hosts data base.
250  * @return 0 on success, -1 on failure.
251  */
252 static int gnutls_CertSearch (vlc_tls_t *obj, const char *host,
253                               const char *service,
254                               const gnutls_datum_t *restrict datum)
255 {
256     assert (host != NULL);
257
258     /* Look up mismatching certificate in store */
259     int val = gnutls_verify_stored_pubkey (NULL, NULL, host, service,
260                                            GNUTLS_CRT_X509, datum, 0);
261     const char *msg;
262     switch (val)
263     {
264         case 0:
265             msg_Dbg (obj, "certificate key match for %s", host);
266             return 0;
267         case GNUTLS_E_NO_CERTIFICATE_FOUND:
268             msg_Dbg (obj, "no known certificates for %s", host);
269             msg = N_("You attempted to reach %s. "
270                 "However the security certificate presented by the server "
271                 "is unknown and could not be authenticated by any trusted "
272                 "Certification Authority. "
273                 "This problem may be caused by a configuration error "
274                 "or an attempt to breach your security or your privacy.\n\n"
275                 "If in doubt, abort now.\n");
276             break;
277         case GNUTLS_E_CERTIFICATE_KEY_MISMATCH:
278             msg_Dbg (obj, "certificate keys mismatch for %s", host);
279             msg = N_("You attempted to reach %s. "
280                 "However the security certificate presented by the server "
281                 "changed since the previous visit "
282                 "and was not authenticated by any trusted "
283                 "Certification Authority. "
284                 "This problem may be caused by a configuration error "
285                 "or an attempt to breach your security or your privacy.\n\n"
286                 "If in doubt, abort now.\n");
287             break;
288         default:
289             msg_Err (obj, "certificate key match error for %s: %s", host,
290                      gnutls_strerror (val));
291             return -1;
292     }
293
294     if (dialog_Question (obj, _("Insecure site"), vlc_gettext (msg),
295                          _("Abort"), _("View certificate"), NULL, host) != 2)
296         return -1;
297
298     gnutls_x509_crt_t cert;
299     gnutls_datum_t desc;
300
301     if (gnutls_x509_crt_init (&cert))
302         return -1;
303     if (gnutls_x509_crt_import (cert, datum, GNUTLS_X509_FMT_DER)
304      || gnutls_x509_crt_print (cert, GNUTLS_CRT_PRINT_ONELINE, &desc))
305     {
306         gnutls_x509_crt_deinit (cert);
307         return -1;
308     }
309     gnutls_x509_crt_deinit (cert);
310
311     val = dialog_Question (obj, _("Insecure site"),
312          _("This is the certificate presented by %s:\n%s\n\n"
313            "If in doubt, abort now.\n"),
314                            _("Abort"), _("Accept 24 hours"),
315                            _("Accept permanently"), host, desc.data);
316     gnutls_free (desc.data);
317
318     time_t expiry = 0;
319     switch (val)
320     {
321         case 2:
322             time (&expiry);
323             expiry += 24 * 60 * 60;
324         case 3:
325             val = gnutls_store_pubkey (NULL, NULL, host, service,
326                                        GNUTLS_CRT_X509, datum, expiry, 0);
327             if (val)
328                 msg_Err (obj, "cannot store X.509 certificate: %s",
329                          gnutls_strerror (val));
330             return 0;
331     }
332     return -1;
333 }
334
335
336 static int gnutls_HandshakeAndValidate (vlc_tls_t *session, const char *host,
337                                         const char *service)
338 {
339     vlc_tls_sys_t *sys = session->sys;
340
341     int val = gnutls_ContinueHandshake (session, host, service);
342     if (val)
343         return val;
344
345     /* certificates chain verification */
346     unsigned status;
347
348     val = gnutls_certificate_verify_peers3 (sys->session, host, &status);
349     if (val)
350     {
351         msg_Err (session, "Certificate verification error: %s",
352                  gnutls_strerror (val));
353         return -1;
354     }
355
356     if (status == 0)
357         return 0; /* good certificate */
358
359     gnutls_datum_t datum;
360
361     if (gnutls_certificate_verification_status_print(status,
362                    gnutls_certificate_type_get (sys->session), &datum, 0) == 0)
363     {
364         msg_Err (session, "Certificate verification failure: %s", datum.data);
365         gnutls_free (datum.data);
366     }
367
368     status &= ~GNUTLS_CERT_INVALID; /* always set / catch-all error */
369     status &= ~GNUTLS_CERT_SIGNER_NOT_FOUND; /* unknown CA */
370     status &= ~GNUTLS_CERT_UNEXPECTED_OWNER; /* mismatched hostname */
371
372     if (status != 0 || host == NULL)
373         return -1; /* really bad certificate */
374
375     /* manual verification */
376     const gnutls_datum_t *data;
377     unsigned count;
378
379     data = gnutls_certificate_get_peers (sys->session, &count);
380     if (data == NULL || count == 0)
381     {
382         msg_Err (session, "Peer certificate not available");
383         return -1;
384     }
385     msg_Dbg (session, "%u certificate(s) in the list", count);
386
387     return gnutls_CertSearch (session, host, service, data);
388 }
389
390 static int
391 gnutls_SessionPrioritize (vlc_object_t *obj, gnutls_session_t session)
392 {
393     char *priorities = var_InheritString (obj, "gnutls-priorities");
394     if (unlikely(priorities == NULL))
395         return VLC_ENOMEM;
396
397     const char *errp;
398     int val = gnutls_priority_set_direct (session, priorities, &errp);
399     if (val < 0)
400     {
401         msg_Err (obj, "cannot set TLS priorities \"%s\": %s", errp,
402                  gnutls_strerror (val));
403         val = VLC_EGENERIC;
404     }
405     else
406         val = VLC_SUCCESS;
407     free (priorities);
408     return val;
409 }
410
411
412 /**
413  * TLS credentials private data
414  */
415 struct vlc_tls_creds_sys
416 {
417     gnutls_certificate_credentials_t x509_cred;
418     gnutls_dh_params_t dh_params; /* XXX: used for server only */
419 };
420
421
422 /**
423  * Terminates TLS session and releases session data.
424  * You still have to close the socket yourself.
425  */
426 static void gnutls_SessionClose (vlc_tls_creds_t *crd, vlc_tls_t *session)
427 {
428     vlc_tls_sys_t *sys = session->sys;
429
430     if (sys->handshaked)
431         gnutls_bye (sys->session, GNUTLS_SHUT_WR);
432     gnutls_deinit (sys->session);
433
434     free (sys);
435     (void) crd;
436 }
437
438
439 static int gnutls_SessionOpen (vlc_tls_creds_t *crd, vlc_tls_t *session,
440                                int type, int fd)
441 {
442     vlc_tls_sys_t *sys = malloc (sizeof (*session->sys));
443     if (unlikely(sys == NULL))
444         return VLC_ENOMEM;
445
446     session->sys = sys;
447     session->sock.p_sys = session;
448     session->sock.pf_send = gnutls_Send;
449     session->sock.pf_recv = gnutls_Recv;
450     if (type == GNUTLS_SERVER)
451         session->handshake = gnutls_ContinueHandshake;
452     else
453         session->handshake = gnutls_HandshakeAndValidate;
454     sys->handshaked = false;
455
456     int val = gnutls_init (&sys->session, type);
457     if (val != 0)
458     {
459         msg_Err (session, "cannot initialize TLS session: %s",
460                  gnutls_strerror (val));
461         free (sys);
462         return VLC_EGENERIC;
463     }
464
465     if (gnutls_SessionPrioritize (VLC_OBJECT (crd), sys->session))
466         goto error;
467
468     val = gnutls_credentials_set (sys->session, GNUTLS_CRD_CERTIFICATE,
469                                   crd->sys->x509_cred);
470     if (val < 0)
471     {
472         msg_Err (session, "cannot set TLS session credentials: %s",
473                  gnutls_strerror (val));
474         goto error;
475     }
476
477     gnutls_transport_set_ptr (sys->session,
478                               (gnutls_transport_ptr_t)(intptr_t)fd);
479     return VLC_SUCCESS;
480
481 error:
482     gnutls_SessionClose (crd, session);
483     return VLC_EGENERIC;
484 }
485
486 /**
487  * Initializes a server-side TLS session.
488  */
489 static int gnutls_ServerSessionOpen (vlc_tls_creds_t *crd, vlc_tls_t *session,
490                                      int fd, const char *hostname)
491 {
492     assert (hostname == NULL);
493     return gnutls_SessionOpen (crd, session, GNUTLS_SERVER, fd);
494 }
495
496 static int gnutls_ClientSessionOpen (vlc_tls_creds_t *crd, vlc_tls_t *session,
497                                      int fd, const char *hostname)
498 {
499     int val = gnutls_SessionOpen (crd, session, GNUTLS_CLIENT, fd);
500     if (val != VLC_SUCCESS)
501         return val;
502
503     vlc_tls_sys_t *sys = session->sys;
504
505     /* minimum DH prime bits */
506     gnutls_dh_set_prime_bits (sys->session, 1024);
507
508     if (likely(hostname != NULL))
509         /* fill Server Name Indication */
510         gnutls_server_name_set (sys->session, GNUTLS_NAME_DNS,
511                                 hostname, strlen (hostname));
512
513     return VLC_SUCCESS;
514 }
515
516
517 /**
518  * Allocates a whole server's TLS credentials.
519  */
520 static int OpenServer (vlc_tls_creds_t *crd, const char *cert, const char *key)
521 {
522     int val;
523
524     if (gnutls_Init (VLC_OBJECT(crd)))
525         return VLC_EGENERIC;
526
527     vlc_tls_creds_sys_t *sys = malloc (sizeof (*sys));
528     if (unlikely(sys == NULL))
529         goto error;
530
531     crd->sys     = sys;
532     crd->open    = gnutls_ServerSessionOpen;
533     crd->close   = gnutls_SessionClose;
534
535     /* Sets server's credentials */
536     val = gnutls_certificate_allocate_credentials (&sys->x509_cred);
537     if (val != 0)
538     {
539         msg_Err (crd, "cannot allocate credentials: %s",
540                  gnutls_strerror (val));
541         goto error;
542     }
543
544     block_t *certblock = block_FilePath (cert);
545     if (certblock == NULL)
546     {
547         msg_Err (crd, "cannot read certificate chain from %s: %s", cert,
548                  vlc_strerror_c(errno));
549         return VLC_EGENERIC;
550     }
551
552     block_t *keyblock = block_FilePath (key);
553     if (keyblock == NULL)
554     {
555         msg_Err (crd, "cannot read private key from %s: %s", key,
556                  vlc_strerror_c(errno));
557         block_Release (certblock);
558         return VLC_EGENERIC;
559     }
560
561     gnutls_datum_t pub = {
562        .data = certblock->p_buffer,
563        .size = certblock->i_buffer,
564     }, priv = {
565        .data = keyblock->p_buffer,
566        .size = keyblock->i_buffer,
567     };
568
569     val = gnutls_certificate_set_x509_key_mem (sys->x509_cred, &pub, &priv,
570                                                 GNUTLS_X509_FMT_PEM);
571     block_Release (keyblock);
572     block_Release (certblock);
573     if (val < 0)
574     {
575         msg_Err (crd, "cannot load X.509 key: %s", gnutls_strerror (val));
576         gnutls_certificate_free_credentials (sys->x509_cred);
577         goto error;
578     }
579
580     /* FIXME:
581      * - support other cipher suites
582      */
583     val = gnutls_dh_params_init (&sys->dh_params);
584     if (val >= 0)
585     {
586         const gnutls_datum_t data = {
587             .data = (unsigned char *)dh_params,
588             .size = sizeof (dh_params) - 1,
589         };
590
591         val = gnutls_dh_params_import_pkcs3 (sys->dh_params, &data,
592                                              GNUTLS_X509_FMT_PEM);
593         if (val == 0)
594             gnutls_certificate_set_dh_params (sys->x509_cred,
595                                               sys->dh_params);
596     }
597     if (val < 0)
598     {
599         msg_Err (crd, "cannot initialize DHE cipher suites: %s",
600                  gnutls_strerror (val));
601     }
602
603     return VLC_SUCCESS;
604
605 error:
606     free (sys);
607     gnutls_Deinit (VLC_OBJECT(crd));
608     return VLC_EGENERIC;
609 }
610
611 /**
612  * Destroys a TLS server object.
613  */
614 static void CloseServer (vlc_tls_creds_t *crd)
615 {
616     vlc_tls_creds_sys_t *sys = crd->sys;
617
618     /* all sessions depending on the server are now deinitialized */
619     gnutls_certificate_free_credentials (sys->x509_cred);
620     gnutls_dh_params_deinit (sys->dh_params);
621     free (sys);
622
623     gnutls_Deinit (VLC_OBJECT(crd));
624 }
625
626 /**
627  * Initializes a client-side TLS credentials.
628  */
629 static int OpenClient (vlc_tls_creds_t *crd)
630 {
631     if (gnutls_Init (VLC_OBJECT(crd)))
632         return VLC_EGENERIC;
633
634     vlc_tls_creds_sys_t *sys = malloc (sizeof (*sys));
635     if (unlikely(sys == NULL))
636         goto error;
637
638     crd->sys = sys;
639     crd->open = gnutls_ClientSessionOpen;
640     crd->close = gnutls_SessionClose;
641
642     int val = gnutls_certificate_allocate_credentials (&sys->x509_cred);
643     if (val != 0)
644     {
645         msg_Err (crd, "cannot allocate credentials: %s",
646                  gnutls_strerror (val));
647         goto error;
648     }
649
650     val = gnutls_certificate_set_x509_system_trust (sys->x509_cred);
651     if (val < 0)
652         msg_Err (crd, "cannot load trusted Certificate Authorities: %s",
653                  gnutls_strerror (val));
654     else
655         msg_Dbg (crd, "loaded %d trusted CAs", val);
656
657     gnutls_certificate_set_verify_flags (sys->x509_cred,
658                                          GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT);
659
660     return VLC_SUCCESS;
661 error:
662     free (sys);
663     gnutls_Deinit (VLC_OBJECT(crd));
664     return VLC_EGENERIC;
665 }
666
667 static void CloseClient (vlc_tls_creds_t *crd)
668 {
669     vlc_tls_creds_sys_t *sys = crd->sys;
670
671     gnutls_certificate_free_credentials (sys->x509_cred);
672     free (sys);
673
674     gnutls_Deinit (VLC_OBJECT(crd));
675 }