LXR qemu/crypto/blockpriv.h

   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#ifndef QCRYPTO_BLOCKPRIV_H
  22#define QCRYPTO_BLOCKPRIV_H
  23
  24#include "crypto/block.h"
  25#include "qemu/thread.h"
  26
  27typedef struct QCryptoBlockDriver QCryptoBlockDriver;
  28
  29struct QCryptoBlock {
  30    QCryptoBlockFormat format;
  31
  32    const QCryptoBlockDriver *driver;
  33    void *opaque;
  34
  35    QCryptoCipher **ciphers;
  36    size_t n_ciphers;
  37    size_t n_free_ciphers;
  38    QCryptoIVGen *ivgen;
  39    QemuMutex mutex;
  40
  41    QCryptoHashAlgorithm kdfhash;
  42    size_t niv;
  43    uint64_t payload_offset; /* In bytes */
  44    uint64_t sector_size; /* In bytes */
  45};
  46
  47struct QCryptoBlockDriver {
  48    int (*open)(QCryptoBlock *block,
  49                QCryptoBlockOpenOptions *options,
  50                const char *optprefix,
  51                QCryptoBlockReadFunc readfunc,
  52                void *opaque,
  53                unsigned int flags,
  54                size_t n_threads,
  55                Error **errp);
  56
  57    int (*create)(QCryptoBlock *block,
  58                  QCryptoBlockCreateOptions *options,
  59                  const char *optprefix,
  60                  QCryptoBlockInitFunc initfunc,
  61                  QCryptoBlockWriteFunc writefunc,
  62                  void *opaque,
  63                  Error **errp);
  64
  65    int (*amend)(QCryptoBlock *block,
  66                 QCryptoBlockReadFunc readfunc,
  67                 QCryptoBlockWriteFunc writefunc,
  68                 void *opaque,
  69                 QCryptoBlockAmendOptions *options,
  70                 bool force,
  71                 Error **errp);
  72
  73    int (*get_info)(QCryptoBlock *block,
  74                    QCryptoBlockInfo *info,
  75                    Error **errp);
  76
  77    void (*cleanup)(QCryptoBlock *block);
  78
  79    int (*encrypt)(QCryptoBlock *block,
  80                   uint64_t startsector,
  81                   uint8_t *buf,
  82                   size_t len,
  83                   Error **errp);
  84    int (*decrypt)(QCryptoBlock *block,
  85                   uint64_t startsector,
  86                   uint8_t *buf,
  87                   size_t len,
  88                   Error **errp);
  89
  90    bool (*has_format)(const uint8_t *buf,
  91                       size_t buflen);
  92};
  93
  94
  95int qcrypto_block_cipher_decrypt_helper(QCryptoCipher *cipher,
  96                                        size_t niv,
  97                                        QCryptoIVGen *ivgen,
  98                                        int sectorsize,
  99                                        uint64_t offset,
 100                                        uint8_t *buf,
 101                                        size_t len,
 102                                        Error **errp);
 103
 104int qcrypto_block_cipher_encrypt_helper(QCryptoCipher *cipher,
 105                                        size_t niv,
 106                                        QCryptoIVGen *ivgen,
 107                                        int sectorsize,
 108                                        uint64_t offset,
 109                                        uint8_t *buf,
 110                                        size_t len,
 111                                        Error **errp);
 112
 113int qcrypto_block_decrypt_helper(QCryptoBlock *block,
 114                                 int sectorsize,
 115                                 uint64_t offset,
 116                                 uint8_t *buf,
 117                                 size_t len,
 118                                 Error **errp);
 119
 120int qcrypto_block_encrypt_helper(QCryptoBlock *block,
 121                                 int sectorsize,
 122                                 uint64_t offset,
 123                                 uint8_t *buf,
 124                                 size_t len,
 125                                 Error **errp);
 126
 127int qcrypto_block_init_cipher(QCryptoBlock *block,
 128                              QCryptoCipherAlgorithm alg,
 129                              QCryptoCipherMode mode,
 130                              const uint8_t *key, size_t nkey,
 131                              size_t n_threads, Error **errp);
 132
 133void qcrypto_block_free_cipher(QCryptoBlock *block);
 134
 135#endif /* QCRYPTO_BLOCKPRIV_H */
 136