block/crypto.c

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