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 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 QCryptoBlockInfo *qcrypto_block_get_info(QCryptoBlock *block,
 119                                          Error **errp)
 120 {
 121     QCryptoBlockInfo *info = g_new0(QCryptoBlockInfo, 1);
 122
 123     info->format = block->format;
 124
 125     if (block->driver->get_info &&
 126         block->driver->get_info(block, info, errp) < 0) {
 127         g_free(info);
 128         return NULL;
 129     }
 130
 131     return info;
 132 }
 133
 134
 135 int qcrypto_block_decrypt(QCryptoBlock *block,
 136                           uint64_t offset,
 137                           uint8_t *buf,
 138                           size_t len,
 139                           Error **errp)
 140 {
 141     return block->driver->decrypt(block, offset, buf, len, errp);
 142 }
 143
 144
 145 int qcrypto_block_encrypt(QCryptoBlock *block,
 146                           uint64_t offset,
 147                           uint8_t *buf,
 148                           size_t len,
 149                           Error **errp)
 150 {
 151     return block->driver->encrypt(block, offset, buf, len, errp);
 152 }
 153
 154
 155 QCryptoCipher *qcrypto_block_get_cipher(QCryptoBlock *block)
 156 {
 157     /* Ciphers should be accessed through pop/push method to be thread-safe.
 158      * Better, they should not be accessed externally at all (note, that
 159      * pop/push are static functions)
 160      * This function is used only in test with one thread (it's safe to skip
 161      * pop/push interface), so it's enough to assert it here:
 162      */
 163     assert(block->n_ciphers <= 1);
 164     return block->ciphers ? block->ciphers[0] : NULL;
 165 }
 166
 167
 168 static QCryptoCipher *qcrypto_block_pop_cipher(QCryptoBlock *block)
 169 {
 170     QCryptoCipher *cipher;
 171
 172     qemu_mutex_lock(&block->mutex);
 173
 174     assert(block->n_free_ciphers > 0);
 175     block->n_free_ciphers--;
 176     cipher = block->ciphers[block->n_free_ciphers];
 177
 178     qemu_mutex_unlock(&block->mutex);
 179
 180     return cipher;
 181 }
 182
 183
 184 static void qcrypto_block_push_cipher(QCryptoBlock *block,
 185                                       QCryptoCipher *cipher)
 186 {
 187     qemu_mutex_lock(&block->mutex);
 188
 189     assert(block->n_free_ciphers < block->n_ciphers);
 190     block->ciphers[block->n_free_ciphers] = cipher;
 191     block->n_free_ciphers++;
 192
 193     qemu_mutex_unlock(&block->mutex);
 194 }
 195
 196
 197 int qcrypto_block_init_cipher(QCryptoBlock *block,
 198                               QCryptoCipherAlgorithm alg,
 199                               QCryptoCipherMode mode,
 200                               const uint8_t *key, size_t nkey,
 201                               size_t n_threads, Error **errp)
 202 {
 203     size_t i;
 204
 205     assert(!block->ciphers && !block->n_ciphers && !block->n_free_ciphers);
 206
 207     block->ciphers = g_new0(QCryptoCipher *, n_threads);
 208
 209     for (i = 0; i < n_threads; i++) {
 210         block->ciphers[i] = qcrypto_cipher_new(alg, mode, key, nkey, errp);
 211         if (!block->ciphers[i]) {
 212             qcrypto_block_free_cipher(block);
 213             return -1;
 214         }
 215         block->n_ciphers++;
 216         block->n_free_ciphers++;
 217     }
 218
 219     return 0;
 220 }
 221
 222
 223 void qcrypto_block_free_cipher(QCryptoBlock *block)
 224 {
 225     size_t i;
 226
 227     if (!block->ciphers) {
 228         return;
 229     }
 230
 231     assert(block->n_ciphers == block->n_free_ciphers);
 232
 233     for (i = 0; i < block->n_ciphers; i++) {
 234         qcrypto_cipher_free(block->ciphers[i]);
 235     }
 236
 237     g_free(block->ciphers);
 238     block->ciphers = NULL;
 239     block->n_ciphers = block->n_free_ciphers = 0;
 240 }
 241
 242 QCryptoIVGen *qcrypto_block_get_ivgen(QCryptoBlock *block)
 243 {
 244     /* ivgen should be accessed under mutex. However, this function is used only
 245      * in test with one thread, so it's enough to assert it here:
 246      */
 247     assert(block->n_ciphers <= 1);
 248     return block->ivgen;
 249 }
 250
 251
 252 QCryptoHashAlgorithm qcrypto_block_get_kdf_hash(QCryptoBlock *block)
 253 {
 254     return block->kdfhash;
 255 }
 256
 257
 258 uint64_t qcrypto_block_get_payload_offset(QCryptoBlock *block)
 259 {
 260     return block->payload_offset;
 261 }
 262
 263
 264 uint64_t qcrypto_block_get_sector_size(QCryptoBlock *block)
 265 {
 266     return block->sector_size;
 267 }
 268
 269
 270 void qcrypto_block_free(QCryptoBlock *block)
 271 {
 272     if (!block) {
 273         return;
 274     }
 275
 276     block->driver->cleanup(block);
 277
 278     qcrypto_block_free_cipher(block);
 279     qcrypto_ivgen_free(block->ivgen);
 280     qemu_mutex_destroy(&block->mutex);
 281     g_free(block);
 282 }
 283
 284
 285 typedef int (*QCryptoCipherEncDecFunc)(QCryptoCipher *cipher,
 286                                         const void *in,
 287                                         void *out,
 288                                         size_t len,
 289                                         Error **errp);
 290
 291 static int do_qcrypto_block_cipher_encdec(QCryptoCipher *cipher,
 292                                           size_t niv,
 293                                           QCryptoIVGen *ivgen,
 294                                           QemuMutex *ivgen_mutex,
 295                                           int sectorsize,
 296                                           uint64_t offset,
 297                                           uint8_t *buf,
 298                                           size_t len,
 299                                           QCryptoCipherEncDecFunc func,
 300                                           Error **errp)
 301 {
 302     uint8_t *iv;
 303     int ret = -1;
 304     uint64_t startsector = offset / sectorsize;
 305
 306     assert(QEMU_IS_ALIGNED(offset, sectorsize));
 307     assert(QEMU_IS_ALIGNED(len, sectorsize));
 308
 309     iv = niv ? g_new0(uint8_t, niv) : NULL;
 310
 311     while (len > 0) {
 312         size_t nbytes;
 313         if (niv) {
 314             if (ivgen_mutex) {
 315                 qemu_mutex_lock(ivgen_mutex);
 316             }
 317             ret = qcrypto_ivgen_calculate(ivgen, startsector, iv, niv, errp);
 318             if (ivgen_mutex) {
 319                 qemu_mutex_unlock(ivgen_mutex);
 320             }
 321
 322             if (ret < 0) {
 323                 goto cleanup;
 324             }
 325
 326             if (qcrypto_cipher_setiv(cipher,
 327                                      iv, niv,
 328                                      errp) < 0) {
 329                 goto cleanup;
 330             }
 331         }
 332
 333         nbytes = len > sectorsize ? sectorsize : len;
 334         if (func(cipher, buf, buf, nbytes, errp) < 0) {
 335             goto cleanup;
 336         }
 337
 338         startsector++;
 339         buf += nbytes;
 340         len -= nbytes;
 341     }
 342
 343     ret = 0;
 344  cleanup:
 345     g_free(iv);
 346     return ret;
 347 }
 348
 349
 350 int qcrypto_block_cipher_decrypt_helper(QCryptoCipher *cipher,
 351                                         size_t niv,
 352                                         QCryptoIVGen *ivgen,
 353                                         int sectorsize,
 354                                         uint64_t offset,
 355                                         uint8_t *buf,
 356                                         size_t len,
 357                                         Error **errp)
 358 {
 359     return do_qcrypto_block_cipher_encdec(cipher, niv, ivgen, NULL, sectorsize,
 360                                           offset, buf, len,
 361                                           qcrypto_cipher_decrypt, errp);
 362 }
 363
 364
 365 int qcrypto_block_cipher_encrypt_helper(QCryptoCipher *cipher,
 366                                         size_t niv,
 367                                         QCryptoIVGen *ivgen,
 368                                         int sectorsize,
 369                                         uint64_t offset,
 370                                         uint8_t *buf,
 371                                         size_t len,
 372                                         Error **errp)
 373 {
 374     return do_qcrypto_block_cipher_encdec(cipher, niv, ivgen, NULL, sectorsize,
 375                                           offset, buf, len,
 376                                           qcrypto_cipher_encrypt, errp);
 377 }
 378
 379 int qcrypto_block_decrypt_helper(QCryptoBlock *block,
 380                                  int sectorsize,
 381                                  uint64_t offset,
 382                                  uint8_t *buf,
 383                                  size_t len,
 384                                  Error **errp)
 385 {
 386     int ret;
 387     QCryptoCipher *cipher = qcrypto_block_pop_cipher(block);
 388
 389     ret = do_qcrypto_block_cipher_encdec(cipher, block->niv, block->ivgen,
 390                                          &block->mutex, sectorsize, offset, buf,
 391                                          len, qcrypto_cipher_decrypt, errp);
 392
 393     qcrypto_block_push_cipher(block, cipher);
 394
 395     return ret;
 396 }
 397
 398 int qcrypto_block_encrypt_helper(QCryptoBlock *block,
 399                                  int sectorsize,
 400                                  uint64_t offset,
 401                                  uint8_t *buf,
 402                                  size_t len,
 403                                  Error **errp)
 404 {
 405     int ret;
 406     QCryptoCipher *cipher = qcrypto_block_pop_cipher(block);
 407
 408     ret = do_qcrypto_block_cipher_encdec(cipher, block->niv, block->ivgen,
 409                                          &block->mutex, sectorsize, offset, buf,
 410                                          len, qcrypto_cipher_encrypt, errp);
 411
 412     qcrypto_block_push_cipher(block, cipher);
 413
 414     return ret;
 415 }