[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/qobject-input-visitor.h"
#include "qapi-visit.h"
#include "qapi/error.h"
#include "block/crypto.h"

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,
                                      void *opaque,
                                      Error **errp)
{
    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,
                                       void *opaque,
                                       Error **errp)
{
    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,
                                      void *opaque,
                                      Error **errp)
{
    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 = {
        BLOCK_CRYPTO_OPT_DEF_LUKS_KEY_SECRET(""),
        { /* 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"
        },
        BLOCK_CRYPTO_OPT_DEF_LUKS_KEY_SECRET(""),
        BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_ALG(""),
        BLOCK_CRYPTO_OPT_DEF_LUKS_CIPHER_MODE(""),
        BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_ALG(""),
        BLOCK_CRYPTO_OPT_DEF_LUKS_IVGEN_HASH_ALG(""),
        BLOCK_CRYPTO_OPT_DEF_LUKS_HASH_ALG(""),
        BLOCK_CRYPTO_OPT_DEF_LUKS_ITER_TIME(""),
        { /* end of list */ }
    },
};


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

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

    v = qobject_input_visitor_new_keyval(QOBJECT(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;

    case Q_CRYPTO_BLOCK_FORMAT_QCOW:
        visit_type_QCryptoBlockOptionsQCow_members(
            v, &ret->u.qcow, &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;
}


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

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

    v = qobject_input_visitor_new_keyval(QOBJECT(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;

    case Q_CRYPTO_BLOCK_FORMAT_QCOW:
        visit_type_QCryptoBlockOptionsQCow_members(
            v, &ret->u.qcow, &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;
    QDict *cryptoopts = NULL;

    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
                               false, errp);
    if (!bs->file) {
        return -EINVAL;
    }

    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;
    }

    cryptoopts = qemu_opts_to_qdict(opts, NULL);

    open_opts = block_crypto_open_opts_init(format, cryptoopts, 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;

    ret = 0;
 cleanup:
    QDECREF(cryptoopts);
    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,
    };
    QDict *cryptoopts;

    cryptoopts = qemu_opts_to_qdict(opts, NULL);

    create_opts = block_crypto_create_opts_init(format, cryptoopts, 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:
    QDECREF(cryptoopts);
    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,
                                 Error **errp)
{
    BlockCrypto *crypto = bs->opaque;
    size_t payload_offset =
        qcrypto_block_get_payload_offset(crypto->block);

    offset += payload_offset;

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

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