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