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