@samitouri / QOSamiQemu
Code Commits Issues Pulls Sessions CI/CD
master
master
c 760 lines 20.1 KB
Raw
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.1 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 "qemu/error-report.h"
23 #include "qemu/thread.h"
24 #include "crypto/tlssession.h"
25 #include "crypto/tlscredsanon.h"
26 #include "crypto/tlscredspsk.h"
27 #include "crypto/tlscredsx509.h"
28 #include "qapi/error.h"
29 #include "authz/base.h"
30 #include "tlscredspriv.h"
31 #include "trace.h"
32
33 #ifdef CONFIG_GNUTLS
34
35
36 #include <gnutls/x509.h>
37
38
39 struct QCryptoTLSSession {
40 QCryptoTLSCreds *creds;
41 QCryptoTLSCredsBox *credsbox;
42 gnutls_session_t handle;
43 char *hostname;
44 char *authzid;
45 bool handshakeComplete;
46 QCryptoTLSSessionWriteFunc writeFunc;
47 QCryptoTLSSessionReadFunc readFunc;
48 void *opaque;
49 char *peername;
50
51 /*
52 * Allow concurrent reads and writes, so track
53 * errors separately
54 */
55 Error *rerr;
56 Error *werr;
57
58 /*
59 * Used to protect against broken GNUTLS thread safety
60 * https://gitlab.com/gnutls/gnutls/-/issues/1717
61 */
62 bool requireThreadSafety;
63 bool lockEnabled;
64 QemuMutex lock;
65 };
66
67
68 void
69 qcrypto_tls_session_free(QCryptoTLSSession *session)
70 {
71 if (!session) {
72 return;
73 }
74
75 error_free(session->rerr);
76 error_free(session->werr);
77
78 gnutls_deinit(session->handle);
79 g_free(session->hostname);
80 g_free(session->peername);
81 g_free(session->authzid);
82 qcrypto_tls_creds_box_unref(session->credsbox);
83 object_unref(OBJECT(session->creds));
84 qemu_mutex_destroy(&session->lock);
85 g_free(session);
86 }
87
88
89 static ssize_t
90 qcrypto_tls_session_push(void *opaque, const void *buf, size_t len)
91 {
92 QCryptoTLSSession *session = opaque;
93 ssize_t ret;
94
95 if (!session->writeFunc) {
96 errno = EIO;
97 return -1;
98 };
99
100 if (session->lockEnabled) {
101 qemu_mutex_unlock(&session->lock);
102 }
103
104 error_free(session->werr);
105 session->werr = NULL;
106
107 ret = session->writeFunc(buf, len, session->opaque, &session->werr);
108
109 if (session->lockEnabled) {
110 qemu_mutex_lock(&session->lock);
111 }
112
113 if (ret == QCRYPTO_TLS_SESSION_ERR_BLOCK) {
114 errno = EAGAIN;
115 return -1;
116 } else if (ret < 0) {
117 errno = EIO;
118 return -1;
119 } else {
120 return ret;
121 }
122 }
123
124
125 static ssize_t
126 qcrypto_tls_session_pull(void *opaque, void *buf, size_t len)
127 {
128 QCryptoTLSSession *session = opaque;
129 ssize_t ret;
130
131 if (!session->readFunc) {
132 errno = EIO;
133 return -1;
134 };
135
136 error_free(session->rerr);
137 session->rerr = NULL;
138
139 if (session->lockEnabled) {
140 qemu_mutex_unlock(&session->lock);
141 }
142
143 ret = session->readFunc(buf, len, session->opaque, &session->rerr);
144
145 if (session->lockEnabled) {
146 qemu_mutex_lock(&session->lock);
147 }
148
149 if (ret == QCRYPTO_TLS_SESSION_ERR_BLOCK) {
150 errno = EAGAIN;
151 return -1;
152 } else if (ret < 0) {
153 errno = EIO;
154 return -1;
155 } else {
156 return ret;
157 }
158 }
159
160 QCryptoTLSSession *
161 qcrypto_tls_session_new(QCryptoTLSCreds *creds,
162 const char *hostname,
163 const char *authzid,
164 QCryptoTLSCredsEndpoint endpoint,
165 Error **errp)
166 {
167 QCryptoTLSSession *session;
168 int ret;
169 g_autofree char *prio = NULL;
170
171 session = g_new0(QCryptoTLSSession, 1);
172 trace_qcrypto_tls_session_new(
173 session, creds, hostname ? hostname : "<none>",
174 authzid ? authzid : "<none>", endpoint);
175
176 if (hostname) {
177 session->hostname = g_strdup(hostname);
178 }
179 if (authzid) {
180 session->authzid = g_strdup(authzid);
181 }
182 session->creds = creds;
183 object_ref(OBJECT(creds));
184
185 qemu_mutex_init(&session->lock);
186
187 if (creds->endpoint != endpoint) {
188 error_setg(errp, "Credentials endpoint doesn't match session");
189 goto error;
190 }
191
192 if (endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
193 ret = gnutls_init(&session->handle, GNUTLS_SERVER);
194 } else {
195 ret = gnutls_init(&session->handle, GNUTLS_CLIENT);
196 }
197 if (ret < 0) {
198 error_setg(errp, "Cannot initialize TLS session: %s",
199 gnutls_strerror(ret));
200 goto error;
201 }
202
203 prio = qcrypto_tls_creds_get_priority(creds);
204 ret = gnutls_priority_set_direct(session->handle, prio, NULL);
205 if (ret < 0) {
206 error_setg(errp, "Unable to set TLS session priority %s: %s",
207 prio, gnutls_strerror(ret));
208 goto error;
209 }
210
211 ret = gnutls_credentials_set(session->handle,
212 creds->box->type,
213 creds->box->data.any);
214 if (ret < 0) {
215 error_setg(errp, "Cannot set session credentials: %s",
216 gnutls_strerror(ret));
217 goto error;
218 }
219
220 /*
221 * creds->box->data.any must be kept alive for as long
222 * as the gnutls_session_t is alive, so acquire a ref
223 */
224 qcrypto_tls_creds_box_ref(creds->box);
225 session->credsbox = creds->box;
226
227 if (object_dynamic_cast(OBJECT(creds),
228 TYPE_QCRYPTO_TLS_CREDS_X509) &&
229 creds->endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
230 /*
231 * This requests, but does not enforce a client cert.
232 * The cert checking code later does enforcement
233 */
234 gnutls_certificate_server_set_request(session->handle,
235 GNUTLS_CERT_REQUEST);
236 }
237
238 gnutls_transport_set_ptr(session->handle, session);
239 gnutls_transport_set_push_function(session->handle,
240 qcrypto_tls_session_push);
241 gnutls_transport_set_pull_function(session->handle,
242 qcrypto_tls_session_pull);
243
244 return session;
245
246 error:
247 qcrypto_tls_session_free(session);
248 return NULL;
249 }
250
251 void qcrypto_tls_session_require_thread_safety(QCryptoTLSSession *sess)
252 {
253 sess->requireThreadSafety = true;
254 }
255
256 static int
257 qcrypto_tls_session_check_certificate(QCryptoTLSSession *session,
258 Error **errp)
259 {
260 int ret;
261 unsigned int status;
262 const gnutls_datum_t *certs;
263 unsigned int nCerts, i;
264 time_t now;
265 gnutls_x509_crt_t cert = NULL;
266 Error *err = NULL;
267
268 now = time(NULL);
269 if (now == ((time_t)-1)) {
270 error_setg_errno(errp, errno, "Cannot get current time");
271 return -1;
272 }
273
274 ret = gnutls_certificate_verify_peers2(session->handle, &status);
275 if (ret < 0) {
276 error_setg(errp, "Verify failed: %s", gnutls_strerror(ret));
277 return -1;
278 }
279
280 if (status != 0) {
281 const char *reason = "Invalid certificate";
282
283 if (status & GNUTLS_CERT_INVALID) {
284 reason = "The certificate is not trusted";
285 }
286
287 if (status & GNUTLS_CERT_SIGNER_NOT_FOUND) {
288 reason = "The certificate hasn't got a known issuer";
289 }
290
291 if (status & GNUTLS_CERT_REVOKED) {
292 reason = "The certificate has been revoked";
293 }
294
295 if (status & GNUTLS_CERT_INSECURE_ALGORITHM) {
296 reason = "The certificate uses an insecure algorithm";
297 }
298
299 error_setg(errp, "%s", reason);
300 return -1;
301 }
302
303 certs = gnutls_certificate_get_peers(session->handle, &nCerts);
304 if (!certs) {
305 error_setg(errp, "No certificate peers");
306 return -1;
307 }
308
309 for (i = 0; i < nCerts; i++) {
310 ret = gnutls_x509_crt_init(&cert);
311 if (ret < 0) {
312 error_setg(errp, "Cannot initialize certificate: %s",
313 gnutls_strerror(ret));
314 return -1;
315 }
316
317 ret = gnutls_x509_crt_import(cert, &certs[i], GNUTLS_X509_FMT_DER);
318 if (ret < 0) {
319 error_setg(errp, "Cannot import certificate: %s",
320 gnutls_strerror(ret));
321 goto error;
322 }
323
324 if (gnutls_x509_crt_get_expiration_time(cert) < now) {
325 error_setg(errp, "The certificate has expired");
326 goto error;
327 }
328
329 if (gnutls_x509_crt_get_activation_time(cert) > now) {
330 error_setg(errp, "The certificate is not yet activated");
331 goto error;
332 }
333
334 if (gnutls_x509_crt_get_activation_time(cert) > now) {
335 error_setg(errp, "The certificate is not yet activated");
336 goto error;
337 }
338
339 if (i == 0) {
340 gnutls_datum_t dname = {};
341 ret = gnutls_x509_crt_get_dn2(cert, &dname);
342 if (ret < 0) {
343 error_setg(errp, "Cannot get client distinguished name: %s",
344 gnutls_strerror(ret));
345 goto error;
346 }
347 session->peername = (char *)g_steal_pointer(&dname.data);
348 trace_qcrypto_tls_session_check_x509_dn(session, session->peername);
349 if (session->authzid) {
350 bool allow;
351
352 allow = qauthz_is_allowed_by_id(session->authzid,
353 session->peername, &err);
354 if (err) {
355 error_propagate(errp, err);
356 goto error;
357 }
358 if (!allow) {
359 error_setg(errp, "TLS x509 authz check for %s is denied",
360 session->peername);
361 goto error;
362 }
363 }
364 if (session->hostname) {
365 if (!gnutls_x509_crt_check_hostname(cert, session->hostname)) {
366 error_setg(errp,
367 "Certificate does not match the hostname %s",
368 session->hostname);
369 goto error;
370 }
371 } else {
372 if (session->creds->endpoint ==
373 QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT) {
374 error_setg(errp, "No hostname for certificate validation");
375 goto error;
376 }
377 }
378 }
379
380 gnutls_x509_crt_deinit(cert);
381 }
382
383 return 0;
384
385 error:
386 gnutls_x509_crt_deinit(cert);
387 return -1;
388 }
389
390
391 int
392 qcrypto_tls_session_check_credentials(QCryptoTLSSession *session,
393 Error **errp)
394 {
395 if (object_dynamic_cast(OBJECT(session->creds),
396 TYPE_QCRYPTO_TLS_CREDS_ANON)) {
397 trace_qcrypto_tls_session_check_creds(session, "nop");
398 return 0;
399 } else if (object_dynamic_cast(OBJECT(session->creds),
400 TYPE_QCRYPTO_TLS_CREDS_PSK)) {
401 trace_qcrypto_tls_session_check_creds(session, "nop");
402 return 0;
403 } else if (object_dynamic_cast(OBJECT(session->creds),
404 TYPE_QCRYPTO_TLS_CREDS_X509)) {
405 if (session->creds->verifyPeer) {
406 int ret = qcrypto_tls_session_check_certificate(session,
407 errp);
408 trace_qcrypto_tls_session_check_creds(session,
409 ret == 0 ? "pass" : "fail");
410 return ret;
411 } else {
412 trace_qcrypto_tls_session_check_creds(session, "skip");
413 return 0;
414 }
415 } else {
416 trace_qcrypto_tls_session_check_creds(session, "error");
417 error_setg(errp, "Unexpected credential type %s",
418 object_get_typename(OBJECT(session->creds)));
419 return -1;
420 }
421 }
422
423
424 void
425 qcrypto_tls_session_set_callbacks(QCryptoTLSSession *session,
426 QCryptoTLSSessionWriteFunc writeFunc,
427 QCryptoTLSSessionReadFunc readFunc,
428 void *opaque)
429 {
430 session->writeFunc = writeFunc;
431 session->readFunc = readFunc;
432 session->opaque = opaque;
433 }
434
435
436 ssize_t
437 qcrypto_tls_session_write(QCryptoTLSSession *session,
438 const char *buf,
439 size_t len,
440 Error **errp)
441 {
442 ssize_t ret;
443
444 if (session->lockEnabled) {
445 qemu_mutex_lock(&session->lock);
446 }
447
448 ret = gnutls_record_send(session->handle, buf, len);
449
450 if (session->lockEnabled) {
451 qemu_mutex_unlock(&session->lock);
452 }
453
454 if (ret < 0) {
455 if (ret == GNUTLS_E_AGAIN) {
456 return QCRYPTO_TLS_SESSION_ERR_BLOCK;
457 } else {
458 if (session->werr) {
459 error_propagate(errp, session->werr);
460 session->werr = NULL;
461 } else {
462 error_setg(errp,
463 "Cannot write to TLS channel: %s",
464 gnutls_strerror(ret));
465 }
466 return -1;
467 }
468 }
469
470 return ret;
471 }
472
473
474 ssize_t
475 qcrypto_tls_session_read(QCryptoTLSSession *session,
476 char *buf,
477 size_t len,
478 Error **errp)
479 {
480 ssize_t ret;
481
482 if (session->lockEnabled) {
483 qemu_mutex_lock(&session->lock);
484 }
485
486 ret = gnutls_record_recv(session->handle, buf, len);
487
488 if (session->lockEnabled) {
489 qemu_mutex_unlock(&session->lock);
490 }
491
492 if (ret < 0) {
493 if (ret == GNUTLS_E_AGAIN) {
494 return QCRYPTO_TLS_SESSION_ERR_BLOCK;
495 } else {
496 if (session->rerr) {
497 error_propagate(errp, session->rerr);
498 session->rerr = NULL;
499 } else {
500 error_setg(errp,
501 "Cannot read from TLS channel: %s",
502 gnutls_strerror(ret));
503 }
504 if (ret == GNUTLS_E_PREMATURE_TERMINATION) {
505 return QCRYPTO_TLS_SESSION_PREMATURE_TERMINATION;
506 } else {
507 return -1;
508 }
509 }
510 }
511
512 return ret;
513 }
514
515
516 size_t
517 qcrypto_tls_session_check_pending(QCryptoTLSSession *session)
518 {
519 return gnutls_record_check_pending(session->handle);
520 }
521
522
523 int
524 qcrypto_tls_session_handshake(QCryptoTLSSession *session,
525 Error **errp)
526 {
527 int ret;
528 ret = gnutls_handshake(session->handle);
529
530 if (!ret) {
531 #ifdef CONFIG_GNUTLS_BUG1717_WORKAROUND
532 gnutls_cipher_algorithm_t cipher =
533 gnutls_cipher_get(session->handle);
534
535 /*
536 * Any use of rekeying in TLS 1.3 is unsafe for
537 * a gnutls with bug 1717, however, we know that
538 * QEMU won't initiate manual rekeying. Thus we
539 * only have to protect against automatic rekeying
540 * which doesn't trigger with CHACHA20
541 */
542 trace_qcrypto_tls_session_parameters(
543 session,
544 session->requireThreadSafety,
545 gnutls_protocol_get_version(session->handle),
546 cipher);
547
548 if (session->requireThreadSafety &&
549 gnutls_protocol_get_version(session->handle) ==
550 GNUTLS_TLS1_3 &&
551 cipher != GNUTLS_CIPHER_CHACHA20_POLY1305) {
552 warn_report("WARNING: activating thread safety countermeasures "
553 "for potentially broken GNUTLS with TLS1.3 cipher=%d",
554 cipher);
555 trace_qcrypto_tls_session_bug1717_workaround(session);
556 session->lockEnabled = true;
557 }
558 #endif
559
560 session->handshakeComplete = true;
561 return QCRYPTO_TLS_HANDSHAKE_COMPLETE;
562 }
563
564 if (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN) {
565 int direction = gnutls_record_get_direction(session->handle);
566 return direction ? QCRYPTO_TLS_HANDSHAKE_SENDING :
567 QCRYPTO_TLS_HANDSHAKE_RECVING;
568 }
569
570 if (session->rerr || session->werr) {
571 error_setg(errp, "TLS handshake failed: %s: %s",
572 gnutls_strerror(ret),
573 error_get_pretty(session->rerr ?
574 session->rerr : session->werr));
575 } else {
576 error_setg(errp, "TLS handshake failed: %s",
577 gnutls_strerror(ret));
578 }
579
580 error_free(session->rerr);
581 error_free(session->werr);
582 session->rerr = session->werr = NULL;
583
584 return -1;
585 }
586
587
588 int
589 qcrypto_tls_session_bye(QCryptoTLSSession *session, Error **errp)
590 {
591 int ret;
592
593 if (!session->handshakeComplete) {
594 return 0;
595 }
596
597 if (session->lockEnabled) {
598 qemu_mutex_lock(&session->lock);
599 }
600 ret = gnutls_bye(session->handle, GNUTLS_SHUT_WR);
601
602 if (session->lockEnabled) {
603 qemu_mutex_unlock(&session->lock);
604 }
605
606 if (!ret) {
607 return QCRYPTO_TLS_BYE_COMPLETE;
608 }
609
610 if (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN) {
611 int direction = gnutls_record_get_direction(session->handle);
612 return direction ? QCRYPTO_TLS_BYE_SENDING : QCRYPTO_TLS_BYE_RECVING;
613 }
614
615 if (session->rerr || session->werr) {
616 error_setg(errp, "TLS termination failed: %s: %s", gnutls_strerror(ret),
617 error_get_pretty(session->rerr ?
618 session->rerr : session->werr));
619 } else {
620 error_setg(errp, "TLS termination failed: %s", gnutls_strerror(ret));
621 }
622
623 error_free(session->rerr);
624 error_free(session->werr);
625 session->rerr = session->werr = NULL;
626
627 return -1;
628 }
629
630 int
631 qcrypto_tls_session_get_key_size(QCryptoTLSSession *session,
632 Error **errp)
633 {
634 gnutls_cipher_algorithm_t cipher;
635 int ssf;
636
637 cipher = gnutls_cipher_get(session->handle);
638 ssf = gnutls_cipher_get_key_size(cipher);
639 if (!ssf) {
640 error_setg(errp, "Cannot get TLS cipher key size");
641 return -1;
642 }
643 return ssf;
644 }
645
646
647 char *
648 qcrypto_tls_session_get_peer_name(QCryptoTLSSession *session)
649 {
650 if (session->peername) {
651 return g_strdup(session->peername);
652 }
653 return NULL;
654 }
655
656
657 #else /* ! CONFIG_GNUTLS */
658
659
660 QCryptoTLSSession *
661 qcrypto_tls_session_new(QCryptoTLSCreds *creds G_GNUC_UNUSED,
662 const char *hostname G_GNUC_UNUSED,
663 const char *authzid G_GNUC_UNUSED,
664 QCryptoTLSCredsEndpoint endpoint G_GNUC_UNUSED,
665 Error **errp)
666 {
667 error_setg(errp, "TLS requires GNUTLS support");
668 return NULL;
669 }
670
671 void qcrypto_tls_session_require_thread_safety(QCryptoTLSSession *sess)
672 {
673 }
674
675 void
676 qcrypto_tls_session_free(QCryptoTLSSession *sess G_GNUC_UNUSED)
677 {
678 }
679
680
681 int
682 qcrypto_tls_session_check_credentials(QCryptoTLSSession *sess G_GNUC_UNUSED,
683 Error **errp)
684 {
685 error_setg(errp, "TLS requires GNUTLS support");
686 return -1;
687 }
688
689
690 void
691 qcrypto_tls_session_set_callbacks(
692 QCryptoTLSSession *sess G_GNUC_UNUSED,
693 QCryptoTLSSessionWriteFunc writeFunc G_GNUC_UNUSED,
694 QCryptoTLSSessionReadFunc readFunc G_GNUC_UNUSED,
695 void *opaque G_GNUC_UNUSED)
696 {
697 }
698
699
700 ssize_t
701 qcrypto_tls_session_write(QCryptoTLSSession *sess,
702 const char *buf,
703 size_t len,
704 Error **errp)
705 {
706 error_setg(errp, "TLS requires GNUTLS support");
707 return -1;
708 }
709
710
711 ssize_t
712 qcrypto_tls_session_read(QCryptoTLSSession *sess,
713 char *buf,
714 size_t len,
715 Error **errp)
716 {
717 error_setg(errp, "TLS requires GNUTLS support");
718 return -1;
719 }
720
721
722 size_t
723 qcrypto_tls_session_check_pending(QCryptoTLSSession *session)
724 {
725 return 0;
726 }
727
728
729 int
730 qcrypto_tls_session_handshake(QCryptoTLSSession *sess,
731 Error **errp)
732 {
733 error_setg(errp, "TLS requires GNUTLS support");
734 return -1;
735 }
736
737
738 int
739 qcrypto_tls_session_bye(QCryptoTLSSession *session, Error **errp)
740 {
741 return QCRYPTO_TLS_BYE_COMPLETE;
742 }
743
744
745 int
746 qcrypto_tls_session_get_key_size(QCryptoTLSSession *sess,
747 Error **errp)
748 {
749 error_setg(errp, "TLS requires GNUTLS support");
750 return -1;
751 }
752
753
754 char *
755 qcrypto_tls_session_get_peer_name(QCryptoTLSSession *sess)
756 {
757 return NULL;
758 }
759
760 #endif