1 /*
2 * QEMU block full disk encryption
3 *
4 * Copyright (c) 2015-2016 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
23 #include "block/block_int.h"
24 #include "block/qdict.h"
25 #include "sysemu/block-backend.h"
26 #include "crypto/block.h"
27 #include "qapi/opts-visitor.h"
28 #include "qapi/qapi-visit-crypto.h"
29 #include "qapi/qobject-input-visitor.h"
30 #include "qapi/error.h"
31 #include "qemu/module.h"
32 #include "qemu/option.h"
33 #include "qemu/cutils.h"
34 #include "qemu/memalign.h"
35 #include "crypto.h"
36
37 typedef struct BlockCrypto BlockCrypto;
38
39 struct BlockCrypto {
40 QCryptoBlock *block;
41 bool updating_keys;
42 BdrvChild *header; /* Reference to the detached LUKS header */
43 };
44
45
block_crypto_probe_generic(QCryptoBlockFormat format,const uint8_t * buf,int buf_size,const char * filename)46 static int block_crypto_probe_generic(QCryptoBlockFormat format,
47 const uint8_t *buf,
48 int buf_size,
49 const char *filename)
50 {
51 if (qcrypto_block_has_format(format, buf, buf_size)) {
52 return 100;
53 } else {
54 return 0;
55 }
56 }
57
58
block_crypto_read_func(QCryptoBlock * block,size_t offset,uint8_t * buf,size_t buflen,void * opaque,Error ** errp)59 static int block_crypto_read_func(QCryptoBlock *block,
60 size_t offset,
61 uint8_t *buf,
62 size_t buflen,
63 void *opaque,
64 Error **errp)
65 {
66 BlockDriverState *bs = opaque;
67 BlockCrypto *crypto = bs->opaque;
68 ssize_t ret;
69
70 GLOBAL_STATE_CODE();
71 GRAPH_RDLOCK_GUARD_MAINLOOP();
72
73 ret = bdrv_pread(crypto->header ? crypto->header : bs->file,
74 offset, buflen, buf, 0);
75 if (ret < 0) {
76 error_setg_errno(errp, -ret, "Could not read encryption header");
77 return ret;
78 }
79 return 0;
80 }
81
block_crypto_write_func(QCryptoBlock * block,size_t offset,const uint8_t * buf,size_t buflen,void * opaque,Error ** errp)82 static int block_crypto_write_func(QCryptoBlock *block,
83 size_t offset,
84 const uint8_t *buf,
85 size_t buflen,
86 void *opaque,
87 Error **errp)
88 {
89 BlockDriverState *bs = opaque;
90 BlockCrypto *crypto = bs->opaque;
91 ssize_t ret;
92
93 GLOBAL_STATE_CODE();
94 GRAPH_RDLOCK_GUARD_MAINLOOP();
95
96 ret = bdrv_pwrite(crypto->header ? crypto->header : bs->file,
97 offset, buflen, buf, 0);
98 if (ret < 0) {
99 error_setg_errno(errp, -ret, "Could not write encryption header");
100 return ret;
101 }
102 return 0;
103 }
104
105
106 struct BlockCryptoCreateData {
107 BlockBackend *blk;
108 uint64_t size;
109 PreallocMode prealloc;
110 };
111
112
113 static int coroutine_fn GRAPH_UNLOCKED
block_crypto_create_write_func(QCryptoBlock * block,size_t offset,const uint8_t * buf,size_t buflen,void * opaque,Error ** errp)114 block_crypto_create_write_func(QCryptoBlock *block, size_t offset,
115 const uint8_t *buf, size_t buflen, void *opaque,
116 Error **errp)
117 {
118 struct BlockCryptoCreateData *data = opaque;
119 ssize_t ret;
120
121 ret = blk_pwrite(data->blk, offset, buflen, buf, 0);
122 if (ret < 0) {
123 error_setg_errno(errp, -ret, "Could not write encryption header");
124 return ret;
125 }
126 return 0;
127 }
128
129 static int coroutine_fn GRAPH_UNLOCKED
block_crypto_create_init_func(QCryptoBlock * block,size_t headerlen,void * opaque,Error ** errp)130 block_crypto_create_init_func(QCryptoBlock *block, size_t headerlen,
131 void *opaque, Error **errp)
132 {
133 struct BlockCryptoCreateData *data = opaque;
134 Error *local_error = NULL;
135 int ret;
136
137 if (data->size > INT64_MAX || headerlen > INT64_MAX - data->size) {
138 ret = -EFBIG;
139 goto error;
140 }
141
142 /* User provided size should reflect amount of space made
143 * available to the guest, so we must take account of that
144 * which will be used by the crypto header
145 */
146 ret = blk_truncate(data->blk, data->size + headerlen, false,
147 data->prealloc, 0, &local_error);
148
149 if (ret >= 0) {
150 return 0;
151 }
152
153 error:
154 if (ret == -EFBIG) {
155 /* Replace the error message with a better one */
156 error_free(local_error);
157 error_setg(errp, "The requested file size is too large");
158 } else {
159 error_propagate(errp, local_error);
160 }
161
162 return ret;
163 }
164
165 static int coroutine_fn GRAPH_UNLOCKED
block_crypto_co_format_luks_payload(BlockdevCreateOptionsLUKS * luks_opts,Error ** errp)166 block_crypto_co_format_luks_payload(BlockdevCreateOptionsLUKS *luks_opts,
167 Error **errp)
168 {
169 BlockDriverState *bs = NULL;
170 BlockBackend *blk = NULL;
171 Error *local_error = NULL;
172 int ret;
173
174 if (luks_opts->size > INT64_MAX) {
175 return -EFBIG;
176 }
177
178 bs = bdrv_co_open_blockdev_ref(luks_opts->file, errp);
179 if (bs == NULL) {
180 return -EIO;
181 }
182
183 blk = blk_co_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE,
184 BLK_PERM_ALL, errp);
185 if (!blk) {
186 ret = -EPERM;
187 goto fail;
188 }
189
190 ret = blk_truncate(blk, luks_opts->size, true,
191 luks_opts->preallocation, 0, &local_error);
192 if (ret < 0) {
193 if (ret == -EFBIG) {
194 /* Replace the error message with a better one */
195 error_free(local_error);
196 error_setg(errp, "The requested file size is too large");
197 }
198 goto fail;
199 }
200
201 ret = 0;
202
203 fail:
204 bdrv_co_unref(bs);
205 return ret;
206 }
207
208 static QemuOptsList block_crypto_runtime_opts_luks = {
209 .name = "crypto",
210 .head = QTAILQ_HEAD_INITIALIZER(block_crypto_runtime_opts_luks.head),
211 .desc = {
212 BLOCK_CRYPTO_OPT_DEF_LUKS_KEY_SECRET(""),
213 { /* end of list */ }
214 },
215 };
216
217
218 static QemuOptsList block_crypto_create_opts_luks = {
219 .name = "crypto",
220 .head = QTAILQ_HEAD_INITIALIZER(block_crypto_create_opts_luks.head),
221 .desc = {
222 {
223 .name = BLOCK_OPT_SIZE,
224 .type = QEMU_OPT_SIZE,
225 .help = "Virtual disk size"
226 },
227 BLOCK_CRYPTO_OPT_DEF_LUKS_KEY_SECRET(""),
228 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG(""),
229 BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE(""),
230 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG(""),
231 BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG(""),
232 BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG(""),
233 BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME(""),
234 BLOCK_CRYPTO_OPT_DEF_LUKS_DETACHED_HEADER(""),
235 { /* end of list */ }
236 },
237 };
238
239
240 static QemuOptsList block_crypto_amend_opts_luks = {
241 .name = "crypto",
242 .head = QTAILQ_HEAD_INITIALIZER(block_crypto_create_opts_luks.head),
243 .desc = {
244 BLOCK_CRYPTO_OPT_DEF_LUKS_STATE(""),
245 BLOCK_CRYPTO_OPT_DEF_LUKS_KEYSLOT(""),
246 BLOCK_CRYPTO_OPT_DEF_LUKS_OLD_SECRET(""),
247 BLOCK_CRYPTO_OPT_DEF_LUKS_NEW_SECRET(""),
248 BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME(""),
249 { /* end of list */ }
250 },
251 };
252
253 QCryptoBlockOpenOptions *
block_crypto_open_opts_init(QDict * opts,Error ** errp)254 block_crypto_open_opts_init(QDict *opts, Error **errp)
255 {
256 Visitor *v;
257 QCryptoBlockOpenOptions *ret;
258
259 v = qobject_input_visitor_new_flat_confused(opts, errp);
260 if (!v) {
261 return NULL;
262 }
263
264 visit_type_QCryptoBlockOpenOptions(v, NULL, &ret, errp);
265
266 visit_free(v);
267 return ret;
268 }
269
270
271 QCryptoBlockCreateOptions *
block_crypto_create_opts_init(QDict * opts,Error ** errp)272 block_crypto_create_opts_init(QDict *opts, Error **errp)
273 {
274 Visitor *v;
275 QCryptoBlockCreateOptions *ret;
276
277 v = qobject_input_visitor_new_flat_confused(opts, errp);
278 if (!v) {
279 return NULL;
280 }
281
282 visit_type_QCryptoBlockCreateOptions(v, NULL, &ret, errp);
283
284 visit_free(v);
285 return ret;
286 }
287
288 QCryptoBlockAmendOptions *
block_crypto_amend_opts_init(QDict * opts,Error ** errp)289 block_crypto_amend_opts_init(QDict *opts, Error **errp)
290 {
291 Visitor *v;
292 QCryptoBlockAmendOptions *ret;
293
294 v = qobject_input_visitor_new_flat_confused(opts, errp);
295 if (!v) {
296 return NULL;
297 }
298
299 visit_type_QCryptoBlockAmendOptions(v, NULL, &ret, errp);
300
301 visit_free(v);
302 return ret;
303 }
304
305
block_crypto_open_generic(QCryptoBlockFormat format,QemuOptsList * opts_spec,BlockDriverState * bs,QDict * options,int flags,Error ** errp)306 static int block_crypto_open_generic(QCryptoBlockFormat format,
307 QemuOptsList *opts_spec,
308 BlockDriverState *bs,
309 QDict *options,
310 int flags,
311 Error **errp)
312 {
313 ERRP_GUARD();
314
315 BlockCrypto *crypto = bs->opaque;
316 QemuOpts *opts = NULL;
317 int ret;
318 QCryptoBlockOpenOptions *open_opts = NULL;
319 unsigned int cflags = 0;
320 QDict *cryptoopts = NULL;
321
322 GLOBAL_STATE_CODE();
323
324 ret = bdrv_open_file_child(NULL, options, "file", bs, errp);
325 if (ret < 0) {
326 return ret;
327 }
328
329 crypto->header = bdrv_open_child(NULL, options, "header", bs,
330 &child_of_bds, BDRV_CHILD_METADATA,
331 true, errp);
332 if (*errp != NULL) {
333 return -EINVAL;
334 }
335
336 GRAPH_RDLOCK_GUARD_MAINLOOP();
337
338 bs->supported_write_flags = BDRV_REQ_FUA &
339 bs->file->bs->supported_write_flags;
340
341 opts = qemu_opts_create(opts_spec, NULL, 0, &error_abort);
342 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
343 ret = -EINVAL;
344 goto cleanup;
345 }
346
347 cryptoopts = qemu_opts_to_qdict(opts, NULL);
348 qdict_put_str(cryptoopts, "format", QCryptoBlockFormat_str(format));
349
350 open_opts = block_crypto_open_opts_init(cryptoopts, errp);
351 if (!open_opts) {
352 ret = -EINVAL;
353 goto cleanup;
354 }
355
356 if (flags & BDRV_O_NO_IO) {
357 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
358 }
359 if (crypto->header != NULL) {
360 cflags |= QCRYPTO_BLOCK_OPEN_DETACHED;
361 }
362 crypto->block = qcrypto_block_open(open_opts, NULL,
363 block_crypto_read_func,
364 bs,
365 cflags,
366 1,
367 errp);
368
369 if (!crypto->block) {
370 ret = -EIO;
371 goto cleanup;
372 }
373
374 bs->encrypted = true;
375
376 ret = 0;
377 cleanup:
378 qobject_unref(cryptoopts);
379 qapi_free_QCryptoBlockOpenOptions(open_opts);
380 return ret;
381 }
382
383
384 static int coroutine_fn GRAPH_UNLOCKED
block_crypto_co_create_generic(BlockDriverState * bs,int64_t size,QCryptoBlockCreateOptions * opts,PreallocMode prealloc,unsigned int flags,Error ** errp)385 block_crypto_co_create_generic(BlockDriverState *bs, int64_t size,
386 QCryptoBlockCreateOptions *opts,
387 PreallocMode prealloc,
388 unsigned int flags,
389 Error **errp)
390 {
391 int ret;
392 BlockBackend *blk;
393 QCryptoBlock *crypto = NULL;
394 struct BlockCryptoCreateData data;
395
396 blk = blk_co_new_with_bs(bs, BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL,
397 errp);
398 if (!blk) {
399 ret = -EPERM;
400 goto cleanup;
401 }
402
403 if (prealloc == PREALLOC_MODE_METADATA) {
404 prealloc = PREALLOC_MODE_OFF;
405 }
406
407 data = (struct BlockCryptoCreateData) {
408 .blk = blk,
409 .size = flags & QCRYPTO_BLOCK_CREATE_DETACHED ? 0 : size,
410 .prealloc = prealloc,
411 };
412
413 crypto = qcrypto_block_create(opts, NULL,
414 block_crypto_create_init_func,
415 block_crypto_create_write_func,
416 &data,
417 flags,
418 errp);
419
420 if (!crypto) {
421 ret = -EIO;
422 goto cleanup;
423 }
424
425 ret = 0;
426 cleanup:
427 qcrypto_block_free(crypto);
428 blk_co_unref(blk);
429 return ret;
430 }
431
432 static int coroutine_fn GRAPH_RDLOCK
block_crypto_co_truncate(BlockDriverState * bs,int64_t offset,bool exact,PreallocMode prealloc,BdrvRequestFlags flags,Error ** errp)433 block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
434 PreallocMode prealloc, BdrvRequestFlags flags,
435 Error **errp)
436 {
437 BlockCrypto *crypto = bs->opaque;
438 uint64_t payload_offset =
439 qcrypto_block_get_payload_offset(crypto->block);
440
441 if (payload_offset > INT64_MAX - offset) {
442 error_setg(errp, "The requested file size is too large");
443 return -EFBIG;
444 }
445
446 offset += payload_offset;
447
448 return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
449 }
450
block_crypto_close(BlockDriverState * bs)451 static void block_crypto_close(BlockDriverState *bs)
452 {
453 BlockCrypto *crypto = bs->opaque;
454 qcrypto_block_free(crypto->block);
455 }
456
block_crypto_reopen_prepare(BDRVReopenState * state,BlockReopenQueue * queue,Error ** errp)457 static int block_crypto_reopen_prepare(BDRVReopenState *state,
458 BlockReopenQueue *queue, Error **errp)
459 {
460 /* nothing needs checking */
461 return 0;
462 }
463
464 /*
465 * 1 MB bounce buffer gives good performance / memory tradeoff
466 * when using cache=none|directsync.
467 */
468 #define BLOCK_CRYPTO_MAX_IO_SIZE (1024 * 1024)
469
470 static int coroutine_fn GRAPH_RDLOCK
block_crypto_co_preadv(BlockDriverState * bs,int64_t offset,int64_t bytes,QEMUIOVector * qiov,BdrvRequestFlags flags)471 block_crypto_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
472 QEMUIOVector *qiov, BdrvRequestFlags flags)
473 {
474 BlockCrypto *crypto = bs->opaque;
475 uint64_t cur_bytes; /* number of bytes in current iteration */
476 uint64_t bytes_done = 0;
477 uint8_t *cipher_data = NULL;
478 QEMUIOVector hd_qiov;
479 int ret = 0;
480 uint64_t sector_size = qcrypto_block_get_sector_size(crypto->block);
481 uint64_t payload_offset = qcrypto_block_get_payload_offset(crypto->block);
482
483 assert(payload_offset < INT64_MAX);
484 assert(QEMU_IS_ALIGNED(offset, sector_size));
485 assert(QEMU_IS_ALIGNED(bytes, sector_size));
486
487 qemu_iovec_init(&hd_qiov, qiov->niov);
488
489 /* Bounce buffer because we don't wish to expose cipher text
490 * in qiov which points to guest memory.
491 */
492 cipher_data =
493 qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_IO_SIZE,
494 qiov->size));
495 if (cipher_data == NULL) {
496 ret = -ENOMEM;
497 goto cleanup;
498 }
499
500 while (bytes) {
501 cur_bytes = MIN(bytes, BLOCK_CRYPTO_MAX_IO_SIZE);
502
503 qemu_iovec_reset(&hd_qiov);
504 qemu_iovec_add(&hd_qiov, cipher_data, cur_bytes);
505
506 ret = bdrv_co_preadv(bs->file, payload_offset + offset + bytes_done,
507 cur_bytes, &hd_qiov, 0);
508 if (ret < 0) {
509 goto cleanup;
510 }
511
512 if (qcrypto_block_decrypt(crypto->block, offset + bytes_done,
513 cipher_data, cur_bytes, NULL) < 0) {
514 ret = -EIO;
515 goto cleanup;
516 }
517
518 qemu_iovec_from_buf(qiov, bytes_done, cipher_data, cur_bytes);
519
520 bytes -= cur_bytes;
521 bytes_done += cur_bytes;
522 }
523
524 cleanup:
525 qemu_iovec_destroy(&hd_qiov);
526 qemu_vfree(cipher_data);
527
528 return ret;
529 }
530
531
532 static int coroutine_fn GRAPH_RDLOCK
block_crypto_co_pwritev(BlockDriverState * bs,int64_t offset,int64_t bytes,QEMUIOVector * qiov,BdrvRequestFlags flags)533 block_crypto_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
534 QEMUIOVector *qiov, BdrvRequestFlags flags)
535 {
536 BlockCrypto *crypto = bs->opaque;
537 uint64_t cur_bytes; /* number of bytes in current iteration */
538 uint64_t bytes_done = 0;
539 uint8_t *cipher_data = NULL;
540 QEMUIOVector hd_qiov;
541 int ret = 0;
542 uint64_t sector_size = qcrypto_block_get_sector_size(crypto->block);
543 uint64_t payload_offset = qcrypto_block_get_payload_offset(crypto->block);
544
545 flags &= ~BDRV_REQ_REGISTERED_BUF;
546
547 assert(payload_offset < INT64_MAX);
548 assert(QEMU_IS_ALIGNED(offset, sector_size));
549 assert(QEMU_IS_ALIGNED(bytes, sector_size));
550
551 qemu_iovec_init(&hd_qiov, qiov->niov);
552
553 /* Bounce buffer because we're not permitted to touch
554 * contents of qiov - it points to guest memory.
555 */
556 cipher_data =
557 qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_IO_SIZE,
558 qiov->size));
559 if (cipher_data == NULL) {
560 ret = -ENOMEM;
561 goto cleanup;
562 }
563
564 while (bytes) {
565 cur_bytes = MIN(bytes, BLOCK_CRYPTO_MAX_IO_SIZE);
566
567 qemu_iovec_to_buf(qiov, bytes_done, cipher_data, cur_bytes);
568
569 if (qcrypto_block_encrypt(crypto->block, offset + bytes_done,
570 cipher_data, cur_bytes, NULL) < 0) {
571 ret = -EIO;
572 goto cleanup;
573 }
574
575 qemu_iovec_reset(&hd_qiov);
576 qemu_iovec_add(&hd_qiov, cipher_data, cur_bytes);
577
578 ret = bdrv_co_pwritev(bs->file, payload_offset + offset + bytes_done,
579 cur_bytes, &hd_qiov, flags);
580 if (ret < 0) {
581 goto cleanup;
582 }
583
584 bytes -= cur_bytes;
585 bytes_done += cur_bytes;
586 }
587
588 cleanup:
589 qemu_iovec_destroy(&hd_qiov);
590 qemu_vfree(cipher_data);
591
592 return ret;
593 }
594
block_crypto_refresh_limits(BlockDriverState * bs,Error ** errp)595 static void block_crypto_refresh_limits(BlockDriverState *bs, Error **errp)
596 {
597 BlockCrypto *crypto = bs->opaque;
598 uint64_t sector_size = qcrypto_block_get_sector_size(crypto->block);
599 bs->bl.request_alignment = sector_size; /* No sub-sector I/O */
600 }
601
602
603 static int64_t coroutine_fn GRAPH_RDLOCK
block_crypto_co_getlength(BlockDriverState * bs)604 block_crypto_co_getlength(BlockDriverState *bs)
605 {
606 BlockCrypto *crypto = bs->opaque;
607 int64_t len = bdrv_co_getlength(bs->file->bs);
608
609 uint64_t offset = qcrypto_block_get_payload_offset(crypto->block);
610 assert(offset < INT64_MAX);
611
612 if (offset > len) {
613 return -EIO;
614 }
615
616 len -= offset;
617
618 return len;
619 }
620
621
block_crypto_measure(QemuOpts * opts,BlockDriverState * in_bs,Error ** errp)622 static BlockMeasureInfo *block_crypto_measure(QemuOpts *opts,
623 BlockDriverState *in_bs,
624 Error **errp)
625 {
626 g_autoptr(QCryptoBlockCreateOptions) create_opts = NULL;
627 Error *local_err = NULL;
628 BlockMeasureInfo *info;
629 uint64_t size;
630 size_t luks_payload_size;
631 QDict *cryptoopts;
632
633 /*
634 * Preallocation mode doesn't affect size requirements but we must consume
635 * the option.
636 */
637 g_free(qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC));
638
639 size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
640
641 if (in_bs) {
642 int64_t ssize = bdrv_getlength(in_bs);
643
644 if (ssize < 0) {
645 error_setg_errno(&local_err, -ssize,
646 "Unable to get image virtual_size");
647 goto err;
648 }
649
650 size = ssize;
651 }
652
653 cryptoopts = qemu_opts_to_qdict_filtered(opts, NULL,
654 &block_crypto_create_opts_luks, true);
655 qdict_put_str(cryptoopts, "format", "luks");
656 create_opts = block_crypto_create_opts_init(cryptoopts, &local_err);
657 qobject_unref(cryptoopts);
658 if (!create_opts) {
659 goto err;
660 }
661
662 if (!qcrypto_block_calculate_payload_offset(create_opts, NULL,
663 &luks_payload_size,
664 &local_err)) {
665 goto err;
666 }
667
668 /*
669 * Unallocated blocks are still encrypted so allocation status makes no
670 * difference to the file size.
671 */
672 info = g_new0(BlockMeasureInfo, 1);
673 info->fully_allocated = luks_payload_size + size;
674 info->required = luks_payload_size + size;
675 return info;
676
677 err:
678 error_propagate(errp, local_err);
679 return NULL;
680 }
681
682
block_crypto_probe_luks(const uint8_t * buf,int buf_size,const char * filename)683 static int block_crypto_probe_luks(const uint8_t *buf,
684 int buf_size,
685 const char *filename) {
686 return block_crypto_probe_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
687 buf, buf_size, filename);
688 }
689
block_crypto_open_luks(BlockDriverState * bs,QDict * options,int flags,Error ** errp)690 static int block_crypto_open_luks(BlockDriverState *bs,
691 QDict *options,
692 int flags,
693 Error **errp)
694 {
695 return block_crypto_open_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
696 &block_crypto_runtime_opts_luks,
697 bs, options, flags, errp);
698 }
699
700 static int coroutine_fn GRAPH_UNLOCKED
block_crypto_co_create_luks(BlockdevCreateOptions * create_options,Error ** errp)701 block_crypto_co_create_luks(BlockdevCreateOptions *create_options, Error **errp)
702 {
703 BlockdevCreateOptionsLUKS *luks_opts;
704 BlockDriverState *hdr_bs = NULL;
705 BlockDriverState *bs = NULL;
706 QCryptoBlockCreateOptions create_opts;
707 PreallocMode preallocation = PREALLOC_MODE_OFF;
708 unsigned int cflags = 0;
709 int ret;
710
711 assert(create_options->driver == BLOCKDEV_DRIVER_LUKS);
712 luks_opts = &create_options->u.luks;
713
714 if (luks_opts->header == NULL && luks_opts->file == NULL) {
715 error_setg(errp, "Either the parameter 'header' or 'file' must "
716 "be specified");
717 return -EINVAL;
718 }
719
720 if ((luks_opts->preallocation != PREALLOC_MODE_OFF) &&
721 (luks_opts->file == NULL)) {
722 error_setg(errp, "Parameter 'preallocation' requires 'file' to be "
723 "specified for formatting LUKS disk");
724 return -EINVAL;
725 }
726
727 create_opts = (QCryptoBlockCreateOptions) {
728 .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
729 .u.luks = *qapi_BlockdevCreateOptionsLUKS_base(luks_opts),
730 };
731
732 if (luks_opts->has_preallocation) {
733 preallocation = luks_opts->preallocation;
734 }
735
736 if (luks_opts->header) {
737 /* LUKS volume with detached header */
738 hdr_bs = bdrv_co_open_blockdev_ref(luks_opts->header, errp);
739 if (hdr_bs == NULL) {
740 return -EIO;
741 }
742
743 cflags |= QCRYPTO_BLOCK_CREATE_DETACHED;
744
745 /* Format the LUKS header node */
746 ret = block_crypto_co_create_generic(hdr_bs, 0, &create_opts,
747 PREALLOC_MODE_OFF, cflags, errp);
748 if (ret < 0) {
749 goto fail;
750 }
751
752 /* Format the LUKS payload node */
753 if (luks_opts->file) {
754 ret = block_crypto_co_format_luks_payload(luks_opts, errp);
755 if (ret < 0) {
756 goto fail;
757 }
758 }
759 } else if (luks_opts->file) {
760 /* LUKS volume with none-detached header */
761 bs = bdrv_co_open_blockdev_ref(luks_opts->file, errp);
762 if (bs == NULL) {
763 return -EIO;
764 }
765
766 ret = block_crypto_co_create_generic(bs, luks_opts->size, &create_opts,
767 preallocation, cflags, errp);
768 if (ret < 0) {
769 goto fail;
770 }
771 }
772
773 ret = 0;
774 fail:
775 if (hdr_bs != NULL) {
776 bdrv_co_unref(hdr_bs);
777 }
778
779 if (bs != NULL) {
780 bdrv_co_unref(bs);
781 }
782 return ret;
783 }
784
785 static int coroutine_fn GRAPH_UNLOCKED
block_crypto_co_create_opts_luks(BlockDriver * drv,const char * filename,QemuOpts * opts,Error ** errp)786 block_crypto_co_create_opts_luks(BlockDriver *drv, const char *filename,
787 QemuOpts *opts, Error **errp)
788 {
789 QCryptoBlockCreateOptions *create_opts = NULL;
790 BlockDriverState *bs = NULL;
791 QDict *cryptoopts;
792 PreallocMode prealloc;
793 char *buf = NULL;
794 int64_t size;
795 bool detached_hdr =
796 qemu_opt_get_bool(opts, "detached-header", false);
797 unsigned int cflags = 0;
798 int ret;
799 Error *local_err = NULL;
800
801 /* Parse options */
802 size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
803
804 buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
805 prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
806 PREALLOC_MODE_OFF, &local_err);
807 g_free(buf);
808 if (local_err) {
809 error_propagate(errp, local_err);
810 return -EINVAL;
811 }
812
813 cryptoopts = qemu_opts_to_qdict_filtered(opts, NULL,
814 &block_crypto_create_opts_luks,
815 true);
816
817 qdict_put_str(cryptoopts, "format", "luks");
818 create_opts = block_crypto_create_opts_init(cryptoopts, errp);
819 if (!create_opts) {
820 ret = -EINVAL;
821 goto fail;
822 }
823
824 /* Create protocol layer */
825 ret = bdrv_co_create_file(filename, opts, errp);
826 if (ret < 0) {
827 goto fail;
828 }
829
830 bs = bdrv_co_open(filename, NULL, NULL,
831 BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_PROTOCOL, errp);
832 if (!bs) {
833 ret = -EINVAL;
834 goto fail;
835 }
836
837 if (detached_hdr) {
838 cflags |= QCRYPTO_BLOCK_CREATE_DETACHED;
839 }
840
841 /* Create format layer */
842 ret = block_crypto_co_create_generic(bs, size, create_opts,
843 prealloc, cflags, errp);
844 if (ret < 0) {
845 goto fail;
846 }
847
848 ret = 0;
849 fail:
850 /*
851 * If an error occurred, delete 'filename'. Even if the file existed
852 * beforehand, it has been truncated and corrupted in the process.
853 */
854 if (ret) {
855 bdrv_graph_co_rdlock();
856 bdrv_co_delete_file_noerr(bs);
857 bdrv_graph_co_rdunlock();
858 }
859
860 bdrv_co_unref(bs);
861 qapi_free_QCryptoBlockCreateOptions(create_opts);
862 qobject_unref(cryptoopts);
863 return ret;
864 }
865
866 static int coroutine_fn GRAPH_RDLOCK
block_crypto_co_get_info_luks(BlockDriverState * bs,BlockDriverInfo * bdi)867 block_crypto_co_get_info_luks(BlockDriverState *bs, BlockDriverInfo *bdi)
868 {
869 BlockDriverInfo subbdi;
870 int ret;
871
872 ret = bdrv_co_get_info(bs->file->bs, &subbdi);
873 if (ret != 0) {
874 return ret;
875 }
876
877 bdi->cluster_size = subbdi.cluster_size;
878
879 return 0;
880 }
881
882 static ImageInfoSpecific *
block_crypto_get_specific_info_luks(BlockDriverState * bs,Error ** errp)883 block_crypto_get_specific_info_luks(BlockDriverState *bs, Error **errp)
884 {
885 BlockCrypto *crypto = bs->opaque;
886 ImageInfoSpecific *spec_info;
887 QCryptoBlockInfo *info;
888
889 info = qcrypto_block_get_info(crypto->block, errp);
890 if (!info) {
891 return NULL;
892 }
893 assert(info->format == Q_CRYPTO_BLOCK_FORMAT_LUKS);
894
895 spec_info = g_new(ImageInfoSpecific, 1);
896 spec_info->type = IMAGE_INFO_SPECIFIC_KIND_LUKS;
897 spec_info->u.luks.data = g_new(QCryptoBlockInfoLUKS, 1);
898 *spec_info->u.luks.data = info->u.luks;
899
900 /* Blank out pointers we've just stolen to avoid double free */
901 memset(&info->u.luks, 0, sizeof(info->u.luks));
902
903 qapi_free_QCryptoBlockInfo(info);
904
905 return spec_info;
906 }
907
908 static int GRAPH_RDLOCK
block_crypto_amend_prepare(BlockDriverState * bs,Error ** errp)909 block_crypto_amend_prepare(BlockDriverState *bs, Error **errp)
910 {
911 BlockCrypto *crypto = bs->opaque;
912 int ret;
913
914 /* apply for exclusive read/write permissions to the underlying file */
915 crypto->updating_keys = true;
916 ret = bdrv_child_refresh_perms(bs, bs->file, errp);
917 if (ret < 0) {
918 /* Well, in this case we will not be updating any keys */
919 crypto->updating_keys = false;
920 }
921 return ret;
922 }
923
924 static void GRAPH_RDLOCK
block_crypto_amend_cleanup(BlockDriverState * bs)925 block_crypto_amend_cleanup(BlockDriverState *bs)
926 {
927 BlockCrypto *crypto = bs->opaque;
928 Error *errp = NULL;
929
930 /* release exclusive read/write permissions to the underlying file */
931 crypto->updating_keys = false;
932 bdrv_child_refresh_perms(bs, bs->file, &errp);
933
934 if (errp) {
935 error_report_err(errp);
936 }
937 }
938
939 static int
block_crypto_amend_options_generic_luks(BlockDriverState * bs,QCryptoBlockAmendOptions * amend_options,bool force,Error ** errp)940 block_crypto_amend_options_generic_luks(BlockDriverState *bs,
941 QCryptoBlockAmendOptions *amend_options,
942 bool force,
943 Error **errp)
944 {
945 BlockCrypto *crypto = bs->opaque;
946
947 assert(crypto);
948 assert(crypto->block);
949
950 return qcrypto_block_amend_options(crypto->block,
951 block_crypto_read_func,
952 block_crypto_write_func,
953 bs,
954 amend_options,
955 force,
956 errp);
957 }
958
959 static int GRAPH_RDLOCK
block_crypto_amend_options_luks(BlockDriverState * bs,QemuOpts * opts,BlockDriverAmendStatusCB * status_cb,void * cb_opaque,bool force,Error ** errp)960 block_crypto_amend_options_luks(BlockDriverState *bs,
961 QemuOpts *opts,
962 BlockDriverAmendStatusCB *status_cb,
963 void *cb_opaque,
964 bool force,
965 Error **errp)
966 {
967 BlockCrypto *crypto = bs->opaque;
968 QDict *cryptoopts = NULL;
969 QCryptoBlockAmendOptions *amend_options = NULL;
970 int ret = -EINVAL;
971
972 assert(crypto);
973 assert(crypto->block);
974
975 cryptoopts = qemu_opts_to_qdict(opts, NULL);
976 qdict_put_str(cryptoopts, "format", "luks");
977 amend_options = block_crypto_amend_opts_init(cryptoopts, errp);
978 qobject_unref(cryptoopts);
979 if (!amend_options) {
980 goto cleanup;
981 }
982
983 ret = block_crypto_amend_prepare(bs, errp);
984 if (ret) {
985 goto perm_cleanup;
986 }
987 ret = block_crypto_amend_options_generic_luks(bs, amend_options,
988 force, errp);
989
990 perm_cleanup:
991 block_crypto_amend_cleanup(bs);
992 cleanup:
993 qapi_free_QCryptoBlockAmendOptions(amend_options);
994 return ret;
995 }
996
997 static int
block_crypto_co_amend_luks(BlockDriverState * bs,BlockdevAmendOptions * opts,bool force,Error ** errp)998 coroutine_fn block_crypto_co_amend_luks(BlockDriverState *bs,
999 BlockdevAmendOptions *opts,
1000 bool force,
1001 Error **errp)
1002 {
1003 QCryptoBlockAmendOptions amend_opts;
1004
1005 amend_opts = (QCryptoBlockAmendOptions) {
1006 .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
1007 .u.luks = *qapi_BlockdevAmendOptionsLUKS_base(&opts->u.luks),
1008 };
1009 return block_crypto_amend_options_generic_luks(bs, &amend_opts,
1010 force, errp);
1011 }
1012
1013 static void
block_crypto_child_perms(BlockDriverState * bs,BdrvChild * c,const BdrvChildRole role,BlockReopenQueue * reopen_queue,uint64_t perm,uint64_t shared,uint64_t * nperm,uint64_t * nshared)1014 block_crypto_child_perms(BlockDriverState *bs, BdrvChild *c,
1015 const BdrvChildRole role,
1016 BlockReopenQueue *reopen_queue,
1017 uint64_t perm, uint64_t shared,
1018 uint64_t *nperm, uint64_t *nshared)
1019 {
1020
1021 BlockCrypto *crypto = bs->opaque;
1022
1023 bdrv_default_perms(bs, c, role, reopen_queue, perm, shared, nperm, nshared);
1024
1025 /*
1026 * For backward compatibility, manually share the write
1027 * and resize permission
1028 */
1029 *nshared |= shared & (BLK_PERM_WRITE | BLK_PERM_RESIZE);
1030 /*
1031 * Since we are not fully a format driver, don't always request
1032 * the read/resize permission but only when explicitly
1033 * requested
1034 */
1035 *nperm &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
1036 *nperm |= perm & (BLK_PERM_WRITE | BLK_PERM_RESIZE);
1037
1038 /*
1039 * This driver doesn't modify LUKS metadata except
1040 * when updating the encryption slots.
1041 * Thus unlike a proper format driver we don't ask for
1042 * shared write/read permission. However we need it
1043 * when we are updating the keys, to ensure that only we
1044 * have access to the device.
1045 *
1046 * Encryption update will set the crypto->updating_keys
1047 * during that period and refresh permissions
1048 *
1049 */
1050 if (crypto->updating_keys) {
1051 /* need exclusive write access for header update */
1052 *nperm |= BLK_PERM_WRITE;
1053 /* unshare read and write permission */
1054 *nshared &= ~(BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE);
1055 }
1056 }
1057
1058
1059 static const char *const block_crypto_strong_runtime_opts[] = {
1060 BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET,
1061
1062 NULL
1063 };
1064
1065 static BlockDriver bdrv_crypto_luks = {
1066 .format_name = "luks",
1067 .instance_size = sizeof(BlockCrypto),
1068 .bdrv_probe = block_crypto_probe_luks,
1069 .bdrv_open = block_crypto_open_luks,
1070 .bdrv_close = block_crypto_close,
1071 .bdrv_child_perm = block_crypto_child_perms,
1072 .bdrv_co_create = block_crypto_co_create_luks,
1073 .bdrv_co_create_opts = block_crypto_co_create_opts_luks,
1074 .bdrv_co_truncate = block_crypto_co_truncate,
1075 .create_opts = &block_crypto_create_opts_luks,
1076 .amend_opts = &block_crypto_amend_opts_luks,
1077
1078 .bdrv_reopen_prepare = block_crypto_reopen_prepare,
1079 .bdrv_refresh_limits = block_crypto_refresh_limits,
1080 .bdrv_co_preadv = block_crypto_co_preadv,
1081 .bdrv_co_pwritev = block_crypto_co_pwritev,
1082 .bdrv_co_getlength = block_crypto_co_getlength,
1083 .bdrv_measure = block_crypto_measure,
1084 .bdrv_co_get_info = block_crypto_co_get_info_luks,
1085 .bdrv_get_specific_info = block_crypto_get_specific_info_luks,
1086 .bdrv_amend_options = block_crypto_amend_options_luks,
1087 .bdrv_co_amend = block_crypto_co_amend_luks,
1088 .bdrv_amend_pre_run = block_crypto_amend_prepare,
1089 .bdrv_amend_clean = block_crypto_amend_cleanup,
1090
1091 .is_format = true,
1092
1093 .strong_runtime_opts = block_crypto_strong_runtime_opts,
1094 };
1095
block_crypto_init(void)1096 static void block_crypto_init(void)
1097 {
1098 bdrv_register(&bdrv_crypto_luks);
1099 }
1100
1101 block_init(block_crypto_init);
1102