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