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 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 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 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 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 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 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 * 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 * 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 * 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 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 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 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 451 static void block_crypto_close(BlockDriverState *bs) 452 { 453 BlockCrypto *crypto = bs->opaque; 454 qcrypto_block_free(crypto->block); 455 } 456 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 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 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 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 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 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 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 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 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 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 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 * 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 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 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 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 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 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 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 1096 static void block_crypto_init(void) 1097 { 1098 bdrv_register(&bdrv_crypto_luks); 1099 } 1100 1101 block_init(block_crypto_init); 1102