[qemu.git] / crypto / block.c

/*
 * 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 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)
{
    uint8_t *iv;
    int ret = -1;
    uint64_t startsector = offset / sectorsize;

    assert(QEMU_IS_ALIGNED(offset, sectorsize));
    assert(QEMU_IS_ALIGNED(len, sectorsize));

    iv = niv ? g_new0(uint8_t, niv) : NULL;

    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) {
                goto cleanup;
            }

            if (qcrypto_cipher_setiv(cipher,
                                     iv, niv,
                                     errp) < 0) {
                goto cleanup;
            }
        }

        nbytes = len > sectorsize ? sectorsize : len;
        if (func(cipher, buf, buf, nbytes, errp) < 0) {
            goto cleanup;
        }

        startsector++;
        buf += nbytes;
        len -= nbytes;
    }

    ret = 0;
 cleanup:
    g_free(iv);
    return ret;
}


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;
}
Commit	Line	Data
7d969014 DB	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"
da34e65c	22	#include "qapi/error.h"
986bc8de MT	23	#include "blockpriv.h"
	24	#include "block-qcow.h"
	25	#include "block-luks.h"
7d969014 DB	26
	27	static const QCryptoBlockDriver *qcrypto_block_drivers[] = {
	28	[Q_CRYPTO_BLOCK_FORMAT_QCOW] = &qcrypto_block_driver_qcow,
3e308f20	29	[Q_CRYPTO_BLOCK_FORMAT_LUKS] = &qcrypto_block_driver_luks,
7d969014 DB	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,
1cd9a787	51	const char *optprefix,
7d969014 DB	52	QCryptoBlockReadFunc readfunc,
	53	void *opaque,
	54	unsigned int flags,
c972fa12	55	size_t n_threads,
7d969014 DB	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]) {
90d6f60d	64	error_setg(errp, "Unsupported block driver %s",
977c736f	65	QCryptoBlockFormat_str(options->format));
7d969014 DB	66	g_free(block);
	67	return NULL;
	68	}
	69
	70	block->driver = qcrypto_block_drivers[options->format];
	71
1cd9a787	72	if (block->driver->open(block, options, optprefix,
c972fa12 VSO	73	readfunc, opaque, flags, n_threads, errp) < 0)
c972fa12 VSO	74	{
7d969014 DB	75	g_free(block);
	76	return NULL;
	77	}
	78
c972fa12 VSO	79	qemu_mutex_init(&block->mutex);
c972fa12 VSO	80
7d969014 DB	81	return block;
	82	}
	83
	84
	85	QCryptoBlock qcrypto_block_create(QCryptoBlockCreateOptions options,
1cd9a787	86	const char *optprefix,
7d969014 DB	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]) {
90d6f60d	98	error_setg(errp, "Unsupported block driver %s",
977c736f	99	QCryptoBlockFormat_str(options->format));
7d969014 DB	100	g_free(block);
	101	return NULL;
	102	}
	103
	104	block->driver = qcrypto_block_drivers[options->format];
	105
1cd9a787	106	if (block->driver->create(block, options, optprefix, initfunc,
7d969014 DB	107	writefunc, opaque, errp) < 0) {
	108	g_free(block);
	109	return NULL;
	110	}
	111
c972fa12 VSO	112	qemu_mutex_init(&block->mutex);
c972fa12 VSO	113
7d969014 DB	114	return block;
	115	}
	116
	117
40c85028 DB	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
7d969014	135	int qcrypto_block_decrypt(QCryptoBlock *block,
4609742a	136	uint64_t offset,
7d969014 DB	137	uint8_t *buf,
	138	size_t len,
	139	Error **errp)
	140	{
4609742a	141	return block->driver->decrypt(block, offset, buf, len, errp);
7d969014 DB	142	}
	143
	144
	145	int qcrypto_block_encrypt(QCryptoBlock *block,
4609742a	146	uint64_t offset,
7d969014 DB	147	uint8_t *buf,
	148	size_t len,
	149	Error **errp)
	150	{
4609742a	151	return block->driver->encrypt(block, offset, buf, len, errp);
7d969014 DB	152	}
	153
	154
	155	QCryptoCipher qcrypto_block_get_cipher(QCryptoBlock block)
	156	{
c972fa12 VSO	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;
7d969014 DB	220	}
	221
	222
c972fa12 VSO	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
7d969014 DB	242	QCryptoIVGen qcrypto_block_get_ivgen(QCryptoBlock block)
7d969014 DB	243	{
c972fa12 VSO	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);
7d969014 DB	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
850f49de DB	264	uint64_t qcrypto_block_get_sector_size(QCryptoBlock *block)
	265	{
	266	return block->sector_size;
	267	}
	268
	269
7d969014 DB	270	void qcrypto_block_free(QCryptoBlock *block)
	271	{
	272	if (!block) {
	273	return;
	274	}
	275
	276	block->driver->cleanup(block);
	277
c972fa12	278	qcrypto_block_free_cipher(block);
7d969014	279	qcrypto_ivgen_free(block->ivgen);
c972fa12	280	qemu_mutex_destroy(&block->mutex);
7d969014 DB	281	g_free(block);
	282	}
	283
	284
1dc57b60	285	typedef int (QCryptoCipherEncDecFunc)(QCryptoCipher cipher,
0270417c VSO	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,
c972fa12	294	QemuMutex *ivgen_mutex,
0270417c VSO	295	int sectorsize,
	296	uint64_t offset,
	297	uint8_t *buf,
	298	size_t len,
	299	QCryptoCipherEncDecFunc func,
	300	Error **errp)
7d969014 DB	301	{
	302	uint8_t *iv;
	303	int ret = -1;
4609742a DB	304	uint64_t startsector = offset / sectorsize;
	305
	306	assert(QEMU_IS_ALIGNED(offset, sectorsize));
	307	assert(QEMU_IS_ALIGNED(len, sectorsize));
7d969014 DB	308
	309	iv = niv ? g_new0(uint8_t, niv) : NULL;
	310
	311	while (len > 0) {
	312	size_t nbytes;
	313	if (niv) {
c972fa12 VSO	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) {
7d969014 DB	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;
1dc57b60	334	if (func(cipher, buf, buf, nbytes, errp) < 0) {
7d969014 DB	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
0270417c VSO	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)
7d969014	358	{
c972fa12	359	return do_qcrypto_block_cipher_encdec(cipher, niv, ivgen, NULL, sectorsize,
0270417c VSO	360	offset, buf, len,
0270417c VSO	361	qcrypto_cipher_decrypt, errp);
1dc57b60	362	}
7d969014	363
7d969014	364
0270417c VSO	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)
1dc57b60	373	{
c972fa12	374	return do_qcrypto_block_cipher_encdec(cipher, niv, ivgen, NULL, sectorsize,
0270417c VSO	375	offset, buf, len,
0270417c VSO	376	qcrypto_cipher_encrypt, errp);
7d969014	377	}
0f0d596c	378
0f0d596c VSO	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	{
c972fa12 VSO	386	int ret;
c972fa12 VSO	387	QCryptoCipher *cipher = qcrypto_block_pop_cipher(block);
0f0d596c	388
c972fa12 VSO	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	}
0f0d596c VSO	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	{
c972fa12 VSO	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;
0f0d596c	415	}