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