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

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