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