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 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 "sysemu/block-backend.h" 25 #include "crypto/block.h" 26 #include "qapi/opts-visitor.h" 27 #include "qapi-visit.h" 28 #include "qapi/error.h" 29 30 #define BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET "key-secret" 31 #define BLOCK_CRYPTO_OPT_LUKS_CIPHER_ALG "cipher-alg" 32 #define BLOCK_CRYPTO_OPT_LUKS_CIPHER_MODE "cipher-mode" 33 #define BLOCK_CRYPTO_OPT_LUKS_IVGEN_ALG "ivgen-alg" 34 #define BLOCK_CRYPTO_OPT_LUKS_IVGEN_HASH_ALG "ivgen-hash-alg" 35 #define BLOCK_CRYPTO_OPT_LUKS_HASH_ALG "hash-alg" 36 #define BLOCK_CRYPTO_OPT_LUKS_ITER_TIME "iter-time" 37 38 typedef struct BlockCrypto BlockCrypto; 39 40 struct BlockCrypto { 41 QCryptoBlock *block; 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 ssize_t 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, buf, buflen); 69 if (ret < 0) { 70 error_setg_errno(errp, -ret, "Could not read encryption header"); 71 return ret; 72 } 73 return ret; 74 } 75 76 77 struct BlockCryptoCreateData { 78 const char *filename; 79 QemuOpts *opts; 80 BlockBackend *blk; 81 uint64_t size; 82 }; 83 84 85 static ssize_t block_crypto_write_func(QCryptoBlock *block, 86 size_t offset, 87 const uint8_t *buf, 88 size_t buflen, 89 void *opaque, 90 Error **errp) 91 { 92 struct BlockCryptoCreateData *data = opaque; 93 ssize_t ret; 94 95 ret = blk_pwrite(data->blk, offset, buf, buflen, 0); 96 if (ret < 0) { 97 error_setg_errno(errp, -ret, "Could not write encryption header"); 98 return ret; 99 } 100 return ret; 101 } 102 103 104 static ssize_t block_crypto_init_func(QCryptoBlock *block, 105 size_t headerlen, 106 void *opaque, 107 Error **errp) 108 { 109 struct BlockCryptoCreateData *data = opaque; 110 int ret; 111 112 /* User provided size should reflect amount of space made 113 * available to the guest, so we must take account of that 114 * which will be used by the crypto header 115 */ 116 data->size += headerlen; 117 118 qemu_opt_set_number(data->opts, BLOCK_OPT_SIZE, data->size, &error_abort); 119 ret = bdrv_create_file(data->filename, data->opts, errp); 120 if (ret < 0) { 121 return -1; 122 } 123 124 data->blk = blk_new_open(data->filename, NULL, NULL, 125 BDRV_O_RDWR | BDRV_O_PROTOCOL, errp); 126 if (!data->blk) { 127 return -1; 128 } 129 130 return 0; 131 } 132 133 134 static QemuOptsList block_crypto_runtime_opts_luks = { 135 .name = "crypto", 136 .head = QTAILQ_HEAD_INITIALIZER(block_crypto_runtime_opts_luks.head), 137 .desc = { 138 { 139 .name = BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET, 140 .type = QEMU_OPT_STRING, 141 .help = "ID of the secret that provides the encryption key", 142 }, 143 { /* end of list */ } 144 }, 145 }; 146 147 148 static QemuOptsList block_crypto_create_opts_luks = { 149 .name = "crypto", 150 .head = QTAILQ_HEAD_INITIALIZER(block_crypto_create_opts_luks.head), 151 .desc = { 152 { 153 .name = BLOCK_OPT_SIZE, 154 .type = QEMU_OPT_SIZE, 155 .help = "Virtual disk size" 156 }, 157 { 158 .name = BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET, 159 .type = QEMU_OPT_STRING, 160 .help = "ID of the secret that provides the encryption key", 161 }, 162 { 163 .name = BLOCK_CRYPTO_OPT_LUKS_CIPHER_ALG, 164 .type = QEMU_OPT_STRING, 165 .help = "Name of encryption cipher algorithm", 166 }, 167 { 168 .name = BLOCK_CRYPTO_OPT_LUKS_CIPHER_MODE, 169 .type = QEMU_OPT_STRING, 170 .help = "Name of encryption cipher mode", 171 }, 172 { 173 .name = BLOCK_CRYPTO_OPT_LUKS_IVGEN_ALG, 174 .type = QEMU_OPT_STRING, 175 .help = "Name of IV generator algorithm", 176 }, 177 { 178 .name = BLOCK_CRYPTO_OPT_LUKS_IVGEN_HASH_ALG, 179 .type = QEMU_OPT_STRING, 180 .help = "Name of IV generator hash algorithm", 181 }, 182 { 183 .name = BLOCK_CRYPTO_OPT_LUKS_HASH_ALG, 184 .type = QEMU_OPT_STRING, 185 .help = "Name of encryption hash algorithm", 186 }, 187 { 188 .name = BLOCK_CRYPTO_OPT_LUKS_ITER_TIME, 189 .type = QEMU_OPT_NUMBER, 190 .help = "Time to spend in PBKDF in milliseconds", 191 }, 192 { /* end of list */ } 193 }, 194 }; 195 196 197 static QCryptoBlockOpenOptions * 198 block_crypto_open_opts_init(QCryptoBlockFormat format, 199 QemuOpts *opts, 200 Error **errp) 201 { 202 Visitor *v; 203 QCryptoBlockOpenOptions *ret = NULL; 204 Error *local_err = NULL; 205 206 ret = g_new0(QCryptoBlockOpenOptions, 1); 207 ret->format = format; 208 209 v = opts_visitor_new(opts); 210 211 visit_start_struct(v, NULL, NULL, 0, &local_err); 212 if (local_err) { 213 goto out; 214 } 215 216 switch (format) { 217 case Q_CRYPTO_BLOCK_FORMAT_LUKS: 218 visit_type_QCryptoBlockOptionsLUKS_members( 219 v, &ret->u.luks, &local_err); 220 break; 221 222 default: 223 error_setg(&local_err, "Unsupported block format %d", format); 224 break; 225 } 226 if (!local_err) { 227 visit_check_struct(v, &local_err); 228 } 229 230 visit_end_struct(v, NULL); 231 232 out: 233 if (local_err) { 234 error_propagate(errp, local_err); 235 qapi_free_QCryptoBlockOpenOptions(ret); 236 ret = NULL; 237 } 238 visit_free(v); 239 return ret; 240 } 241 242 243 static QCryptoBlockCreateOptions * 244 block_crypto_create_opts_init(QCryptoBlockFormat format, 245 QemuOpts *opts, 246 Error **errp) 247 { 248 Visitor *v; 249 QCryptoBlockCreateOptions *ret = NULL; 250 Error *local_err = NULL; 251 252 ret = g_new0(QCryptoBlockCreateOptions, 1); 253 ret->format = format; 254 255 v = opts_visitor_new(opts); 256 257 visit_start_struct(v, NULL, NULL, 0, &local_err); 258 if (local_err) { 259 goto out; 260 } 261 262 switch (format) { 263 case Q_CRYPTO_BLOCK_FORMAT_LUKS: 264 visit_type_QCryptoBlockCreateOptionsLUKS_members( 265 v, &ret->u.luks, &local_err); 266 break; 267 268 default: 269 error_setg(&local_err, "Unsupported block format %d", format); 270 break; 271 } 272 if (!local_err) { 273 visit_check_struct(v, &local_err); 274 } 275 276 visit_end_struct(v, NULL); 277 278 out: 279 if (local_err) { 280 error_propagate(errp, local_err); 281 qapi_free_QCryptoBlockCreateOptions(ret); 282 ret = NULL; 283 } 284 visit_free(v); 285 return ret; 286 } 287 288 289 static int block_crypto_open_generic(QCryptoBlockFormat format, 290 QemuOptsList *opts_spec, 291 BlockDriverState *bs, 292 QDict *options, 293 int flags, 294 Error **errp) 295 { 296 BlockCrypto *crypto = bs->opaque; 297 QemuOpts *opts = NULL; 298 Error *local_err = NULL; 299 int ret = -EINVAL; 300 QCryptoBlockOpenOptions *open_opts = NULL; 301 unsigned int cflags = 0; 302 303 bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file, 304 false, errp); 305 if (!bs->file) { 306 return -EINVAL; 307 } 308 309 opts = qemu_opts_create(opts_spec, NULL, 0, &error_abort); 310 qemu_opts_absorb_qdict(opts, options, &local_err); 311 if (local_err) { 312 error_propagate(errp, local_err); 313 goto cleanup; 314 } 315 316 open_opts = block_crypto_open_opts_init(format, opts, errp); 317 if (!open_opts) { 318 goto cleanup; 319 } 320 321 if (flags & BDRV_O_NO_IO) { 322 cflags |= QCRYPTO_BLOCK_OPEN_NO_IO; 323 } 324 crypto->block = qcrypto_block_open(open_opts, 325 block_crypto_read_func, 326 bs, 327 cflags, 328 errp); 329 330 if (!crypto->block) { 331 ret = -EIO; 332 goto cleanup; 333 } 334 335 bs->encrypted = true; 336 bs->valid_key = true; 337 338 ret = 0; 339 cleanup: 340 qapi_free_QCryptoBlockOpenOptions(open_opts); 341 return ret; 342 } 343 344 345 static int block_crypto_create_generic(QCryptoBlockFormat format, 346 const char *filename, 347 QemuOpts *opts, 348 Error **errp) 349 { 350 int ret = -EINVAL; 351 QCryptoBlockCreateOptions *create_opts = NULL; 352 QCryptoBlock *crypto = NULL; 353 struct BlockCryptoCreateData data = { 354 .size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), 355 BDRV_SECTOR_SIZE), 356 .opts = opts, 357 .filename = filename, 358 }; 359 360 create_opts = block_crypto_create_opts_init(format, opts, errp); 361 if (!create_opts) { 362 return -1; 363 } 364 365 crypto = qcrypto_block_create(create_opts, 366 block_crypto_init_func, 367 block_crypto_write_func, 368 &data, 369 errp); 370 371 if (!crypto) { 372 ret = -EIO; 373 goto cleanup; 374 } 375 376 ret = 0; 377 cleanup: 378 qcrypto_block_free(crypto); 379 blk_unref(data.blk); 380 qapi_free_QCryptoBlockCreateOptions(create_opts); 381 return ret; 382 } 383 384 static int block_crypto_truncate(BlockDriverState *bs, int64_t offset, 385 Error **errp) 386 { 387 BlockCrypto *crypto = bs->opaque; 388 size_t payload_offset = 389 qcrypto_block_get_payload_offset(crypto->block); 390 391 offset += payload_offset; 392 393 return bdrv_truncate(bs->file, offset, errp); 394 } 395 396 static void block_crypto_close(BlockDriverState *bs) 397 { 398 BlockCrypto *crypto = bs->opaque; 399 qcrypto_block_free(crypto->block); 400 } 401 402 403 #define BLOCK_CRYPTO_MAX_SECTORS 32 404 405 static coroutine_fn int 406 block_crypto_co_readv(BlockDriverState *bs, int64_t sector_num, 407 int remaining_sectors, QEMUIOVector *qiov) 408 { 409 BlockCrypto *crypto = bs->opaque; 410 int cur_nr_sectors; /* number of sectors in current iteration */ 411 uint64_t bytes_done = 0; 412 uint8_t *cipher_data = NULL; 413 QEMUIOVector hd_qiov; 414 int ret = 0; 415 size_t payload_offset = 416 qcrypto_block_get_payload_offset(crypto->block) / 512; 417 418 qemu_iovec_init(&hd_qiov, qiov->niov); 419 420 /* Bounce buffer so we have a linear mem region for 421 * entire sector. XXX optimize so we avoid bounce 422 * buffer in case that qiov->niov == 1 423 */ 424 cipher_data = 425 qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_SECTORS * 512, 426 qiov->size)); 427 if (cipher_data == NULL) { 428 ret = -ENOMEM; 429 goto cleanup; 430 } 431 432 while (remaining_sectors) { 433 cur_nr_sectors = remaining_sectors; 434 435 if (cur_nr_sectors > BLOCK_CRYPTO_MAX_SECTORS) { 436 cur_nr_sectors = BLOCK_CRYPTO_MAX_SECTORS; 437 } 438 439 qemu_iovec_reset(&hd_qiov); 440 qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512); 441 442 ret = bdrv_co_readv(bs->file, 443 payload_offset + sector_num, 444 cur_nr_sectors, &hd_qiov); 445 if (ret < 0) { 446 goto cleanup; 447 } 448 449 if (qcrypto_block_decrypt(crypto->block, 450 sector_num, 451 cipher_data, cur_nr_sectors * 512, 452 NULL) < 0) { 453 ret = -EIO; 454 goto cleanup; 455 } 456 457 qemu_iovec_from_buf(qiov, bytes_done, 458 cipher_data, cur_nr_sectors * 512); 459 460 remaining_sectors -= cur_nr_sectors; 461 sector_num += cur_nr_sectors; 462 bytes_done += cur_nr_sectors * 512; 463 } 464 465 cleanup: 466 qemu_iovec_destroy(&hd_qiov); 467 qemu_vfree(cipher_data); 468 469 return ret; 470 } 471 472 473 static coroutine_fn int 474 block_crypto_co_writev(BlockDriverState *bs, int64_t sector_num, 475 int remaining_sectors, QEMUIOVector *qiov) 476 { 477 BlockCrypto *crypto = bs->opaque; 478 int cur_nr_sectors; /* number of sectors in current iteration */ 479 uint64_t bytes_done = 0; 480 uint8_t *cipher_data = NULL; 481 QEMUIOVector hd_qiov; 482 int ret = 0; 483 size_t payload_offset = 484 qcrypto_block_get_payload_offset(crypto->block) / 512; 485 486 qemu_iovec_init(&hd_qiov, qiov->niov); 487 488 /* Bounce buffer so we have a linear mem region for 489 * entire sector. XXX optimize so we avoid bounce 490 * buffer in case that qiov->niov == 1 491 */ 492 cipher_data = 493 qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_SECTORS * 512, 494 qiov->size)); 495 if (cipher_data == NULL) { 496 ret = -ENOMEM; 497 goto cleanup; 498 } 499 500 while (remaining_sectors) { 501 cur_nr_sectors = remaining_sectors; 502 503 if (cur_nr_sectors > BLOCK_CRYPTO_MAX_SECTORS) { 504 cur_nr_sectors = BLOCK_CRYPTO_MAX_SECTORS; 505 } 506 507 qemu_iovec_to_buf(qiov, bytes_done, 508 cipher_data, cur_nr_sectors * 512); 509 510 if (qcrypto_block_encrypt(crypto->block, 511 sector_num, 512 cipher_data, cur_nr_sectors * 512, 513 NULL) < 0) { 514 ret = -EIO; 515 goto cleanup; 516 } 517 518 qemu_iovec_reset(&hd_qiov); 519 qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512); 520 521 ret = bdrv_co_writev(bs->file, 522 payload_offset + sector_num, 523 cur_nr_sectors, &hd_qiov); 524 if (ret < 0) { 525 goto cleanup; 526 } 527 528 remaining_sectors -= cur_nr_sectors; 529 sector_num += cur_nr_sectors; 530 bytes_done += cur_nr_sectors * 512; 531 } 532 533 cleanup: 534 qemu_iovec_destroy(&hd_qiov); 535 qemu_vfree(cipher_data); 536 537 return ret; 538 } 539 540 541 static int64_t block_crypto_getlength(BlockDriverState *bs) 542 { 543 BlockCrypto *crypto = bs->opaque; 544 int64_t len = bdrv_getlength(bs->file->bs); 545 546 ssize_t offset = qcrypto_block_get_payload_offset(crypto->block); 547 548 len -= offset; 549 550 return len; 551 } 552 553 554 static int block_crypto_probe_luks(const uint8_t *buf, 555 int buf_size, 556 const char *filename) { 557 return block_crypto_probe_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS, 558 buf, buf_size, filename); 559 } 560 561 static int block_crypto_open_luks(BlockDriverState *bs, 562 QDict *options, 563 int flags, 564 Error **errp) 565 { 566 return block_crypto_open_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS, 567 &block_crypto_runtime_opts_luks, 568 bs, options, flags, errp); 569 } 570 571 static int block_crypto_create_luks(const char *filename, 572 QemuOpts *opts, 573 Error **errp) 574 { 575 return block_crypto_create_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS, 576 filename, opts, errp); 577 } 578 579 static int block_crypto_get_info_luks(BlockDriverState *bs, 580 BlockDriverInfo *bdi) 581 { 582 BlockDriverInfo subbdi; 583 int ret; 584 585 ret = bdrv_get_info(bs->file->bs, &subbdi); 586 if (ret != 0) { 587 return ret; 588 } 589 590 bdi->unallocated_blocks_are_zero = false; 591 bdi->can_write_zeroes_with_unmap = false; 592 bdi->cluster_size = subbdi.cluster_size; 593 594 return 0; 595 } 596 597 static ImageInfoSpecific * 598 block_crypto_get_specific_info_luks(BlockDriverState *bs) 599 { 600 BlockCrypto *crypto = bs->opaque; 601 ImageInfoSpecific *spec_info; 602 QCryptoBlockInfo *info; 603 604 info = qcrypto_block_get_info(crypto->block, NULL); 605 if (!info) { 606 return NULL; 607 } 608 if (info->format != Q_CRYPTO_BLOCK_FORMAT_LUKS) { 609 qapi_free_QCryptoBlockInfo(info); 610 return NULL; 611 } 612 613 spec_info = g_new(ImageInfoSpecific, 1); 614 spec_info->type = IMAGE_INFO_SPECIFIC_KIND_LUKS; 615 spec_info->u.luks.data = g_new(QCryptoBlockInfoLUKS, 1); 616 *spec_info->u.luks.data = info->u.luks; 617 618 /* Blank out pointers we've just stolen to avoid double free */ 619 memset(&info->u.luks, 0, sizeof(info->u.luks)); 620 621 qapi_free_QCryptoBlockInfo(info); 622 623 return spec_info; 624 } 625 626 BlockDriver bdrv_crypto_luks = { 627 .format_name = "luks", 628 .instance_size = sizeof(BlockCrypto), 629 .bdrv_probe = block_crypto_probe_luks, 630 .bdrv_open = block_crypto_open_luks, 631 .bdrv_close = block_crypto_close, 632 .bdrv_child_perm = bdrv_format_default_perms, 633 .bdrv_create = block_crypto_create_luks, 634 .bdrv_truncate = block_crypto_truncate, 635 .create_opts = &block_crypto_create_opts_luks, 636 637 .bdrv_co_readv = block_crypto_co_readv, 638 .bdrv_co_writev = block_crypto_co_writev, 639 .bdrv_getlength = block_crypto_getlength, 640 .bdrv_get_info = block_crypto_get_info_luks, 641 .bdrv_get_specific_info = block_crypto_get_specific_info_luks, 642 }; 643 644 static void block_crypto_init(void) 645 { 646 bdrv_register(&bdrv_crypto_luks); 647 } 648 649 block_init(block_crypto_init); 650