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 "qapi/error.h"
23#include "crypto/init.h"
24#include "crypto/block.h"
25#include "crypto/block-luks-priv.h"
26#include "qemu/buffer.h"
27#include "qemu/module.h"
28#include "crypto/secret.h"
29#ifndef _WIN32
30#include <sys/resource.h>
31#endif
32
33#if (defined(_WIN32) || defined RUSAGE_THREAD) && \
34 (defined(CONFIG_NETTLE) || defined(CONFIG_GCRYPT) || \
35 defined(CONFIG_GNUTLS_CRYPTO))
36#define TEST_LUKS
37#else
38#undef TEST_LUKS
39#endif
40
41static QCryptoBlockCreateOptions qcow_create_opts = {
42 .format = Q_CRYPTO_BLOCK_FORMAT_QCOW,
43 .u.qcow = {
44 .key_secret = (char *)"sec0",
45 },
46};
47
48static QCryptoBlockOpenOptions qcow_open_opts = {
49 .format = Q_CRYPTO_BLOCK_FORMAT_QCOW,
50 .u.qcow = {
51 .key_secret = (char *)"sec0",
52 },
53};
54
55
56#ifdef TEST_LUKS
57static QCryptoBlockOpenOptions luks_open_opts = {
58 .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
59 .u.luks = {
60 .key_secret = (char *)"sec0",
61 },
62};
63
64
65
66static QCryptoBlockCreateOptions luks_create_opts_default = {
67 .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
68 .u.luks = {
69 .key_secret = (char *)"sec0",
70 },
71};
72
73
74
75static QCryptoBlockCreateOptions luks_create_opts_aes256_cbc_plain64 = {
76 .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
77 .u.luks = {
78 .key_secret = (char *)"sec0",
79 .has_cipher_alg = true,
80 .cipher_alg = QCRYPTO_CIPHER_ALG_AES_256,
81 .has_cipher_mode = true,
82 .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
83 .has_ivgen_alg = true,
84 .ivgen_alg = QCRYPTO_IVGEN_ALG_PLAIN64,
85 },
86};
87
88
89static QCryptoBlockCreateOptions luks_create_opts_aes256_cbc_essiv = {
90 .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
91 .u.luks = {
92 .key_secret = (char *)"sec0",
93 .has_cipher_alg = true,
94 .cipher_alg = QCRYPTO_CIPHER_ALG_AES_256,
95 .has_cipher_mode = true,
96 .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
97 .has_ivgen_alg = true,
98 .ivgen_alg = QCRYPTO_IVGEN_ALG_ESSIV,
99 .has_ivgen_hash_alg = true,
100 .ivgen_hash_alg = QCRYPTO_HASH_ALG_SHA256,
101 .has_hash_alg = true,
102 .hash_alg = QCRYPTO_HASH_ALG_SHA1,
103 },
104};
105#endif
106
107
108static struct QCryptoBlockTestData {
109 const char *path;
110 QCryptoBlockCreateOptions *create_opts;
111 QCryptoBlockOpenOptions *open_opts;
112
113 bool expect_header;
114
115 QCryptoCipherAlgorithm cipher_alg;
116 QCryptoCipherMode cipher_mode;
117 QCryptoHashAlgorithm hash_alg;
118
119 QCryptoIVGenAlgorithm ivgen_alg;
120 QCryptoHashAlgorithm ivgen_hash;
121
122 bool slow;
123} test_data[] = {
124 {
125 .path = "/crypto/block/qcow",
126 .create_opts = &qcow_create_opts,
127 .open_opts = &qcow_open_opts,
128
129 .expect_header = false,
130
131 .cipher_alg = QCRYPTO_CIPHER_ALG_AES_128,
132 .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
133
134 .ivgen_alg = QCRYPTO_IVGEN_ALG_PLAIN64,
135 },
136#ifdef TEST_LUKS
137 {
138 .path = "/crypto/block/luks/default",
139 .create_opts = &luks_create_opts_default,
140 .open_opts = &luks_open_opts,
141
142 .expect_header = true,
143
144 .cipher_alg = QCRYPTO_CIPHER_ALG_AES_256,
145 .cipher_mode = QCRYPTO_CIPHER_MODE_XTS,
146 .hash_alg = QCRYPTO_HASH_ALG_SHA256,
147
148 .ivgen_alg = QCRYPTO_IVGEN_ALG_PLAIN64,
149
150 .slow = true,
151 },
152 {
153 .path = "/crypto/block/luks/aes-256-cbc-plain64",
154 .create_opts = &luks_create_opts_aes256_cbc_plain64,
155 .open_opts = &luks_open_opts,
156
157 .expect_header = true,
158
159 .cipher_alg = QCRYPTO_CIPHER_ALG_AES_256,
160 .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
161 .hash_alg = QCRYPTO_HASH_ALG_SHA256,
162
163 .ivgen_alg = QCRYPTO_IVGEN_ALG_PLAIN64,
164
165 .slow = true,
166 },
167 {
168 .path = "/crypto/block/luks/aes-256-cbc-essiv",
169 .create_opts = &luks_create_opts_aes256_cbc_essiv,
170 .open_opts = &luks_open_opts,
171
172 .expect_header = true,
173
174 .cipher_alg = QCRYPTO_CIPHER_ALG_AES_256,
175 .cipher_mode = QCRYPTO_CIPHER_MODE_CBC,
176 .hash_alg = QCRYPTO_HASH_ALG_SHA1,
177
178 .ivgen_alg = QCRYPTO_IVGEN_ALG_ESSIV,
179 .ivgen_hash = QCRYPTO_HASH_ALG_SHA256,
180
181 .slow = true,
182 },
183#endif
184};
185
186
187static int test_block_read_func(QCryptoBlock *block,
188 size_t offset,
189 uint8_t *buf,
190 size_t buflen,
191 void *opaque,
192 Error **errp)
193{
194 Buffer *header = opaque;
195
196 g_assert_cmpint(offset + buflen, <=, header->capacity);
197
198 memcpy(buf, header->buffer + offset, buflen);
199
200 return 0;
201}
202
203
204static int test_block_init_func(QCryptoBlock *block,
205 size_t headerlen,
206 void *opaque,
207 Error **errp)
208{
209 Buffer *header = opaque;
210
211 g_assert_cmpint(header->capacity, ==, 0);
212
213 buffer_reserve(header, headerlen);
214
215 return 0;
216}
217
218
219static int test_block_write_func(QCryptoBlock *block,
220 size_t offset,
221 const uint8_t *buf,
222 size_t buflen,
223 void *opaque,
224 Error **errp)
225{
226 Buffer *header = opaque;
227
228 g_assert_cmpint(buflen + offset, <=, header->capacity);
229
230 memcpy(header->buffer + offset, buf, buflen);
231 header->offset = offset + buflen;
232
233 return 0;
234}
235
236
237static Object *test_block_secret(void)
238{
239 return object_new_with_props(
240 TYPE_QCRYPTO_SECRET,
241 object_get_objects_root(),
242 "sec0",
243 &error_abort,
244 "data", "123456",
245 NULL);
246}
247
248static void test_block_assert_setup(const struct QCryptoBlockTestData *data,
249 QCryptoBlock *blk)
250{
251 QCryptoIVGen *ivgen;
252 QCryptoCipher *cipher;
253
254 ivgen = qcrypto_block_get_ivgen(blk);
255 cipher = qcrypto_block_get_cipher(blk);
256
257 g_assert(ivgen);
258 g_assert(cipher);
259
260 g_assert_cmpint(data->cipher_alg, ==, cipher->alg);
261 g_assert_cmpint(data->cipher_mode, ==, cipher->mode);
262 g_assert_cmpint(data->hash_alg, ==,
263 qcrypto_block_get_kdf_hash(blk));
264
265 g_assert_cmpint(data->ivgen_alg, ==,
266 qcrypto_ivgen_get_algorithm(ivgen));
267 g_assert_cmpint(data->ivgen_hash, ==,
268 qcrypto_ivgen_get_hash(ivgen));
269}
270
271
272static void test_block(gconstpointer opaque)
273{
274 const struct QCryptoBlockTestData *data = opaque;
275 QCryptoBlock *blk;
276 Buffer header;
277 Object *sec = test_block_secret();
278
279 memset(&header, 0, sizeof(header));
280 buffer_init(&header, "header");
281
282 blk = qcrypto_block_create(data->create_opts, NULL,
283 test_block_init_func,
284 test_block_write_func,
285 &header,
286 &error_abort);
287 g_assert(blk);
288
289 if (data->expect_header) {
290 g_assert_cmpint(header.capacity, >, 0);
291 } else {
292 g_assert_cmpint(header.capacity, ==, 0);
293 }
294
295 test_block_assert_setup(data, blk);
296
297 qcrypto_block_free(blk);
298 object_unparent(sec);
299
300
301 blk = qcrypto_block_open(data->open_opts, NULL,
302 test_block_read_func,
303 &header,
304 0,
305 1,
306 NULL);
307 g_assert(blk == NULL);
308
309
310 blk = qcrypto_block_open(data->open_opts, NULL,
311 test_block_read_func,
312 &header,
313 QCRYPTO_BLOCK_OPEN_NO_IO,
314 1,
315 &error_abort);
316
317 g_assert(qcrypto_block_get_cipher(blk) == NULL);
318 g_assert(qcrypto_block_get_ivgen(blk) == NULL);
319
320 qcrypto_block_free(blk);
321
322
323
324 sec = test_block_secret();
325 blk = qcrypto_block_open(data->open_opts, NULL,
326 test_block_read_func,
327 &header,
328 0,
329 1,
330 &error_abort);
331 g_assert(blk);
332
333 test_block_assert_setup(data, blk);
334
335 qcrypto_block_free(blk);
336
337 object_unparent(sec);
338
339 buffer_free(&header);
340}
341
342
343#ifdef TEST_LUKS
344typedef const char *(*LuksHeaderDoBadStuff)(QCryptoBlockLUKSHeader *hdr);
345
346static void
347test_luks_bad_header(gconstpointer data)
348{
349 LuksHeaderDoBadStuff badstuff = data;
350 QCryptoBlock *blk;
351 Buffer buf;
352 Object *sec = test_block_secret();
353 QCryptoBlockLUKSHeader hdr;
354 Error *err = NULL;
355 const char *msg;
356
357 memset(&buf, 0, sizeof(buf));
358 buffer_init(&buf, "header");
359
360
361 blk = qcrypto_block_create(&luks_create_opts_default, NULL,
362 test_block_init_func,
363 test_block_write_func,
364 &buf,
365 &error_abort);
366 g_assert(blk);
367
368 qcrypto_block_free(blk);
369
370
371 g_assert(buf.offset >= sizeof(hdr));
372 memcpy(&hdr, buf.buffer, sizeof(hdr));
373 qcrypto_block_luks_to_disk_endian(&hdr);
374
375 msg = badstuff(&hdr);
376
377 qcrypto_block_luks_from_disk_endian(&hdr);
378 memcpy(buf.buffer, &hdr, sizeof(hdr));
379
380
381 blk = qcrypto_block_open(&luks_open_opts, NULL,
382 test_block_read_func,
383 &buf,
384 0,
385 1,
386 &err);
387 g_assert(!blk);
388 g_assert(err);
389
390 g_assert_cmpstr(error_get_pretty(err), ==, msg);
391 error_free(err);
392
393 object_unparent(sec);
394
395 buffer_free(&buf);
396}
397
398static const char *luks_bad_null_term_cipher_name(QCryptoBlockLUKSHeader *hdr)
399{
400
401 char *offset = hdr->cipher_name + strlen(hdr->cipher_name);
402 memset(offset, ' ', sizeof(hdr->cipher_name) - (offset - hdr->cipher_name));
403
404 return "LUKS header cipher name is not NUL terminated";
405}
406
407static const char *luks_bad_null_term_cipher_mode(QCryptoBlockLUKSHeader *hdr)
408{
409
410 char *offset = hdr->cipher_mode + strlen(hdr->cipher_mode);
411 memset(offset, ' ', sizeof(hdr->cipher_mode) - (offset - hdr->cipher_mode));
412
413 return "LUKS header cipher mode is not NUL terminated";
414}
415
416static const char *luks_bad_null_term_hash_spec(QCryptoBlockLUKSHeader *hdr)
417{
418
419 char *offset = hdr->hash_spec + strlen(hdr->hash_spec);
420 memset(offset, ' ', sizeof(hdr->hash_spec) - (offset - hdr->hash_spec));
421
422 return "LUKS header hash spec is not NUL terminated";
423}
424
425static const char *luks_bad_cipher_name_empty(QCryptoBlockLUKSHeader *hdr)
426{
427 memcpy(hdr->cipher_name, "", 1);
428
429 return "Algorithm '' with key size 32 bytes not supported";
430}
431
432static const char *luks_bad_cipher_name_unknown(QCryptoBlockLUKSHeader *hdr)
433{
434 memcpy(hdr->cipher_name, "aess", 5);
435
436 return "Algorithm 'aess' with key size 32 bytes not supported";
437}
438
439static const char *luks_bad_cipher_xts_size(QCryptoBlockLUKSHeader *hdr)
440{
441 hdr->master_key_len = 33;
442
443 return "XTS cipher key length should be a multiple of 2";
444}
445
446static const char *luks_bad_cipher_cbc_size(QCryptoBlockLUKSHeader *hdr)
447{
448 hdr->master_key_len = 33;
449 memcpy(hdr->cipher_mode, "cbc-essiv", 10);
450
451 return "Algorithm 'aes' with key size 33 bytes not supported";
452}
453
454static const char *luks_bad_cipher_mode_empty(QCryptoBlockLUKSHeader *hdr)
455{
456 memcpy(hdr->cipher_mode, "", 1);
457
458 return "Unexpected cipher mode string format ''";
459}
460
461static const char *luks_bad_cipher_mode_unknown(QCryptoBlockLUKSHeader *hdr)
462{
463 memcpy(hdr->cipher_mode, "xfs", 4);
464
465 return "Unexpected cipher mode string format 'xfs'";
466}
467
468static const char *luks_bad_ivgen_separator(QCryptoBlockLUKSHeader *hdr)
469{
470 memcpy(hdr->cipher_mode, "xts:plain64", 12);
471
472 return "Unexpected cipher mode string format 'xts:plain64'";
473}
474
475static const char *luks_bad_ivgen_name_empty(QCryptoBlockLUKSHeader *hdr)
476{
477 memcpy(hdr->cipher_mode, "xts-", 5);
478
479 return "IV generator '' not supported";
480}
481
482static const char *luks_bad_ivgen_name_unknown(QCryptoBlockLUKSHeader *hdr)
483{
484 memcpy(hdr->cipher_mode, "xts-plain65", 12);
485
486 return "IV generator 'plain65' not supported";
487}
488
489static const char *luks_bad_ivgen_hash_empty(QCryptoBlockLUKSHeader *hdr)
490{
491 memcpy(hdr->cipher_mode, "xts-plain65:", 13);
492
493 return "Hash algorithm '' not supported";
494}
495
496static const char *luks_bad_ivgen_hash_unknown(QCryptoBlockLUKSHeader *hdr)
497{
498 memcpy(hdr->cipher_mode, "xts-plain65:sha257", 19);
499
500 return "Hash algorithm 'sha257' not supported";
501}
502
503static const char *luks_bad_hash_spec_empty(QCryptoBlockLUKSHeader *hdr)
504{
505 memcpy(hdr->hash_spec, "", 1);
506
507 return "Hash algorithm '' not supported";
508}
509
510static const char *luks_bad_hash_spec_unknown(QCryptoBlockLUKSHeader *hdr)
511{
512 memcpy(hdr->hash_spec, "sha2566", 8);
513
514 return "Hash algorithm 'sha2566' not supported";
515}
516
517static const char *luks_bad_stripes(QCryptoBlockLUKSHeader *hdr)
518{
519 hdr->key_slots[0].stripes = 3999;
520
521 return "Keyslot 0 is corrupted (stripes 3999 != 4000)";
522}
523
524static const char *luks_bad_key_overlap_header(QCryptoBlockLUKSHeader *hdr)
525{
526 hdr->key_slots[0].key_offset_sector = 2;
527
528 return "Keyslot 0 is overlapping with the LUKS header";
529}
530
531static const char *luks_bad_key_overlap_key(QCryptoBlockLUKSHeader *hdr)
532{
533 hdr->key_slots[0].key_offset_sector = hdr->key_slots[1].key_offset_sector;
534
535 return "Keyslots 0 and 1 are overlapping in the header";
536}
537
538static const char *luks_bad_key_overlap_payload(QCryptoBlockLUKSHeader *hdr)
539{
540 hdr->key_slots[0].key_offset_sector = hdr->payload_offset_sector + 42;
541
542 return "Keyslot 0 is overlapping with the encrypted payload";
543}
544
545static const char *luks_bad_payload_overlap_header(QCryptoBlockLUKSHeader *hdr)
546{
547 hdr->payload_offset_sector = 2;
548
549 return "LUKS payload is overlapping with the header";
550}
551
552static const char *luks_bad_key_iterations(QCryptoBlockLUKSHeader *hdr)
553{
554 hdr->key_slots[0].iterations = 0;
555
556 return "Keyslot 0 iteration count is zero";
557}
558
559static const char *luks_bad_iterations(QCryptoBlockLUKSHeader *hdr)
560{
561 hdr->master_key_iterations = 0;
562
563 return "LUKS key iteration count is zero";
564}
565#endif
566
567int main(int argc, char **argv)
568{
569 gsize i;
570
571 module_call_init(MODULE_INIT_QOM);
572 g_test_init(&argc, &argv, NULL);
573
574 g_assert(qcrypto_init(NULL) == 0);
575
576 for (i = 0; i < G_N_ELEMENTS(test_data); i++) {
577 if (test_data[i].open_opts->format == Q_CRYPTO_BLOCK_FORMAT_LUKS &&
578 !qcrypto_hash_supports(test_data[i].hash_alg)) {
579 continue;
580 }
581 if (!test_data[i].slow ||
582 g_test_slow()) {
583 g_test_add_data_func(test_data[i].path, &test_data[i], test_block);
584 }
585 }
586
587#ifdef TEST_LUKS
588 if (g_test_slow()) {
589 g_test_add_data_func("/crypto/block/luks/bad/cipher-name-nul-term",
590 luks_bad_null_term_cipher_name,
591 test_luks_bad_header);
592 g_test_add_data_func("/crypto/block/luks/bad/cipher-mode-nul-term",
593 luks_bad_null_term_cipher_mode,
594 test_luks_bad_header);
595 g_test_add_data_func("/crypto/block/luks/bad/hash-spec-nul-term",
596 luks_bad_null_term_hash_spec,
597 test_luks_bad_header);
598 g_test_add_data_func("/crypto/block/luks/bad/cipher-name-empty",
599 luks_bad_cipher_name_empty,
600 test_luks_bad_header);
601 g_test_add_data_func("/crypto/block/luks/bad/cipher-name-unknown",
602 luks_bad_cipher_name_unknown,
603 test_luks_bad_header);
604 g_test_add_data_func("/crypto/block/luks/bad/cipher-xts-size",
605 luks_bad_cipher_xts_size,
606 test_luks_bad_header);
607 g_test_add_data_func("/crypto/block/luks/bad/cipher-cbc-size",
608 luks_bad_cipher_cbc_size,
609 test_luks_bad_header);
610 g_test_add_data_func("/crypto/block/luks/bad/cipher-mode-empty",
611 luks_bad_cipher_mode_empty,
612 test_luks_bad_header);
613 g_test_add_data_func("/crypto/block/luks/bad/cipher-mode-unknown",
614 luks_bad_cipher_mode_unknown,
615 test_luks_bad_header);
616 g_test_add_data_func("/crypto/block/luks/bad/ivgen-separator",
617 luks_bad_ivgen_separator,
618 test_luks_bad_header);
619 g_test_add_data_func("/crypto/block/luks/bad/ivgen-name-empty",
620 luks_bad_ivgen_name_empty,
621 test_luks_bad_header);
622 g_test_add_data_func("/crypto/block/luks/bad/ivgen-name-unknown",
623 luks_bad_ivgen_name_unknown,
624 test_luks_bad_header);
625 g_test_add_data_func("/crypto/block/luks/bad/ivgen-hash-empty",
626 luks_bad_ivgen_hash_empty,
627 test_luks_bad_header);
628 g_test_add_data_func("/crypto/block/luks/bad/ivgen-hash-unknown",
629 luks_bad_ivgen_hash_unknown,
630 test_luks_bad_header);
631 g_test_add_data_func("/crypto/block/luks/bad/hash-spec-empty",
632 luks_bad_hash_spec_empty,
633 test_luks_bad_header);
634 g_test_add_data_func("/crypto/block/luks/bad/hash-spec-unknown",
635 luks_bad_hash_spec_unknown,
636 test_luks_bad_header);
637 g_test_add_data_func("/crypto/block/luks/bad/stripes",
638 luks_bad_stripes,
639 test_luks_bad_header);
640 g_test_add_data_func("/crypto/block/luks/bad/key-overlap-header",
641 luks_bad_key_overlap_header,
642 test_luks_bad_header);
643 g_test_add_data_func("/crypto/block/luks/bad/key-overlap-key",
644 luks_bad_key_overlap_key,
645 test_luks_bad_header);
646 g_test_add_data_func("/crypto/block/luks/bad/key-overlap-payload",
647 luks_bad_key_overlap_payload,
648 test_luks_bad_header);
649 g_test_add_data_func("/crypto/block/luks/bad/payload-overlap-header",
650 luks_bad_payload_overlap_header,
651 test_luks_bad_header);
652 g_test_add_data_func("/crypto/block/luks/bad/iterations",
653 luks_bad_iterations,
654 test_luks_bad_header);
655 g_test_add_data_func("/crypto/block/luks/bad/key-iterations",
656 luks_bad_key_iterations,
657 test_luks_bad_header);
658 }
659#endif
660
661 return g_test_run();
662}
663
