text: /*
   * QEMU Crypto block device encryption
   *
   * Copyright (c) 2015-2016 Red Hat, Inc.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, see <http://www.gnu.org/licenses/>.
   *
   */
  
  #include "qemu/osdep.h"
  #include "qapi/error.h"
  #include "blockpriv.h"
  #include "block-qcow.h"
  #include "block-luks.h"
  
  static const QCryptoBlockDriver *qcrypto_block_drivers[] = {
      [Q_CRYPTO_BLOCK_FORMAT_QCOW] = &qcrypto_block_driver_qcow,
      [Q_CRYPTO_BLOCK_FORMAT_LUKS] = &qcrypto_block_driver_luks,
  };
  
  
  bool qcrypto_block_has_format(QCryptoBlockFormat format,
                                const uint8_t *buf,
                                size_t len)
  {
      const QCryptoBlockDriver *driver;
  
      if (format >= G_N_ELEMENTS(qcrypto_block_drivers) ||
          !qcrypto_block_drivers[format]) {
          return false;
      }
  
      driver = qcrypto_block_drivers[format];
  
      return driver->has_format(buf, len);
  }
  
  
  QCryptoBlock *qcrypto_block_open(QCryptoBlockOpenOptions *options,
                                   const char *optprefix,
                                   QCryptoBlockReadFunc readfunc,
                                   void *opaque,
                                   unsigned int flags,
                                   size_t n_threads,
                                   Error **errp)
  {
      QCryptoBlock *block = g_new0(QCryptoBlock, 1);
  
      block->format = options->format;
  
      if (options->format >= G_N_ELEMENTS(qcrypto_block_drivers) ||
          !qcrypto_block_drivers[options->format]) {
          error_setg(errp, "Unsupported block driver %s",
                     QCryptoBlockFormat_str(options->format));
          g_free(block);
          return NULL;
      }
  
      block->driver = qcrypto_block_drivers[options->format];
  
      if (block->driver->open(block, options, optprefix,
                              readfunc, opaque, flags, n_threads, errp) < 0)
      {
          g_free(block);
          return NULL;
      }
  
      qemu_mutex_init(&block->mutex);
  
      return block;
  }
  
  
  QCryptoBlock *qcrypto_block_create(QCryptoBlockCreateOptions *options,
                                     const char *optprefix,
                                     QCryptoBlockInitFunc initfunc,
                                     QCryptoBlockWriteFunc writefunc,
                                     void *opaque,
                                     Error **errp)
  {
      QCryptoBlock *block = g_new0(QCryptoBlock, 1);
  
      block->format = options->format;
  
      if (options->format >= G_N_ELEMENTS(qcrypto_block_drivers) ||
          !qcrypto_block_drivers[options->format]) {
          error_setg(errp, "Unsupported block driver %s",
                     QCryptoBlockFormat_str(options->format));
          g_free(block);
          return NULL;
      }
  
      block->driver = qcrypto_block_drivers[options->format];
  
      if (block->driver->create(block, options, optprefix, initfunc,
                                writefunc, opaque, errp) < 0) {
          g_free(block);
          return NULL;
      }
  
      qemu_mutex_init(&block->mutex);
  
      return block;
  }
  
  
  QCryptoBlockInfo *qcrypto_block_get_info(QCryptoBlock *block,
                                           Error **errp)
  {
      QCryptoBlockInfo *info = g_new0(QCryptoBlockInfo, 1);
  
      info->format = block->format;
  
      if (block->driver->get_info &&
          block->driver->get_info(block, info, errp) < 0) {
          g_free(info);
          return NULL;
      }
  
      return info;
  }
  
  
  int qcrypto_block_decrypt(QCryptoBlock *block,
                            uint64_t offset,
                            uint8_t *buf,
                            size_t len,
                            Error **errp)
  {
      return block->driver->decrypt(block, offset, buf, len, errp);
  }
  
  
  int qcrypto_block_encrypt(QCryptoBlock *block,
                            uint64_t offset,
                            uint8_t *buf,
                            size_t len,
                            Error **errp)
  {
      return block->driver->encrypt(block, offset, buf, len, errp);
  }
  
  
  QCryptoCipher *qcrypto_block_get_cipher(QCryptoBlock *block)
  {
      /* Ciphers should be accessed through pop/push method to be thread-safe.
       * Better, they should not be accessed externally at all (note, that
       * pop/push are static functions)
       * This function is used only in test with one thread (it's safe to skip
       * pop/push interface), so it's enough to assert it here:
       */
      assert(block->n_ciphers <= 1);
      return block->ciphers ? block->ciphers[0] : NULL;
  }
  
  
  static QCryptoCipher *qcrypto_block_pop_cipher(QCryptoBlock *block)
  {
      QCryptoCipher *cipher;
  
      qemu_mutex_lock(&block->mutex);
  
      assert(block->n_free_ciphers > 0);
      block->n_free_ciphers--;
      cipher = block->ciphers[block->n_free_ciphers];
  
      qemu_mutex_unlock(&block->mutex);
  
      return cipher;
  }
  
  
  static void qcrypto_block_push_cipher(QCryptoBlock *block,
                                        QCryptoCipher *cipher)
  {
      qemu_mutex_lock(&block->mutex);
  
      assert(block->n_free_ciphers < block->n_ciphers);
      block->ciphers[block->n_free_ciphers] = cipher;
      block->n_free_ciphers++;
  
      qemu_mutex_unlock(&block->mutex);
  }
  
  
  int qcrypto_block_init_cipher(QCryptoBlock *block,
                                QCryptoCipherAlgorithm alg,
                                QCryptoCipherMode mode,
                                const uint8_t *key, size_t nkey,
                                size_t n_threads, Error **errp)
  {
      size_t i;
  
      assert(!block->ciphers && !block->n_ciphers && !block->n_free_ciphers);
  
      block->ciphers = g_new0(QCryptoCipher *, n_threads);
  
      for (i = 0; i < n_threads; i++) {
          block->ciphers[i] = qcrypto_cipher_new(alg, mode, key, nkey, errp);
          if (!block->ciphers[i]) {
              qcrypto_block_free_cipher(block);
              return -1;
          }
          block->n_ciphers++;
          block->n_free_ciphers++;
      }
  
      return 0;
  }
  
  
  void qcrypto_block_free_cipher(QCryptoBlock *block)
  {
      size_t i;
  
      if (!block->ciphers) {
          return;
      }
  
      assert(block->n_ciphers == block->n_free_ciphers);
  
      for (i = 0; i < block->n_ciphers; i++) {
          qcrypto_cipher_free(block->ciphers[i]);
      }
  
      g_free(block->ciphers);
      block->ciphers = NULL;
      block->n_ciphers = block->n_free_ciphers = 0;
  }
  
  QCryptoIVGen *qcrypto_block_get_ivgen(QCryptoBlock *block)
  {
      /* ivgen should be accessed under mutex. However, this function is used only
       * in test with one thread, so it's enough to assert it here:
       */
      assert(block->n_ciphers <= 1);
      return block->ivgen;
  }
  
  
  QCryptoHashAlgorithm qcrypto_block_get_kdf_hash(QCryptoBlock *block)
  {
      return block->kdfhash;
  }
  
  
  uint64_t qcrypto_block_get_payload_offset(QCryptoBlock *block)
  {
      return block->payload_offset;
  }
  
  
  uint64_t qcrypto_block_get_sector_size(QCryptoBlock *block)
  {
      return block->sector_size;
  }
  
  
  void qcrypto_block_free(QCryptoBlock *block)
  {
      if (!block) {
          return;
      }
  
      block->driver->cleanup(block);
  
      qcrypto_block_free_cipher(block);
      qcrypto_ivgen_free(block->ivgen);
      qemu_mutex_destroy(&block->mutex);
      g_free(block);
  }
  
  
  typedef int (*QCryptoCipherEncDecFunc)(QCryptoCipher *cipher,
                                          const void *in,
                                          void *out,
                                          size_t len,
                                          Error **errp);
  
  static int do_qcrypto_block_cipher_encdec(QCryptoCipher *cipher,
                                            size_t niv,
                                            QCryptoIVGen *ivgen,
                                            QemuMutex *ivgen_mutex,
                                            int sectorsize,
                                            uint64_t offset,
                                            uint8_t *buf,
                                            size_t len,
                                            QCryptoCipherEncDecFunc func,
                                            Error **errp)
  {
      g_autofree uint8_t *iv = niv ? g_new0(uint8_t, niv) : NULL;
      int ret = -1;
      uint64_t startsector = offset / sectorsize;
  
      assert(QEMU_IS_ALIGNED(offset, sectorsize));
      assert(QEMU_IS_ALIGNED(len, sectorsize));
  
      while (len > 0) {
          size_t nbytes;
          if (niv) {
              if (ivgen_mutex) {
                  qemu_mutex_lock(ivgen_mutex);
              }
              ret = qcrypto_ivgen_calculate(ivgen, startsector, iv, niv, errp);
              if (ivgen_mutex) {
                  qemu_mutex_unlock(ivgen_mutex);
              }
  
              if (ret < 0) {
                  return -1;
              }
  
              if (qcrypto_cipher_setiv(cipher,
                                       iv, niv,
                                       errp) < 0) {
                  return -1;
              }
          }
  
          nbytes = len > sectorsize ? sectorsize : len;
          if (func(cipher, buf, buf, nbytes, errp) < 0) {
              return -1;
          }
  
          startsector++;
          buf += nbytes;
          len -= nbytes;
      }
  
      return 0;
  }
  
  
  int qcrypto_block_cipher_decrypt_helper(QCryptoCipher *cipher,
                                          size_t niv,
                                          QCryptoIVGen *ivgen,
                                          int sectorsize,
                                          uint64_t offset,
                                          uint8_t *buf,
                                          size_t len,
                                          Error **errp)
  {
      return do_qcrypto_block_cipher_encdec(cipher, niv, ivgen, NULL, sectorsize,
                                            offset, buf, len,
                                            qcrypto_cipher_decrypt, errp);
  }
  
  
  int qcrypto_block_cipher_encrypt_helper(QCryptoCipher *cipher,
                                          size_t niv,
                                          QCryptoIVGen *ivgen,
                                          int sectorsize,
                                          uint64_t offset,
                                          uint8_t *buf,
                                          size_t len,
                                          Error **errp)
  {
      return do_qcrypto_block_cipher_encdec(cipher, niv, ivgen, NULL, sectorsize,
                                            offset, buf, len,
                                            qcrypto_cipher_encrypt, errp);
  }
  
  int qcrypto_block_decrypt_helper(QCryptoBlock *block,
                                   int sectorsize,
                                   uint64_t offset,
                                   uint8_t *buf,
                                   size_t len,
                                   Error **errp)
  {
      int ret;
      QCryptoCipher *cipher = qcrypto_block_pop_cipher(block);
  
      ret = do_qcrypto_block_cipher_encdec(cipher, block->niv, block->ivgen,
                                           &block->mutex, sectorsize, offset, buf,
                                           len, qcrypto_cipher_decrypt, errp);
  
      qcrypto_block_push_cipher(block, cipher);
  
      return ret;
  }
  
  int qcrypto_block_encrypt_helper(QCryptoBlock *block,
                                   int sectorsize,
                                   uint64_t offset,
                                   uint8_t *buf,
                                   size_t len,
                                   Error **errp)
  {
      int ret;
      QCryptoCipher *cipher = qcrypto_block_pop_cipher(block);
  
      ret = do_qcrypto_block_cipher_encdec(cipher, block->niv, block->ivgen,
                                           &block->mutex, sectorsize, offset, buf,
                                           len, qcrypto_cipher_encrypt, errp);
  
      qcrypto_block_push_cipher(block, cipher);
  
      return ret;
  }
  