c67c5f54f61a17275f40673fe570d7cf1f8422b9
[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 struct
337 {
338     unsigned flag;
339     const char msg[29];
340 } cert_errs[] =
341 {
342     { GNUTLS_CERT_INVALID,            "Certificate not verified"     },
343     { GNUTLS_CERT_REVOKED,            "Certificate revoked"          },
344     { GNUTLS_CERT_SIGNER_NOT_FOUND,   "Signer not found"             },
345     { GNUTLS_CERT_SIGNER_NOT_CA,      "Signer not a CA"              },
346     { GNUTLS_CERT_INSECURE_ALGORITHM, "Signature algorithm insecure" },
347     { GNUTLS_CERT_NOT_ACTIVATED,      "Certificate not activated"    },
348     { GNUTLS_CERT_EXPIRED,            "Certificate expired"          },
349 };
350
351
352 static int gnutls_HandshakeAndValidate (vlc_tls_t *session, const char *host,
353                                         const char *service)
354 {
355     vlc_tls_sys_t *sys = session->sys;
356
357     int val = gnutls_ContinueHandshake (session, host, service);
358     if (val)
359         return val;
360
361     /* certificates chain verification */
362     unsigned status;
363
364     val = gnutls_certificate_verify_peers2 (sys->session, &status);
365     if (val)
366     {
367         msg_Err (session, "Certificate verification error: %s",
368                  gnutls_strerror (val));
369         return -1;
370     }
371     if (status)
372     {
373         msg_Err (session, "Certificate verification failure (0x%04X)", status);
374         for (size_t i = 0; i < sizeof (cert_errs) / sizeof (cert_errs[0]); i++)
375             if (status & cert_errs[i].flag)
376                 msg_Err (session, " * %s", cert_errs[i].msg);
377         if (status & ~(GNUTLS_CERT_INVALID|GNUTLS_CERT_SIGNER_NOT_FOUND))
378             return -1;
379     }
380
381     if (host == NULL)
382         return status ? -1 : 0;
383
384     /* certificate (host)name verification */
385     const gnutls_datum_t *data;
386     unsigned count;
387     data = gnutls_certificate_get_peers (sys->session, &count);
388     if (data == NULL || count == 0)
389     {
390         msg_Err (session, "Peer certificate not available");
391         return -1;
392     }
393     msg_Dbg (session, "%u certificate(s) in the list", count);
394
395     if (status && gnutls_CertSearch (session, host, service, data))
396         return -1;
397
398     gnutls_x509_crt_t cert;
399     val = gnutls_x509_crt_init (&cert);
400     if (val)
401     {
402         msg_Err (session, "X.509 fatal error: %s", gnutls_strerror (val));
403         return -1;
404     }
405
406     val = gnutls_x509_crt_import (cert, data, GNUTLS_X509_FMT_DER);
407     if (val)
408     {
409         msg_Err (session, "Certificate import error: %s",
410                  gnutls_strerror (val));
411         goto error;
412     }
413
414     val = !gnutls_x509_crt_check_hostname (cert, host);
415     if (val)
416     {
417         msg_Err (session, "Certificate does not match \"%s\"", host);
418         val = gnutls_CertSearch (session, host, service, data);
419     }
420 error:
421     gnutls_x509_crt_deinit (cert);
422     return val;
423 }
424
425 static int
426 gnutls_SessionPrioritize (vlc_object_t *obj, gnutls_session_t session)
427 {
428     char *priorities = var_InheritString (obj, "gnutls-priorities");
429     if (unlikely(priorities == NULL))
430         return VLC_ENOMEM;
431
432     const char *errp;
433     int val = gnutls_priority_set_direct (session, priorities, &errp);
434     if (val < 0)
435     {
436         msg_Err (obj, "cannot set TLS priorities \"%s\": %s", errp,
437                  gnutls_strerror (val));
438         val = VLC_EGENERIC;
439     }
440     else
441         val = VLC_SUCCESS;
442     free (priorities);
443     return val;
444 }
445
446
447 /**
448  * TLS credentials private data
449  */
450 struct vlc_tls_creds_sys
451 {
452     gnutls_certificate_credentials_t x509_cred;
453     gnutls_dh_params_t dh_params; /* XXX: used for server only */
454     int (*handshake) (vlc_tls_t *, const char *, const char *);
455         /* ^^ XXX: useful for server only */
456 };
457
458
459 /**
460  * Terminates TLS session and releases session data.
461  * You still have to close the socket yourself.
462  */
463 static void gnutls_SessionClose (vlc_tls_creds_t *crd, vlc_tls_t *session)
464 {
465     vlc_tls_sys_t *sys = session->sys;
466
467     if (sys->handshaked)
468         gnutls_bye (sys->session, GNUTLS_SHUT_WR);
469     gnutls_deinit (sys->session);
470
471     free (sys);
472     (void) crd;
473 }
474
475
476 /**
477  * Initializes a server-side TLS session.
478  */
479 static int gnutls_SessionOpen (vlc_tls_creds_t *crd, vlc_tls_t *session,
480                                int type, int fd)
481 {
482     vlc_tls_sys_t *sys = malloc (sizeof (*session->sys));
483     if (unlikely(sys == NULL))
484         return VLC_ENOMEM;
485
486     session->sys = sys;
487     session->sock.p_sys = session;
488     session->sock.pf_send = gnutls_Send;
489     session->sock.pf_recv = gnutls_Recv;
490     session->handshake = crd->sys->handshake;
491     sys->handshaked = false;
492
493     int val = gnutls_init (&sys->session, type);
494     if (val != 0)
495     {
496         msg_Err (session, "cannot initialize TLS session: %s",
497                  gnutls_strerror (val));
498         free (sys);
499         return VLC_EGENERIC;
500     }
501
502     if (gnutls_SessionPrioritize (VLC_OBJECT (crd), sys->session))
503         goto error;
504
505     val = gnutls_credentials_set (sys->session, GNUTLS_CRD_CERTIFICATE,
506                                   crd->sys->x509_cred);
507     if (val < 0)
508     {
509         msg_Err (session, "cannot set TLS session credentials: %s",
510                  gnutls_strerror (val));
511         goto error;
512     }
513
514     gnutls_transport_set_ptr (sys->session,
515                               (gnutls_transport_ptr_t)(intptr_t)fd);
516     return VLC_SUCCESS;
517
518 error:
519     gnutls_SessionClose (crd, session);
520     return VLC_EGENERIC;
521 }
522
523 static int gnutls_ServerSessionOpen (vlc_tls_creds_t *crd, vlc_tls_t *session,
524                                      int fd, const char *hostname)
525 {
526     int val = gnutls_SessionOpen (crd, session, GNUTLS_SERVER, fd);
527     if (val != VLC_SUCCESS)
528         return val;
529
530     if (session->handshake == gnutls_HandshakeAndValidate)
531         gnutls_certificate_server_set_request (session->sys->session,
532                                                GNUTLS_CERT_REQUIRE);
533     assert (hostname == NULL);
534     return VLC_SUCCESS;
535 }
536
537 static int gnutls_ClientSessionOpen (vlc_tls_creds_t *crd, vlc_tls_t *session,
538                                      int fd, const char *hostname)
539 {
540     int val = gnutls_SessionOpen (crd, session, GNUTLS_CLIENT, fd);
541     if (val != VLC_SUCCESS)
542         return val;
543
544     vlc_tls_sys_t *sys = session->sys;
545
546     /* minimum DH prime bits */
547     gnutls_dh_set_prime_bits (sys->session, 1024);
548
549     if (likely(hostname != NULL))
550         /* fill Server Name Indication */
551         gnutls_server_name_set (sys->session, GNUTLS_NAME_DNS,
552                                 hostname, strlen (hostname));
553
554     return VLC_SUCCESS;
555 }
556
557
558 /**
559  * Adds one or more Certificate Authorities to the trusted set.
560  *
561  * @param path (UTF-8) path to an X.509 certificates list.
562  *
563  * @return -1 on error, 0 on success.
564  */
565 static int gnutls_AddCA (vlc_tls_creds_t *crd, const char *path)
566 {
567     block_t *block = block_FilePath (path);
568     if (block == NULL)
569     {
570         msg_Err (crd, "cannot read trusted CA from %s: %s", path,
571                  vlc_strerror_c(errno));
572         return VLC_EGENERIC;
573     }
574
575     gnutls_datum_t d = {
576        .data = block->p_buffer,
577        .size = block->i_buffer,
578     };
579
580     int val = gnutls_certificate_set_x509_trust_mem (crd->sys->x509_cred, &d,
581                                                      GNUTLS_X509_FMT_PEM);
582     block_Release (block);
583     if (val < 0)
584     {
585         msg_Err (crd, "cannot load trusted CA from %s: %s", path,
586                  gnutls_strerror (val));
587         return VLC_EGENERIC;
588     }
589     msg_Dbg (crd, " %d trusted CA%s added from %s", val, (val != 1) ? "s" : "",
590              path);
591
592     /* enables peer's certificate verification */
593     crd->sys->handshake = gnutls_HandshakeAndValidate;
594     return VLC_SUCCESS;
595 }
596
597
598 /**
599  * Adds a Certificates Revocation List to be sent to TLS clients.
600  *
601  * @param path (UTF-8) path of the CRL file.
602  *
603  * @return -1 on error, 0 on success.
604  */
605 static int gnutls_AddCRL (vlc_tls_creds_t *crd, const char *path)
606 {
607     block_t *block = block_FilePath (path);
608     if (block == NULL)
609     {
610         msg_Err (crd, "cannot read CRL from %s: %s", path,
611                  vlc_strerror_c(errno));
612         return VLC_EGENERIC;
613     }
614
615     gnutls_datum_t d = {
616        .data = block->p_buffer,
617        .size = block->i_buffer,
618     };
619
620     int val = gnutls_certificate_set_x509_crl_mem (crd->sys->x509_cred, &d,
621                                                    GNUTLS_X509_FMT_PEM);
622     block_Release (block);
623     if (val < 0)
624     {
625         msg_Err (crd, "cannot add CRL (%s): %s", path, gnutls_strerror (val));
626         return VLC_EGENERIC;
627     }
628     msg_Dbg (crd, "%d CRL%s added from %s", val, (val != 1) ? "s" : "", path);
629     return VLC_SUCCESS;
630 }
631
632
633 /**
634  * Allocates a whole server's TLS credentials.
635  */
636 static int OpenServer (vlc_tls_creds_t *crd, const char *cert, const char *key)
637 {
638     int val;
639
640     if (gnutls_Init (VLC_OBJECT(crd)))
641         return VLC_EGENERIC;
642
643     vlc_tls_creds_sys_t *sys = malloc (sizeof (*sys));
644     if (unlikely(sys == NULL))
645         goto error;
646
647     crd->sys     = sys;
648     crd->add_CA  = gnutls_AddCA;
649     crd->add_CRL = gnutls_AddCRL;
650     crd->open    = gnutls_ServerSessionOpen;
651     crd->close   = gnutls_SessionClose;
652     /* No certificate validation by default */
653     sys->handshake  = gnutls_ContinueHandshake;
654
655     /* Sets server's credentials */
656     val = gnutls_certificate_allocate_credentials (&sys->x509_cred);
657     if (val != 0)
658     {
659         msg_Err (crd, "cannot allocate credentials: %s",
660                  gnutls_strerror (val));
661         goto error;
662     }
663
664     block_t *certblock = block_FilePath (cert);
665     if (certblock == NULL)
666     {
667         msg_Err (crd, "cannot read certificate chain from %s: %s", cert,
668                  vlc_strerror_c(errno));
669         return VLC_EGENERIC;
670     }
671
672     block_t *keyblock = block_FilePath (key);
673     if (keyblock == NULL)
674     {
675         msg_Err (crd, "cannot read private key from %s: %s", key,
676                  vlc_strerror_c(errno));
677         block_Release (certblock);
678         return VLC_EGENERIC;
679     }
680
681     gnutls_datum_t pub = {
682        .data = certblock->p_buffer,
683        .size = certblock->i_buffer,
684     }, priv = {
685        .data = keyblock->p_buffer,
686        .size = keyblock->i_buffer,
687     };
688
689     val = gnutls_certificate_set_x509_key_mem (sys->x509_cred, &pub, &priv,
690                                                 GNUTLS_X509_FMT_PEM);
691     block_Release (keyblock);
692     block_Release (certblock);
693     if (val < 0)
694     {
695         msg_Err (crd, "cannot load X.509 key: %s", gnutls_strerror (val));
696         gnutls_certificate_free_credentials (sys->x509_cred);
697         goto error;
698     }
699
700     /* FIXME:
701      * - support other cipher suites
702      */
703     val = gnutls_dh_params_init (&sys->dh_params);
704     if (val >= 0)
705     {
706         const gnutls_datum_t data = {
707             .data = (unsigned char *)dh_params,
708             .size = sizeof (dh_params) - 1,
709         };
710
711         val = gnutls_dh_params_import_pkcs3 (sys->dh_params, &data,
712                                              GNUTLS_X509_FMT_PEM);
713         if (val == 0)
714             gnutls_certificate_set_dh_params (sys->x509_cred,
715                                               sys->dh_params);
716     }
717     if (val < 0)
718     {
719         msg_Err (crd, "cannot initialize DHE cipher suites: %s",
720                  gnutls_strerror (val));
721     }
722
723     return VLC_SUCCESS;
724
725 error:
726     free (sys);
727     gnutls_Deinit (VLC_OBJECT(crd));
728     return VLC_EGENERIC;
729 }
730
731 /**
732  * Destroys a TLS server object.
733  */
734 static void CloseServer (vlc_tls_creds_t *crd)
735 {
736     vlc_tls_creds_sys_t *sys = crd->sys;
737
738     /* all sessions depending on the server are now deinitialized */
739     gnutls_certificate_free_credentials (sys->x509_cred);
740     gnutls_dh_params_deinit (sys->dh_params);
741     free (sys);
742
743     gnutls_Deinit (VLC_OBJECT(crd));
744 }
745
746 /**
747  * Initializes a client-side TLS credentials.
748  */
749 static int OpenClient (vlc_tls_creds_t *crd)
750 {
751     if (gnutls_Init (VLC_OBJECT(crd)))
752         return VLC_EGENERIC;
753
754     vlc_tls_creds_sys_t *sys = malloc (sizeof (*sys));
755     if (unlikely(sys == NULL))
756         goto error;
757
758     crd->sys = sys;
759     //crd->add_CA = gnutls_AddCA;
760     //crd->add_CRL = gnutls_AddCRL;
761     crd->open = gnutls_ClientSessionOpen;
762     crd->close = gnutls_SessionClose;
763     sys->handshake = gnutls_HandshakeAndValidate;
764
765     int val = gnutls_certificate_allocate_credentials (&sys->x509_cred);
766     if (val != 0)
767     {
768         msg_Err (crd, "cannot allocate credentials: %s",
769                  gnutls_strerror (val));
770         goto error;
771     }
772
773     val = gnutls_certificate_set_x509_system_trust (sys->x509_cred);
774     if (val < 0)
775         msg_Err (crd, "cannot load trusted Certificate Authorities: %s",
776                  gnutls_strerror (val));
777     else
778         msg_Dbg (crd, "loaded %d trusted CAs", val);
779
780     gnutls_certificate_set_verify_flags (sys->x509_cred,
781                                          GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT);
782
783     return VLC_SUCCESS;
784 error:
785     free (sys);
786     gnutls_Deinit (VLC_OBJECT(crd));
787     return VLC_EGENERIC;
788 }
789
790 static void CloseClient (vlc_tls_creds_t *crd)
791 {
792     vlc_tls_creds_sys_t *sys = crd->sys;
793
794     gnutls_certificate_free_credentials (sys->x509_cred);
795     free (sys);
796
797     gnutls_Deinit (VLC_OBJECT(crd));
798 }