[linux-2.6-block.git] / crypto / chacha_generic.c

/*
 * ChaCha and XChaCha stream ciphers, including ChaCha20 (RFC7539)
 *
 * Copyright (C) 2015 Martin Willi
 * Copyright (C) 2018 Google LLC
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <asm/unaligned.h>
#include <crypto/algapi.h>
#include <crypto/chacha.h>
#include <crypto/internal/skcipher.h>
#include <linux/module.h>

static void chacha_docrypt(u32 *state, u8 *dst, const u8 *src,
			   unsigned int bytes, int nrounds)
{
	/* aligned to potentially speed up crypto_xor() */
	u8 stream[CHACHA_BLOCK_SIZE] __aligned(sizeof(long));

	if (dst != src)
		memcpy(dst, src, bytes);

	while (bytes >= CHACHA_BLOCK_SIZE) {
		chacha_block(state, stream, nrounds);
		crypto_xor(dst, stream, CHACHA_BLOCK_SIZE);
		bytes -= CHACHA_BLOCK_SIZE;
		dst += CHACHA_BLOCK_SIZE;
	}
	if (bytes) {
		chacha_block(state, stream, nrounds);
		crypto_xor(dst, stream, bytes);
	}
}

static int chacha_stream_xor(struct skcipher_request *req,
			     struct chacha_ctx *ctx, u8 *iv)
{
	struct skcipher_walk walk;
	u32 state[16];
	int err;

	err = skcipher_walk_virt(&walk, req, false);

	crypto_chacha_init(state, ctx, iv);

	while (walk.nbytes > 0) {
		unsigned int nbytes = walk.nbytes;

		if (nbytes < walk.total)
			nbytes = round_down(nbytes, walk.stride);

		chacha_docrypt(state, walk.dst.virt.addr, walk.src.virt.addr,
			       nbytes, ctx->nrounds);
		err = skcipher_walk_done(&walk, walk.nbytes - nbytes);
	}

	return err;
}

void crypto_chacha_init(u32 *state, struct chacha_ctx *ctx, u8 *iv)
{
	state[0]  = 0x61707865; /* "expa" */
	state[1]  = 0x3320646e; /* "nd 3" */
	state[2]  = 0x79622d32; /* "2-by" */
	state[3]  = 0x6b206574; /* "te k" */
	state[4]  = ctx->key[0];
	state[5]  = ctx->key[1];
	state[6]  = ctx->key[2];
	state[7]  = ctx->key[3];
	state[8]  = ctx->key[4];
	state[9]  = ctx->key[5];
	state[10] = ctx->key[6];
	state[11] = ctx->key[7];
	state[12] = get_unaligned_le32(iv +  0);
	state[13] = get_unaligned_le32(iv +  4);
	state[14] = get_unaligned_le32(iv +  8);
	state[15] = get_unaligned_le32(iv + 12);
}
EXPORT_SYMBOL_GPL(crypto_chacha_init);

static int chacha_setkey(struct crypto_skcipher *tfm, const u8 *key,
			 unsigned int keysize, int nrounds)
{
	struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);
	int i;

	if (keysize != CHACHA_KEY_SIZE)
		return -EINVAL;

	for (i = 0; i < ARRAY_SIZE(ctx->key); i++)
		ctx->key[i] = get_unaligned_le32(key + i * sizeof(u32));

	ctx->nrounds = nrounds;
	return 0;
}

int crypto_chacha20_setkey(struct crypto_skcipher *tfm, const u8 *key,
			   unsigned int keysize)
{
	return chacha_setkey(tfm, key, keysize, 20);
}
EXPORT_SYMBOL_GPL(crypto_chacha20_setkey);

int crypto_chacha12_setkey(struct crypto_skcipher *tfm, const u8 *key,
			   unsigned int keysize)
{
	return chacha_setkey(tfm, key, keysize, 12);
}
EXPORT_SYMBOL_GPL(crypto_chacha12_setkey);

int crypto_chacha_crypt(struct skcipher_request *req)
{
	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
	struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);

	return chacha_stream_xor(req, ctx, req->iv);
}
EXPORT_SYMBOL_GPL(crypto_chacha_crypt);

int crypto_xchacha_crypt(struct skcipher_request *req)
{
	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
	struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);
	struct chacha_ctx subctx;
	u32 state[16];
	u8 real_iv[16];

	/* Compute the subkey given the original key and first 128 nonce bits */
	crypto_chacha_init(state, ctx, req->iv);
	hchacha_block(state, subctx.key, ctx->nrounds);
	subctx.nrounds = ctx->nrounds;

	/* Build the real IV */
	memcpy(&real_iv[0], req->iv + 24, 8); /* stream position */
	memcpy(&real_iv[8], req->iv + 16, 8); /* remaining 64 nonce bits */

	/* Generate the stream and XOR it with the data */
	return chacha_stream_xor(req, &subctx, real_iv);
}
EXPORT_SYMBOL_GPL(crypto_xchacha_crypt);

static struct skcipher_alg algs[] = {
	{
		.base.cra_name		= "chacha20",
		.base.cra_driver_name	= "chacha20-generic",
		.base.cra_priority	= 100,
		.base.cra_blocksize	= 1,
		.base.cra_ctxsize	= sizeof(struct chacha_ctx),
		.base.cra_module	= THIS_MODULE,

		.min_keysize		= CHACHA_KEY_SIZE,
		.max_keysize		= CHACHA_KEY_SIZE,
		.ivsize			= CHACHA_IV_SIZE,
		.chunksize		= CHACHA_BLOCK_SIZE,
		.setkey			= crypto_chacha20_setkey,
		.encrypt		= crypto_chacha_crypt,
		.decrypt		= crypto_chacha_crypt,
	}, {
		.base.cra_name		= "xchacha20",
		.base.cra_driver_name	= "xchacha20-generic",
		.base.cra_priority	= 100,
		.base.cra_blocksize	= 1,
		.base.cra_ctxsize	= sizeof(struct chacha_ctx),
		.base.cra_module	= THIS_MODULE,

		.min_keysize		= CHACHA_KEY_SIZE,
		.max_keysize		= CHACHA_KEY_SIZE,
		.ivsize			= XCHACHA_IV_SIZE,
		.chunksize		= CHACHA_BLOCK_SIZE,
		.setkey			= crypto_chacha20_setkey,
		.encrypt		= crypto_xchacha_crypt,
		.decrypt		= crypto_xchacha_crypt,
	}, {
		.base.cra_name		= "xchacha12",
		.base.cra_driver_name	= "xchacha12-generic",
		.base.cra_priority	= 100,
		.base.cra_blocksize	= 1,
		.base.cra_ctxsize	= sizeof(struct chacha_ctx),
		.base.cra_module	= THIS_MODULE,

		.min_keysize		= CHACHA_KEY_SIZE,
		.max_keysize		= CHACHA_KEY_SIZE,
		.ivsize			= XCHACHA_IV_SIZE,
		.chunksize		= CHACHA_BLOCK_SIZE,
		.setkey			= crypto_chacha12_setkey,
		.encrypt		= crypto_xchacha_crypt,
		.decrypt		= crypto_xchacha_crypt,
	}
};

static int __init chacha_generic_mod_init(void)
{
	return crypto_register_skciphers(algs, ARRAY_SIZE(algs));
}

static void __exit chacha_generic_mod_fini(void)
{
	crypto_unregister_skciphers(algs, ARRAY_SIZE(algs));
}

module_init(chacha_generic_mod_init);
module_exit(chacha_generic_mod_fini);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Martin Willi <martin@strongswan.org>");
MODULE_DESCRIPTION("ChaCha and XChaCha stream ciphers (generic)");
MODULE_ALIAS_CRYPTO("chacha20");
MODULE_ALIAS_CRYPTO("chacha20-generic");
MODULE_ALIAS_CRYPTO("xchacha20");
MODULE_ALIAS_CRYPTO("xchacha20-generic");
MODULE_ALIAS_CRYPTO("xchacha12");
MODULE_ALIAS_CRYPTO("xchacha12-generic");
Commit	Line	Data
c08d0e64	1	/*
aa762409	2	* ChaCha and XChaCha stream ciphers, including ChaCha20 (RFC7539)
c08d0e64 MW	3	*
c08d0e64 MW	4	* Copyright (C) 2015 Martin Willi
de61d7ae	5	* Copyright (C) 2018 Google LLC
c08d0e64 MW	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*/
	12
dbd872a1	13	#include <asm/unaligned.h>
c08d0e64	14	#include <crypto/algapi.h>
1ca1b917	15	#include <crypto/chacha.h>
9ae433bc AB	16	#include <crypto/internal/skcipher.h>
9ae433bc AB	17	#include <linux/module.h>
c08d0e64	18
1ca1b917 EB	19	static void chacha_docrypt(u32 state, u8 dst, const u8 *src,
1ca1b917 EB	20	unsigned int bytes, int nrounds)
c08d0e64	21	{
a5e9f557	22	/* aligned to potentially speed up crypto_xor() */
1ca1b917	23	u8 stream[CHACHA_BLOCK_SIZE] __aligned(sizeof(long));
c08d0e64 MW	24
	25	if (dst != src)
	26	memcpy(dst, src, bytes);
	27
1ca1b917 EB	28	while (bytes >= CHACHA_BLOCK_SIZE) {
	29	chacha_block(state, stream, nrounds);
	30	crypto_xor(dst, stream, CHACHA_BLOCK_SIZE);
	31	bytes -= CHACHA_BLOCK_SIZE;
	32	dst += CHACHA_BLOCK_SIZE;
c08d0e64 MW	33	}
c08d0e64 MW	34	if (bytes) {
1ca1b917	35	chacha_block(state, stream, nrounds);
a5e9f557	36	crypto_xor(dst, stream, bytes);
c08d0e64 MW	37	}
	38	}
	39
1ca1b917 EB	40	static int chacha_stream_xor(struct skcipher_request *req,
1ca1b917 EB	41	struct chacha_ctx ctx, u8 iv)
de61d7ae EB	42	{
	43	struct skcipher_walk walk;
	44	u32 state[16];
	45	int err;
	46
	47	err = skcipher_walk_virt(&walk, req, false);
	48
1ca1b917	49	crypto_chacha_init(state, ctx, iv);
de61d7ae EB	50
	51	while (walk.nbytes > 0) {
	52	unsigned int nbytes = walk.nbytes;
	53
	54	if (nbytes < walk.total)
	55	nbytes = round_down(nbytes, walk.stride);
	56
1ca1b917 EB	57	chacha_docrypt(state, walk.dst.virt.addr, walk.src.virt.addr,
1ca1b917 EB	58	nbytes, ctx->nrounds);
de61d7ae EB	59	err = skcipher_walk_done(&walk, walk.nbytes - nbytes);
	60	}
	61
	62	return err;
	63	}
	64
1ca1b917	65	void crypto_chacha_init(u32 state, struct chacha_ctx ctx, u8 *iv)
c08d0e64	66	{
ecf3220d EB	67	state[0] = 0x61707865; /* "expa" */
	68	state[1] = 0x3320646e; /* "nd 3" */
	69	state[2] = 0x79622d32; /* "2-by" */
	70	state[3] = 0x6b206574; /* "te k" */
c08d0e64 MW	71	state[4] = ctx->key[0];
	72	state[5] = ctx->key[1];
	73	state[6] = ctx->key[2];
	74	state[7] = ctx->key[3];
	75	state[8] = ctx->key[4];
	76	state[9] = ctx->key[5];
	77	state[10] = ctx->key[6];
	78	state[11] = ctx->key[7];
dbd872a1 EB	79	state[12] = get_unaligned_le32(iv + 0);
	80	state[13] = get_unaligned_le32(iv + 4);
	81	state[14] = get_unaligned_le32(iv + 8);
	82	state[15] = get_unaligned_le32(iv + 12);
c08d0e64	83	}
1ca1b917	84	EXPORT_SYMBOL_GPL(crypto_chacha_init);
c08d0e64	85
1ca1b917 EB	86	static int chacha_setkey(struct crypto_skcipher tfm, const u8 key,
1ca1b917 EB	87	unsigned int keysize, int nrounds)
c08d0e64	88	{
1ca1b917	89	struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);
c08d0e64 MW	90	int i;
c08d0e64 MW	91
1ca1b917	92	if (keysize != CHACHA_KEY_SIZE)
c08d0e64 MW	93	return -EINVAL;
	94
	95	for (i = 0; i < ARRAY_SIZE(ctx->key); i++)
dbd872a1	96	ctx->key[i] = get_unaligned_le32(key + i * sizeof(u32));
c08d0e64	97
1ca1b917	98	ctx->nrounds = nrounds;
c08d0e64 MW	99	return 0;
c08d0e64 MW	100	}
1ca1b917 EB	101
	102	int crypto_chacha20_setkey(struct crypto_skcipher tfm, const u8 key,
	103	unsigned int keysize)
	104	{
	105	return chacha_setkey(tfm, key, keysize, 20);
	106	}
31d7247d	107	EXPORT_SYMBOL_GPL(crypto_chacha20_setkey);
c08d0e64	108
aa762409 EB	109	int crypto_chacha12_setkey(struct crypto_skcipher tfm, const u8 key,
	110	unsigned int keysize)
	111	{
	112	return chacha_setkey(tfm, key, keysize, 12);
	113	}
	114	EXPORT_SYMBOL_GPL(crypto_chacha12_setkey);
	115
1ca1b917	116	int crypto_chacha_crypt(struct skcipher_request *req)
c08d0e64	117	{
9ae433bc	118	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
1ca1b917	119	struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);
c08d0e64	120
1ca1b917	121	return chacha_stream_xor(req, ctx, req->iv);
de61d7ae	122	}
1ca1b917	123	EXPORT_SYMBOL_GPL(crypto_chacha_crypt);
c08d0e64	124
1ca1b917	125	int crypto_xchacha_crypt(struct skcipher_request *req)
de61d7ae EB	126	{
de61d7ae EB	127	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
1ca1b917 EB	128	struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);
1ca1b917 EB	129	struct chacha_ctx subctx;
de61d7ae EB	130	u32 state[16];
de61d7ae EB	131	u8 real_iv[16];
4de43726	132
de61d7ae	133	/* Compute the subkey given the original key and first 128 nonce bits */
1ca1b917 EB	134	crypto_chacha_init(state, ctx, req->iv);
	135	hchacha_block(state, subctx.key, ctx->nrounds);
	136	subctx.nrounds = ctx->nrounds;
4de43726	137
de61d7ae EB	138	/* Build the real IV */
	139	memcpy(&real_iv[0], req->iv + 24, 8); /* stream position */
	140	memcpy(&real_iv[8], req->iv + 16, 8); /* remaining 64 nonce bits */
c08d0e64	141
de61d7ae	142	/* Generate the stream and XOR it with the data */
1ca1b917	143	return chacha_stream_xor(req, &subctx, real_iv);
c08d0e64	144	}
1ca1b917	145	EXPORT_SYMBOL_GPL(crypto_xchacha_crypt);
de61d7ae EB	146
	147	static struct skcipher_alg algs[] = {
	148	{
	149	.base.cra_name = "chacha20",
	150	.base.cra_driver_name = "chacha20-generic",
	151	.base.cra_priority = 100,
	152	.base.cra_blocksize = 1,
1ca1b917	153	.base.cra_ctxsize = sizeof(struct chacha_ctx),
de61d7ae EB	154	.base.cra_module = THIS_MODULE,
de61d7ae EB	155
1ca1b917 EB	156	.min_keysize = CHACHA_KEY_SIZE,
	157	.max_keysize = CHACHA_KEY_SIZE,
	158	.ivsize = CHACHA_IV_SIZE,
	159	.chunksize = CHACHA_BLOCK_SIZE,
de61d7ae	160	.setkey = crypto_chacha20_setkey,
1ca1b917 EB	161	.encrypt = crypto_chacha_crypt,
1ca1b917 EB	162	.decrypt = crypto_chacha_crypt,
de61d7ae EB	163	}, {
	164	.base.cra_name = "xchacha20",
	165	.base.cra_driver_name = "xchacha20-generic",
	166	.base.cra_priority = 100,
	167	.base.cra_blocksize = 1,
1ca1b917	168	.base.cra_ctxsize = sizeof(struct chacha_ctx),
de61d7ae EB	169	.base.cra_module = THIS_MODULE,
de61d7ae EB	170
1ca1b917 EB	171	.min_keysize = CHACHA_KEY_SIZE,
	172	.max_keysize = CHACHA_KEY_SIZE,
	173	.ivsize = XCHACHA_IV_SIZE,
	174	.chunksize = CHACHA_BLOCK_SIZE,
de61d7ae	175	.setkey = crypto_chacha20_setkey,
1ca1b917 EB	176	.encrypt = crypto_xchacha_crypt,
1ca1b917 EB	177	.decrypt = crypto_xchacha_crypt,
aa762409 EB	178	}, {
	179	.base.cra_name = "xchacha12",
	180	.base.cra_driver_name = "xchacha12-generic",
	181	.base.cra_priority = 100,
	182	.base.cra_blocksize = 1,
	183	.base.cra_ctxsize = sizeof(struct chacha_ctx),
	184	.base.cra_module = THIS_MODULE,
	185
	186	.min_keysize = CHACHA_KEY_SIZE,
	187	.max_keysize = CHACHA_KEY_SIZE,
	188	.ivsize = XCHACHA_IV_SIZE,
	189	.chunksize = CHACHA_BLOCK_SIZE,
	190	.setkey = crypto_chacha12_setkey,
	191	.encrypt = crypto_xchacha_crypt,
	192	.decrypt = crypto_xchacha_crypt,
de61d7ae	193	}
c08d0e64 MW	194	};
c08d0e64 MW	195
1ca1b917	196	static int __init chacha_generic_mod_init(void)
c08d0e64	197	{
de61d7ae	198	return crypto_register_skciphers(algs, ARRAY_SIZE(algs));
c08d0e64 MW	199	}
c08d0e64 MW	200
1ca1b917	201	static void __exit chacha_generic_mod_fini(void)
c08d0e64	202	{
de61d7ae	203	crypto_unregister_skciphers(algs, ARRAY_SIZE(algs));
c08d0e64 MW	204	}
c08d0e64 MW	205
1ca1b917 EB	206	module_init(chacha_generic_mod_init);
1ca1b917 EB	207	module_exit(chacha_generic_mod_fini);
c08d0e64 MW	208
	209	MODULE_LICENSE("GPL");
	210	MODULE_AUTHOR("Martin Willi <martin@strongswan.org>");
1ca1b917	211	MODULE_DESCRIPTION("ChaCha and XChaCha stream ciphers (generic)");
c08d0e64 MW	212	MODULE_ALIAS_CRYPTO("chacha20");
c08d0e64 MW	213	MODULE_ALIAS_CRYPTO("chacha20-generic");
de61d7ae EB	214	MODULE_ALIAS_CRYPTO("xchacha20");
de61d7ae EB	215	MODULE_ALIAS_CRYPTO("xchacha20-generic");
aa762409 EB	216	MODULE_ALIAS_CRYPTO("xchacha12");
aa762409 EB	217	MODULE_ALIAS_CRYPTO("xchacha12-generic");