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