/src/qemu/crypto/tlscreds.c
Line | Count | Source |
1 | | /* |
2 | | * QEMU crypto TLS 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 "qapi/error.h" |
23 | | #include "qapi-types-crypto.h" |
24 | | #include "qemu/module.h" |
25 | | #include "qemu/error-report.h" |
26 | | #include "tlscredspriv.h" |
27 | | #include "trace.h" |
28 | | |
29 | | #define DH_BITS 2048 |
30 | | |
31 | | #ifdef CONFIG_GNUTLS |
32 | | int |
33 | | qcrypto_tls_creds_get_dh_params_file(QCryptoTLSCreds *creds, |
34 | | const char *filename, |
35 | | gnutls_dh_params_t *dh_params, |
36 | | Error **errp) |
37 | | { |
38 | | int ret; |
39 | | |
40 | | trace_qcrypto_tls_creds_load_dh(creds, filename ? filename : "<generated>"); |
41 | | |
42 | | if (filename != NULL) { |
43 | | GError *gerr = NULL; |
44 | | gchar *contents; |
45 | | gsize len; |
46 | | gnutls_datum_t data; |
47 | | if (!g_file_get_contents(filename, |
48 | | &contents, |
49 | | &len, |
50 | | &gerr)) { |
51 | | |
52 | | error_setg(errp, "%s", gerr->message); |
53 | | g_error_free(gerr); |
54 | | return -1; |
55 | | } |
56 | | warn_report_once("Use of an external DH parameters file '%s' is " |
57 | | "deprecated and will be removed in a future release", |
58 | | filename); |
59 | | |
60 | | data.data = (unsigned char *)contents; |
61 | | data.size = len; |
62 | | ret = gnutls_dh_params_init(dh_params); |
63 | | if (ret < 0) { |
64 | | g_free(contents); |
65 | | error_setg(errp, "Unable to initialize DH parameters: %s", |
66 | | gnutls_strerror(ret)); |
67 | | return -1; |
68 | | } |
69 | | ret = gnutls_dh_params_import_pkcs3(*dh_params, |
70 | | &data, |
71 | | GNUTLS_X509_FMT_PEM); |
72 | | g_free(contents); |
73 | | if (ret < 0) { |
74 | | gnutls_dh_params_deinit(*dh_params); |
75 | | *dh_params = NULL; |
76 | | error_setg(errp, "Unable to load DH parameters from %s: %s", |
77 | | filename, gnutls_strerror(ret)); |
78 | | return -1; |
79 | | } |
80 | | } else { |
81 | | *dh_params = NULL; |
82 | | } |
83 | | |
84 | | return 0; |
85 | | } |
86 | | |
87 | | |
88 | | char * |
89 | | qcrypto_tls_creds_build_path(QCryptoTLSCreds *creds, |
90 | | const char *filename) |
91 | | { |
92 | | return g_strdup_printf("%s/%s", creds->dir, filename); |
93 | | } |
94 | | |
95 | | |
96 | | int |
97 | | qcrypto_tls_creds_get_path(QCryptoTLSCreds *creds, |
98 | | const char *filename, |
99 | | bool required, |
100 | | char **cred, |
101 | | Error **errp) |
102 | | { |
103 | | int ret = -1; |
104 | | |
105 | | *cred = qcrypto_tls_creds_build_path(creds, filename); |
106 | | |
107 | | if (access(*cred, R_OK) < 0) { |
108 | | if (errno == ENOENT && !required) { |
109 | | ret = 0; |
110 | | } else { |
111 | | error_setg_errno(errp, errno, |
112 | | "Unable to access credentials %s", |
113 | | *cred); |
114 | | } |
115 | | g_free(*cred); |
116 | | *cred = NULL; |
117 | | goto cleanup; |
118 | | } |
119 | | |
120 | | ret = 0; |
121 | | cleanup: |
122 | | trace_qcrypto_tls_creds_get_path(creds, filename, |
123 | | *cred ? *cred : "<none>"); |
124 | | return ret; |
125 | | } |
126 | | |
127 | | |
128 | | #endif /* ! CONFIG_GNUTLS */ |
129 | | |
130 | | |
131 | | static void |
132 | | qcrypto_tls_creds_prop_set_verify(Object *obj, |
133 | | bool value, |
134 | | Error **errp G_GNUC_UNUSED) |
135 | 0 | { |
136 | 0 | QCryptoTLSCreds *creds = QCRYPTO_TLS_CREDS(obj); |
137 | |
|
138 | 0 | creds->verifyPeer = value; |
139 | 0 | } |
140 | | |
141 | | |
142 | | static bool |
143 | | qcrypto_tls_creds_prop_get_verify(Object *obj, |
144 | | Error **errp G_GNUC_UNUSED) |
145 | 0 | { |
146 | 0 | QCryptoTLSCreds *creds = QCRYPTO_TLS_CREDS(obj); |
147 | |
|
148 | 0 | return creds->verifyPeer; |
149 | 0 | } |
150 | | |
151 | | |
152 | | static void |
153 | | qcrypto_tls_creds_prop_set_dir(Object *obj, |
154 | | const char *value, |
155 | | Error **errp G_GNUC_UNUSED) |
156 | 0 | { |
157 | 0 | QCryptoTLSCreds *creds = QCRYPTO_TLS_CREDS(obj); |
158 | |
|
159 | 0 | creds->dir = g_strdup(value); |
160 | 0 | } |
161 | | |
162 | | |
163 | | static char * |
164 | | qcrypto_tls_creds_prop_get_dir(Object *obj, |
165 | | Error **errp G_GNUC_UNUSED) |
166 | 0 | { |
167 | 0 | QCryptoTLSCreds *creds = QCRYPTO_TLS_CREDS(obj); |
168 | |
|
169 | 0 | return g_strdup(creds->dir); |
170 | 0 | } |
171 | | |
172 | | |
173 | | static void |
174 | | qcrypto_tls_creds_prop_set_priority(Object *obj, |
175 | | const char *value, |
176 | | Error **errp G_GNUC_UNUSED) |
177 | 0 | { |
178 | 0 | QCryptoTLSCreds *creds = QCRYPTO_TLS_CREDS(obj); |
179 | |
|
180 | 0 | creds->priority = g_strdup(value); |
181 | 0 | } |
182 | | |
183 | | |
184 | | static char * |
185 | | qcrypto_tls_creds_prop_get_priority(Object *obj, |
186 | | Error **errp G_GNUC_UNUSED) |
187 | 0 | { |
188 | 0 | QCryptoTLSCreds *creds = QCRYPTO_TLS_CREDS(obj); |
189 | |
|
190 | 0 | return g_strdup(creds->priority); |
191 | 0 | } |
192 | | |
193 | | |
194 | | static void |
195 | | qcrypto_tls_creds_prop_set_endpoint(Object *obj, |
196 | | int value, |
197 | | Error **errp G_GNUC_UNUSED) |
198 | 0 | { |
199 | 0 | QCryptoTLSCreds *creds = QCRYPTO_TLS_CREDS(obj); |
200 | |
|
201 | 0 | creds->endpoint = value; |
202 | 0 | } |
203 | | |
204 | | |
205 | | static int |
206 | | qcrypto_tls_creds_prop_get_endpoint(Object *obj, |
207 | | Error **errp G_GNUC_UNUSED) |
208 | 0 | { |
209 | 0 | QCryptoTLSCreds *creds = QCRYPTO_TLS_CREDS(obj); |
210 | |
|
211 | 0 | return creds->endpoint; |
212 | 0 | } |
213 | | |
214 | | |
215 | | static void |
216 | | qcrypto_tls_creds_class_init(ObjectClass *oc, const void *data) |
217 | 61 | { |
218 | 61 | object_class_property_add_bool(oc, "verify-peer", |
219 | 61 | qcrypto_tls_creds_prop_get_verify, |
220 | 61 | qcrypto_tls_creds_prop_set_verify); |
221 | 61 | object_class_property_add_str(oc, "dir", |
222 | 61 | qcrypto_tls_creds_prop_get_dir, |
223 | 61 | qcrypto_tls_creds_prop_set_dir); |
224 | 61 | object_class_property_add_enum(oc, "endpoint", |
225 | 61 | "QCryptoTLSCredsEndpoint", |
226 | 61 | &QCryptoTLSCredsEndpoint_lookup, |
227 | 61 | qcrypto_tls_creds_prop_get_endpoint, |
228 | 61 | qcrypto_tls_creds_prop_set_endpoint); |
229 | 61 | object_class_property_add_str(oc, "priority", |
230 | 61 | qcrypto_tls_creds_prop_get_priority, |
231 | 61 | qcrypto_tls_creds_prop_set_priority); |
232 | 61 | } |
233 | | |
234 | | |
235 | | static void |
236 | | qcrypto_tls_creds_init(Object *obj) |
237 | 0 | { |
238 | 0 | QCryptoTLSCreds *creds = QCRYPTO_TLS_CREDS(obj); |
239 | |
|
240 | 0 | creds->verifyPeer = true; |
241 | 0 | } |
242 | | |
243 | | |
244 | | static void |
245 | | qcrypto_tls_creds_finalize(Object *obj) |
246 | 0 | { |
247 | 0 | QCryptoTLSCreds *creds = QCRYPTO_TLS_CREDS(obj); |
248 | |
|
249 | | #ifdef CONFIG_GNUTLS |
250 | | qcrypto_tls_creds_box_unref(creds->box); |
251 | | #endif |
252 | 0 | g_free(creds->dir); |
253 | 0 | g_free(creds->priority); |
254 | 0 | } |
255 | | |
256 | | bool qcrypto_tls_creds_check_endpoint(QCryptoTLSCreds *creds, |
257 | | QCryptoTLSCredsEndpoint endpoint, |
258 | | Error **errp) |
259 | 0 | { |
260 | 0 | if (creds->endpoint != endpoint) { |
261 | 0 | error_setg(errp, "Expected TLS credentials for a %s endpoint", |
262 | 0 | QCryptoTLSCredsEndpoint_str(endpoint)); |
263 | 0 | return false; |
264 | 0 | } |
265 | 0 | return true; |
266 | 0 | } |
267 | | |
268 | | |
269 | | char *qcrypto_tls_creds_get_priority(QCryptoTLSCreds *creds) |
270 | 0 | { |
271 | 0 | QCryptoTLSCredsClass *tcc = QCRYPTO_TLS_CREDS_GET_CLASS(creds); |
272 | 0 | const char *priorityBase = |
273 | 0 | creds->priority ? creds->priority : CONFIG_TLS_PRIORITY; |
274 | |
|
275 | 0 | if (tcc->prioritySuffix) { |
276 | 0 | return g_strdup_printf("%s:%s", priorityBase, tcc->prioritySuffix); |
277 | 0 | } else { |
278 | 0 | return g_strdup(priorityBase); |
279 | 0 | } |
280 | 0 | } |
281 | | |
282 | | |
283 | | bool qcrypto_tls_creds_reload(QCryptoTLSCreds *creds, |
284 | | Error **errp) |
285 | 0 | { |
286 | 0 | QCryptoTLSCredsClass *credscls = QCRYPTO_TLS_CREDS_GET_CLASS(creds); |
287 | |
|
288 | 0 | if (credscls->reload) { |
289 | 0 | return credscls->reload(creds, errp); |
290 | 0 | } |
291 | | |
292 | 0 | error_setg(errp, "%s does not support reloading credentials", |
293 | 0 | object_get_typename(OBJECT(creds))); |
294 | 0 | return false; |
295 | 0 | } |
296 | | |
297 | | |
298 | | static const TypeInfo qcrypto_tls_creds_info = { |
299 | | .parent = TYPE_OBJECT, |
300 | | .name = TYPE_QCRYPTO_TLS_CREDS, |
301 | | .instance_size = sizeof(QCryptoTLSCreds), |
302 | | .instance_init = qcrypto_tls_creds_init, |
303 | | .instance_finalize = qcrypto_tls_creds_finalize, |
304 | | .class_init = qcrypto_tls_creds_class_init, |
305 | | .class_size = sizeof(QCryptoTLSCredsClass), |
306 | | .abstract = true, |
307 | | }; |
308 | | |
309 | | |
310 | | static void |
311 | | qcrypto_tls_creds_register_types(void) |
312 | 61 | { |
313 | 61 | type_register_static(&qcrypto_tls_creds_info); |
314 | 61 | } |
315 | | |
316 | | |
317 | | type_init(qcrypto_tls_creds_register_types); |