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 "crypto/blockpriv.h"
  24 #include "crypto/block-qcow.h"
  25 #include "crypto/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                                  QCryptoBlockReadFunc readfunc,
  52                                  void *opaque,
  53                                  unsigned int flags,
  54                                  Error **errp)
  55 {
  56     QCryptoBlock *block = g_new0(QCryptoBlock, 1);
  57
  58     block->format = options->format;
  59
  60     if (options->format >= G_N_ELEMENTS(qcrypto_block_drivers) ||
  61         !qcrypto_block_drivers[options->format]) {
  62         error_setg(errp, "Unsupported block driver %d", options->format);
  63         g_free(block);
  64         return NULL;
  65     }
  66
  67     block->driver = qcrypto_block_drivers[options->format];
  68
  69     if (block->driver->open(block, options,
  70                             readfunc, opaque, flags, errp) < 0) {
  71         g_free(block);
  72         return NULL;
  73     }
  74
  75     return block;
  76 }
  77
  78
  79 QCryptoBlock *qcrypto_block_create(QCryptoBlockCreateOptions *options,
  80                                    QCryptoBlockInitFunc initfunc,
  81                                    QCryptoBlockWriteFunc writefunc,
  82                                    void *opaque,
  83                                    Error **errp)
  84 {
  85     QCryptoBlock *block = g_new0(QCryptoBlock, 1);
  86
  87     block->format = options->format;
  88
  89     if (options->format >= G_N_ELEMENTS(qcrypto_block_drivers) ||
  90         !qcrypto_block_drivers[options->format]) {
  91         error_setg(errp, "Unsupported block driver %d", options->format);
  92         g_free(block);
  93         return NULL;
  94     }
  95
  96     block->driver = qcrypto_block_drivers[options->format];
  97
  98     if (block->driver->create(block, options, initfunc,
  99                               writefunc, opaque, errp) < 0) {
 100         g_free(block);
 101         return NULL;
 102     }
 103
 104     return block;
 105 }
 106
 107
 108 int qcrypto_block_decrypt(QCryptoBlock *block,
 109                           uint64_t startsector,
 110                           uint8_t *buf,
 111                           size_t len,
 112                           Error **errp)
 113 {
 114     return block->driver->decrypt(block, startsector, buf, len, errp);
 115 }
 116
 117
 118 int qcrypto_block_encrypt(QCryptoBlock *block,
 119                           uint64_t startsector,
 120                           uint8_t *buf,
 121                           size_t len,
 122                           Error **errp)
 123 {
 124     return block->driver->encrypt(block, startsector, buf, len, errp);
 125 }
 126
 127
 128 QCryptoCipher *qcrypto_block_get_cipher(QCryptoBlock *block)
 129 {
 130     return block->cipher;
 131 }
 132
 133
 134 QCryptoIVGen *qcrypto_block_get_ivgen(QCryptoBlock *block)
 135 {
 136     return block->ivgen;
 137 }
 138
 139
 140 QCryptoHashAlgorithm qcrypto_block_get_kdf_hash(QCryptoBlock *block)
 141 {
 142     return block->kdfhash;
 143 }
 144
 145
 146 uint64_t qcrypto_block_get_payload_offset(QCryptoBlock *block)
 147 {
 148     return block->payload_offset;
 149 }
 150
 151
 152 void qcrypto_block_free(QCryptoBlock *block)
 153 {
 154     if (!block) {
 155         return;
 156     }
 157
 158     block->driver->cleanup(block);
 159
 160     qcrypto_cipher_free(block->cipher);
 161     qcrypto_ivgen_free(block->ivgen);
 162     g_free(block);
 163 }
 164
 165
 166 int qcrypto_block_decrypt_helper(QCryptoCipher *cipher,
 167                                  size_t niv,
 168                                  QCryptoIVGen *ivgen,
 169                                  int sectorsize,
 170                                  uint64_t startsector,
 171                                  uint8_t *buf,
 172                                  size_t len,
 173                                  Error **errp)
 174 {
 175     uint8_t *iv;
 176     int ret = -1;
 177
 178     iv = niv ? g_new0(uint8_t, niv) : NULL;
 179
 180     while (len > 0) {
 181         size_t nbytes;
 182         if (niv) {
 183             if (qcrypto_ivgen_calculate(ivgen,
 184                                         startsector,
 185                                         iv, niv,
 186                                         errp) < 0) {
 187                 goto cleanup;
 188             }
 189
 190             if (qcrypto_cipher_setiv(cipher,
 191                                      iv, niv,
 192                                      errp) < 0) {
 193                 goto cleanup;
 194             }
 195         }
 196
 197         nbytes = len > sectorsize ? sectorsize : len;
 198         if (qcrypto_cipher_decrypt(cipher, buf, buf,
 199                                    nbytes, errp) < 0) {
 200             goto cleanup;
 201         }
 202
 203         startsector++;
 204         buf += nbytes;
 205         len -= nbytes;
 206     }
 207
 208     ret = 0;
 209  cleanup:
 210     g_free(iv);
 211     return ret;
 212 }
 213
 214
 215 int qcrypto_block_encrypt_helper(QCryptoCipher *cipher,
 216                                  size_t niv,
 217                                  QCryptoIVGen *ivgen,
 218                                  int sectorsize,
 219                                  uint64_t startsector,
 220                                  uint8_t *buf,
 221                                  size_t len,
 222                                  Error **errp)
 223 {
 224     uint8_t *iv;
 225     int ret = -1;
 226
 227     iv = niv ? g_new0(uint8_t, niv) : NULL;
 228
 229     while (len > 0) {
 230         size_t nbytes;
 231         if (niv) {
 232             if (qcrypto_ivgen_calculate(ivgen,
 233                                         startsector,
 234                                         iv, niv,
 235                                         errp) < 0) {
 236                 goto cleanup;
 237             }
 238
 239             if (qcrypto_cipher_setiv(cipher,
 240                                      iv, niv,
 241                                      errp) < 0) {
 242                 goto cleanup;
 243             }
 244         }
 245
 246         nbytes = len > sectorsize ? sectorsize : len;
 247         if (qcrypto_cipher_encrypt(cipher, buf, buf,
 248                                    nbytes, errp) < 0) {
 249             goto cleanup;
 250         }
 251
 252         startsector++;
 253         buf += nbytes;
 254         len -= nbytes;
 255     }
 256
 257     ret = 0;
 258  cleanup:
 259     g_free(iv);
 260     return ret;
 261 }