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