crypto/block.c

   1 /*
   2  * QEMU Crypto block device 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 #include "qapi/error.h"
  23 #include "blockpriv.h"
  24 #include "block-qcow.h"
  25 #include "block-luks.h"
  26
  27 static const QCryptoBlockDriver *qcrypto_block_drivers[] = {
  28     [Q_CRYPTO_BLOCK_FORMAT_QCOW] = &qcrypto_block_driver_qcow,
  29     [Q_CRYPTO_BLOCK_FORMAT_LUKS] = &qcrypto_block_driver_luks,
  30 };
  31
  32
  33 bool qcrypto_block_has_format(QCryptoBlockFormat format,
  34                               const uint8_t *buf,
  35                               size_t len)
  36 {
  37     const QCryptoBlockDriver *driver;
  38
  39     if (format >= G_N_ELEMENTS(qcrypto_block_drivers) ||
  40         !qcrypto_block_drivers[format]) {
  41         return false;
  42     }
  43
  44     driver = qcrypto_block_drivers[format];
  45
  46     return driver->has_format(buf, len);
  47 }
  48
  49
  50 QCryptoBlock *qcrypto_block_open(QCryptoBlockOpenOptions *options,
  51                                  const char *optprefix,
  52                                  QCryptoBlockReadFunc readfunc,
  53                                  void *opaque,
  54                                  unsigned int flags,
  55                                  size_t n_threads,
  56                                  Error **errp)
  57 {
  58     QCryptoBlock *block = g_new0(QCryptoBlock, 1);
  59
  60     block->format = options->format;
  61
  62     if (options->format >= G_N_ELEMENTS(qcrypto_block_drivers) ||
  63         !qcrypto_block_drivers[options->format]) {
  64         error_setg(errp, "Unsupported block driver %s",
  65                    QCryptoBlockFormat_str(options->format));
  66         g_free(block);
  67         return NULL;
  68     }
  69
  70     block->driver = qcrypto_block_drivers[options->format];
  71
  72     if (block->driver->open(block, options, optprefix,
  73                             readfunc, opaque, flags, n_threads, errp) < 0)
  74     {
  75         g_free(block);
  76         return NULL;
  77     }
  78
  79     qemu_mutex_init(&block->mutex);
  80
  81     return block;
  82 }
  83
  84
  85 QCryptoBlock *qcrypto_block_create(QCryptoBlockCreateOptions *options,
  86                                    const char *optprefix,
  87                                    QCryptoBlockInitFunc initfunc,
  88                                    QCryptoBlockWriteFunc writefunc,
  89                                    void *opaque,
  90                                    unsigned int flags,
  91                                    Error **errp)
  92 {
  93     QCryptoBlock *block = g_new0(QCryptoBlock, 1);
  94
  95     block->format = options->format;
  96
  97     if (options->format >= G_N_ELEMENTS(qcrypto_block_drivers) ||
  98         !qcrypto_block_drivers[options->format]) {
  99         error_setg(errp, "Unsupported block driver %s",
 100                    QCryptoBlockFormat_str(options->format));
 101         g_free(block);
 102         return NULL;
 103     }
 104
 105     block->driver = qcrypto_block_drivers[options->format];
 106     block->detached_header = flags & QCRYPTO_BLOCK_CREATE_DETACHED;
 107
 108     if (block->driver->create(block, options, optprefix, initfunc,
 109                               writefunc, opaque, errp) < 0) {
 110         g_free(block);
 111         return NULL;
 112     }
 113
 114     qemu_mutex_init(&block->mutex);
 115
 116     return block;
 117 }
 118
 119
 120 static int qcrypto_block_headerlen_hdr_init_func(QCryptoBlock *block,
 121         size_t headerlen, void *opaque, Error **errp)
 122 {
 123     size_t *headerlenp = opaque;
 124
 125     /* Stash away the payload size */
 126     *headerlenp = headerlen;
 127     return 0;
 128 }
 129
 130
 131 static int qcrypto_block_headerlen_hdr_write_func(QCryptoBlock *block,
 132         size_t offset, const uint8_t *buf, size_t buflen,
 133         void *opaque, Error **errp)
 134 {
 135     /* Discard the bytes, we're not actually writing to an image */
 136     return 0;
 137 }
 138
 139
 140 bool
 141 qcrypto_block_calculate_payload_offset(QCryptoBlockCreateOptions *create_opts,
 142                                        const char *optprefix,
 143                                        size_t *len,
 144                                        Error **errp)
 145 {
 146     /* Fake LUKS creation in order to determine the payload size */
 147     g_autoptr(QCryptoBlock) crypto =
 148         qcrypto_block_create(create_opts, optprefix,
 149                              qcrypto_block_headerlen_hdr_init_func,
 150                              qcrypto_block_headerlen_hdr_write_func,
 151                              len, 0, errp);
 152     return crypto != NULL;
 153 }
 154
 155 int qcrypto_block_amend_options(QCryptoBlock *block,
 156                                 QCryptoBlockReadFunc readfunc,
 157                                 QCryptoBlockWriteFunc writefunc,
 158                                 void *opaque,
 159                                 QCryptoBlockAmendOptions *options,
 160                                 bool force,
 161                                 Error **errp)
 162 {
 163     if (options->format != block->format) {
 164         error_setg(errp,
 165                    "Cannot amend encryption format");
 166         return -1;
 167     }
 168
 169     if (!block->driver->amend) {
 170         error_setg(errp,
 171                    "Crypto format %s doesn't support format options amendment",
 172                    QCryptoBlockFormat_str(block->format));
 173         return -1;
 174     }
 175
 176     return block->driver->amend(block,
 177                                 readfunc,
 178                                 writefunc,
 179                                 opaque,
 180                                 options,
 181                                 force,
 182                                 errp);
 183 }
 184
 185 QCryptoBlockInfo *qcrypto_block_get_info(QCryptoBlock *block,
 186                                          Error **errp)
 187 {
 188     QCryptoBlockInfo *info = g_new0(QCryptoBlockInfo, 1);
 189
 190     info->format = block->format;
 191
 192     if (block->driver->get_info &&
 193         block->driver->get_info(block, info, errp) < 0) {
 194         g_free(info);
 195         return NULL;
 196     }
 197
 198     return info;
 199 }
 200
 201
 202 int qcrypto_block_decrypt(QCryptoBlock *block,
 203                           uint64_t offset,
 204                           uint8_t *buf,
 205                           size_t len,
 206                           Error **errp)
 207 {
 208     return block->driver->decrypt(block, offset, buf, len, errp);
 209 }
 210
 211
 212 int qcrypto_block_encrypt(QCryptoBlock *block,
 213                           uint64_t offset,
 214                           uint8_t *buf,
 215                           size_t len,
 216                           Error **errp)
 217 {
 218     return block->driver->encrypt(block, offset, buf, len, errp);
 219 }
 220
 221
 222 QCryptoCipher *qcrypto_block_get_cipher(QCryptoBlock *block)
 223 {
 224     /* Ciphers should be accessed through pop/push method to be thread-safe.
 225      * Better, they should not be accessed externally at all (note, that
 226      * pop/push are static functions)
 227      * This function is used only in test with one thread (it's safe to skip
 228      * pop/push interface), so it's enough to assert it here:
 229      */
 230     assert(block->n_ciphers <= 1);
 231     return block->ciphers ? block->ciphers[0] : NULL;
 232 }
 233
 234
 235 static QCryptoCipher *qcrypto_block_pop_cipher(QCryptoBlock *block)
 236 {
 237     QCryptoCipher *cipher;
 238
 239     qemu_mutex_lock(&block->mutex);
 240
 241     assert(block->n_free_ciphers > 0);
 242     block->n_free_ciphers--;
 243     cipher = block->ciphers[block->n_free_ciphers];
 244
 245     qemu_mutex_unlock(&block->mutex);
 246
 247     return cipher;
 248 }
 249
 250
 251 static void qcrypto_block_push_cipher(QCryptoBlock *block,
 252                                       QCryptoCipher *cipher)
 253 {
 254     qemu_mutex_lock(&block->mutex);
 255
 256     assert(block->n_free_ciphers < block->n_ciphers);
 257     block->ciphers[block->n_free_ciphers] = cipher;
 258     block->n_free_ciphers++;
 259
 260     qemu_mutex_unlock(&block->mutex);
 261 }
 262
 263
 264 int qcrypto_block_init_cipher(QCryptoBlock *block,
 265                               QCryptoCipherAlgorithm alg,
 266                               QCryptoCipherMode mode,
 267                               const uint8_t *key, size_t nkey,
 268                               size_t n_threads, Error **errp)
 269 {
 270     size_t i;
 271
 272     assert(!block->ciphers && !block->n_ciphers && !block->n_free_ciphers);
 273
 274     block->ciphers = g_new0(QCryptoCipher *, n_threads);
 275
 276     for (i = 0; i < n_threads; i++) {
 277         block->ciphers[i] = qcrypto_cipher_new(alg, mode, key, nkey, errp);
 278         if (!block->ciphers[i]) {
 279             qcrypto_block_free_cipher(block);
 280             return -1;
 281         }
 282         block->n_ciphers++;
 283         block->n_free_ciphers++;
 284     }
 285
 286     return 0;
 287 }
 288
 289
 290 void qcrypto_block_free_cipher(QCryptoBlock *block)
 291 {
 292     size_t i;
 293
 294     if (!block->ciphers) {
 295         return;
 296     }
 297
 298     assert(block->n_ciphers == block->n_free_ciphers);
 299
 300     for (i = 0; i < block->n_ciphers; i++) {
 301         qcrypto_cipher_free(block->ciphers[i]);
 302     }
 303
 304     g_free(block->ciphers);
 305     block->ciphers = NULL;
 306     block->n_ciphers = block->n_free_ciphers = 0;
 307 }
 308
 309 QCryptoIVGen *qcrypto_block_get_ivgen(QCryptoBlock *block)
 310 {
 311     /* ivgen should be accessed under mutex. However, this function is used only
 312      * in test with one thread, so it's enough to assert it here:
 313      */
 314     assert(block->n_ciphers <= 1);
 315     return block->ivgen;
 316 }
 317
 318
 319 QCryptoHashAlgorithm qcrypto_block_get_kdf_hash(QCryptoBlock *block)
 320 {
 321     return block->kdfhash;
 322 }
 323
 324
 325 uint64_t qcrypto_block_get_payload_offset(QCryptoBlock *block)
 326 {
 327     return block->payload_offset;
 328 }
 329
 330
 331 uint64_t qcrypto_block_get_sector_size(QCryptoBlock *block)
 332 {
 333     return block->sector_size;
 334 }
 335
 336
 337 void qcrypto_block_free(QCryptoBlock *block)
 338 {
 339     if (!block) {
 340         return;
 341     }
 342
 343     block->driver->cleanup(block);
 344
 345     qcrypto_block_free_cipher(block);
 346     qcrypto_ivgen_free(block->ivgen);
 347     qemu_mutex_destroy(&block->mutex);
 348     g_free(block);
 349 }
 350
 351
 352 typedef int (*QCryptoCipherEncDecFunc)(QCryptoCipher *cipher,
 353                                         const void *in,
 354                                         void *out,
 355                                         size_t len,
 356                                         Error **errp);
 357
 358 static int do_qcrypto_block_cipher_encdec(QCryptoCipher *cipher,
 359                                           size_t niv,
 360                                           QCryptoIVGen *ivgen,
 361                                           QemuMutex *ivgen_mutex,
 362                                           int sectorsize,
 363                                           uint64_t offset,
 364                                           uint8_t *buf,
 365                                           size_t len,
 366                                           QCryptoCipherEncDecFunc func,
 367                                           Error **errp)
 368 {
 369     g_autofree uint8_t *iv = niv ? g_new0(uint8_t, niv) : NULL;
 370     int ret = -1;
 371     uint64_t startsector = offset / sectorsize;
 372
 373     assert(QEMU_IS_ALIGNED(offset, sectorsize));
 374     assert(QEMU_IS_ALIGNED(len, sectorsize));
 375
 376     while (len > 0) {
 377         size_t nbytes;
 378         if (niv) {
 379             if (ivgen_mutex) {
 380                 qemu_mutex_lock(ivgen_mutex);
 381             }
 382             ret = qcrypto_ivgen_calculate(ivgen, startsector, iv, niv, errp);
 383             if (ivgen_mutex) {
 384                 qemu_mutex_unlock(ivgen_mutex);
 385             }
 386
 387             if (ret < 0) {
 388                 return -1;
 389             }
 390
 391             if (qcrypto_cipher_setiv(cipher,
 392                                      iv, niv,
 393                                      errp) < 0) {
 394                 return -1;
 395             }
 396         }
 397
 398         nbytes = len > sectorsize ? sectorsize : len;
 399         if (func(cipher, buf, buf, nbytes, errp) < 0) {
 400             return -1;
 401         }
 402
 403         startsector++;
 404         buf += nbytes;
 405         len -= nbytes;
 406     }
 407
 408     return 0;
 409 }
 410
 411
 412 int qcrypto_block_cipher_decrypt_helper(QCryptoCipher *cipher,
 413                                         size_t niv,
 414                                         QCryptoIVGen *ivgen,
 415                                         int sectorsize,
 416                                         uint64_t offset,
 417                                         uint8_t *buf,
 418                                         size_t len,
 419                                         Error **errp)
 420 {
 421     return do_qcrypto_block_cipher_encdec(cipher, niv, ivgen, NULL, sectorsize,
 422                                           offset, buf, len,
 423                                           qcrypto_cipher_decrypt, errp);
 424 }
 425
 426
 427 int qcrypto_block_cipher_encrypt_helper(QCryptoCipher *cipher,
 428                                         size_t niv,
 429                                         QCryptoIVGen *ivgen,
 430                                         int sectorsize,
 431                                         uint64_t offset,
 432                                         uint8_t *buf,
 433                                         size_t len,
 434                                         Error **errp)
 435 {
 436     return do_qcrypto_block_cipher_encdec(cipher, niv, ivgen, NULL, sectorsize,
 437                                           offset, buf, len,
 438                                           qcrypto_cipher_encrypt, errp);
 439 }
 440
 441 int qcrypto_block_decrypt_helper(QCryptoBlock *block,
 442                                  int sectorsize,
 443                                  uint64_t offset,
 444                                  uint8_t *buf,
 445                                  size_t len,
 446                                  Error **errp)
 447 {
 448     int ret;
 449     QCryptoCipher *cipher = qcrypto_block_pop_cipher(block);
 450
 451     ret = do_qcrypto_block_cipher_encdec(cipher, block->niv, block->ivgen,
 452                                          &block->mutex, sectorsize, offset, buf,
 453                                          len, qcrypto_cipher_decrypt, errp);
 454
 455     qcrypto_block_push_cipher(block, cipher);
 456
 457     return ret;
 458 }
 459
 460 int qcrypto_block_encrypt_helper(QCryptoBlock *block,
 461                                  int sectorsize,
 462                                  uint64_t offset,
 463                                  uint8_t *buf,
 464                                  size_t len,
 465                                  Error **errp)
 466 {
 467     int ret;
 468     QCryptoCipher *cipher = qcrypto_block_pop_cipher(block);
 469
 470     ret = do_qcrypto_block_cipher_encdec(cipher, block->niv, block->ivgen,
 471                                          &block->mutex, sectorsize, offset, buf,
 472                                          len, qcrypto_cipher_encrypt, errp);
 473
 474     qcrypto_block_push_cipher(block, cipher);
 475
 476     return ret;
 477 }