[qemu.git] / crypto / cipher-afalg.c

/*
 * QEMU Crypto af_alg-backend cipher support
 *
 * Copyright (c) 2017 HUAWEI TECHNOLOGIES CO., LTD.
 *
 * Authors:
 *    Longpeng(Mike) <longpeng2@huawei.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or
 * (at your option) any later version.  See the COPYING file in the
 * top-level directory.
 */
#include "qemu/osdep.h"
#include "qemu/sockets.h"
#include "qemu-common.h"
#include "qapi/error.h"
#include "crypto/cipher.h"
#include "cipherpriv.h"


static char *
qcrypto_afalg_cipher_format_name(QCryptoCipherAlgorithm alg,
                                 QCryptoCipherMode mode,
                                 Error **errp)
{
    char *name;
    const char *alg_name;
    const char *mode_name;

    switch (alg) {
    case QCRYPTO_CIPHER_ALG_AES_128:
    case QCRYPTO_CIPHER_ALG_AES_192:
    case QCRYPTO_CIPHER_ALG_AES_256:
        alg_name = "aes";
        break;
    case QCRYPTO_CIPHER_ALG_CAST5_128:
        alg_name = "cast5";
        break;
    case QCRYPTO_CIPHER_ALG_SERPENT_128:
    case QCRYPTO_CIPHER_ALG_SERPENT_192:
    case QCRYPTO_CIPHER_ALG_SERPENT_256:
        alg_name = "serpent";
        break;
    case QCRYPTO_CIPHER_ALG_TWOFISH_128:
    case QCRYPTO_CIPHER_ALG_TWOFISH_192:
    case QCRYPTO_CIPHER_ALG_TWOFISH_256:
        alg_name = "twofish";
        break;

    default:
        error_setg(errp, "Unsupported cipher algorithm %d", alg);
        return NULL;
    }

    mode_name = QCryptoCipherMode_str(mode);
    name = g_strdup_printf("%s(%s)", mode_name, alg_name);

    return name;
}

static const struct QCryptoCipherDriver qcrypto_cipher_afalg_driver;

QCryptoCipher *
qcrypto_afalg_cipher_ctx_new(QCryptoCipherAlgorithm alg,
                             QCryptoCipherMode mode,
                             const uint8_t *key,
                             size_t nkey, Error **errp)
{
    QCryptoAFAlg *afalg;
    size_t expect_niv;
    char *name;

    name = qcrypto_afalg_cipher_format_name(alg, mode, errp);
    if (!name) {
        return NULL;
    }

    afalg = qcrypto_afalg_comm_alloc(AFALG_TYPE_CIPHER, name, errp);
    if (!afalg) {
        g_free(name);
        return NULL;
    }

    g_free(name);

    /* setkey */
    if (qemu_setsockopt(afalg->tfmfd, SOL_ALG, ALG_SET_KEY, key,
                        nkey) != 0) {
        error_setg_errno(errp, errno, "Set key failed");
        qcrypto_afalg_comm_free(afalg);
        return NULL;
    }

    /* prepare msg header */
    afalg->msg = g_new0(struct msghdr, 1);
    afalg->msg->msg_controllen += CMSG_SPACE(ALG_OPTYPE_LEN);
    expect_niv = qcrypto_cipher_get_iv_len(alg, mode);
    if (expect_niv) {
        afalg->msg->msg_controllen += CMSG_SPACE(ALG_MSGIV_LEN(expect_niv));
    }
    afalg->msg->msg_control = g_new0(uint8_t, afalg->msg->msg_controllen);

    /* We use 1st msghdr for crypto-info and 2nd msghdr for IV-info */
    afalg->cmsg = CMSG_FIRSTHDR(afalg->msg);
    afalg->cmsg->cmsg_type = ALG_SET_OP;
    afalg->cmsg->cmsg_len = CMSG_SPACE(ALG_OPTYPE_LEN);
    if (expect_niv) {
        afalg->cmsg = CMSG_NXTHDR(afalg->msg, afalg->cmsg);
        afalg->cmsg->cmsg_type = ALG_SET_IV;
        afalg->cmsg->cmsg_len = CMSG_SPACE(ALG_MSGIV_LEN(expect_niv));
    }
    afalg->cmsg = CMSG_FIRSTHDR(afalg->msg);

    afalg->base.driver = &qcrypto_cipher_afalg_driver;
    return &afalg->base;
}

static int
qcrypto_afalg_cipher_setiv(QCryptoCipher *cipher,
                           const uint8_t *iv,
                           size_t niv, Error **errp)
{
    QCryptoAFAlg *afalg = container_of(cipher, QCryptoAFAlg, base);
    struct af_alg_iv *alg_iv;
    size_t expect_niv;

    expect_niv = qcrypto_cipher_get_iv_len(cipher->alg, cipher->mode);
    if (niv != expect_niv) {
        error_setg(errp, "Set IV len(%zu) not match expected(%zu)",
                   niv, expect_niv);
        return -1;
    }

    /* move ->cmsg to next msghdr, for IV-info */
    afalg->cmsg = CMSG_NXTHDR(afalg->msg, afalg->cmsg);

    /* build setiv msg */
    afalg->cmsg->cmsg_level = SOL_ALG;
    alg_iv = (struct af_alg_iv *)CMSG_DATA(afalg->cmsg);
    alg_iv->ivlen = niv;
    memcpy(alg_iv->iv, iv, niv);

    return 0;
}

static int
qcrypto_afalg_cipher_op(QCryptoAFAlg *afalg,
                        const void *in, void *out,
                        size_t len, bool do_encrypt,
                        Error **errp)
{
    uint32_t *type = NULL;
    struct iovec iov;
    size_t ret, rlen, done = 0;
    uint32_t origin_controllen;

    origin_controllen = afalg->msg->msg_controllen;
    /* movev ->cmsg to first header, for crypto-info */
    afalg->cmsg = CMSG_FIRSTHDR(afalg->msg);

    /* build encrypt msg */
    afalg->cmsg->cmsg_level = SOL_ALG;
    afalg->msg->msg_iov = &iov;
    afalg->msg->msg_iovlen = 1;
    type = (uint32_t *)CMSG_DATA(afalg->cmsg);
    if (do_encrypt) {
        *type = ALG_OP_ENCRYPT;
    } else {
        *type = ALG_OP_DECRYPT;
    }

    do {
        iov.iov_base = (void *)in + done;
        iov.iov_len = len - done;

        /* send info to AF_ALG core */
        ret = sendmsg(afalg->opfd, afalg->msg, 0);
        if (ret == -1) {
            error_setg_errno(errp, errno, "Send data to AF_ALG core failed");
            return -1;
        }

        /* encrypto && get result */
        rlen = read(afalg->opfd, out, ret);
        if (rlen == -1) {
            error_setg_errno(errp, errno, "Get result from AF_ALG core failed");
            return -1;
        }
        assert(rlen == ret);

        /* do not update IV for following chunks */
        afalg->msg->msg_controllen = 0;
        done += ret;
    } while (done < len);

    afalg->msg->msg_controllen = origin_controllen;

    return 0;
}

static int
qcrypto_afalg_cipher_encrypt(QCryptoCipher *cipher,
                             const void *in, void *out,
                             size_t len, Error **errp)
{
    QCryptoAFAlg *afalg = container_of(cipher, QCryptoAFAlg, base);

    return qcrypto_afalg_cipher_op(afalg, in, out, len, true, errp);
}

static int
qcrypto_afalg_cipher_decrypt(QCryptoCipher *cipher,
                             const void *in, void *out,
                             size_t len, Error **errp)
{
    QCryptoAFAlg *afalg = container_of(cipher, QCryptoAFAlg, base);

    return qcrypto_afalg_cipher_op(afalg, in, out, len, false, errp);
}

static void qcrypto_afalg_comm_ctx_free(QCryptoCipher *cipher)
{
    QCryptoAFAlg *afalg = container_of(cipher, QCryptoAFAlg, base);

    qcrypto_afalg_comm_free(afalg);
}

static const struct QCryptoCipherDriver qcrypto_cipher_afalg_driver = {
    .cipher_encrypt = qcrypto_afalg_cipher_encrypt,
    .cipher_decrypt = qcrypto_afalg_cipher_decrypt,
    .cipher_setiv = qcrypto_afalg_cipher_setiv,
    .cipher_free = qcrypto_afalg_comm_ctx_free,
};
Commit	Line	Data
25c60df3 LM	1	/*
	2	* QEMU Crypto af_alg-backend cipher support
	3	*
	4	* Copyright (c) 2017 HUAWEI TECHNOLOGIES CO., LTD.
	5	*
	6	* Authors:
	7	* Longpeng(Mike) <longpeng2@huawei.com>
	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2 or
	10	* (at your option) any later version. See the COPYING file in the
	11	* top-level directory.
	12	*/
	13	#include "qemu/osdep.h"
	14	#include "qemu/sockets.h"
	15	#include "qemu-common.h"
	16	#include "qapi/error.h"
	17	#include "crypto/cipher.h"
	18	#include "cipherpriv.h"
	19
	20
	21	static char *
	22	qcrypto_afalg_cipher_format_name(QCryptoCipherAlgorithm alg,
	23	QCryptoCipherMode mode,
	24	Error **errp)
	25	{
	26	char *name;
	27	const char *alg_name;
	28	const char *mode_name;
	29
	30	switch (alg) {
	31	case QCRYPTO_CIPHER_ALG_AES_128:
	32	case QCRYPTO_CIPHER_ALG_AES_192:
	33	case QCRYPTO_CIPHER_ALG_AES_256:
	34	alg_name = "aes";
	35	break;
	36	case QCRYPTO_CIPHER_ALG_CAST5_128:
	37	alg_name = "cast5";
	38	break;
	39	case QCRYPTO_CIPHER_ALG_SERPENT_128:
	40	case QCRYPTO_CIPHER_ALG_SERPENT_192:
	41	case QCRYPTO_CIPHER_ALG_SERPENT_256:
	42	alg_name = "serpent";
	43	break;
	44	case QCRYPTO_CIPHER_ALG_TWOFISH_128:
	45	case QCRYPTO_CIPHER_ALG_TWOFISH_192:
	46	case QCRYPTO_CIPHER_ALG_TWOFISH_256:
	47	alg_name = "twofish";
	48	break;
	49
	50	default:
	51	error_setg(errp, "Unsupported cipher algorithm %d", alg);
	52	return NULL;
	53	}
	54
977c736f	55	mode_name = QCryptoCipherMode_str(mode);
25c60df3 LM	56	name = g_strdup_printf("%s(%s)", mode_name, alg_name);
	57
	58	return name;
	59	}
	60
da30cd77 RH	61	static const struct QCryptoCipherDriver qcrypto_cipher_afalg_driver;
da30cd77 RH	62
3eedf5cc	63	QCryptoCipher *
25c60df3 LM	64	qcrypto_afalg_cipher_ctx_new(QCryptoCipherAlgorithm alg,
	65	QCryptoCipherMode mode,
	66	const uint8_t *key,
	67	size_t nkey, Error **errp)
	68	{
	69	QCryptoAFAlg *afalg;
	70	size_t expect_niv;
	71	char *name;
	72
	73	name = qcrypto_afalg_cipher_format_name(alg, mode, errp);
	74	if (!name) {
	75	return NULL;
	76	}
	77
	78	afalg = qcrypto_afalg_comm_alloc(AFALG_TYPE_CIPHER, name, errp);
	79	if (!afalg) {
	80	g_free(name);
	81	return NULL;
	82	}
	83
	84	g_free(name);
	85
	86	/* setkey */
	87	if (qemu_setsockopt(afalg->tfmfd, SOL_ALG, ALG_SET_KEY, key,
	88	nkey) != 0) {
	89	error_setg_errno(errp, errno, "Set key failed");
	90	qcrypto_afalg_comm_free(afalg);
	91	return NULL;
	92	}
	93
	94	/* prepare msg header */
	95	afalg->msg = g_new0(struct msghdr, 1);
	96	afalg->msg->msg_controllen += CMSG_SPACE(ALG_OPTYPE_LEN);
	97	expect_niv = qcrypto_cipher_get_iv_len(alg, mode);
	98	if (expect_niv) {
	99	afalg->msg->msg_controllen += CMSG_SPACE(ALG_MSGIV_LEN(expect_niv));
	100	}
	101	afalg->msg->msg_control = g_new0(uint8_t, afalg->msg->msg_controllen);
	102
	103	/* We use 1st msghdr for crypto-info and 2nd msghdr for IV-info */
	104	afalg->cmsg = CMSG_FIRSTHDR(afalg->msg);
	105	afalg->cmsg->cmsg_type = ALG_SET_OP;
	106	afalg->cmsg->cmsg_len = CMSG_SPACE(ALG_OPTYPE_LEN);
	107	if (expect_niv) {
	108	afalg->cmsg = CMSG_NXTHDR(afalg->msg, afalg->cmsg);
	109	afalg->cmsg->cmsg_type = ALG_SET_IV;
	110	afalg->cmsg->cmsg_len = CMSG_SPACE(ALG_MSGIV_LEN(expect_niv));
	111	}
	112	afalg->cmsg = CMSG_FIRSTHDR(afalg->msg);
	113
da30cd77	114	afalg->base.driver = &qcrypto_cipher_afalg_driver;
3eedf5cc	115	return &afalg->base;
25c60df3 LM	116	}
	117
	118	static int
	119	qcrypto_afalg_cipher_setiv(QCryptoCipher *cipher,
	120	const uint8_t *iv,
	121	size_t niv, Error **errp)
	122	{
3eedf5cc	123	QCryptoAFAlg *afalg = container_of(cipher, QCryptoAFAlg, base);
25c60df3 LM	124	struct af_alg_iv *alg_iv;
25c60df3 LM	125	size_t expect_niv;
25c60df3 LM	126
	127	expect_niv = qcrypto_cipher_get_iv_len(cipher->alg, cipher->mode);
	128	if (niv != expect_niv) {
	129	error_setg(errp, "Set IV len(%zu) not match expected(%zu)",
	130	niv, expect_niv);
	131	return -1;
	132	}
	133
	134	/* move ->cmsg to next msghdr, for IV-info */
	135	afalg->cmsg = CMSG_NXTHDR(afalg->msg, afalg->cmsg);
	136
	137	/* build setiv msg */
	138	afalg->cmsg->cmsg_level = SOL_ALG;
	139	alg_iv = (struct af_alg_iv *)CMSG_DATA(afalg->cmsg);
	140	alg_iv->ivlen = niv;
	141	memcpy(alg_iv->iv, iv, niv);
	142
	143	return 0;
	144	}
	145
	146	static int
	147	qcrypto_afalg_cipher_op(QCryptoAFAlg *afalg,
	148	const void in, void out,
	149	size_t len, bool do_encrypt,
	150	Error **errp)
	151	{
	152	uint32_t *type = NULL;
	153	struct iovec iov;
	154	size_t ret, rlen, done = 0;
	155	uint32_t origin_controllen;
	156
	157	origin_controllen = afalg->msg->msg_controllen;
	158	/* movev ->cmsg to first header, for crypto-info */
	159	afalg->cmsg = CMSG_FIRSTHDR(afalg->msg);
	160
	161	/* build encrypt msg */
	162	afalg->cmsg->cmsg_level = SOL_ALG;
	163	afalg->msg->msg_iov = &iov;
	164	afalg->msg->msg_iovlen = 1;
	165	type = (uint32_t *)CMSG_DATA(afalg->cmsg);
	166	if (do_encrypt) {
	167	*type = ALG_OP_ENCRYPT;
	168	} else {
	169	*type = ALG_OP_DECRYPT;
	170	}
	171
	172	do {
	173	iov.iov_base = (void *)in + done;
	174	iov.iov_len = len - done;
	175
	176	/* send info to AF_ALG core */
	177	ret = sendmsg(afalg->opfd, afalg->msg, 0);
	178	if (ret == -1) {
	179	error_setg_errno(errp, errno, "Send data to AF_ALG core failed");
	180	return -1;
	181	}
	182
	183	/* encrypto && get result */
	184	rlen = read(afalg->opfd, out, ret);
	185	if (rlen == -1) {
	186	error_setg_errno(errp, errno, "Get result from AF_ALG core failed");
	187	return -1;
	188	}
	189	assert(rlen == ret);
190
191	/* do not update IV for following chunks */
192	afalg->msg->msg_controllen = 0;
193	done += ret;
194	} while (done < len);
195
196	afalg->msg->msg_controllen = origin_controllen;
197
198	return 0;
199	}
200
201	static int
202	qcrypto_afalg_cipher_encrypt(QCryptoCipher *cipher,
203	const void in, void out,
204	size_t len, Error **errp)
205	{
3eedf5cc RH	206	QCryptoAFAlg *afalg = container_of(cipher, QCryptoAFAlg, base);
	207
	208	return qcrypto_afalg_cipher_op(afalg, in, out, len, true, errp);
25c60df3 LM	209	}
	210
	211	static int
	212	qcrypto_afalg_cipher_decrypt(QCryptoCipher *cipher,
	213	const void in, void out,
	214	size_t len, Error **errp)
	215	{
3eedf5cc RH	216	QCryptoAFAlg *afalg = container_of(cipher, QCryptoAFAlg, base);
	217
	218	return qcrypto_afalg_cipher_op(afalg, in, out, len, false, errp);
25c60df3 LM	219	}
	220
	221	static void qcrypto_afalg_comm_ctx_free(QCryptoCipher *cipher)
	222	{
3eedf5cc RH	223	QCryptoAFAlg *afalg = container_of(cipher, QCryptoAFAlg, base);
	224
	225	qcrypto_afalg_comm_free(afalg);
25c60df3 LM	226	}
25c60df3 LM	227
da30cd77	228	static const struct QCryptoCipherDriver qcrypto_cipher_afalg_driver = {
25c60df3 LM	229	.cipher_encrypt = qcrypto_afalg_cipher_encrypt,
	230	.cipher_decrypt = qcrypto_afalg_cipher_decrypt,
	231	.cipher_setiv = qcrypto_afalg_cipher_setiv,
	232	.cipher_free = qcrypto_afalg_comm_ctx_free,
	233	};