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 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                                       Error **errp,
  63                                       void *opaque)
  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                                        Error **errp,
  90                                        void *opaque)
  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                                       Error **errp,
 107                                       void *opaque)
 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 {
 386     BlockCrypto *crypto = bs->opaque;
 387     size_t payload_offset =
 388         qcrypto_block_get_payload_offset(crypto->block);
 389
 390     offset += payload_offset;
 391
 392     return bdrv_truncate(bs->file, offset);
 393 }
 394
 395 static void block_crypto_close(BlockDriverState *bs)
 396 {
 397     BlockCrypto *crypto = bs->opaque;
 398     qcrypto_block_free(crypto->block);
 399 }
 400
 401
 402 #define BLOCK_CRYPTO_MAX_SECTORS 32
 403
 404 static coroutine_fn int
 405 block_crypto_co_readv(BlockDriverState *bs, int64_t sector_num,
 406                       int remaining_sectors, QEMUIOVector *qiov)
 407 {
 408     BlockCrypto *crypto = bs->opaque;
 409     int cur_nr_sectors; /* number of sectors in current iteration */
 410     uint64_t bytes_done = 0;
 411     uint8_t *cipher_data = NULL;
 412     QEMUIOVector hd_qiov;
 413     int ret = 0;
 414     size_t payload_offset =
 415         qcrypto_block_get_payload_offset(crypto->block) / 512;
 416
 417     qemu_iovec_init(&hd_qiov, qiov->niov);
 418
 419     /* Bounce buffer so we have a linear mem region for
 420      * entire sector. XXX optimize so we avoid bounce
 421      * buffer in case that qiov->niov == 1
 422      */
 423     cipher_data =
 424         qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_SECTORS * 512,
 425                                               qiov->size));
 426     if (cipher_data == NULL) {
 427         ret = -ENOMEM;
 428         goto cleanup;
 429     }
 430
 431     while (remaining_sectors) {
 432         cur_nr_sectors = remaining_sectors;
 433
 434         if (cur_nr_sectors > BLOCK_CRYPTO_MAX_SECTORS) {
 435             cur_nr_sectors = BLOCK_CRYPTO_MAX_SECTORS;
 436         }
 437
 438         qemu_iovec_reset(&hd_qiov);
 439         qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512);
 440
 441         ret = bdrv_co_readv(bs->file,
 442                             payload_offset + sector_num,
 443                             cur_nr_sectors, &hd_qiov);
 444         if (ret < 0) {
 445             goto cleanup;
 446         }
 447
 448         if (qcrypto_block_decrypt(crypto->block,
 449                                   sector_num,
 450                                   cipher_data, cur_nr_sectors * 512,
 451                                   NULL) < 0) {
 452             ret = -EIO;
 453             goto cleanup;
 454         }
 455
 456         qemu_iovec_from_buf(qiov, bytes_done,
 457                             cipher_data, cur_nr_sectors * 512);
 458
 459         remaining_sectors -= cur_nr_sectors;
 460         sector_num += cur_nr_sectors;
 461         bytes_done += cur_nr_sectors * 512;
 462     }
 463
 464  cleanup:
 465     qemu_iovec_destroy(&hd_qiov);
 466     qemu_vfree(cipher_data);
 467
 468     return ret;
 469 }
 470
 471
 472 static coroutine_fn int
 473 block_crypto_co_writev(BlockDriverState *bs, int64_t sector_num,
 474                        int remaining_sectors, QEMUIOVector *qiov)
 475 {
 476     BlockCrypto *crypto = bs->opaque;
 477     int cur_nr_sectors; /* number of sectors in current iteration */
 478     uint64_t bytes_done = 0;
 479     uint8_t *cipher_data = NULL;
 480     QEMUIOVector hd_qiov;
 481     int ret = 0;
 482     size_t payload_offset =
 483         qcrypto_block_get_payload_offset(crypto->block) / 512;
 484
 485     qemu_iovec_init(&hd_qiov, qiov->niov);
 486
 487     /* Bounce buffer so we have a linear mem region for
 488      * entire sector. XXX optimize so we avoid bounce
 489      * buffer in case that qiov->niov == 1
 490      */
 491     cipher_data =
 492         qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_SECTORS * 512,
 493                                               qiov->size));
 494     if (cipher_data == NULL) {
 495         ret = -ENOMEM;
 496         goto cleanup;
 497     }
 498
 499     while (remaining_sectors) {
 500         cur_nr_sectors = remaining_sectors;
 501
 502         if (cur_nr_sectors > BLOCK_CRYPTO_MAX_SECTORS) {
 503             cur_nr_sectors = BLOCK_CRYPTO_MAX_SECTORS;
 504         }
 505
 506         qemu_iovec_to_buf(qiov, bytes_done,
 507                           cipher_data, cur_nr_sectors * 512);
 508
 509         if (qcrypto_block_encrypt(crypto->block,
 510                                   sector_num,
 511                                   cipher_data, cur_nr_sectors * 512,
 512                                   NULL) < 0) {
 513             ret = -EIO;
 514             goto cleanup;
 515         }
 516
 517         qemu_iovec_reset(&hd_qiov);
 518         qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512);
 519
 520         ret = bdrv_co_writev(bs->file,
 521                              payload_offset + sector_num,
 522                              cur_nr_sectors, &hd_qiov);
 523         if (ret < 0) {
 524             goto cleanup;
 525         }
 526
 527         remaining_sectors -= cur_nr_sectors;
 528         sector_num += cur_nr_sectors;
 529         bytes_done += cur_nr_sectors * 512;
 530     }
 531
 532  cleanup:
 533     qemu_iovec_destroy(&hd_qiov);
 534     qemu_vfree(cipher_data);
 535
 536     return ret;
 537 }
 538
 539
 540 static int64_t block_crypto_getlength(BlockDriverState *bs)
 541 {
 542     BlockCrypto *crypto = bs->opaque;
 543     int64_t len = bdrv_getlength(bs->file->bs);
 544
 545     ssize_t offset = qcrypto_block_get_payload_offset(crypto->block);
 546
 547     len -= offset;
 548
 549     return len;
 550 }
 551
 552
 553 static int block_crypto_probe_luks(const uint8_t *buf,
 554                                    int buf_size,
 555                                    const char *filename) {
 556     return block_crypto_probe_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
 557                                       buf, buf_size, filename);
 558 }
 559
 560 static int block_crypto_open_luks(BlockDriverState *bs,
 561                                   QDict *options,
 562                                   int flags,
 563                                   Error **errp)
 564 {
 565     return block_crypto_open_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
 566                                      &block_crypto_runtime_opts_luks,
 567                                      bs, options, flags, errp);
 568 }
 569
 570 static int block_crypto_create_luks(const char *filename,
 571                                     QemuOpts *opts,
 572                                     Error **errp)
 573 {
 574     return block_crypto_create_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
 575                                        filename, opts, errp);
 576 }
 577
 578 static int block_crypto_get_info_luks(BlockDriverState *bs,
 579                                       BlockDriverInfo *bdi)
 580 {
 581     BlockDriverInfo subbdi;
 582     int ret;
 583
 584     ret = bdrv_get_info(bs->file->bs, &subbdi);
 585     if (ret != 0) {
 586         return ret;
 587     }
 588
 589     bdi->unallocated_blocks_are_zero = false;
 590     bdi->can_write_zeroes_with_unmap = false;
 591     bdi->cluster_size = subbdi.cluster_size;
 592
 593     return 0;
 594 }
 595
 596 static ImageInfoSpecific *
 597 block_crypto_get_specific_info_luks(BlockDriverState *bs)
 598 {
 599     BlockCrypto *crypto = bs->opaque;
 600     ImageInfoSpecific *spec_info;
 601     QCryptoBlockInfo *info;
 602
 603     info = qcrypto_block_get_info(crypto->block, NULL);
 604     if (!info) {
 605         return NULL;
 606     }
 607     if (info->format != Q_CRYPTO_BLOCK_FORMAT_LUKS) {
 608         qapi_free_QCryptoBlockInfo(info);
 609         return NULL;
 610     }
 611
 612     spec_info = g_new(ImageInfoSpecific, 1);
 613     spec_info->type = IMAGE_INFO_SPECIFIC_KIND_LUKS;
 614     spec_info->u.luks.data = g_new(QCryptoBlockInfoLUKS, 1);
 615     *spec_info->u.luks.data = info->u.luks;
 616
 617     /* Blank out pointers we've just stolen to avoid double free */
 618     memset(&info->u.luks, 0, sizeof(info->u.luks));
 619
 620     qapi_free_QCryptoBlockInfo(info);
 621
 622     return spec_info;
 623 }
 624
 625 BlockDriver bdrv_crypto_luks = {
 626     .format_name        = "luks",
 627     .instance_size      = sizeof(BlockCrypto),
 628     .bdrv_probe         = block_crypto_probe_luks,
 629     .bdrv_open          = block_crypto_open_luks,
 630     .bdrv_close         = block_crypto_close,
 631     .bdrv_create        = block_crypto_create_luks,
 632     .bdrv_truncate      = block_crypto_truncate,
 633     .create_opts        = &block_crypto_create_opts_luks,
 634
 635     .bdrv_co_readv      = block_crypto_co_readv,
 636     .bdrv_co_writev     = block_crypto_co_writev,
 637     .bdrv_getlength     = block_crypto_getlength,
 638     .bdrv_get_info      = block_crypto_get_info_luks,
 639     .bdrv_get_specific_info = block_crypto_get_specific_info_luks,
 640 };
 641
 642 static void block_crypto_init(void)
 643 {
 644     bdrv_register(&bdrv_crypto_luks);
 645 }
 646
 647 block_init(block_crypto_init);