[mirror_qemu.git] / block / crypto.c

/*
 * QEMU block full disk 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 "block/block_int.h"
#include "sysemu/block-backend.h"
#include "crypto/block.h"
#include "qapi/opts-visitor.h"
#include "qapi-visit.h"
#include "qapi/error.h"

#define BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET "key-secret"
#define BLOCK_CRYPTO_OPT_LUKS_CIPHER_ALG "cipher-alg"
#define BLOCK_CRYPTO_OPT_LUKS_CIPHER_MODE "cipher-mode"
#define BLOCK_CRYPTO_OPT_LUKS_IVGEN_ALG "ivgen-alg"
#define BLOCK_CRYPTO_OPT_LUKS_IVGEN_HASH_ALG "ivgen-hash-alg"
#define BLOCK_CRYPTO_OPT_LUKS_HASH_ALG "hash-alg"
#define BLOCK_CRYPTO_OPT_LUKS_ITER_TIME "iter-time"

typedef struct BlockCrypto BlockCrypto;

struct BlockCrypto {
    QCryptoBlock *block;
};


static int block_crypto_probe_generic(QCryptoBlockFormat format,
                                      const uint8_t *buf,
                                      int buf_size,
                                      const char *filename)
{
    if (qcrypto_block_has_format(format, buf, buf_size)) {
        return 100;
    } else {
        return 0;
    }
}


static ssize_t block_crypto_read_func(QCryptoBlock *block,
                                      size_t offset,
                                      uint8_t *buf,
                                      size_t buflen,
                                      Error **errp,
                                      void *opaque)
{
    BlockDriverState *bs = opaque;
    ssize_t ret;

    ret = bdrv_pread(bs->file, offset, buf, buflen);
    if (ret < 0) {
        error_setg_errno(errp, -ret, "Could not read encryption header");
        return ret;
    }
    return ret;
}


struct BlockCryptoCreateData {
    const char *filename;
    QemuOpts *opts;
    BlockBackend *blk;
    uint64_t size;
};


static ssize_t block_crypto_write_func(QCryptoBlock *block,
                                       size_t offset,
                                       const uint8_t *buf,
                                       size_t buflen,
                                       Error **errp,
                                       void *opaque)
{
    struct BlockCryptoCreateData *data = opaque;
    ssize_t ret;

    ret = blk_pwrite(data->blk, offset, buf, buflen, 0);
    if (ret < 0) {
        error_setg_errno(errp, -ret, "Could not write encryption header");
        return ret;
    }
    return ret;
}


static ssize_t block_crypto_init_func(QCryptoBlock *block,
                                      size_t headerlen,
                                      Error **errp,
                                      void *opaque)
{
    struct BlockCryptoCreateData *data = opaque;
    int ret;

    /* User provided size should reflect amount of space made
     * available to the guest, so we must take account of that
     * which will be used by the crypto header
     */
    data->size += headerlen;

    qemu_opt_set_number(data->opts, BLOCK_OPT_SIZE, data->size, &error_abort);
    ret = bdrv_create_file(data->filename, data->opts, errp);
    if (ret < 0) {
        return -1;
    }

    data->blk = blk_new_open(data->filename, NULL, NULL,
                             BDRV_O_RDWR | BDRV_O_PROTOCOL, errp);
    if (!data->blk) {
        return -1;
    }

    return 0;
}


static QemuOptsList block_crypto_runtime_opts_luks = {
    .name = "crypto",
    .head = QTAILQ_HEAD_INITIALIZER(block_crypto_runtime_opts_luks.head),
    .desc = {
        {
            .name = BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET,
            .type = QEMU_OPT_STRING,
            .help = "ID of the secret that provides the encryption key",
        },
        { /* end of list */ }
    },
};


static QemuOptsList block_crypto_create_opts_luks = {
    .name = "crypto",
    .head = QTAILQ_HEAD_INITIALIZER(block_crypto_create_opts_luks.head),
    .desc = {
        {
            .name = BLOCK_OPT_SIZE,
            .type = QEMU_OPT_SIZE,
            .help = "Virtual disk size"
        },
        {
            .name = BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET,
            .type = QEMU_OPT_STRING,
            .help = "ID of the secret that provides the encryption key",
        },
        {
            .name = BLOCK_CRYPTO_OPT_LUKS_CIPHER_ALG,
            .type = QEMU_OPT_STRING,
            .help = "Name of encryption cipher algorithm",
        },
        {
            .name = BLOCK_CRYPTO_OPT_LUKS_CIPHER_MODE,
            .type = QEMU_OPT_STRING,
            .help = "Name of encryption cipher mode",
        },
        {
            .name = BLOCK_CRYPTO_OPT_LUKS_IVGEN_ALG,
            .type = QEMU_OPT_STRING,
            .help = "Name of IV generator algorithm",
        },
        {
            .name = BLOCK_CRYPTO_OPT_LUKS_IVGEN_HASH_ALG,
            .type = QEMU_OPT_STRING,
            .help = "Name of IV generator hash algorithm",
        },
        {
            .name = BLOCK_CRYPTO_OPT_LUKS_HASH_ALG,
            .type = QEMU_OPT_STRING,
            .help = "Name of encryption hash algorithm",
        },
        {
            .name = BLOCK_CRYPTO_OPT_LUKS_ITER_TIME,
            .type = QEMU_OPT_NUMBER,
            .help = "Time to spend in PBKDF in milliseconds",
        },
        { /* end of list */ }
    },
};


static QCryptoBlockOpenOptions *
block_crypto_open_opts_init(QCryptoBlockFormat format,
                            QemuOpts *opts,
                            Error **errp)
{
    Visitor *v;
    QCryptoBlockOpenOptions *ret = NULL;
    Error *local_err = NULL;

    ret = g_new0(QCryptoBlockOpenOptions, 1);
    ret->format = format;

    v = opts_visitor_new(opts);

    visit_start_struct(v, NULL, NULL, 0, &local_err);
    if (local_err) {
        goto out;
    }

    switch (format) {
    case Q_CRYPTO_BLOCK_FORMAT_LUKS:
        visit_type_QCryptoBlockOptionsLUKS_members(
            v, &ret->u.luks, &local_err);
        break;

    default:
        error_setg(&local_err, "Unsupported block format %d", format);
        break;
    }
    if (!local_err) {
        visit_check_struct(v, &local_err);
    }

    visit_end_struct(v, NULL);

 out:
    if (local_err) {
        error_propagate(errp, local_err);
        qapi_free_QCryptoBlockOpenOptions(ret);
        ret = NULL;
    }
    visit_free(v);
    return ret;
}


static QCryptoBlockCreateOptions *
block_crypto_create_opts_init(QCryptoBlockFormat format,
                              QemuOpts *opts,
                              Error **errp)
{
    Visitor *v;
    QCryptoBlockCreateOptions *ret = NULL;
    Error *local_err = NULL;

    ret = g_new0(QCryptoBlockCreateOptions, 1);
    ret->format = format;

    v = opts_visitor_new(opts);

    visit_start_struct(v, NULL, NULL, 0, &local_err);
    if (local_err) {
        goto out;
    }

    switch (format) {
    case Q_CRYPTO_BLOCK_FORMAT_LUKS:
        visit_type_QCryptoBlockCreateOptionsLUKS_members(
            v, &ret->u.luks, &local_err);
        break;

    default:
        error_setg(&local_err, "Unsupported block format %d", format);
        break;
    }
    if (!local_err) {
        visit_check_struct(v, &local_err);
    }

    visit_end_struct(v, NULL);

 out:
    if (local_err) {
        error_propagate(errp, local_err);
        qapi_free_QCryptoBlockCreateOptions(ret);
        ret = NULL;
    }
    visit_free(v);
    return ret;
}


static int block_crypto_open_generic(QCryptoBlockFormat format,
                                     QemuOptsList *opts_spec,
                                     BlockDriverState *bs,
                                     QDict *options,
                                     int flags,
                                     Error **errp)
{
    BlockCrypto *crypto = bs->opaque;
    QemuOpts *opts = NULL;
    Error *local_err = NULL;
    int ret = -EINVAL;
    QCryptoBlockOpenOptions *open_opts = NULL;
    unsigned int cflags = 0;

    opts = qemu_opts_create(opts_spec, NULL, 0, &error_abort);
    qemu_opts_absorb_qdict(opts, options, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        goto cleanup;
    }

    open_opts = block_crypto_open_opts_init(format, opts, errp);
    if (!open_opts) {
        goto cleanup;
    }

    if (flags & BDRV_O_NO_IO) {
        cflags |= QCRYPTO_BLOCK_OPEN_NO_IO;
    }
    crypto->block = qcrypto_block_open(open_opts,
                                       block_crypto_read_func,
                                       bs,
                                       cflags,
                                       errp);

    if (!crypto->block) {
        ret = -EIO;
        goto cleanup;
    }

    bs->encrypted = true;
    bs->valid_key = true;

    ret = 0;
 cleanup:
    qapi_free_QCryptoBlockOpenOptions(open_opts);
    return ret;
}


static int block_crypto_create_generic(QCryptoBlockFormat format,
                                       const char *filename,
                                       QemuOpts *opts,
                                       Error **errp)
{
    int ret = -EINVAL;
    QCryptoBlockCreateOptions *create_opts = NULL;
    QCryptoBlock *crypto = NULL;
    struct BlockCryptoCreateData data = {
        .size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
                         BDRV_SECTOR_SIZE),
        .opts = opts,
        .filename = filename,
    };

    create_opts = block_crypto_create_opts_init(format, opts, errp);
    if (!create_opts) {
        return -1;
    }

    crypto = qcrypto_block_create(create_opts,
                                  block_crypto_init_func,
                                  block_crypto_write_func,
                                  &data,
                                  errp);

    if (!crypto) {
        ret = -EIO;
        goto cleanup;
    }

    ret = 0;
 cleanup:
    qcrypto_block_free(crypto);
    blk_unref(data.blk);
    qapi_free_QCryptoBlockCreateOptions(create_opts);
    return ret;
}

static int block_crypto_truncate(BlockDriverState *bs, int64_t offset)
{
    BlockCrypto *crypto = bs->opaque;
    size_t payload_offset =
        qcrypto_block_get_payload_offset(crypto->block);

    offset += payload_offset;

    return bdrv_truncate(bs->file->bs, offset);
}

static void block_crypto_close(BlockDriverState *bs)
{
    BlockCrypto *crypto = bs->opaque;
    qcrypto_block_free(crypto->block);
}


#define BLOCK_CRYPTO_MAX_SECTORS 32

static coroutine_fn int
block_crypto_co_readv(BlockDriverState *bs, int64_t sector_num,
                      int remaining_sectors, QEMUIOVector *qiov)
{
    BlockCrypto *crypto = bs->opaque;
    int cur_nr_sectors; /* number of sectors in current iteration */
    uint64_t bytes_done = 0;
    uint8_t *cipher_data = NULL;
    QEMUIOVector hd_qiov;
    int ret = 0;
    size_t payload_offset =
        qcrypto_block_get_payload_offset(crypto->block) / 512;

    qemu_iovec_init(&hd_qiov, qiov->niov);

    /* Bounce buffer so we have a linear mem region for
     * entire sector. XXX optimize so we avoid bounce
     * buffer in case that qiov->niov == 1
     */
    cipher_data =
        qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_SECTORS * 512,
                                              qiov->size));
    if (cipher_data == NULL) {
        ret = -ENOMEM;
        goto cleanup;
    }

    while (remaining_sectors) {
        cur_nr_sectors = remaining_sectors;

        if (cur_nr_sectors > BLOCK_CRYPTO_MAX_SECTORS) {
            cur_nr_sectors = BLOCK_CRYPTO_MAX_SECTORS;
        }

        qemu_iovec_reset(&hd_qiov);
        qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512);

        ret = bdrv_co_readv(bs->file,
                            payload_offset + sector_num,
                            cur_nr_sectors, &hd_qiov);
        if (ret < 0) {
            goto cleanup;
        }

        if (qcrypto_block_decrypt(crypto->block,
                                  sector_num,
                                  cipher_data, cur_nr_sectors * 512,
                                  NULL) < 0) {
            ret = -EIO;
            goto cleanup;
        }

        qemu_iovec_from_buf(qiov, bytes_done,
                            cipher_data, cur_nr_sectors * 512);

        remaining_sectors -= cur_nr_sectors;
        sector_num += cur_nr_sectors;
        bytes_done += cur_nr_sectors * 512;
    }

 cleanup:
    qemu_iovec_destroy(&hd_qiov);
    qemu_vfree(cipher_data);

    return ret;
}


static coroutine_fn int
block_crypto_co_writev(BlockDriverState *bs, int64_t sector_num,
                       int remaining_sectors, QEMUIOVector *qiov)
{
    BlockCrypto *crypto = bs->opaque;
    int cur_nr_sectors; /* number of sectors in current iteration */
    uint64_t bytes_done = 0;
    uint8_t *cipher_data = NULL;
    QEMUIOVector hd_qiov;
    int ret = 0;
    size_t payload_offset =
        qcrypto_block_get_payload_offset(crypto->block) / 512;

    qemu_iovec_init(&hd_qiov, qiov->niov);

    /* Bounce buffer so we have a linear mem region for
     * entire sector. XXX optimize so we avoid bounce
     * buffer in case that qiov->niov == 1
     */
    cipher_data =
        qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_SECTORS * 512,
                                              qiov->size));
    if (cipher_data == NULL) {
        ret = -ENOMEM;
        goto cleanup;
    }

    while (remaining_sectors) {
        cur_nr_sectors = remaining_sectors;

        if (cur_nr_sectors > BLOCK_CRYPTO_MAX_SECTORS) {
            cur_nr_sectors = BLOCK_CRYPTO_MAX_SECTORS;
        }

        qemu_iovec_to_buf(qiov, bytes_done,
                          cipher_data, cur_nr_sectors * 512);

        if (qcrypto_block_encrypt(crypto->block,
                                  sector_num,
                                  cipher_data, cur_nr_sectors * 512,
                                  NULL) < 0) {
            ret = -EIO;
            goto cleanup;
        }

        qemu_iovec_reset(&hd_qiov);
        qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512);

        ret = bdrv_co_writev(bs->file,
                             payload_offset + sector_num,
                             cur_nr_sectors, &hd_qiov);
        if (ret < 0) {
            goto cleanup;
        }

        remaining_sectors -= cur_nr_sectors;
        sector_num += cur_nr_sectors;
        bytes_done += cur_nr_sectors * 512;
    }

 cleanup:
    qemu_iovec_destroy(&hd_qiov);
    qemu_vfree(cipher_data);

    return ret;
}


static int64_t block_crypto_getlength(BlockDriverState *bs)
{
    BlockCrypto *crypto = bs->opaque;
    int64_t len = bdrv_getlength(bs->file->bs);

    ssize_t offset = qcrypto_block_get_payload_offset(crypto->block);

    len -= offset;

    return len;
}


static int block_crypto_probe_luks(const uint8_t *buf,
                                   int buf_size,
                                   const char *filename) {
    return block_crypto_probe_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
                                      buf, buf_size, filename);
}

static int block_crypto_open_luks(BlockDriverState *bs,
                                  QDict *options,
                                  int flags,
                                  Error **errp)
{
    return block_crypto_open_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
                                     &block_crypto_runtime_opts_luks,
                                     bs, options, flags, errp);
}

static int block_crypto_create_luks(const char *filename,
                                    QemuOpts *opts,
                                    Error **errp)
{
    return block_crypto_create_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
                                       filename, opts, errp);
}

static int block_crypto_get_info_luks(BlockDriverState *bs,
                                      BlockDriverInfo *bdi)
{
    BlockDriverInfo subbdi;
    int ret;

    ret = bdrv_get_info(bs->file->bs, &subbdi);
    if (ret != 0) {
        return ret;
    }

    bdi->unallocated_blocks_are_zero = false;
    bdi->can_write_zeroes_with_unmap = false;
    bdi->cluster_size = subbdi.cluster_size;

    return 0;
}

static ImageInfoSpecific *
block_crypto_get_specific_info_luks(BlockDriverState *bs)
{
    BlockCrypto *crypto = bs->opaque;
    ImageInfoSpecific *spec_info;
    QCryptoBlockInfo *info;

    info = qcrypto_block_get_info(crypto->block, NULL);
    if (!info) {
        return NULL;
    }
    if (info->format != Q_CRYPTO_BLOCK_FORMAT_LUKS) {
        qapi_free_QCryptoBlockInfo(info);
        return NULL;
    }

    spec_info = g_new(ImageInfoSpecific, 1);
    spec_info->type = IMAGE_INFO_SPECIFIC_KIND_LUKS;
    spec_info->u.luks.data = g_new(QCryptoBlockInfoLUKS, 1);
    *spec_info->u.luks.data = info->u.luks;

    /* Blank out pointers we've just stolen to avoid double free */
    memset(&info->u.luks, 0, sizeof(info->u.luks));

    qapi_free_QCryptoBlockInfo(info);

    return spec_info;
}

BlockDriver bdrv_crypto_luks = {
    .format_name        = "luks",
    .instance_size      = sizeof(BlockCrypto),
    .bdrv_probe         = block_crypto_probe_luks,
    .bdrv_open          = block_crypto_open_luks,
    .bdrv_close         = block_crypto_close,
    .bdrv_create        = block_crypto_create_luks,
    .bdrv_truncate      = block_crypto_truncate,
    .create_opts        = &block_crypto_create_opts_luks,

    .bdrv_co_readv      = block_crypto_co_readv,
    .bdrv_co_writev     = block_crypto_co_writev,
    .bdrv_getlength     = block_crypto_getlength,
    .bdrv_get_info      = block_crypto_get_info_luks,
    .bdrv_get_specific_info = block_crypto_get_specific_info_luks,
};

static void block_crypto_init(void)
{
    bdrv_register(&bdrv_crypto_luks);
}

block_init(block_crypto_init);
Commit	Line	Data
78368575 DB	1	/*
	2	* QEMU block full disk 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
	23	#include "block/block_int.h"
	24	#include "sysemu/block-backend.h"
	25	#include "crypto/block.h"
	26	#include "qapi/opts-visitor.h"
	27	#include "qapi-visit.h"
	28	#include "qapi/error.h"
	29
	30	#define BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET "key-secret"
	31	#define BLOCK_CRYPTO_OPT_LUKS_CIPHER_ALG "cipher-alg"
	32	#define BLOCK_CRYPTO_OPT_LUKS_CIPHER_MODE "cipher-mode"
	33	#define BLOCK_CRYPTO_OPT_LUKS_IVGEN_ALG "ivgen-alg"
	34	#define BLOCK_CRYPTO_OPT_LUKS_IVGEN_HASH_ALG "ivgen-hash-alg"
	35	#define BLOCK_CRYPTO_OPT_LUKS_HASH_ALG "hash-alg"
3bd18890	36	#define BLOCK_CRYPTO_OPT_LUKS_ITER_TIME "iter-time"
78368575 DB	37
	38	typedef struct BlockCrypto BlockCrypto;
	39
	40	struct BlockCrypto {
	41	QCryptoBlock *block;
	42	};
	43
	44
	45	static int block_crypto_probe_generic(QCryptoBlockFormat format,
	46	const uint8_t *buf,
	47	int buf_size,
	48	const char *filename)
	49	{
	50	if (qcrypto_block_has_format(format, buf, buf_size)) {
	51	return 100;
	52	} else {
	53	return 0;
	54	}
	55	}
	56
	57
	58	static ssize_t block_crypto_read_func(QCryptoBlock *block,
	59	size_t offset,
	60	uint8_t *buf,
	61	size_t buflen,
	62	Error **errp,
	63	void *opaque)
	64	{
	65	BlockDriverState *bs = opaque;
	66	ssize_t ret;
	67
cf2ab8fc	68	ret = bdrv_pread(bs->file, offset, buf, buflen);
78368575 DB	69	if (ret < 0) {
	70	error_setg_errno(errp, -ret, "Could not read encryption header");
	71	return ret;
	72	}
	73	return ret;
	74	}
	75
	76
	77	struct BlockCryptoCreateData {
	78	const char *filename;
	79	QemuOpts *opts;
	80	BlockBackend *blk;
	81	uint64_t size;
	82	};
	83
	84
	85	static ssize_t block_crypto_write_func(QCryptoBlock *block,
	86	size_t offset,
	87	const uint8_t *buf,
	88	size_t buflen,
	89	Error **errp,
	90	void *opaque)
	91	{
	92	struct BlockCryptoCreateData *data = opaque;
	93	ssize_t ret;
	94
8341f00d	95	ret = blk_pwrite(data->blk, offset, buf, buflen, 0);
78368575 DB	96	if (ret < 0) {
	97	error_setg_errno(errp, -ret, "Could not write encryption header");
	98	return ret;
	99	}
	100	return ret;
	101	}
	102
	103
	104	static ssize_t block_crypto_init_func(QCryptoBlock *block,
	105	size_t headerlen,
	106	Error **errp,
	107	void *opaque)
	108	{
	109	struct BlockCryptoCreateData *data = opaque;
	110	int ret;
	111
	112	/* User provided size should reflect amount of space made
	113	* available to the guest, so we must take account of that
	114	* which will be used by the crypto header
	115	*/
	116	data->size += headerlen;
	117
	118	qemu_opt_set_number(data->opts, BLOCK_OPT_SIZE, data->size, &error_abort);
	119	ret = bdrv_create_file(data->filename, data->opts, errp);
	120	if (ret < 0) {
	121	return -1;
	122	}
	123
	124	data->blk = blk_new_open(data->filename, NULL, NULL,
72e775c7	125	BDRV_O_RDWR \| BDRV_O_PROTOCOL, errp);
78368575 DB	126	if (!data->blk) {
	127	return -1;
	128	}
	129
	130	return 0;
	131	}
	132
	133
	134	static QemuOptsList block_crypto_runtime_opts_luks = {
	135	.name = "crypto",
	136	.head = QTAILQ_HEAD_INITIALIZER(block_crypto_runtime_opts_luks.head),
	137	.desc = {
	138	{
	139	.name = BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET,
	140	.type = QEMU_OPT_STRING,
	141	.help = "ID of the secret that provides the encryption key",
	142	},
	143	{ /* end of list */ }
	144	},
	145	};
	146
	147
	148	static QemuOptsList block_crypto_create_opts_luks = {
	149	.name = "crypto",
	150	.head = QTAILQ_HEAD_INITIALIZER(block_crypto_create_opts_luks.head),
	151	.desc = {
	152	{
	153	.name = BLOCK_OPT_SIZE,
	154	.type = QEMU_OPT_SIZE,
	155	.help = "Virtual disk size"
	156	},
	157	{
	158	.name = BLOCK_CRYPTO_OPT_LUKS_KEY_SECRET,
	159	.type = QEMU_OPT_STRING,
	160	.help = "ID of the secret that provides the encryption key",
	161	},
	162	{
	163	.name = BLOCK_CRYPTO_OPT_LUKS_CIPHER_ALG,
	164	.type = QEMU_OPT_STRING,
	165	.help = "Name of encryption cipher algorithm",
	166	},
	167	{
	168	.name = BLOCK_CRYPTO_OPT_LUKS_CIPHER_MODE,
	169	.type = QEMU_OPT_STRING,
	170	.help = "Name of encryption cipher mode",
	171	},
	172	{
	173	.name = BLOCK_CRYPTO_OPT_LUKS_IVGEN_ALG,
	174	.type = QEMU_OPT_STRING,
	175	.help = "Name of IV generator algorithm",
	176	},
	177	{
	178	.name = BLOCK_CRYPTO_OPT_LUKS_IVGEN_HASH_ALG,
	179	.type = QEMU_OPT_STRING,
	180	.help = "Name of IV generator hash algorithm",
	181	},
	182	{
	183	.name = BLOCK_CRYPTO_OPT_LUKS_HASH_ALG,
	184	.type = QEMU_OPT_STRING,
	185	.help = "Name of encryption hash algorithm",
	186	},
3bd18890 DB	187	{
	188	.name = BLOCK_CRYPTO_OPT_LUKS_ITER_TIME,
	189	.type = QEMU_OPT_NUMBER,
	190	.help = "Time to spend in PBKDF in milliseconds",
	191	},
78368575 DB	192	{ /* end of list */ }
	193	},
	194	};
	195
	196
	197	static QCryptoBlockOpenOptions *
	198	block_crypto_open_opts_init(QCryptoBlockFormat format,
	199	QemuOpts *opts,
	200	Error **errp)
	201	{
09204eac	202	Visitor *v;
78368575 DB	203	QCryptoBlockOpenOptions *ret = NULL;
	204	Error *local_err = NULL;
	205
	206	ret = g_new0(QCryptoBlockOpenOptions, 1);
	207	ret->format = format;
	208
09204eac	209	v = opts_visitor_new(opts);
78368575	210
09204eac	211	visit_start_struct(v, NULL, NULL, 0, &local_err);
78368575 DB	212	if (local_err) {
	213	goto out;
	214	}
	215
	216	switch (format) {
	217	case Q_CRYPTO_BLOCK_FORMAT_LUKS:
	218	visit_type_QCryptoBlockOptionsLUKS_members(
09204eac	219	v, &ret->u.luks, &local_err);
78368575 DB	220	break;
	221
	222	default:
	223	error_setg(&local_err, "Unsupported block format %d", format);
	224	break;
	225	}
15c2f669	226	if (!local_err) {
09204eac	227	visit_check_struct(v, &local_err);
15c2f669	228	}
78368575	229
09204eac	230	visit_end_struct(v, NULL);
78368575 DB	231
	232	out:
	233	if (local_err) {
	234	error_propagate(errp, local_err);
	235	qapi_free_QCryptoBlockOpenOptions(ret);
	236	ret = NULL;
	237	}
09204eac	238	visit_free(v);
78368575 DB	239	return ret;
	240	}
	241
	242
	243	static QCryptoBlockCreateOptions *
	244	block_crypto_create_opts_init(QCryptoBlockFormat format,
	245	QemuOpts *opts,
	246	Error **errp)
	247	{
09204eac	248	Visitor *v;
78368575 DB	249	QCryptoBlockCreateOptions *ret = NULL;
	250	Error *local_err = NULL;
	251
	252	ret = g_new0(QCryptoBlockCreateOptions, 1);
	253	ret->format = format;
	254
09204eac	255	v = opts_visitor_new(opts);
78368575	256
09204eac	257	visit_start_struct(v, NULL, NULL, 0, &local_err);
78368575 DB	258	if (local_err) {
	259	goto out;
	260	}
	261
	262	switch (format) {
	263	case Q_CRYPTO_BLOCK_FORMAT_LUKS:
	264	visit_type_QCryptoBlockCreateOptionsLUKS_members(
09204eac	265	v, &ret->u.luks, &local_err);
78368575 DB	266	break;
	267
	268	default:
	269	error_setg(&local_err, "Unsupported block format %d", format);
	270	break;
	271	}
15c2f669	272	if (!local_err) {
09204eac	273	visit_check_struct(v, &local_err);
15c2f669	274	}
78368575	275
09204eac	276	visit_end_struct(v, NULL);
78368575 DB	277
	278	out:
	279	if (local_err) {
	280	error_propagate(errp, local_err);
	281	qapi_free_QCryptoBlockCreateOptions(ret);
	282	ret = NULL;
	283	}
09204eac	284	visit_free(v);
78368575 DB	285	return ret;
	286	}
	287
	288
	289	static int block_crypto_open_generic(QCryptoBlockFormat format,
	290	QemuOptsList *opts_spec,
	291	BlockDriverState *bs,
	292	QDict *options,
	293	int flags,
	294	Error **errp)
	295	{
	296	BlockCrypto *crypto = bs->opaque;
	297	QemuOpts *opts = NULL;
	298	Error *local_err = NULL;
	299	int ret = -EINVAL;
	300	QCryptoBlockOpenOptions *open_opts = NULL;
	301	unsigned int cflags = 0;
	302
	303	opts = qemu_opts_create(opts_spec, NULL, 0, &error_abort);
	304	qemu_opts_absorb_qdict(opts, options, &local_err);
	305	if (local_err) {
	306	error_propagate(errp, local_err);
	307	goto cleanup;
	308	}
	309
	310	open_opts = block_crypto_open_opts_init(format, opts, errp);
	311	if (!open_opts) {
	312	goto cleanup;
	313	}
	314
	315	if (flags & BDRV_O_NO_IO) {
	316	cflags \|= QCRYPTO_BLOCK_OPEN_NO_IO;
	317	}
	318	crypto->block = qcrypto_block_open(open_opts,
	319	block_crypto_read_func,
	320	bs,
	321	cflags,
	322	errp);
	323
	324	if (!crypto->block) {
	325	ret = -EIO;
	326	goto cleanup;
	327	}
	328
54115412 EB	329	bs->encrypted = true;
54115412 EB	330	bs->valid_key = true;
78368575 DB	331
	332	ret = 0;
	333	cleanup:
	334	qapi_free_QCryptoBlockOpenOptions(open_opts);
	335	return ret;
	336	}
	337
	338
	339	static int block_crypto_create_generic(QCryptoBlockFormat format,
	340	const char *filename,
	341	QemuOpts *opts,
	342	Error **errp)
	343	{
	344	int ret = -EINVAL;
	345	QCryptoBlockCreateOptions *create_opts = NULL;
	346	QCryptoBlock *crypto = NULL;
	347	struct BlockCryptoCreateData data = {
	348	.size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
	349	BDRV_SECTOR_SIZE),
	350	.opts = opts,
	351	.filename = filename,
	352	};
	353
	354	create_opts = block_crypto_create_opts_init(format, opts, errp);
	355	if (!create_opts) {
	356	return -1;
	357	}
	358
	359	crypto = qcrypto_block_create(create_opts,
	360	block_crypto_init_func,
	361	block_crypto_write_func,
	362	&data,
	363	errp);
	364
	365	if (!crypto) {
	366	ret = -EIO;
	367	goto cleanup;
	368	}
	369
	370	ret = 0;
	371	cleanup:
	372	qcrypto_block_free(crypto);
	373	blk_unref(data.blk);
	374	qapi_free_QCryptoBlockCreateOptions(create_opts);
	375	return ret;
	376	}
	377
	378	static int block_crypto_truncate(BlockDriverState *bs, int64_t offset)
	379	{
	380	BlockCrypto *crypto = bs->opaque;
	381	size_t payload_offset =
	382	qcrypto_block_get_payload_offset(crypto->block);
	383
	384	offset += payload_offset;
	385
	386	return bdrv_truncate(bs->file->bs, offset);
	387	}
	388
	389	static void block_crypto_close(BlockDriverState *bs)
	390	{
	391	BlockCrypto *crypto = bs->opaque;
	392	qcrypto_block_free(crypto->block);
	393	}
	394
395
396	#define BLOCK_CRYPTO_MAX_SECTORS 32
397
398	static coroutine_fn int
399	block_crypto_co_readv(BlockDriverState *bs, int64_t sector_num,
400	int remaining_sectors, QEMUIOVector *qiov)
401	{
402	BlockCrypto *crypto = bs->opaque;
403	int cur_nr_sectors; /* number of sectors in current iteration */
404	uint64_t bytes_done = 0;
405	uint8_t *cipher_data = NULL;
406	QEMUIOVector hd_qiov;
407	int ret = 0;
408	size_t payload_offset =
409	qcrypto_block_get_payload_offset(crypto->block) / 512;
410
411	qemu_iovec_init(&hd_qiov, qiov->niov);
412
413	/* Bounce buffer so we have a linear mem region for
414	* entire sector. XXX optimize so we avoid bounce
415	* buffer in case that qiov->niov == 1
416	*/
417	cipher_data =
418	qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_SECTORS * 512,
419	qiov->size));
420	if (cipher_data == NULL) {
421	ret = -ENOMEM;
422	goto cleanup;
423	}
424
425	while (remaining_sectors) {
426	cur_nr_sectors = remaining_sectors;
427
428	if (cur_nr_sectors > BLOCK_CRYPTO_MAX_SECTORS) {
429	cur_nr_sectors = BLOCK_CRYPTO_MAX_SECTORS;
430	}
431
432	qemu_iovec_reset(&hd_qiov);
433	qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512);
434
28b04a8f	435	ret = bdrv_co_readv(bs->file,
78368575 DB	436	payload_offset + sector_num,
	437	cur_nr_sectors, &hd_qiov);
	438	if (ret < 0) {
	439	goto cleanup;
	440	}
	441
	442	if (qcrypto_block_decrypt(crypto->block,
	443	sector_num,
	444	cipher_data, cur_nr_sectors * 512,
	445	NULL) < 0) {
	446	ret = -EIO;
	447	goto cleanup;
	448	}
	449
	450	qemu_iovec_from_buf(qiov, bytes_done,
	451	cipher_data, cur_nr_sectors * 512);
	452
	453	remaining_sectors -= cur_nr_sectors;
	454	sector_num += cur_nr_sectors;
	455	bytes_done += cur_nr_sectors * 512;
	456	}
	457
	458	cleanup:
	459	qemu_iovec_destroy(&hd_qiov);
	460	qemu_vfree(cipher_data);
	461
	462	return ret;
	463	}
	464
	465
	466	static coroutine_fn int
	467	block_crypto_co_writev(BlockDriverState *bs, int64_t sector_num,
	468	int remaining_sectors, QEMUIOVector *qiov)
	469	{
	470	BlockCrypto *crypto = bs->opaque;
	471	int cur_nr_sectors; /* number of sectors in current iteration */
	472	uint64_t bytes_done = 0;
	473	uint8_t *cipher_data = NULL;
	474	QEMUIOVector hd_qiov;
	475	int ret = 0;
	476	size_t payload_offset =
	477	qcrypto_block_get_payload_offset(crypto->block) / 512;
	478
	479	qemu_iovec_init(&hd_qiov, qiov->niov);
	480
	481	/* Bounce buffer so we have a linear mem region for
	482	* entire sector. XXX optimize so we avoid bounce
	483	* buffer in case that qiov->niov == 1
	484	*/
	485	cipher_data =
	486	qemu_try_blockalign(bs->file->bs, MIN(BLOCK_CRYPTO_MAX_SECTORS * 512,
	487	qiov->size));
	488	if (cipher_data == NULL) {
	489	ret = -ENOMEM;
	490	goto cleanup;
	491	}
	492
	493	while (remaining_sectors) {
	494	cur_nr_sectors = remaining_sectors;
	495
	496	if (cur_nr_sectors > BLOCK_CRYPTO_MAX_SECTORS) {
	497	cur_nr_sectors = BLOCK_CRYPTO_MAX_SECTORS;
	498	}
	499
500	qemu_iovec_to_buf(qiov, bytes_done,
501	cipher_data, cur_nr_sectors * 512);
502
503	if (qcrypto_block_encrypt(crypto->block,
504	sector_num,
505	cipher_data, cur_nr_sectors * 512,
506	NULL) < 0) {
507	ret = -EIO;
508	goto cleanup;
509	}
510
511	qemu_iovec_reset(&hd_qiov);
512	qemu_iovec_add(&hd_qiov, cipher_data, cur_nr_sectors * 512);
513
25ec177d	514	ret = bdrv_co_writev(bs->file,
78368575 DB	515	payload_offset + sector_num,
	516	cur_nr_sectors, &hd_qiov);
	517	if (ret < 0) {
	518	goto cleanup;
	519	}
	520
	521	remaining_sectors -= cur_nr_sectors;
	522	sector_num += cur_nr_sectors;
	523	bytes_done += cur_nr_sectors * 512;
	524	}
	525
	526	cleanup:
	527	qemu_iovec_destroy(&hd_qiov);
	528	qemu_vfree(cipher_data);
	529
	530	return ret;
	531	}
	532
	533
	534	static int64_t block_crypto_getlength(BlockDriverState *bs)
	535	{
	536	BlockCrypto *crypto = bs->opaque;
	537	int64_t len = bdrv_getlength(bs->file->bs);
	538
	539	ssize_t offset = qcrypto_block_get_payload_offset(crypto->block);
	540
	541	len -= offset;
	542
	543	return len;
	544	}
	545
	546
	547	static int block_crypto_probe_luks(const uint8_t *buf,
	548	int buf_size,
	549	const char *filename) {
	550	return block_crypto_probe_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
	551	buf, buf_size, filename);
	552	}
	553
	554	static int block_crypto_open_luks(BlockDriverState *bs,
	555	QDict *options,
	556	int flags,
	557	Error **errp)
	558	{
	559	return block_crypto_open_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
	560	&block_crypto_runtime_opts_luks,
	561	bs, options, flags, errp);
	562	}
	563
	564	static int block_crypto_create_luks(const char *filename,
	565	QemuOpts *opts,
	566	Error **errp)
	567	{
	568	return block_crypto_create_generic(Q_CRYPTO_BLOCK_FORMAT_LUKS,
	569	filename, opts, errp);
	570	}
	571
c7c4cf49 DB	572	static int block_crypto_get_info_luks(BlockDriverState *bs,
	573	BlockDriverInfo *bdi)
	574	{
	575	BlockDriverInfo subbdi;
	576	int ret;
	577
	578	ret = bdrv_get_info(bs->file->bs, &subbdi);
	579	if (ret != 0) {
	580	return ret;
	581	}
	582
	583	bdi->unallocated_blocks_are_zero = false;
	584	bdi->can_write_zeroes_with_unmap = false;
	585	bdi->cluster_size = subbdi.cluster_size;
	586
	587	return 0;
	588	}
	589
	590	static ImageInfoSpecific *
	591	block_crypto_get_specific_info_luks(BlockDriverState *bs)
	592	{
	593	BlockCrypto *crypto = bs->opaque;
	594	ImageInfoSpecific *spec_info;
	595	QCryptoBlockInfo *info;
	596
	597	info = qcrypto_block_get_info(crypto->block, NULL);
	598	if (!info) {
	599	return NULL;
	600	}
	601	if (info->format != Q_CRYPTO_BLOCK_FORMAT_LUKS) {
	602	qapi_free_QCryptoBlockInfo(info);
	603	return NULL;
	604	}
	605
	606	spec_info = g_new(ImageInfoSpecific, 1);
	607	spec_info->type = IMAGE_INFO_SPECIFIC_KIND_LUKS;
	608	spec_info->u.luks.data = g_new(QCryptoBlockInfoLUKS, 1);
	609	*spec_info->u.luks.data = info->u.luks;
	610
	611	/* Blank out pointers we've just stolen to avoid double free */
	612	memset(&info->u.luks, 0, sizeof(info->u.luks));
	613
	614	qapi_free_QCryptoBlockInfo(info);
	615
	616	return spec_info;
	617	}
	618
78368575 DB	619	BlockDriver bdrv_crypto_luks = {
	620	.format_name = "luks",
	621	.instance_size = sizeof(BlockCrypto),
	622	.bdrv_probe = block_crypto_probe_luks,
	623	.bdrv_open = block_crypto_open_luks,
	624	.bdrv_close = block_crypto_close,
	625	.bdrv_create = block_crypto_create_luks,
	626	.bdrv_truncate = block_crypto_truncate,
	627	.create_opts = &block_crypto_create_opts_luks,
	628
	629	.bdrv_co_readv = block_crypto_co_readv,
	630	.bdrv_co_writev = block_crypto_co_writev,
	631	.bdrv_getlength = block_crypto_getlength,
c7c4cf49 DB	632	.bdrv_get_info = block_crypto_get_info_luks,
c7c4cf49 DB	633	.bdrv_get_specific_info = block_crypto_get_specific_info_luks,
78368575 DB	634	};
	635
	636	static void block_crypto_init(void)
	637	{
	638	bdrv_register(&bdrv_crypto_luks);
	639	}
	640
	641	block_init(block_crypto_init);