xref: /openbmc/qemu/crypto/tlssession.c (revision 6598f0cd) 
1 /*
2  * QEMU crypto TLS session support
3  *
4  * Copyright (c) 2015 Red Hat, Inc.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library 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 GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18  *
19  */
20 
21 #include "qemu/osdep.h"
22 #include "crypto/tlssession.h"
23 #include "crypto/tlscredsanon.h"
24 #include "crypto/tlscredspsk.h"
25 #include "crypto/tlscredsx509.h"
26 #include "qapi/error.h"
27 #include "qemu/acl.h"
28 #include "trace.h"
29 
30 #ifdef CONFIG_GNUTLS
31 
32 
33 #include <gnutls/x509.h>
34 
35 
36 struct QCryptoTLSSession {
37     QCryptoTLSCreds *creds;
38     gnutls_session_t handle;
39     char *hostname;
40     char *aclname;
41     bool handshakeComplete;
42     QCryptoTLSSessionWriteFunc writeFunc;
43     QCryptoTLSSessionReadFunc readFunc;
44     void *opaque;
45     char *peername;
46 };
47 
48 
49 void
50 qcrypto_tls_session_free(QCryptoTLSSession *session)
51 {
52     if (!session) {
53         return;
54     }
55 
56     gnutls_deinit(session->handle);
57     g_free(session->hostname);
58     g_free(session->peername);
59     g_free(session->aclname);
60     object_unref(OBJECT(session->creds));
61     g_free(session);
62 }
63 
64 
65 static ssize_t
66 qcrypto_tls_session_push(void *opaque, const void *buf, size_t len)
67 {
68     QCryptoTLSSession *session = opaque;
69 
70     if (!session->writeFunc) {
71         errno = EIO;
72         return -1;
73     };
74 
75     return session->writeFunc(buf, len, session->opaque);
76 }
77 
78 
79 static ssize_t
80 qcrypto_tls_session_pull(void *opaque, void *buf, size_t len)
81 {
82     QCryptoTLSSession *session = opaque;
83 
84     if (!session->readFunc) {
85         errno = EIO;
86         return -1;
87     };
88 
89     return session->readFunc(buf, len, session->opaque);
90 }
91 
92 #define TLS_PRIORITY_ADDITIONAL_ANON "+ANON-DH"
93 
94 #if GNUTLS_VERSION_MAJOR >= 3
95 #define TLS_ECDHE_PSK "+ECDHE-PSK:"
96 #else
97 #define TLS_ECDHE_PSK ""
98 #endif
99 #define TLS_PRIORITY_ADDITIONAL_PSK TLS_ECDHE_PSK "+DHE-PSK:+PSK"
100 
101 QCryptoTLSSession *
102 qcrypto_tls_session_new(QCryptoTLSCreds *creds,
103                         const char *hostname,
104                         const char *aclname,
105                         QCryptoTLSCredsEndpoint endpoint,
106                         Error **errp)
107 {
108     QCryptoTLSSession *session;
109     int ret;
110 
111     session = g_new0(QCryptoTLSSession, 1);
112     trace_qcrypto_tls_session_new(
113         session, creds, hostname ? hostname : "<none>",
114         aclname ? aclname : "<none>", endpoint);
115 
116     if (hostname) {
117         session->hostname = g_strdup(hostname);
118     }
119     if (aclname) {
120         session->aclname = g_strdup(aclname);
121     }
122     session->creds = creds;
123     object_ref(OBJECT(creds));
124 
125     if (creds->endpoint != endpoint) {
126         error_setg(errp, "Credentials endpoint doesn't match session");
127         goto error;
128     }
129 
130     if (endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
131         ret = gnutls_init(&session->handle, GNUTLS_SERVER);
132     } else {
133         ret = gnutls_init(&session->handle, GNUTLS_CLIENT);
134     }
135     if (ret < 0) {
136         error_setg(errp, "Cannot initialize TLS session: %s",
137                    gnutls_strerror(ret));
138         goto error;
139     }
140 
141     if (object_dynamic_cast(OBJECT(creds),
142                             TYPE_QCRYPTO_TLS_CREDS_ANON)) {
143         QCryptoTLSCredsAnon *acreds = QCRYPTO_TLS_CREDS_ANON(creds);
144         char *prio;
145 
146         if (creds->priority != NULL) {
147             prio = g_strdup_printf("%s:%s",
148                                    creds->priority,
149                                    TLS_PRIORITY_ADDITIONAL_ANON);
150         } else {
151             prio = g_strdup(CONFIG_TLS_PRIORITY ":"
152                             TLS_PRIORITY_ADDITIONAL_ANON);
153         }
154 
155         ret = gnutls_priority_set_direct(session->handle, prio, NULL);
156         if (ret < 0) {
157             error_setg(errp, "Unable to set TLS session priority %s: %s",
158                        prio, gnutls_strerror(ret));
159             g_free(prio);
160             goto error;
161         }
162         g_free(prio);
163         if (creds->endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
164             ret = gnutls_credentials_set(session->handle,
165                                          GNUTLS_CRD_ANON,
166                                          acreds->data.server);
167         } else {
168             ret = gnutls_credentials_set(session->handle,
169                                          GNUTLS_CRD_ANON,
170                                          acreds->data.client);
171         }
172         if (ret < 0) {
173             error_setg(errp, "Cannot set session credentials: %s",
174                        gnutls_strerror(ret));
175             goto error;
176         }
177     } else if (object_dynamic_cast(OBJECT(creds),
178                                    TYPE_QCRYPTO_TLS_CREDS_PSK)) {
179         QCryptoTLSCredsPSK *pcreds = QCRYPTO_TLS_CREDS_PSK(creds);
180         char *prio;
181 
182         if (creds->priority != NULL) {
183             prio = g_strdup_printf("%s:%s",
184                                    creds->priority,
185                                    TLS_PRIORITY_ADDITIONAL_PSK);
186         } else {
187             prio = g_strdup(CONFIG_TLS_PRIORITY ":"
188                             TLS_PRIORITY_ADDITIONAL_PSK);
189         }
190 
191         ret = gnutls_priority_set_direct(session->handle, prio, NULL);
192         if (ret < 0) {
193             error_setg(errp, "Unable to set TLS session priority %s: %s",
194                        prio, gnutls_strerror(ret));
195             g_free(prio);
196             goto error;
197         }
198         g_free(prio);
199         if (creds->endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
200             ret = gnutls_credentials_set(session->handle,
201                                          GNUTLS_CRD_PSK,
202                                          pcreds->data.server);
203         } else {
204             ret = gnutls_credentials_set(session->handle,
205                                          GNUTLS_CRD_PSK,
206                                          pcreds->data.client);
207         }
208         if (ret < 0) {
209             error_setg(errp, "Cannot set session credentials: %s",
210                        gnutls_strerror(ret));
211             goto error;
212         }
213     } else if (object_dynamic_cast(OBJECT(creds),
214                                    TYPE_QCRYPTO_TLS_CREDS_X509)) {
215         QCryptoTLSCredsX509 *tcreds = QCRYPTO_TLS_CREDS_X509(creds);
216         const char *prio = creds->priority;
217         if (!prio) {
218             prio = CONFIG_TLS_PRIORITY;
219         }
220 
221         ret = gnutls_priority_set_direct(session->handle, prio, NULL);
222         if (ret < 0) {
223             error_setg(errp, "Cannot set default TLS session priority %s: %s",
224                        prio, gnutls_strerror(ret));
225             goto error;
226         }
227         ret = gnutls_credentials_set(session->handle,
228                                      GNUTLS_CRD_CERTIFICATE,
229                                      tcreds->data);
230         if (ret < 0) {
231             error_setg(errp, "Cannot set session credentials: %s",
232                        gnutls_strerror(ret));
233             goto error;
234         }
235 
236         if (creds->endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
237             /* This requests, but does not enforce a client cert.
238              * The cert checking code later does enforcement */
239             gnutls_certificate_server_set_request(session->handle,
240                                                   GNUTLS_CERT_REQUEST);
241         }
242     } else {
243         error_setg(errp, "Unsupported TLS credentials type %s",
244                    object_get_typename(OBJECT(creds)));
245         goto error;
246     }
247 
248     gnutls_transport_set_ptr(session->handle, session);
249     gnutls_transport_set_push_function(session->handle,
250                                        qcrypto_tls_session_push);
251     gnutls_transport_set_pull_function(session->handle,
252                                        qcrypto_tls_session_pull);
253 
254     return session;
255 
256  error:
257     qcrypto_tls_session_free(session);
258     return NULL;
259 }
260 
261 static int
262 qcrypto_tls_session_check_certificate(QCryptoTLSSession *session,
263                                       Error **errp)
264 {
265     int ret;
266     unsigned int status;
267     const gnutls_datum_t *certs;
268     unsigned int nCerts, i;
269     time_t now;
270     gnutls_x509_crt_t cert = NULL;
271 
272     now = time(NULL);
273     if (now == ((time_t)-1)) {
274         error_setg_errno(errp, errno, "Cannot get current time");
275         return -1;
276     }
277 
278     ret = gnutls_certificate_verify_peers2(session->handle, &status);
279     if (ret < 0) {
280         error_setg(errp, "Verify failed: %s", gnutls_strerror(ret));
281         return -1;
282     }
283 
284     if (status != 0) {
285         const char *reason = "Invalid certificate";
286 
287         if (status & GNUTLS_CERT_INVALID) {
288             reason = "The certificate is not trusted";
289         }
290 
291         if (status & GNUTLS_CERT_SIGNER_NOT_FOUND) {
292             reason = "The certificate hasn't got a known issuer";
293         }
294 
295         if (status & GNUTLS_CERT_REVOKED) {
296             reason = "The certificate has been revoked";
297         }
298 
299         if (status & GNUTLS_CERT_INSECURE_ALGORITHM) {
300             reason = "The certificate uses an insecure algorithm";
301         }
302 
303         error_setg(errp, "%s", reason);
304         return -1;
305     }
306 
307     certs = gnutls_certificate_get_peers(session->handle, &nCerts);
308     if (!certs) {
309         error_setg(errp, "No certificate peers");
310         return -1;
311     }
312 
313     for (i = 0; i < nCerts; i++) {
314         ret = gnutls_x509_crt_init(&cert);
315         if (ret < 0) {
316             error_setg(errp, "Cannot initialize certificate: %s",
317                        gnutls_strerror(ret));
318             return -1;
319         }
320 
321         ret = gnutls_x509_crt_import(cert, &certs[i], GNUTLS_X509_FMT_DER);
322         if (ret < 0) {
323             error_setg(errp, "Cannot import certificate: %s",
324                        gnutls_strerror(ret));
325             goto error;
326         }
327 
328         if (gnutls_x509_crt_get_expiration_time(cert) < now) {
329             error_setg(errp, "The certificate has expired");
330             goto error;
331         }
332 
333         if (gnutls_x509_crt_get_activation_time(cert) > now) {
334             error_setg(errp, "The certificate is not yet activated");
335             goto error;
336         }
337 
338         if (gnutls_x509_crt_get_activation_time(cert) > now) {
339             error_setg(errp, "The certificate is not yet activated");
340             goto error;
341         }
342 
343         if (i == 0) {
344             size_t dnameSize = 1024;
345             session->peername = g_malloc(dnameSize);
346         requery:
347             ret = gnutls_x509_crt_get_dn(cert, session->peername, &dnameSize);
348             if (ret < 0) {
349                 if (ret == GNUTLS_E_SHORT_MEMORY_BUFFER) {
350                     session->peername = g_realloc(session->peername,
351                                                   dnameSize);
352                     goto requery;
353                 }
354                 error_setg(errp, "Cannot get client distinguished name: %s",
355                            gnutls_strerror(ret));
356                 goto error;
357             }
358             if (session->aclname) {
359                 qemu_acl *acl = qemu_acl_find(session->aclname);
360                 int allow;
361                 if (!acl) {
362                     error_setg(errp, "Cannot find ACL %s",
363                                session->aclname);
364                     goto error;
365                 }
366 
367                 allow = qemu_acl_party_is_allowed(acl, session->peername);
368 
369                 if (!allow) {
370                     error_setg(errp, "TLS x509 ACL check for %s is denied",
371                                session->peername);
372                     goto error;
373                 }
374             }
375             if (session->hostname) {
376                 if (!gnutls_x509_crt_check_hostname(cert, session->hostname)) {
377                     error_setg(errp,
378                                "Certificate does not match the hostname %s",
379                                session->hostname);
380                     goto error;
381                 }
382             }
383         }
384 
385         gnutls_x509_crt_deinit(cert);
386     }
387 
388     return 0;
389 
390  error:
391     gnutls_x509_crt_deinit(cert);
392     return -1;
393 }
394 
395 
396 int
397 qcrypto_tls_session_check_credentials(QCryptoTLSSession *session,
398                                       Error **errp)
399 {
400     if (object_dynamic_cast(OBJECT(session->creds),
401                             TYPE_QCRYPTO_TLS_CREDS_ANON)) {
402         trace_qcrypto_tls_session_check_creds(session, "nop");
403         return 0;
404     } else if (object_dynamic_cast(OBJECT(session->creds),
405                             TYPE_QCRYPTO_TLS_CREDS_PSK)) {
406         trace_qcrypto_tls_session_check_creds(session, "nop");
407         return 0;
408     } else if (object_dynamic_cast(OBJECT(session->creds),
409                             TYPE_QCRYPTO_TLS_CREDS_X509)) {
410         if (session->creds->verifyPeer) {
411             int ret = qcrypto_tls_session_check_certificate(session,
412                                                             errp);
413             trace_qcrypto_tls_session_check_creds(session,
414                                                   ret == 0 ? "pass" : "fail");
415             return ret;
416         } else {
417             trace_qcrypto_tls_session_check_creds(session, "skip");
418             return 0;
419         }
420     } else {
421         trace_qcrypto_tls_session_check_creds(session, "error");
422         error_setg(errp, "Unexpected credential type %s",
423                    object_get_typename(OBJECT(session->creds)));
424         return -1;
425     }
426 }
427 
428 
429 void
430 qcrypto_tls_session_set_callbacks(QCryptoTLSSession *session,
431                                   QCryptoTLSSessionWriteFunc writeFunc,
432                                   QCryptoTLSSessionReadFunc readFunc,
433                                   void *opaque)
434 {
435     session->writeFunc = writeFunc;
436     session->readFunc = readFunc;
437     session->opaque = opaque;
438 }
439 
440 
441 ssize_t
442 qcrypto_tls_session_write(QCryptoTLSSession *session,
443                           const char *buf,
444                           size_t len)
445 {
446     ssize_t ret = gnutls_record_send(session->handle, buf, len);
447 
448     if (ret < 0) {
449         switch (ret) {
450         case GNUTLS_E_AGAIN:
451             errno = EAGAIN;
452             break;
453         case GNUTLS_E_INTERRUPTED:
454             errno = EINTR;
455             break;
456         default:
457             errno = EIO;
458             break;
459         }
460         ret = -1;
461     }
462 
463     return ret;
464 }
465 
466 
467 ssize_t
468 qcrypto_tls_session_read(QCryptoTLSSession *session,
469                          char *buf,
470                          size_t len)
471 {
472     ssize_t ret = gnutls_record_recv(session->handle, buf, len);
473 
474     if (ret < 0) {
475         switch (ret) {
476         case GNUTLS_E_AGAIN:
477             errno = EAGAIN;
478             break;
479         case GNUTLS_E_INTERRUPTED:
480             errno = EINTR;
481             break;
482         default:
483             errno = EIO;
484             break;
485         }
486         ret = -1;
487     }
488 
489     return ret;
490 }
491 
492 
493 int
494 qcrypto_tls_session_handshake(QCryptoTLSSession *session,
495                               Error **errp)
496 {
497     int ret = gnutls_handshake(session->handle);
498     if (ret == 0) {
499         session->handshakeComplete = true;
500     } else {
501         if (ret == GNUTLS_E_INTERRUPTED ||
502             ret == GNUTLS_E_AGAIN) {
503             ret = 1;
504         } else {
505             error_setg(errp, "TLS handshake failed: %s",
506                        gnutls_strerror(ret));
507             ret = -1;
508         }
509     }
510 
511     return ret;
512 }
513 
514 
515 QCryptoTLSSessionHandshakeStatus
516 qcrypto_tls_session_get_handshake_status(QCryptoTLSSession *session)
517 {
518     if (session->handshakeComplete) {
519         return QCRYPTO_TLS_HANDSHAKE_COMPLETE;
520     } else if (gnutls_record_get_direction(session->handle) == 0) {
521         return QCRYPTO_TLS_HANDSHAKE_RECVING;
522     } else {
523         return QCRYPTO_TLS_HANDSHAKE_SENDING;
524     }
525 }
526 
527 
528 int
529 qcrypto_tls_session_get_key_size(QCryptoTLSSession *session,
530                                  Error **errp)
531 {
532     gnutls_cipher_algorithm_t cipher;
533     int ssf;
534 
535     cipher = gnutls_cipher_get(session->handle);
536     ssf = gnutls_cipher_get_key_size(cipher);
537     if (!ssf) {
538         error_setg(errp, "Cannot get TLS cipher key size");
539         return -1;
540     }
541     return ssf;
542 }
543 
544 
545 char *
546 qcrypto_tls_session_get_peer_name(QCryptoTLSSession *session)
547 {
548     if (session->peername) {
549         return g_strdup(session->peername);
550     }
551     return NULL;
552 }
553 
554 
555 #else /* ! CONFIG_GNUTLS */
556 
557 
558 QCryptoTLSSession *
559 qcrypto_tls_session_new(QCryptoTLSCreds *creds G_GNUC_UNUSED,
560                         const char *hostname G_GNUC_UNUSED,
561                         const char *aclname G_GNUC_UNUSED,
562                         QCryptoTLSCredsEndpoint endpoint G_GNUC_UNUSED,
563                         Error **errp)
564 {
565     error_setg(errp, "TLS requires GNUTLS support");
566     return NULL;
567 }
568 
569 
570 void
571 qcrypto_tls_session_free(QCryptoTLSSession *sess G_GNUC_UNUSED)
572 {
573 }
574 
575 
576 int
577 qcrypto_tls_session_check_credentials(QCryptoTLSSession *sess G_GNUC_UNUSED,
578                                       Error **errp)
579 {
580     error_setg(errp, "TLS requires GNUTLS support");
581     return -1;
582 }
583 
584 
585 void
586 qcrypto_tls_session_set_callbacks(
587     QCryptoTLSSession *sess G_GNUC_UNUSED,
588     QCryptoTLSSessionWriteFunc writeFunc G_GNUC_UNUSED,
589     QCryptoTLSSessionReadFunc readFunc G_GNUC_UNUSED,
590     void *opaque G_GNUC_UNUSED)
591 {
592 }
593 
594 
595 ssize_t
596 qcrypto_tls_session_write(QCryptoTLSSession *sess,
597                           const char *buf,
598                           size_t len)
599 {
600     errno = -EIO;
601     return -1;
602 }
603 
604 
605 ssize_t
606 qcrypto_tls_session_read(QCryptoTLSSession *sess,
607                          char *buf,
608                          size_t len)
609 {
610     errno = -EIO;
611     return -1;
612 }
613 
614 
615 int
616 qcrypto_tls_session_handshake(QCryptoTLSSession *sess,
617                               Error **errp)
618 {
619     error_setg(errp, "TLS requires GNUTLS support");
620     return -1;
621 }
622 
623 
624 QCryptoTLSSessionHandshakeStatus
625 qcrypto_tls_session_get_handshake_status(QCryptoTLSSession *sess)
626 {
627     return QCRYPTO_TLS_HANDSHAKE_COMPLETE;
628 }
629 
630 
631 int
632 qcrypto_tls_session_get_key_size(QCryptoTLSSession *sess,
633                                  Error **errp)
634 {
635     error_setg(errp, "TLS requires GNUTLS support");
636     return -1;
637 }
638 
639 
640 char *
641 qcrypto_tls_session_get_peer_name(QCryptoTLSSession *sess)
642 {
643     return NULL;
644 }
645 
646 #endif
647