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/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
30static void
31qcrypto_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
67static 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
153
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
169static 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
182static void
183qcrypto_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
235static bool
236qcrypto_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
244static void
245qcrypto_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
255static int
256qcrypto_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
265static void
266qcrypto_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
277static char *
278qcrypto_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
286static void
287qcrypto_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
298static char *
299qcrypto_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
307static void
308qcrypto_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
319static char *
320qcrypto_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
328static void
329qcrypto_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
340static char *
341qcrypto_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
349static void
350qcrypto_secret_complete(UserCreatable *uc, Error **errp)
351{
352 object_property_set_bool(OBJECT(uc), true, "loaded", errp);
353}
354
355
356static void
357qcrypto_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
368static void
369qcrypto_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
404int 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
443char *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
468char *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
488static 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
502static void
503qcrypto_secret_register_types(void)
504{
505 type_register_static(&qcrypto_secret_info);
506}
507
508
509type_init(qcrypto_secret_register_types);
510
