[mirror_qemu.git] / crypto / cipher-gcrypt.c

/*
 * QEMU Crypto cipher libgcrypt algorithms
 *
 * Copyright (c) 2015 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 "crypto/xts.h"

#include <gcrypt.h>


bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg,
                             QCryptoCipherMode mode)
{
    switch (alg) {
    case QCRYPTO_CIPHER_ALG_DES_RFB:
    case QCRYPTO_CIPHER_ALG_3DES:
    case QCRYPTO_CIPHER_ALG_AES_128:
    case QCRYPTO_CIPHER_ALG_AES_192:
    case QCRYPTO_CIPHER_ALG_AES_256:
    case QCRYPTO_CIPHER_ALG_CAST5_128:
    case QCRYPTO_CIPHER_ALG_SERPENT_128:
    case QCRYPTO_CIPHER_ALG_SERPENT_192:
    case QCRYPTO_CIPHER_ALG_SERPENT_256:
    case QCRYPTO_CIPHER_ALG_TWOFISH_128:
    case QCRYPTO_CIPHER_ALG_TWOFISH_256:
        break;
    default:
        return false;
    }

    switch (mode) {
    case QCRYPTO_CIPHER_MODE_ECB:
    case QCRYPTO_CIPHER_MODE_CBC:
    case QCRYPTO_CIPHER_MODE_XTS:
    case QCRYPTO_CIPHER_MODE_CTR:
        return true;
    default:
        return false;
    }
}

typedef struct QCryptoCipherGcrypt QCryptoCipherGcrypt;
struct QCryptoCipherGcrypt {
    gcry_cipher_hd_t handle;
    gcry_cipher_hd_t tweakhandle;
    size_t blocksize;
    /* Initialization vector or Counter */
    uint8_t *iv;
};

static void gcrypt_cipher_free_ctx(QCryptoCipherGcrypt *ctx,
                                   QCryptoCipherMode mode)
{
    if (!ctx) {
        return;
    }

    gcry_cipher_close(ctx->handle);
    if (mode == QCRYPTO_CIPHER_MODE_XTS) {
        gcry_cipher_close(ctx->tweakhandle);
    }
    g_free(ctx->iv);
    g_free(ctx);
}


static QCryptoCipherGcrypt *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
                                                   QCryptoCipherMode mode,
                                                   const uint8_t *key,
                                                   size_t nkey,
                                                   Error **errp)
{
    QCryptoCipherGcrypt *ctx;
    gcry_error_t err;
    int gcryalg, gcrymode;

    switch (mode) {
    case QCRYPTO_CIPHER_MODE_ECB:
    case QCRYPTO_CIPHER_MODE_XTS:
        gcrymode = GCRY_CIPHER_MODE_ECB;
        break;
    case QCRYPTO_CIPHER_MODE_CBC:
        gcrymode = GCRY_CIPHER_MODE_CBC;
        break;
    case QCRYPTO_CIPHER_MODE_CTR:
        gcrymode = GCRY_CIPHER_MODE_CTR;
        break;
    default:
        error_setg(errp, "Unsupported cipher mode %s",
                   QCryptoCipherMode_lookup[mode]);
        return NULL;
    }

    if (!qcrypto_cipher_validate_key_length(alg, mode, nkey, errp)) {
        return NULL;
    }

    switch (alg) {
    case QCRYPTO_CIPHER_ALG_DES_RFB:
        gcryalg = GCRY_CIPHER_DES;
        break;

    case QCRYPTO_CIPHER_ALG_3DES:
        gcryalg = GCRY_CIPHER_3DES;
        break;

    case QCRYPTO_CIPHER_ALG_AES_128:
        gcryalg = GCRY_CIPHER_AES128;
        break;

    case QCRYPTO_CIPHER_ALG_AES_192:
        gcryalg = GCRY_CIPHER_AES192;
        break;

    case QCRYPTO_CIPHER_ALG_AES_256:
        gcryalg = GCRY_CIPHER_AES256;
        break;

    case QCRYPTO_CIPHER_ALG_CAST5_128:
        gcryalg = GCRY_CIPHER_CAST5;
        break;

    case QCRYPTO_CIPHER_ALG_SERPENT_128:
        gcryalg = GCRY_CIPHER_SERPENT128;
        break;

    case QCRYPTO_CIPHER_ALG_SERPENT_192:
        gcryalg = GCRY_CIPHER_SERPENT192;
        break;

    case QCRYPTO_CIPHER_ALG_SERPENT_256:
        gcryalg = GCRY_CIPHER_SERPENT256;
        break;

    case QCRYPTO_CIPHER_ALG_TWOFISH_128:
        gcryalg = GCRY_CIPHER_TWOFISH128;
        break;

    case QCRYPTO_CIPHER_ALG_TWOFISH_256:
        gcryalg = GCRY_CIPHER_TWOFISH;
        break;

    default:
        error_setg(errp, "Unsupported cipher algorithm %s",
                   QCryptoCipherAlgorithm_lookup[alg]);
        return NULL;
    }

    ctx = g_new0(QCryptoCipherGcrypt, 1);

    err = gcry_cipher_open(&ctx->handle, gcryalg, gcrymode, 0);
    if (err != 0) {
        error_setg(errp, "Cannot initialize cipher: %s",
                   gcry_strerror(err));
        goto error;
    }
    if (mode == QCRYPTO_CIPHER_MODE_XTS) {
        err = gcry_cipher_open(&ctx->tweakhandle, gcryalg, gcrymode, 0);
        if (err != 0) {
            error_setg(errp, "Cannot initialize cipher: %s",
                       gcry_strerror(err));
            goto error;
        }
    }

    if (alg == QCRYPTO_CIPHER_ALG_DES_RFB) {
        /* We're using standard DES cipher from gcrypt, so we need
         * to munge the key so that the results are the same as the
         * bizarre RFB variant of DES :-)
         */
        uint8_t *rfbkey = qcrypto_cipher_munge_des_rfb_key(key, nkey);
        err = gcry_cipher_setkey(ctx->handle, rfbkey, nkey);
        g_free(rfbkey);
        ctx->blocksize = 8;
    } else {
        if (mode == QCRYPTO_CIPHER_MODE_XTS) {
            nkey /= 2;
            err = gcry_cipher_setkey(ctx->handle, key, nkey);
            if (err != 0) {
                error_setg(errp, "Cannot set key: %s",
                           gcry_strerror(err));
                goto error;
            }
            err = gcry_cipher_setkey(ctx->tweakhandle, key + nkey, nkey);
        } else {
            err = gcry_cipher_setkey(ctx->handle, key, nkey);
        }
        if (err != 0) {
            error_setg(errp, "Cannot set key: %s",
                       gcry_strerror(err));
            goto error;
        }
        switch (alg) {
        case QCRYPTO_CIPHER_ALG_AES_128:
        case QCRYPTO_CIPHER_ALG_AES_192:
        case QCRYPTO_CIPHER_ALG_AES_256:
        case QCRYPTO_CIPHER_ALG_SERPENT_128:
        case QCRYPTO_CIPHER_ALG_SERPENT_192:
        case QCRYPTO_CIPHER_ALG_SERPENT_256:
        case QCRYPTO_CIPHER_ALG_TWOFISH_128:
        case QCRYPTO_CIPHER_ALG_TWOFISH_256:
            ctx->blocksize = 16;
            break;
        case QCRYPTO_CIPHER_ALG_3DES:
        case QCRYPTO_CIPHER_ALG_CAST5_128:
            ctx->blocksize = 8;
            break;
        default:
            g_assert_not_reached();
        }
    }

    if (mode == QCRYPTO_CIPHER_MODE_XTS) {
        if (ctx->blocksize != XTS_BLOCK_SIZE) {
            error_setg(errp,
                       "Cipher block size %zu must equal XTS block size %d",
                       ctx->blocksize, XTS_BLOCK_SIZE);
            goto error;
        }
        ctx->iv = g_new0(uint8_t, ctx->blocksize);
    }

    return ctx;

 error:
    gcrypt_cipher_free_ctx(ctx, mode);
    return NULL;
}


void qcrypto_cipher_free(QCryptoCipher *cipher)
{
    if (!cipher) {
        return;
    }
    gcrypt_cipher_free_ctx(cipher->opaque, cipher->mode);
    g_free(cipher);
}


static void qcrypto_gcrypt_xts_encrypt(const void *ctx,
                                       size_t length,
                                       uint8_t *dst,
                                       const uint8_t *src)
{
    gcry_error_t err;
    err = gcry_cipher_encrypt((gcry_cipher_hd_t)ctx, dst, length, src, length);
    g_assert(err == 0);
}

static void qcrypto_gcrypt_xts_decrypt(const void *ctx,
                                       size_t length,
                                       uint8_t *dst,
                                       const uint8_t *src)
{
    gcry_error_t err;
    err = gcry_cipher_decrypt((gcry_cipher_hd_t)ctx, dst, length, src, length);
    g_assert(err == 0);
}

int qcrypto_cipher_encrypt(QCryptoCipher *cipher,
                           const void *in,
                           void *out,
                           size_t len,
                           Error **errp)
{
    QCryptoCipherGcrypt *ctx = cipher->opaque;
    gcry_error_t err;

    if (len % ctx->blocksize) {
        error_setg(errp, "Length %zu must be a multiple of block size %zu",
                   len, ctx->blocksize);
        return -1;
    }

    if (cipher->mode == QCRYPTO_CIPHER_MODE_XTS) {
        xts_encrypt(ctx->handle, ctx->tweakhandle,
                    qcrypto_gcrypt_xts_encrypt,
                    qcrypto_gcrypt_xts_decrypt,
                    ctx->iv, len, out, in);
    } else {
        err = gcry_cipher_encrypt(ctx->handle,
                                  out, len,
                                  in, len);
        if (err != 0) {
            error_setg(errp, "Cannot encrypt data: %s",
                       gcry_strerror(err));
            return -1;
        }
    }

    return 0;
}


int qcrypto_cipher_decrypt(QCryptoCipher *cipher,
                           const void *in,
                           void *out,
                           size_t len,
                           Error **errp)
{
    QCryptoCipherGcrypt *ctx = cipher->opaque;
    gcry_error_t err;

    if (len % ctx->blocksize) {
        error_setg(errp, "Length %zu must be a multiple of block size %zu",
                   len, ctx->blocksize);
        return -1;
    }

    if (cipher->mode == QCRYPTO_CIPHER_MODE_XTS) {
        xts_decrypt(ctx->handle, ctx->tweakhandle,
                    qcrypto_gcrypt_xts_encrypt,
                    qcrypto_gcrypt_xts_decrypt,
                    ctx->iv, len, out, in);
    } else {
        err = gcry_cipher_decrypt(ctx->handle,
                                  out, len,
                                  in, len);
        if (err != 0) {
            error_setg(errp, "Cannot decrypt data: %s",
                       gcry_strerror(err));
            return -1;
        }
    }

    return 0;
}

int qcrypto_cipher_setiv(QCryptoCipher *cipher,
                         const uint8_t *iv, size_t niv,
                         Error **errp)
{
    QCryptoCipherGcrypt *ctx = cipher->opaque;
    gcry_error_t err;

    if (niv != ctx->blocksize) {
        error_setg(errp, "Expected IV size %zu not %zu",
                   ctx->blocksize, niv);
        return -1;
    }

    if (ctx->iv) {
        memcpy(ctx->iv, iv, niv);
    } else {
        if (cipher->mode == QCRYPTO_CIPHER_MODE_CTR) {
            err = gcry_cipher_setctr(ctx->handle, iv, niv);
            if (err != 0) {
                error_setg(errp, "Cannot set Counter: %s",
                       gcry_strerror(err));
                return -1;
            }
        } else {
            gcry_cipher_reset(ctx->handle);
            err = gcry_cipher_setiv(ctx->handle, iv, niv);
            if (err != 0) {
                error_setg(errp, "Cannot set IV: %s",
                       gcry_strerror(err));
                return -1;
            }
        }
    }

    return 0;
}


QCryptoCipher *qcrypto_cipher_new(QCryptoCipherAlgorithm alg,
                                  QCryptoCipherMode mode,
                                  const uint8_t *key, size_t nkey,
                                  Error **errp)
{
    QCryptoCipher *cipher;
    QCryptoCipherGcrypt *ctx;

    ctx = qcrypto_cipher_ctx_new(alg, mode, key, nkey, errp);
    if (!ctx) {
        return NULL;
    }

    cipher = g_new0(QCryptoCipher, 1);
    cipher->alg = alg;
    cipher->mode = mode;
    cipher->opaque = ctx;

    return cipher;
}
Commit	Line	Data
62893b67 DB	1	/*
	2	* QEMU Crypto cipher libgcrypt algorithms
	3	*
	4	* Copyright (c) 2015 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
42f7a448	21	#include "qemu/osdep.h"
eaec903c DB	22	#include "crypto/xts.h"
eaec903c DB	23
62893b67 DB	24	#include <gcrypt.h>
	25
	26
f844836d GA	27	bool qcrypto_cipher_supports(QCryptoCipherAlgorithm alg,
f844836d GA	28	QCryptoCipherMode mode)
62893b67 DB	29	{
	30	switch (alg) {
	31	case QCRYPTO_CIPHER_ALG_DES_RFB:
ffb7bf45	32	case QCRYPTO_CIPHER_ALG_3DES:
62893b67 DB	33	case QCRYPTO_CIPHER_ALG_AES_128:
	34	case QCRYPTO_CIPHER_ALG_AES_192:
	35	case QCRYPTO_CIPHER_ALG_AES_256:
084a85ee	36	case QCRYPTO_CIPHER_ALG_CAST5_128:
94318522 DB	37	case QCRYPTO_CIPHER_ALG_SERPENT_128:
	38	case QCRYPTO_CIPHER_ALG_SERPENT_192:
	39	case QCRYPTO_CIPHER_ALG_SERPENT_256:
50f6753e DB	40	case QCRYPTO_CIPHER_ALG_TWOFISH_128:
50f6753e DB	41	case QCRYPTO_CIPHER_ALG_TWOFISH_256:
f844836d GA	42	break;
	43	default:
	44	return false;
	45	}
	46
	47	switch (mode) {
	48	case QCRYPTO_CIPHER_MODE_ECB:
	49	case QCRYPTO_CIPHER_MODE_CBC:
	50	case QCRYPTO_CIPHER_MODE_XTS:
	51	case QCRYPTO_CIPHER_MODE_CTR:
62893b67 DB	52	return true;
	53	default:
	54	return false;
	55	}
	56	}
	57
3a661f1e DB	58	typedef struct QCryptoCipherGcrypt QCryptoCipherGcrypt;
	59	struct QCryptoCipherGcrypt {
	60	gcry_cipher_hd_t handle;
eaec903c	61	gcry_cipher_hd_t tweakhandle;
3a661f1e	62	size_t blocksize;
3c28292f	63	/* Initialization vector or Counter */
eaec903c	64	uint8_t *iv;
3a661f1e	65	};
62893b67	66
cc5eff01 LM	67	static void gcrypt_cipher_free_ctx(QCryptoCipherGcrypt *ctx,
	68	QCryptoCipherMode mode)
	69	{
	70	if (!ctx) {
	71	return;
	72	}
	73
	74	gcry_cipher_close(ctx->handle);
	75	if (mode == QCRYPTO_CIPHER_MODE_XTS) {
	76	gcry_cipher_close(ctx->tweakhandle);
	77	}
	78	g_free(ctx->iv);
	79	g_free(ctx);
	80	}
	81
	82
468fb271 LM	83	static QCryptoCipherGcrypt *qcrypto_cipher_ctx_new(QCryptoCipherAlgorithm alg,
	84	QCryptoCipherMode mode,
	85	const uint8_t *key,
	86	size_t nkey,
	87	Error **errp)
62893b67	88	{
3a661f1e	89	QCryptoCipherGcrypt *ctx;
62893b67 DB	90	gcry_error_t err;
	91	int gcryalg, gcrymode;
	92
	93	switch (mode) {
	94	case QCRYPTO_CIPHER_MODE_ECB:
eaec903c	95	case QCRYPTO_CIPHER_MODE_XTS:
62893b67 DB	96	gcrymode = GCRY_CIPHER_MODE_ECB;
	97	break;
	98	case QCRYPTO_CIPHER_MODE_CBC:
	99	gcrymode = GCRY_CIPHER_MODE_CBC;
	100	break;
3c28292f GA	101	case QCRYPTO_CIPHER_MODE_CTR:
	102	gcrymode = GCRY_CIPHER_MODE_CTR;
	103	break;
62893b67	104	default:
90d6f60d DB	105	error_setg(errp, "Unsupported cipher mode %s",
90d6f60d DB	106	QCryptoCipherMode_lookup[mode]);
62893b67 DB	107	return NULL;
	108	}
	109
eaec903c	110	if (!qcrypto_cipher_validate_key_length(alg, mode, nkey, errp)) {
62893b67 DB	111	return NULL;
	112	}
	113
	114	switch (alg) {
	115	case QCRYPTO_CIPHER_ALG_DES_RFB:
	116	gcryalg = GCRY_CIPHER_DES;
	117	break;
	118
ffb7bf45 LM	119	case QCRYPTO_CIPHER_ALG_3DES:
	120	gcryalg = GCRY_CIPHER_3DES;
	121	break;
	122
62893b67 DB	123	case QCRYPTO_CIPHER_ALG_AES_128:
	124	gcryalg = GCRY_CIPHER_AES128;
	125	break;
	126
	127	case QCRYPTO_CIPHER_ALG_AES_192:
	128	gcryalg = GCRY_CIPHER_AES192;
	129	break;
	130
	131	case QCRYPTO_CIPHER_ALG_AES_256:
	132	gcryalg = GCRY_CIPHER_AES256;
	133	break;
	134
084a85ee DB	135	case QCRYPTO_CIPHER_ALG_CAST5_128:
	136	gcryalg = GCRY_CIPHER_CAST5;
	137	break;
	138
94318522 DB	139	case QCRYPTO_CIPHER_ALG_SERPENT_128:
	140	gcryalg = GCRY_CIPHER_SERPENT128;
	141	break;
	142
	143	case QCRYPTO_CIPHER_ALG_SERPENT_192:
	144	gcryalg = GCRY_CIPHER_SERPENT192;
	145	break;
	146
	147	case QCRYPTO_CIPHER_ALG_SERPENT_256:
	148	gcryalg = GCRY_CIPHER_SERPENT256;
	149	break;
	150
50f6753e DB	151	case QCRYPTO_CIPHER_ALG_TWOFISH_128:
	152	gcryalg = GCRY_CIPHER_TWOFISH128;
	153	break;
	154
	155	case QCRYPTO_CIPHER_ALG_TWOFISH_256:
	156	gcryalg = GCRY_CIPHER_TWOFISH;
	157	break;
	158
62893b67	159	default:
90d6f60d DB	160	error_setg(errp, "Unsupported cipher algorithm %s",
90d6f60d DB	161	QCryptoCipherAlgorithm_lookup[alg]);
62893b67 DB	162	return NULL;
	163	}
	164
3a661f1e DB	165	ctx = g_new0(QCryptoCipherGcrypt, 1);
	166
	167	err = gcry_cipher_open(&ctx->handle, gcryalg, gcrymode, 0);
62893b67 DB	168	if (err != 0) {
	169	error_setg(errp, "Cannot initialize cipher: %s",
	170	gcry_strerror(err));
	171	goto error;
	172	}
468fb271	173	if (mode == QCRYPTO_CIPHER_MODE_XTS) {
eaec903c DB	174	err = gcry_cipher_open(&ctx->tweakhandle, gcryalg, gcrymode, 0);
	175	if (err != 0) {
	176	error_setg(errp, "Cannot initialize cipher: %s",
	177	gcry_strerror(err));
	178	goto error;
	179	}
	180	}
62893b67	181
468fb271	182	if (alg == QCRYPTO_CIPHER_ALG_DES_RFB) {
62893b67 DB	183	/* We're using standard DES cipher from gcrypt, so we need
	184	* to munge the key so that the results are the same as the
	185	* bizarre RFB variant of DES :-)
	186	*/
	187	uint8_t *rfbkey = qcrypto_cipher_munge_des_rfb_key(key, nkey);
3a661f1e	188	err = gcry_cipher_setkey(ctx->handle, rfbkey, nkey);
62893b67	189	g_free(rfbkey);
3a661f1e	190	ctx->blocksize = 8;
62893b67	191	} else {
468fb271	192	if (mode == QCRYPTO_CIPHER_MODE_XTS) {
eaec903c DB	193	nkey /= 2;
	194	err = gcry_cipher_setkey(ctx->handle, key, nkey);
	195	if (err != 0) {
	196	error_setg(errp, "Cannot set key: %s",
	197	gcry_strerror(err));
	198	goto error;
	199	}
	200	err = gcry_cipher_setkey(ctx->tweakhandle, key + nkey, nkey);
	201	} else {
	202	err = gcry_cipher_setkey(ctx->handle, key, nkey);
	203	}
	204	if (err != 0) {
	205	error_setg(errp, "Cannot set key: %s",
	206	gcry_strerror(err));
	207	goto error;
	208	}
468fb271	209	switch (alg) {
084a85ee DB	210	case QCRYPTO_CIPHER_ALG_AES_128:
	211	case QCRYPTO_CIPHER_ALG_AES_192:
	212	case QCRYPTO_CIPHER_ALG_AES_256:
94318522 DB	213	case QCRYPTO_CIPHER_ALG_SERPENT_128:
	214	case QCRYPTO_CIPHER_ALG_SERPENT_192:
	215	case QCRYPTO_CIPHER_ALG_SERPENT_256:
50f6753e DB	216	case QCRYPTO_CIPHER_ALG_TWOFISH_128:
50f6753e DB	217	case QCRYPTO_CIPHER_ALG_TWOFISH_256:
084a85ee DB	218	ctx->blocksize = 16;
084a85ee DB	219	break;
ffb7bf45	220	case QCRYPTO_CIPHER_ALG_3DES:
084a85ee DB	221	case QCRYPTO_CIPHER_ALG_CAST5_128:
	222	ctx->blocksize = 8;
	223	break;
	224	default:
	225	g_assert_not_reached();
	226	}
62893b67	227	}
eaec903c	228
468fb271	229	if (mode == QCRYPTO_CIPHER_MODE_XTS) {
a5d2f44d DB	230	if (ctx->blocksize != XTS_BLOCK_SIZE) {
	231	error_setg(errp,
	232	"Cipher block size %zu must equal XTS block size %d",
	233	ctx->blocksize, XTS_BLOCK_SIZE);
	234	goto error;
	235	}
eaec903c	236	ctx->iv = g_new0(uint8_t, ctx->blocksize);
62893b67 DB	237	}
62893b67 DB	238
468fb271	239	return ctx;
62893b67 DB	240
62893b67 DB	241	error:
cc5eff01	242	gcrypt_cipher_free_ctx(ctx, mode);
62893b67 DB	243	return NULL;
	244	}
	245
	246
	247	void qcrypto_cipher_free(QCryptoCipher *cipher)
	248	{
62893b67 DB	249	if (!cipher) {
	250	return;
	251	}
cc5eff01	252	gcrypt_cipher_free_ctx(cipher->opaque, cipher->mode);
62893b67 DB	253	g_free(cipher);
	254	}
	255
	256
eaec903c DB	257	static void qcrypto_gcrypt_xts_encrypt(const void *ctx,
	258	size_t length,
	259	uint8_t *dst,
	260	const uint8_t *src)
	261	{
	262	gcry_error_t err;
	263	err = gcry_cipher_encrypt((gcry_cipher_hd_t)ctx, dst, length, src, length);
	264	g_assert(err == 0);
	265	}
	266
	267	static void qcrypto_gcrypt_xts_decrypt(const void *ctx,
	268	size_t length,
	269	uint8_t *dst,
	270	const uint8_t *src)
	271	{
	272	gcry_error_t err;
	273	err = gcry_cipher_decrypt((gcry_cipher_hd_t)ctx, dst, length, src, length);
	274	g_assert(err == 0);
	275	}
	276
62893b67 DB	277	int qcrypto_cipher_encrypt(QCryptoCipher *cipher,
	278	const void *in,
	279	void *out,
	280	size_t len,
	281	Error **errp)
	282	{
3a661f1e	283	QCryptoCipherGcrypt *ctx = cipher->opaque;
62893b67 DB	284	gcry_error_t err;
62893b67 DB	285
3a661f1e DB	286	if (len % ctx->blocksize) {
	287	error_setg(errp, "Length %zu must be a multiple of block size %zu",
	288	len, ctx->blocksize);
	289	return -1;
	290	}
	291
eaec903c DB	292	if (cipher->mode == QCRYPTO_CIPHER_MODE_XTS) {
	293	xts_encrypt(ctx->handle, ctx->tweakhandle,
	294	qcrypto_gcrypt_xts_encrypt,
	295	qcrypto_gcrypt_xts_decrypt,
	296	ctx->iv, len, out, in);
	297	} else {
	298	err = gcry_cipher_encrypt(ctx->handle,
	299	out, len,
	300	in, len);
	301	if (err != 0) {
	302	error_setg(errp, "Cannot encrypt data: %s",
	303	gcry_strerror(err));
	304	return -1;
	305	}
62893b67 DB	306	}
	307
	308	return 0;
	309	}
	310
	311
	312	int qcrypto_cipher_decrypt(QCryptoCipher *cipher,
	313	const void *in,
	314	void *out,
	315	size_t len,
	316	Error **errp)
	317	{
3a661f1e	318	QCryptoCipherGcrypt *ctx = cipher->opaque;
62893b67 DB	319	gcry_error_t err;
62893b67 DB	320
3a661f1e DB	321	if (len % ctx->blocksize) {
	322	error_setg(errp, "Length %zu must be a multiple of block size %zu",
	323	len, ctx->blocksize);
	324	return -1;
	325	}
	326
eaec903c DB	327	if (cipher->mode == QCRYPTO_CIPHER_MODE_XTS) {
	328	xts_decrypt(ctx->handle, ctx->tweakhandle,
	329	qcrypto_gcrypt_xts_encrypt,
	330	qcrypto_gcrypt_xts_decrypt,
	331	ctx->iv, len, out, in);
	332	} else {
	333	err = gcry_cipher_decrypt(ctx->handle,
	334	out, len,
	335	in, len);
	336	if (err != 0) {
	337	error_setg(errp, "Cannot decrypt data: %s",
	338	gcry_strerror(err));
	339	return -1;
	340	}
62893b67 DB	341	}
	342
	343	return 0;
	344	}
	345
	346	int qcrypto_cipher_setiv(QCryptoCipher *cipher,
	347	const uint8_t *iv, size_t niv,
	348	Error **errp)
	349	{
3a661f1e	350	QCryptoCipherGcrypt *ctx = cipher->opaque;
62893b67 DB	351	gcry_error_t err;
62893b67 DB	352
3a661f1e DB	353	if (niv != ctx->blocksize) {
	354	error_setg(errp, "Expected IV size %zu not %zu",
	355	ctx->blocksize, niv);
	356	return -1;
	357	}
	358
eaec903c DB	359	if (ctx->iv) {
	360	memcpy(ctx->iv, iv, niv);
	361	} else {
3c28292f GA	362	if (cipher->mode == QCRYPTO_CIPHER_MODE_CTR) {
	363	err = gcry_cipher_setctr(ctx->handle, iv, niv);
	364	if (err != 0) {
	365	error_setg(errp, "Cannot set Counter: %s",
	366	gcry_strerror(err));
	367	return -1;
	368	}
	369	} else {
	370	gcry_cipher_reset(ctx->handle);
	371	err = gcry_cipher_setiv(ctx->handle, iv, niv);
	372	if (err != 0) {
	373	error_setg(errp, "Cannot set IV: %s",
	374	gcry_strerror(err));
	375	return -1;
	376	}
eaec903c	377	}
62893b67 DB	378	}
	379
	380	return 0;
	381	}
468fb271 LM	382
	383
	384	QCryptoCipher *qcrypto_cipher_new(QCryptoCipherAlgorithm alg,
	385	QCryptoCipherMode mode,
	386	const uint8_t *key, size_t nkey,
	387	Error **errp)
	388	{
	389	QCryptoCipher *cipher;
	390	QCryptoCipherGcrypt *ctx;
	391
	392	ctx = qcrypto_cipher_ctx_new(alg, mode, key, nkey, errp);
	393	if (!ctx) {
	394	return NULL;
	395	}
	396
	397	cipher = g_new0(QCryptoCipher, 1);
	398	cipher->alg = alg;
	399	cipher->mode = mode;
	400	cipher->opaque = ctx;
	401
	402	return cipher;
	403	}