Merge remote-tracking branch 'remotes/kraxel/tags/pull-vga-20170103-1' into staging
[qemu.git] / crypto / secret.c
1 /*
2 * QEMU crypto secret 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/secret.h"
23 #include "crypto/cipher.h"
24 #include "qapi/error.h"
25 #include "qom/object_interfaces.h"
26 #include "qemu/base64.h"
27 #include "trace.h"
28
29
30 static void
31 qcrypto_secret_load_data(QCryptoSecret *secret,
32 uint8_t **output,
33 size_t *outputlen,
34 Error **errp)
35 {
36 char *data = NULL;
37 size_t length = 0;
38 GError *gerr = NULL;
39
40 *output = NULL;
41 *outputlen = 0;
42
43 if (secret->file) {
44 if (secret->data) {
45 error_setg(errp,
46 "'file' and 'data' are mutually exclusive");
47 return;
48 }
49 if (!g_file_get_contents(secret->file, &data, &length, &gerr)) {
50 error_setg(errp,
51 "Unable to read %s: %s",
52 secret->file, gerr->message);
53 g_error_free(gerr);
54 return;
55 }
56 *output = (uint8_t *)data;
57 *outputlen = length;
58 } else if (secret->data) {
59 *outputlen = strlen(secret->data);
60 *output = (uint8_t *)g_strdup(secret->data);
61 } else {
62 error_setg(errp, "Either 'file' or 'data' must be provided");
63 }
64 }
65
66
67 static void qcrypto_secret_decrypt(QCryptoSecret *secret,
68 const uint8_t *input,
69 size_t inputlen,
70 uint8_t **output,
71 size_t *outputlen,
72 Error **errp)
73 {
74 uint8_t *key = NULL, *ciphertext = NULL, *iv = NULL;
75 size_t keylen, ciphertextlen, ivlen;
76 QCryptoCipher *aes = NULL;
77 uint8_t *plaintext = NULL;
78
79 *output = NULL;
80 *outputlen = 0;
81
82 if (qcrypto_secret_lookup(secret->keyid,
83 &key, &keylen,
84 errp) < 0) {
85 goto cleanup;
86 }
87
88 if (keylen != 32) {
89 error_setg(errp, "Key should be 32 bytes in length");
90 goto cleanup;
91 }
92
93 if (!secret->iv) {
94 error_setg(errp, "IV is required to decrypt secret");
95 goto cleanup;
96 }
97
98 iv = qbase64_decode(secret->iv, -1, &ivlen, errp);
99 if (!iv) {
100 goto cleanup;
101 }
102 if (ivlen != 16) {
103 error_setg(errp, "IV should be 16 bytes in length not %zu",
104 ivlen);
105 goto cleanup;
106 }
107
108 aes = qcrypto_cipher_new(QCRYPTO_CIPHER_ALG_AES_256,
109 QCRYPTO_CIPHER_MODE_CBC,
110 key, keylen,
111 errp);
112 if (!aes) {
113 goto cleanup;
114 }
115
116 if (qcrypto_cipher_setiv(aes, iv, ivlen, errp) < 0) {
117 goto cleanup;
118 }
119
120 if (secret->format == QCRYPTO_SECRET_FORMAT_BASE64) {
121 ciphertext = qbase64_decode((const gchar*)input,
122 inputlen,
123 &ciphertextlen,
124 errp);
125 if (!ciphertext) {
126 goto cleanup;
127 }
128 plaintext = g_new0(uint8_t, ciphertextlen + 1);
129 } else {
130 ciphertextlen = inputlen;
131 plaintext = g_new0(uint8_t, inputlen + 1);
132 }
133 if (qcrypto_cipher_decrypt(aes,
134 ciphertext ? ciphertext : input,
135 plaintext,
136 ciphertextlen,
137 errp) < 0) {
138 plaintext = NULL;
139 goto cleanup;
140 }
141
142 if (plaintext[ciphertextlen - 1] > 16 ||
143 plaintext[ciphertextlen - 1] > ciphertextlen) {
144 error_setg(errp, "Incorrect number of padding bytes (%d) "
145 "found on decrypted data",
146 (int)plaintext[ciphertextlen - 1]);
147 g_free(plaintext);
148 plaintext = NULL;
149 goto cleanup;
150 }
151
152 /* Even though plaintext may contain arbitrary NUL
153 * ensure it is explicitly NUL terminated.
154 */
155 ciphertextlen -= plaintext[ciphertextlen - 1];
156 plaintext[ciphertextlen] = '\0';
157
158 *output = plaintext;
159 *outputlen = ciphertextlen;
160
161 cleanup:
162 g_free(ciphertext);
163 g_free(iv);
164 g_free(key);
165 qcrypto_cipher_free(aes);
166 }
167
168
169 static void qcrypto_secret_decode(const uint8_t *input,
170 size_t inputlen,
171 uint8_t **output,
172 size_t *outputlen,
173 Error **errp)
174 {
175 *output = qbase64_decode((const gchar*)input,
176 inputlen,
177 outputlen,
178 errp);
179 }
180
181
182 static void
183 qcrypto_secret_prop_set_loaded(Object *obj,
184 bool value,
185 Error **errp)
186 {
187 QCryptoSecret *secret = QCRYPTO_SECRET(obj);
188
189 if (value) {
190 Error *local_err = NULL;
191 uint8_t *input = NULL;
192 size_t inputlen = 0;
193 uint8_t *output = NULL;
194 size_t outputlen = 0;
195
196 qcrypto_secret_load_data(secret, &input, &inputlen, &local_err);
197 if (local_err) {
198 error_propagate(errp, local_err);
199 return;
200 }
201
202 if (secret->keyid) {
203 qcrypto_secret_decrypt(secret, input, inputlen,
204 &output, &outputlen, &local_err);
205 g_free(input);
206 if (local_err) {
207 error_propagate(errp, local_err);
208 return;
209 }
210 input = output;
211 inputlen = outputlen;
212 } else {
213 if (secret->format != QCRYPTO_SECRET_FORMAT_RAW) {
214 qcrypto_secret_decode(input, inputlen,
215 &output, &outputlen, &local_err);
216 g_free(input);
217 if (local_err) {
218 error_propagate(errp, local_err);
219 return;
220 }
221 input = output;
222 inputlen = outputlen;
223 }
224 }
225
226 secret->rawdata = input;
227 secret->rawlen = inputlen;
228 } else {
229 g_free(secret->rawdata);
230 secret->rawlen = 0;
231 }
232 }
233
234
235 static bool
236 qcrypto_secret_prop_get_loaded(Object *obj,
237 Error **errp G_GNUC_UNUSED)
238 {
239 QCryptoSecret *secret = QCRYPTO_SECRET(obj);
240 return secret->data != NULL;
241 }
242
243
244 static void
245 qcrypto_secret_prop_set_format(Object *obj,
246 int value,
247 Error **errp G_GNUC_UNUSED)
248 {
249 QCryptoSecret *creds = QCRYPTO_SECRET(obj);
250
251 creds->format = value;
252 }
253
254
255 static int
256 qcrypto_secret_prop_get_format(Object *obj,
257 Error **errp G_GNUC_UNUSED)
258 {
259 QCryptoSecret *creds = QCRYPTO_SECRET(obj);
260
261 return creds->format;
262 }
263
264
265 static void
266 qcrypto_secret_prop_set_data(Object *obj,
267 const char *value,
268 Error **errp)
269 {
270 QCryptoSecret *secret = QCRYPTO_SECRET(obj);
271
272 g_free(secret->data);
273 secret->data = g_strdup(value);
274 }
275
276
277 static char *
278 qcrypto_secret_prop_get_data(Object *obj,
279 Error **errp)
280 {
281 QCryptoSecret *secret = QCRYPTO_SECRET(obj);
282 return g_strdup(secret->data);
283 }
284
285
286 static void
287 qcrypto_secret_prop_set_file(Object *obj,
288 const char *value,
289 Error **errp)
290 {
291 QCryptoSecret *secret = QCRYPTO_SECRET(obj);
292
293 g_free(secret->file);
294 secret->file = g_strdup(value);
295 }
296
297
298 static char *
299 qcrypto_secret_prop_get_file(Object *obj,
300 Error **errp)
301 {
302 QCryptoSecret *secret = QCRYPTO_SECRET(obj);
303 return g_strdup(secret->file);
304 }
305
306
307 static void
308 qcrypto_secret_prop_set_iv(Object *obj,
309 const char *value,
310 Error **errp)
311 {
312 QCryptoSecret *secret = QCRYPTO_SECRET(obj);
313
314 g_free(secret->iv);
315 secret->iv = g_strdup(value);
316 }
317
318
319 static char *
320 qcrypto_secret_prop_get_iv(Object *obj,
321 Error **errp)
322 {
323 QCryptoSecret *secret = QCRYPTO_SECRET(obj);
324 return g_strdup(secret->iv);
325 }
326
327
328 static void
329 qcrypto_secret_prop_set_keyid(Object *obj,
330 const char *value,
331 Error **errp)
332 {
333 QCryptoSecret *secret = QCRYPTO_SECRET(obj);
334
335 g_free(secret->keyid);
336 secret->keyid = g_strdup(value);
337 }
338
339
340 static char *
341 qcrypto_secret_prop_get_keyid(Object *obj,
342 Error **errp)
343 {
344 QCryptoSecret *secret = QCRYPTO_SECRET(obj);
345 return g_strdup(secret->keyid);
346 }
347
348
349 static void
350 qcrypto_secret_complete(UserCreatable *uc, Error **errp)
351 {
352 object_property_set_bool(OBJECT(uc), true, "loaded", errp);
353 }
354
355
356 static void
357 qcrypto_secret_finalize(Object *obj)
358 {
359 QCryptoSecret *secret = QCRYPTO_SECRET(obj);
360
361 g_free(secret->iv);
362 g_free(secret->file);
363 g_free(secret->keyid);
364 g_free(secret->rawdata);
365 g_free(secret->data);
366 }
367
368 static void
369 qcrypto_secret_class_init(ObjectClass *oc, void *data)
370 {
371 UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
372
373 ucc->complete = qcrypto_secret_complete;
374
375 object_class_property_add_bool(oc, "loaded",
376 qcrypto_secret_prop_get_loaded,
377 qcrypto_secret_prop_set_loaded,
378 NULL);
379 object_class_property_add_enum(oc, "format",
380 "QCryptoSecretFormat",
381 QCryptoSecretFormat_lookup,
382 qcrypto_secret_prop_get_format,
383 qcrypto_secret_prop_set_format,
384 NULL);
385 object_class_property_add_str(oc, "data",
386 qcrypto_secret_prop_get_data,
387 qcrypto_secret_prop_set_data,
388 NULL);
389 object_class_property_add_str(oc, "file",
390 qcrypto_secret_prop_get_file,
391 qcrypto_secret_prop_set_file,
392 NULL);
393 object_class_property_add_str(oc, "keyid",
394 qcrypto_secret_prop_get_keyid,
395 qcrypto_secret_prop_set_keyid,
396 NULL);
397 object_class_property_add_str(oc, "iv",
398 qcrypto_secret_prop_get_iv,
399 qcrypto_secret_prop_set_iv,
400 NULL);
401 }
402
403
404 int qcrypto_secret_lookup(const char *secretid,
405 uint8_t **data,
406 size_t *datalen,
407 Error **errp)
408 {
409 Object *obj;
410 QCryptoSecret *secret;
411
412 obj = object_resolve_path_component(
413 object_get_objects_root(), secretid);
414 if (!obj) {
415 error_setg(errp, "No secret with id '%s'", secretid);
416 return -1;
417 }
418
419 secret = (QCryptoSecret *)
420 object_dynamic_cast(obj,
421 TYPE_QCRYPTO_SECRET);
422 if (!secret) {
423 error_setg(errp, "Object with id '%s' is not a secret",
424 secretid);
425 return -1;
426 }
427
428 if (!secret->rawdata) {
429 error_setg(errp, "Secret with id '%s' has no data",
430 secretid);
431 return -1;
432 }
433
434 *data = g_new0(uint8_t, secret->rawlen + 1);
435 memcpy(*data, secret->rawdata, secret->rawlen);
436 (*data)[secret->rawlen] = '\0';
437 *datalen = secret->rawlen;
438
439 return 0;
440 }
441
442
443 char *qcrypto_secret_lookup_as_utf8(const char *secretid,
444 Error **errp)
445 {
446 uint8_t *data;
447 size_t datalen;
448
449 if (qcrypto_secret_lookup(secretid,
450 &data,
451 &datalen,
452 errp) < 0) {
453 return NULL;
454 }
455
456 if (!g_utf8_validate((const gchar*)data, datalen, NULL)) {
457 error_setg(errp,
458 "Data from secret %s is not valid UTF-8",
459 secretid);
460 g_free(data);
461 return NULL;
462 }
463
464 return (char *)data;
465 }
466
467
468 char *qcrypto_secret_lookup_as_base64(const char *secretid,
469 Error **errp)
470 {
471 uint8_t *data;
472 size_t datalen;
473 char *ret;
474
475 if (qcrypto_secret_lookup(secretid,
476 &data,
477 &datalen,
478 errp) < 0) {
479 return NULL;
480 }
481
482 ret = g_base64_encode(data, datalen);
483 g_free(data);
484 return ret;
485 }
486
487
488 static const TypeInfo qcrypto_secret_info = {
489 .parent = TYPE_OBJECT,
490 .name = TYPE_QCRYPTO_SECRET,
491 .instance_size = sizeof(QCryptoSecret),
492 .instance_finalize = qcrypto_secret_finalize,
493 .class_size = sizeof(QCryptoSecretClass),
494 .class_init = qcrypto_secret_class_init,
495 .interfaces = (InterfaceInfo[]) {
496 { TYPE_USER_CREATABLE },
497 { }
498 }
499 };
500
501
502 static void
503 qcrypto_secret_register_types(void)
504 {
505 type_register_static(&qcrypto_secret_info);
506 }
507
508
509 type_init(qcrypto_secret_register_types);