Merge tag 'pull-target-arm-20220809' of https://git.linaro.org/people/pmaydell/qemu...
[qemu.git] / crypto / tlscredsx509.c
1 /*
2 * QEMU crypto TLS x509 credential 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 "crypto/tlscredsx509.h"
23 #include "tlscredspriv.h"
24 #include "crypto/secret.h"
25 #include "qapi/error.h"
26 #include "qemu/module.h"
27 #include "qom/object_interfaces.h"
28 #include "trace.h"
29
30
31 #ifdef CONFIG_GNUTLS
32
33 #include <gnutls/gnutls.h>
34 #include <gnutls/x509.h>
35
36
37 static int
38 qcrypto_tls_creds_check_cert_times(gnutls_x509_crt_t cert,
39 const char *certFile,
40 bool isServer,
41 bool isCA,
42 Error **errp)
43 {
44 time_t now = time(NULL);
45
46 if (now == ((time_t)-1)) {
47 error_setg_errno(errp, errno, "cannot get current time");
48 return -1;
49 }
50
51 if (gnutls_x509_crt_get_expiration_time(cert) < now) {
52 error_setg(errp,
53 (isCA ?
54 "The CA certificate %s has expired" :
55 (isServer ?
56 "The server certificate %s has expired" :
57 "The client certificate %s has expired")),
58 certFile);
59 return -1;
60 }
61
62 if (gnutls_x509_crt_get_activation_time(cert) > now) {
63 error_setg(errp,
64 (isCA ?
65 "The CA certificate %s is not yet active" :
66 (isServer ?
67 "The server certificate %s is not yet active" :
68 "The client certificate %s is not yet active")),
69 certFile);
70 return -1;
71 }
72
73 return 0;
74 }
75
76
77 static int
78 qcrypto_tls_creds_check_cert_basic_constraints(QCryptoTLSCredsX509 *creds,
79 gnutls_x509_crt_t cert,
80 const char *certFile,
81 bool isServer,
82 bool isCA,
83 Error **errp)
84 {
85 int status;
86
87 status = gnutls_x509_crt_get_basic_constraints(cert, NULL, NULL, NULL);
88 trace_qcrypto_tls_creds_x509_check_basic_constraints(
89 creds, certFile, status);
90
91 if (status > 0) { /* It is a CA cert */
92 if (!isCA) {
93 error_setg(errp, isServer ?
94 "The certificate %s basic constraints show a CA, "
95 "but we need one for a server" :
96 "The certificate %s basic constraints show a CA, "
97 "but we need one for a client",
98 certFile);
99 return -1;
100 }
101 } else if (status == 0) { /* It is not a CA cert */
102 if (isCA) {
103 error_setg(errp,
104 "The certificate %s basic constraints do not "
105 "show a CA",
106 certFile);
107 return -1;
108 }
109 } else if (status == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE) {
110 /* Missing basicConstraints */
111 if (isCA) {
112 error_setg(errp,
113 "The certificate %s is missing basic constraints "
114 "for a CA",
115 certFile);
116 return -1;
117 }
118 } else { /* General error */
119 error_setg(errp,
120 "Unable to query certificate %s basic constraints: %s",
121 certFile, gnutls_strerror(status));
122 return -1;
123 }
124
125 return 0;
126 }
127
128
129 static int
130 qcrypto_tls_creds_check_cert_key_usage(QCryptoTLSCredsX509 *creds,
131 gnutls_x509_crt_t cert,
132 const char *certFile,
133 bool isCA,
134 Error **errp)
135 {
136 int status;
137 unsigned int usage = 0;
138 unsigned int critical = 0;
139
140 status = gnutls_x509_crt_get_key_usage(cert, &usage, &critical);
141 trace_qcrypto_tls_creds_x509_check_key_usage(
142 creds, certFile, status, usage, critical);
143
144 if (status < 0) {
145 if (status == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE) {
146 usage = isCA ? GNUTLS_KEY_KEY_CERT_SIGN :
147 GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT;
148 } else {
149 error_setg(errp,
150 "Unable to query certificate %s key usage: %s",
151 certFile, gnutls_strerror(status));
152 return -1;
153 }
154 }
155
156 if (isCA) {
157 if (!(usage & GNUTLS_KEY_KEY_CERT_SIGN)) {
158 if (critical) {
159 error_setg(errp,
160 "Certificate %s usage does not permit "
161 "certificate signing", certFile);
162 return -1;
163 }
164 }
165 } else {
166 if (!(usage & GNUTLS_KEY_DIGITAL_SIGNATURE)) {
167 if (critical) {
168 error_setg(errp,
169 "Certificate %s usage does not permit digital "
170 "signature", certFile);
171 return -1;
172 }
173 }
174 if (!(usage & GNUTLS_KEY_KEY_ENCIPHERMENT)) {
175 if (critical) {
176 error_setg(errp,
177 "Certificate %s usage does not permit key "
178 "encipherment", certFile);
179 return -1;
180 }
181 }
182 }
183
184 return 0;
185 }
186
187
188 static int
189 qcrypto_tls_creds_check_cert_key_purpose(QCryptoTLSCredsX509 *creds,
190 gnutls_x509_crt_t cert,
191 const char *certFile,
192 bool isServer,
193 Error **errp)
194 {
195 int status;
196 size_t i;
197 unsigned int purposeCritical;
198 unsigned int critical;
199 char *buffer = NULL;
200 size_t size;
201 bool allowClient = false, allowServer = false;
202
203 critical = 0;
204 for (i = 0; ; i++) {
205 size = 0;
206 status = gnutls_x509_crt_get_key_purpose_oid(cert, i, buffer,
207 &size, NULL);
208
209 if (status == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE) {
210
211 /* If there is no data at all, then we must allow
212 client/server to pass */
213 if (i == 0) {
214 allowServer = allowClient = true;
215 }
216 break;
217 }
218 if (status != GNUTLS_E_SHORT_MEMORY_BUFFER) {
219 error_setg(errp,
220 "Unable to query certificate %s key purpose: %s",
221 certFile, gnutls_strerror(status));
222 return -1;
223 }
224
225 buffer = g_new0(char, size);
226
227 status = gnutls_x509_crt_get_key_purpose_oid(cert, i, buffer,
228 &size, &purposeCritical);
229
230 if (status < 0) {
231 trace_qcrypto_tls_creds_x509_check_key_purpose(
232 creds, certFile, status, "<none>", purposeCritical);
233 g_free(buffer);
234 error_setg(errp,
235 "Unable to query certificate %s key purpose: %s",
236 certFile, gnutls_strerror(status));
237 return -1;
238 }
239 trace_qcrypto_tls_creds_x509_check_key_purpose(
240 creds, certFile, status, buffer, purposeCritical);
241 if (purposeCritical) {
242 critical = true;
243 }
244
245 if (g_str_equal(buffer, GNUTLS_KP_TLS_WWW_SERVER)) {
246 allowServer = true;
247 } else if (g_str_equal(buffer, GNUTLS_KP_TLS_WWW_CLIENT)) {
248 allowClient = true;
249 } else if (g_str_equal(buffer, GNUTLS_KP_ANY)) {
250 allowServer = allowClient = true;
251 }
252
253 g_free(buffer);
254 buffer = NULL;
255 }
256
257 if (isServer) {
258 if (!allowServer) {
259 if (critical) {
260 error_setg(errp,
261 "Certificate %s purpose does not allow "
262 "use with a TLS server", certFile);
263 return -1;
264 }
265 }
266 } else {
267 if (!allowClient) {
268 if (critical) {
269 error_setg(errp,
270 "Certificate %s purpose does not allow use "
271 "with a TLS client", certFile);
272 return -1;
273 }
274 }
275 }
276
277 return 0;
278 }
279
280
281 static int
282 qcrypto_tls_creds_check_cert(QCryptoTLSCredsX509 *creds,
283 gnutls_x509_crt_t cert,
284 const char *certFile,
285 bool isServer,
286 bool isCA,
287 Error **errp)
288 {
289 if (qcrypto_tls_creds_check_cert_times(cert, certFile,
290 isServer, isCA,
291 errp) < 0) {
292 return -1;
293 }
294
295 if (qcrypto_tls_creds_check_cert_basic_constraints(creds,
296 cert, certFile,
297 isServer, isCA,
298 errp) < 0) {
299 return -1;
300 }
301
302 if (qcrypto_tls_creds_check_cert_key_usage(creds,
303 cert, certFile,
304 isCA, errp) < 0) {
305 return -1;
306 }
307
308 if (!isCA &&
309 qcrypto_tls_creds_check_cert_key_purpose(creds,
310 cert, certFile,
311 isServer, errp) < 0) {
312 return -1;
313 }
314
315 return 0;
316 }
317
318
319 static int
320 qcrypto_tls_creds_check_cert_pair(gnutls_x509_crt_t cert,
321 const char *certFile,
322 gnutls_x509_crt_t *cacerts,
323 size_t ncacerts,
324 const char *cacertFile,
325 bool isServer,
326 Error **errp)
327 {
328 unsigned int status;
329
330 if (gnutls_x509_crt_list_verify(&cert, 1,
331 cacerts, ncacerts,
332 NULL, 0,
333 0, &status) < 0) {
334 error_setg(errp, isServer ?
335 "Unable to verify server certificate %s against "
336 "CA certificate %s" :
337 "Unable to verify client certificate %s against "
338 "CA certificate %s",
339 certFile, cacertFile);
340 return -1;
341 }
342
343 if (status != 0) {
344 const char *reason = "Invalid certificate";
345
346 if (status & GNUTLS_CERT_INVALID) {
347 reason = "The certificate is not trusted";
348 }
349
350 if (status & GNUTLS_CERT_SIGNER_NOT_FOUND) {
351 reason = "The certificate hasn't got a known issuer";
352 }
353
354 if (status & GNUTLS_CERT_REVOKED) {
355 reason = "The certificate has been revoked";
356 }
357
358 if (status & GNUTLS_CERT_INSECURE_ALGORITHM) {
359 reason = "The certificate uses an insecure algorithm";
360 }
361
362 error_setg(errp,
363 "Our own certificate %s failed validation against %s: %s",
364 certFile, cacertFile, reason);
365 return -1;
366 }
367
368 return 0;
369 }
370
371
372 static gnutls_x509_crt_t
373 qcrypto_tls_creds_load_cert(QCryptoTLSCredsX509 *creds,
374 const char *certFile,
375 bool isServer,
376 Error **errp)
377 {
378 gnutls_datum_t data;
379 gnutls_x509_crt_t cert = NULL;
380 g_autofree char *buf = NULL;
381 gsize buflen;
382 GError *gerr = NULL;
383 int ret = -1;
384 int err;
385
386 trace_qcrypto_tls_creds_x509_load_cert(creds, isServer, certFile);
387
388 err = gnutls_x509_crt_init(&cert);
389 if (err < 0) {
390 error_setg(errp, "Unable to initialize certificate: %s",
391 gnutls_strerror(err));
392 goto cleanup;
393 }
394
395 if (!g_file_get_contents(certFile, &buf, &buflen, &gerr)) {
396 error_setg(errp, "Cannot load CA cert list %s: %s",
397 certFile, gerr->message);
398 g_error_free(gerr);
399 goto cleanup;
400 }
401
402 data.data = (unsigned char *)buf;
403 data.size = strlen(buf);
404
405 err = gnutls_x509_crt_import(cert, &data, GNUTLS_X509_FMT_PEM);
406 if (err < 0) {
407 error_setg(errp, isServer ?
408 "Unable to import server certificate %s: %s" :
409 "Unable to import client certificate %s: %s",
410 certFile,
411 gnutls_strerror(err));
412 goto cleanup;
413 }
414
415 ret = 0;
416
417 cleanup:
418 if (ret != 0) {
419 gnutls_x509_crt_deinit(cert);
420 cert = NULL;
421 }
422 return cert;
423 }
424
425
426 static int
427 qcrypto_tls_creds_load_ca_cert_list(QCryptoTLSCredsX509 *creds,
428 const char *certFile,
429 gnutls_x509_crt_t *certs,
430 unsigned int certMax,
431 size_t *ncerts,
432 Error **errp)
433 {
434 gnutls_datum_t data;
435 g_autofree char *buf = NULL;
436 gsize buflen;
437 GError *gerr = NULL;
438
439 *ncerts = 0;
440 trace_qcrypto_tls_creds_x509_load_cert_list(creds, certFile);
441
442 if (!g_file_get_contents(certFile, &buf, &buflen, &gerr)) {
443 error_setg(errp, "Cannot load CA cert list %s: %s",
444 certFile, gerr->message);
445 g_error_free(gerr);
446 return -1;
447 }
448
449 data.data = (unsigned char *)buf;
450 data.size = strlen(buf);
451
452 if (gnutls_x509_crt_list_import(certs, &certMax, &data,
453 GNUTLS_X509_FMT_PEM, 0) < 0) {
454 error_setg(errp,
455 "Unable to import CA certificate list %s",
456 certFile);
457 return -1;
458 }
459 *ncerts = certMax;
460
461 return 0;
462 }
463
464
465 #define MAX_CERTS 16
466 static int
467 qcrypto_tls_creds_x509_sanity_check(QCryptoTLSCredsX509 *creds,
468 bool isServer,
469 const char *cacertFile,
470 const char *certFile,
471 Error **errp)
472 {
473 gnutls_x509_crt_t cert = NULL;
474 gnutls_x509_crt_t cacerts[MAX_CERTS];
475 size_t ncacerts = 0;
476 size_t i;
477 int ret = -1;
478
479 memset(cacerts, 0, sizeof(cacerts));
480 if (certFile &&
481 access(certFile, R_OK) == 0) {
482 cert = qcrypto_tls_creds_load_cert(creds,
483 certFile, isServer,
484 errp);
485 if (!cert) {
486 goto cleanup;
487 }
488 }
489 if (access(cacertFile, R_OK) == 0) {
490 if (qcrypto_tls_creds_load_ca_cert_list(creds,
491 cacertFile, cacerts,
492 MAX_CERTS, &ncacerts,
493 errp) < 0) {
494 goto cleanup;
495 }
496 }
497
498 if (cert &&
499 qcrypto_tls_creds_check_cert(creds,
500 cert, certFile, isServer,
501 false, errp) < 0) {
502 goto cleanup;
503 }
504
505 for (i = 0; i < ncacerts; i++) {
506 if (qcrypto_tls_creds_check_cert(creds,
507 cacerts[i], cacertFile,
508 isServer, true, errp) < 0) {
509 goto cleanup;
510 }
511 }
512
513 if (cert && ncacerts &&
514 qcrypto_tls_creds_check_cert_pair(cert, certFile, cacerts,
515 ncacerts, cacertFile,
516 isServer, errp) < 0) {
517 goto cleanup;
518 }
519
520 ret = 0;
521
522 cleanup:
523 if (cert) {
524 gnutls_x509_crt_deinit(cert);
525 }
526 for (i = 0; i < ncacerts; i++) {
527 gnutls_x509_crt_deinit(cacerts[i]);
528 }
529 return ret;
530 }
531
532
533 static int
534 qcrypto_tls_creds_x509_load(QCryptoTLSCredsX509 *creds,
535 Error **errp)
536 {
537 char *cacert = NULL, *cacrl = NULL, *cert = NULL,
538 *key = NULL, *dhparams = NULL;
539 int ret;
540 int rv = -1;
541
542 trace_qcrypto_tls_creds_x509_load(creds,
543 creds->parent_obj.dir ? creds->parent_obj.dir : "<nodir>");
544
545 if (creds->parent_obj.endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
546 if (qcrypto_tls_creds_get_path(&creds->parent_obj,
547 QCRYPTO_TLS_CREDS_X509_CA_CERT,
548 true, &cacert, errp) < 0 ||
549 qcrypto_tls_creds_get_path(&creds->parent_obj,
550 QCRYPTO_TLS_CREDS_X509_CA_CRL,
551 false, &cacrl, errp) < 0 ||
552 qcrypto_tls_creds_get_path(&creds->parent_obj,
553 QCRYPTO_TLS_CREDS_X509_SERVER_CERT,
554 true, &cert, errp) < 0 ||
555 qcrypto_tls_creds_get_path(&creds->parent_obj,
556 QCRYPTO_TLS_CREDS_X509_SERVER_KEY,
557 true, &key, errp) < 0 ||
558 qcrypto_tls_creds_get_path(&creds->parent_obj,
559 QCRYPTO_TLS_CREDS_DH_PARAMS,
560 false, &dhparams, errp) < 0) {
561 goto cleanup;
562 }
563 } else {
564 if (qcrypto_tls_creds_get_path(&creds->parent_obj,
565 QCRYPTO_TLS_CREDS_X509_CA_CERT,
566 true, &cacert, errp) < 0 ||
567 qcrypto_tls_creds_get_path(&creds->parent_obj,
568 QCRYPTO_TLS_CREDS_X509_CLIENT_CERT,
569 false, &cert, errp) < 0 ||
570 qcrypto_tls_creds_get_path(&creds->parent_obj,
571 QCRYPTO_TLS_CREDS_X509_CLIENT_KEY,
572 false, &key, errp) < 0) {
573 goto cleanup;
574 }
575 }
576
577 if (creds->sanityCheck &&
578 qcrypto_tls_creds_x509_sanity_check(creds,
579 creds->parent_obj.endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER,
580 cacert, cert, errp) < 0) {
581 goto cleanup;
582 }
583
584 ret = gnutls_certificate_allocate_credentials(&creds->data);
585 if (ret < 0) {
586 error_setg(errp, "Cannot allocate credentials: '%s'",
587 gnutls_strerror(ret));
588 goto cleanup;
589 }
590
591 ret = gnutls_certificate_set_x509_trust_file(creds->data,
592 cacert,
593 GNUTLS_X509_FMT_PEM);
594 if (ret < 0) {
595 error_setg(errp, "Cannot load CA certificate '%s': %s",
596 cacert, gnutls_strerror(ret));
597 goto cleanup;
598 }
599
600 if (cert != NULL && key != NULL) {
601 char *password = NULL;
602 if (creds->passwordid) {
603 password = qcrypto_secret_lookup_as_utf8(creds->passwordid,
604 errp);
605 if (!password) {
606 goto cleanup;
607 }
608 }
609 ret = gnutls_certificate_set_x509_key_file2(creds->data,
610 cert, key,
611 GNUTLS_X509_FMT_PEM,
612 password,
613 0);
614 g_free(password);
615 if (ret < 0) {
616 error_setg(errp, "Cannot load certificate '%s' & key '%s': %s",
617 cert, key, gnutls_strerror(ret));
618 goto cleanup;
619 }
620 }
621
622 if (cacrl != NULL) {
623 ret = gnutls_certificate_set_x509_crl_file(creds->data,
624 cacrl,
625 GNUTLS_X509_FMT_PEM);
626 if (ret < 0) {
627 error_setg(errp, "Cannot load CRL '%s': %s",
628 cacrl, gnutls_strerror(ret));
629 goto cleanup;
630 }
631 }
632
633 if (creds->parent_obj.endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) {
634 if (qcrypto_tls_creds_get_dh_params_file(&creds->parent_obj, dhparams,
635 &creds->parent_obj.dh_params,
636 errp) < 0) {
637 goto cleanup;
638 }
639 gnutls_certificate_set_dh_params(creds->data,
640 creds->parent_obj.dh_params);
641 }
642
643 rv = 0;
644 cleanup:
645 g_free(cacert);
646 g_free(cacrl);
647 g_free(cert);
648 g_free(key);
649 g_free(dhparams);
650 return rv;
651 }
652
653
654 static void
655 qcrypto_tls_creds_x509_unload(QCryptoTLSCredsX509 *creds)
656 {
657 if (creds->data) {
658 gnutls_certificate_free_credentials(creds->data);
659 creds->data = NULL;
660 }
661 if (creds->parent_obj.dh_params) {
662 gnutls_dh_params_deinit(creds->parent_obj.dh_params);
663 creds->parent_obj.dh_params = NULL;
664 }
665 }
666
667
668 #else /* ! CONFIG_GNUTLS */
669
670
671 static void
672 qcrypto_tls_creds_x509_load(QCryptoTLSCredsX509 *creds G_GNUC_UNUSED,
673 Error **errp)
674 {
675 error_setg(errp, "TLS credentials support requires GNUTLS");
676 }
677
678
679 static void
680 qcrypto_tls_creds_x509_unload(QCryptoTLSCredsX509 *creds G_GNUC_UNUSED)
681 {
682 /* nada */
683 }
684
685
686 #endif /* ! CONFIG_GNUTLS */
687
688
689 static void
690 qcrypto_tls_creds_x509_prop_set_loaded(Object *obj,
691 bool value,
692 Error **errp)
693 {
694 QCryptoTLSCredsX509 *creds = QCRYPTO_TLS_CREDS_X509(obj);
695
696 qcrypto_tls_creds_x509_unload(creds);
697 if (value) {
698 qcrypto_tls_creds_x509_load(creds, errp);
699 }
700 }
701
702
703 #ifdef CONFIG_GNUTLS
704
705
706 static bool
707 qcrypto_tls_creds_x509_prop_get_loaded(Object *obj,
708 Error **errp G_GNUC_UNUSED)
709 {
710 QCryptoTLSCredsX509 *creds = QCRYPTO_TLS_CREDS_X509(obj);
711
712 return creds->data != NULL;
713 }
714
715
716 #else /* ! CONFIG_GNUTLS */
717
718
719 static bool
720 qcrypto_tls_creds_x509_prop_get_loaded(Object *obj G_GNUC_UNUSED,
721 Error **errp G_GNUC_UNUSED)
722 {
723 return false;
724 }
725
726
727 #endif /* ! CONFIG_GNUTLS */
728
729
730 static void
731 qcrypto_tls_creds_x509_prop_set_sanity(Object *obj,
732 bool value,
733 Error **errp G_GNUC_UNUSED)
734 {
735 QCryptoTLSCredsX509 *creds = QCRYPTO_TLS_CREDS_X509(obj);
736
737 creds->sanityCheck = value;
738 }
739
740
741 static void
742 qcrypto_tls_creds_x509_prop_set_passwordid(Object *obj,
743 const char *value,
744 Error **errp G_GNUC_UNUSED)
745 {
746 QCryptoTLSCredsX509 *creds = QCRYPTO_TLS_CREDS_X509(obj);
747
748 creds->passwordid = g_strdup(value);
749 }
750
751
752 static char *
753 qcrypto_tls_creds_x509_prop_get_passwordid(Object *obj,
754 Error **errp G_GNUC_UNUSED)
755 {
756 QCryptoTLSCredsX509 *creds = QCRYPTO_TLS_CREDS_X509(obj);
757
758 return g_strdup(creds->passwordid);
759 }
760
761
762 static bool
763 qcrypto_tls_creds_x509_prop_get_sanity(Object *obj,
764 Error **errp G_GNUC_UNUSED)
765 {
766 QCryptoTLSCredsX509 *creds = QCRYPTO_TLS_CREDS_X509(obj);
767
768 return creds->sanityCheck;
769 }
770
771
772 #ifdef CONFIG_GNUTLS
773
774
775 static bool
776 qcrypto_tls_creds_x509_reload(QCryptoTLSCreds *creds, Error **errp)
777 {
778 QCryptoTLSCredsX509 *x509_creds = QCRYPTO_TLS_CREDS_X509(creds);
779 Error *local_err = NULL;
780 gnutls_certificate_credentials_t creds_data = x509_creds->data;
781 gnutls_dh_params_t creds_dh_params = x509_creds->parent_obj.dh_params;
782
783 x509_creds->data = NULL;
784 x509_creds->parent_obj.dh_params = NULL;
785 qcrypto_tls_creds_x509_load(x509_creds, &local_err);
786 if (local_err) {
787 qcrypto_tls_creds_x509_unload(x509_creds);
788 x509_creds->data = creds_data;
789 x509_creds->parent_obj.dh_params = creds_dh_params;
790 error_propagate(errp, local_err);
791 return false;
792 }
793
794 if (creds_data) {
795 gnutls_certificate_free_credentials(creds_data);
796 }
797 if (creds_dh_params) {
798 gnutls_dh_params_deinit(creds_dh_params);
799 }
800 return true;
801 }
802
803
804 #else /* ! CONFIG_GNUTLS */
805
806
807 static bool
808 qcrypto_tls_creds_x509_reload(QCryptoTLSCreds *creds, Error **errp)
809 {
810 return false;
811 }
812
813
814 #endif /* ! CONFIG_GNUTLS */
815
816
817 static void
818 qcrypto_tls_creds_x509_complete(UserCreatable *uc, Error **errp)
819 {
820 object_property_set_bool(OBJECT(uc), "loaded", true, errp);
821 }
822
823
824 static void
825 qcrypto_tls_creds_x509_init(Object *obj)
826 {
827 QCryptoTLSCredsX509 *creds = QCRYPTO_TLS_CREDS_X509(obj);
828
829 creds->sanityCheck = true;
830 }
831
832
833 static void
834 qcrypto_tls_creds_x509_finalize(Object *obj)
835 {
836 QCryptoTLSCredsX509 *creds = QCRYPTO_TLS_CREDS_X509(obj);
837
838 g_free(creds->passwordid);
839 qcrypto_tls_creds_x509_unload(creds);
840 }
841
842
843 static void
844 qcrypto_tls_creds_x509_class_init(ObjectClass *oc, void *data)
845 {
846 UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
847 QCryptoTLSCredsClass *ctcc = QCRYPTO_TLS_CREDS_CLASS(oc);
848
849 ctcc->reload = qcrypto_tls_creds_x509_reload;
850
851 ucc->complete = qcrypto_tls_creds_x509_complete;
852
853 object_class_property_add_bool(oc, "loaded",
854 qcrypto_tls_creds_x509_prop_get_loaded,
855 qcrypto_tls_creds_x509_prop_set_loaded);
856 object_class_property_add_bool(oc, "sanity-check",
857 qcrypto_tls_creds_x509_prop_get_sanity,
858 qcrypto_tls_creds_x509_prop_set_sanity);
859 object_class_property_add_str(oc, "passwordid",
860 qcrypto_tls_creds_x509_prop_get_passwordid,
861 qcrypto_tls_creds_x509_prop_set_passwordid);
862 }
863
864
865 static const TypeInfo qcrypto_tls_creds_x509_info = {
866 .parent = TYPE_QCRYPTO_TLS_CREDS,
867 .name = TYPE_QCRYPTO_TLS_CREDS_X509,
868 .instance_size = sizeof(QCryptoTLSCredsX509),
869 .instance_init = qcrypto_tls_creds_x509_init,
870 .instance_finalize = qcrypto_tls_creds_x509_finalize,
871 .class_size = sizeof(QCryptoTLSCredsX509Class),
872 .class_init = qcrypto_tls_creds_x509_class_init,
873 .interfaces = (InterfaceInfo[]) {
874 { TYPE_USER_CREATABLE },
875 { }
876 }
877 };
878
879
880 static void
881 qcrypto_tls_creds_x509_register_types(void)
882 {
883 type_register_static(&qcrypto_tls_creds_x509_info);
884 }
885
886
887 type_init(qcrypto_tls_creds_x509_register_types);