Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b8181f36 authored by Eric Biggers's avatar Eric Biggers
Browse files

BACKPORT, FROMGIT: crypto: chacha20-generic - refactor to allow varying number of rounds 



In preparation for adding XChaCha12 support, rename/refactor
chacha20-generic to support different numbers of rounds.  The
justification for needing XChaCha12 support is explained in more detail
in the patch "crypto: chacha - add XChaCha12 support".

The only difference between ChaCha{8,12,20} are the number of rounds
itself; all other parts of the algorithm are the same.  Therefore,
remove the "20" from all definitions, structures, functions, files, etc.
that will be shared by all ChaCha versions.

Also make ->setkey() store the round count in the chacha_ctx (previously
chacha20_ctx).  The generic code then passes the round count through to
chacha_block().  There will be a ->setkey() function for each explicitly
allowed round count; the encrypt/decrypt functions will be the same.  I
decided not to do it the opposite way (same ->setkey() function for all
round counts, with different encrypt/decrypt functions) because that
would have required more boilerplate code in architecture-specific
implementations of ChaCha and XChaCha.

Reviewed-by: default avatarArd Biesheuvel <ard.biesheuvel@linaro.org>
Acked-by: default avatarMartin Willi <martin@strongswan.org>
Signed-off-by: default avatarEric Biggers <ebiggers@google.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>

(cherry picked from commit 1ca1b917940c24ca3d1f490118c5474168622953
 https://git.kernel.org/pub/scm/linux/kernel/git/herbert/cryptodev-2.6.git

 master)

Conflicts:
	arch/arm/crypto/chacha20-neon-glue.c
	arch/arm64/crypto/chacha20-neon-glue.c
	arch/x86/crypto/chacha20_glue.c
	drivers/char/random.c
	drivers/crypto/caam/caamalg.c
	drivers/crypto/caam/caamalg_qi2.c
	drivers/crypto/caam/compat.h
	include/crypto/chacha20.h
	lib/Makefile

Bug: 112008522
Test: As series, see Ic61c13b53facfd2173065be715a7ee5f3af8760b
Change-Id: I7fa203ddc7095ce8675a32f49b8a5230cd0cf5f6
Signed-off-by: default avatarEric Biggers <ebiggers@google.com>
parent 1141ebc5

arch/arm/crypto/chacha20-neon-glue.c

+21 −21
Original line number Diff line number Diff line
@@ -19,7 +19,7 @@ 
 */



#include <crypto/algapi.h>

#include <crypto/chacha20.h>

#include <crypto/chacha.h>

#include <linux/crypto.h>

#include <linux/kernel.h>

#include <linux/module.h>
@@ -34,20 +34,20 @@ asmlinkage void chacha20_4block_xor_neon(u32 *state, u8 *dst, const u8 *src); 
static void chacha20_dosimd(u32 *state, u8 *dst, const u8 *src,

			    unsigned int bytes)

{

	u8 buf[CHACHA20_BLOCK_SIZE];

	u8 buf[CHACHA_BLOCK_SIZE];



	while (bytes >= CHACHA20_BLOCK_SIZE * 4) {

	while (bytes >= CHACHA_BLOCK_SIZE * 4) {

		chacha20_4block_xor_neon(state, dst, src);

		bytes -= CHACHA20_BLOCK_SIZE * 4;

		src += CHACHA20_BLOCK_SIZE * 4;

		dst += CHACHA20_BLOCK_SIZE * 4;

		bytes -= CHACHA_BLOCK_SIZE * 4;

		src += CHACHA_BLOCK_SIZE * 4;

		dst += CHACHA_BLOCK_SIZE * 4;

		state[12] += 4;

	}

	while (bytes >= CHACHA20_BLOCK_SIZE) {

	while (bytes >= CHACHA_BLOCK_SIZE) {

		chacha20_block_xor_neon(state, dst, src);

		bytes -= CHACHA20_BLOCK_SIZE;

		src += CHACHA20_BLOCK_SIZE;

		dst += CHACHA20_BLOCK_SIZE;

		bytes -= CHACHA_BLOCK_SIZE;

		src += CHACHA_BLOCK_SIZE;

		dst += CHACHA_BLOCK_SIZE;

		state[12]++;

	}

	if (bytes) {
@@ -64,22 +64,22 @@ static int chacha20_simd(struct blkcipher_desc *desc, struct scatterlist *dst, 
	u32 state[16];

	int err;



	if (nbytes <= CHACHA20_BLOCK_SIZE || !may_use_simd())

		return crypto_chacha20_crypt(desc, dst, src, nbytes);

	if (nbytes <= CHACHA_BLOCK_SIZE || !may_use_simd())

		return crypto_chacha_crypt(desc, dst, src, nbytes);



	desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;

	blkcipher_walk_init(&walk, dst, src, nbytes);

	err = blkcipher_walk_virt_block(desc, &walk, CHACHA20_BLOCK_SIZE);

	err = blkcipher_walk_virt_block(desc, &walk, CHACHA_BLOCK_SIZE);



	crypto_chacha20_init(state, crypto_blkcipher_ctx(desc->tfm), walk.iv);

	crypto_chacha_init(state, crypto_blkcipher_ctx(desc->tfm), walk.iv);



	kernel_neon_begin();



	while (walk.nbytes >= CHACHA20_BLOCK_SIZE) {

	while (walk.nbytes >= CHACHA_BLOCK_SIZE) {

		chacha20_dosimd(state, walk.dst.virt.addr, walk.src.virt.addr,

				rounddown(walk.nbytes, CHACHA20_BLOCK_SIZE));

				rounddown(walk.nbytes, CHACHA_BLOCK_SIZE));

		err = blkcipher_walk_done(desc, &walk,

					  walk.nbytes % CHACHA20_BLOCK_SIZE);

					  walk.nbytes % CHACHA_BLOCK_SIZE);

	}



	if (walk.nbytes) {
@@ -100,14 +100,14 @@ static struct crypto_alg alg = { 
	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= 1,

	.cra_type		= &crypto_blkcipher_type,

	.cra_ctxsize		= sizeof(struct chacha20_ctx),

	.cra_ctxsize		= sizeof(struct chacha_ctx),

	.cra_alignmask		= sizeof(u32) - 1,

	.cra_module		= THIS_MODULE,

	.cra_u			= {

		.blkcipher = {

			.min_keysize	= CHACHA20_KEY_SIZE,

			.max_keysize	= CHACHA20_KEY_SIZE,

			.ivsize		= CHACHA20_IV_SIZE,

			.min_keysize	= CHACHA_KEY_SIZE,

			.max_keysize	= CHACHA_KEY_SIZE,

			.ivsize		= CHACHA_IV_SIZE,

			.geniv		= "seqiv",

			.setkey		= crypto_chacha20_setkey,

			.encrypt	= chacha20_simd,

arch/x86/crypto/chacha20_glue.c

+25 −25
Original line number Diff line number Diff line
@@ -10,7 +10,7 @@ 
 */



#include <crypto/algapi.h>

#include <crypto/chacha20.h>

#include <crypto/chacha.h>

#include <linux/crypto.h>

#include <linux/kernel.h>

#include <linux/module.h>
@@ -29,31 +29,31 @@ static bool chacha20_use_avx2; 
static void chacha20_dosimd(u32 *state, u8 *dst, const u8 *src,

			    unsigned int bytes)

{

	u8 buf[CHACHA20_BLOCK_SIZE];

	u8 buf[CHACHA_BLOCK_SIZE];



#ifdef CONFIG_AS_AVX2

	if (chacha20_use_avx2) {

		while (bytes >= CHACHA20_BLOCK_SIZE * 8) {

		while (bytes >= CHACHA_BLOCK_SIZE * 8) {

			chacha20_8block_xor_avx2(state, dst, src);

			bytes -= CHACHA20_BLOCK_SIZE * 8;

			src += CHACHA20_BLOCK_SIZE * 8;

			dst += CHACHA20_BLOCK_SIZE * 8;

			bytes -= CHACHA_BLOCK_SIZE * 8;

			src += CHACHA_BLOCK_SIZE * 8;

			dst += CHACHA_BLOCK_SIZE * 8;

			state[12] += 8;

		}

	}

#endif

	while (bytes >= CHACHA20_BLOCK_SIZE * 4) {

	while (bytes >= CHACHA_BLOCK_SIZE * 4) {

		chacha20_4block_xor_ssse3(state, dst, src);

		bytes -= CHACHA20_BLOCK_SIZE * 4;

		src += CHACHA20_BLOCK_SIZE * 4;

		dst += CHACHA20_BLOCK_SIZE * 4;

		bytes -= CHACHA_BLOCK_SIZE * 4;

		src += CHACHA_BLOCK_SIZE * 4;

		dst += CHACHA_BLOCK_SIZE * 4;

		state[12] += 4;

	}

	while (bytes >= CHACHA20_BLOCK_SIZE) {

	while (bytes >= CHACHA_BLOCK_SIZE) {

		chacha20_block_xor_ssse3(state, dst, src);

		bytes -= CHACHA20_BLOCK_SIZE;

		src += CHACHA20_BLOCK_SIZE;

		dst += CHACHA20_BLOCK_SIZE;

		bytes -= CHACHA_BLOCK_SIZE;

		src += CHACHA_BLOCK_SIZE;

		dst += CHACHA_BLOCK_SIZE;

		state[12]++;

	}

	if (bytes) {
@@ -70,23 +70,23 @@ static int chacha20_simd(struct blkcipher_desc *desc, struct scatterlist *dst, 
	struct blkcipher_walk walk;

	int err;



	if (nbytes <= CHACHA20_BLOCK_SIZE || !may_use_simd())

		return crypto_chacha20_crypt(desc, dst, src, nbytes);

	if (nbytes <= CHACHA_BLOCK_SIZE || !may_use_simd())

		return crypto_chacha_crypt(desc, dst, src, nbytes);



	state = (u32 *)roundup((uintptr_t)state_buf, CHACHA20_STATE_ALIGN);



	blkcipher_walk_init(&walk, dst, src, nbytes);

	err = blkcipher_walk_virt_block(desc, &walk, CHACHA20_BLOCK_SIZE);

	err = blkcipher_walk_virt_block(desc, &walk, CHACHA_BLOCK_SIZE);



	crypto_chacha20_init(state, crypto_blkcipher_ctx(desc->tfm), walk.iv);

	crypto_chacha_init(state, crypto_blkcipher_ctx(desc->tfm), walk.iv);



	kernel_fpu_begin();



	while (walk.nbytes >= CHACHA20_BLOCK_SIZE) {

	while (walk.nbytes >= CHACHA_BLOCK_SIZE) {

		chacha20_dosimd(state, walk.dst.virt.addr, walk.src.virt.addr,

				rounddown(walk.nbytes, CHACHA20_BLOCK_SIZE));

				rounddown(walk.nbytes, CHACHA_BLOCK_SIZE));

		err = blkcipher_walk_done(desc, &walk,

					  walk.nbytes % CHACHA20_BLOCK_SIZE);

					  walk.nbytes % CHACHA_BLOCK_SIZE);

	}



	if (walk.nbytes) {
@@ -107,14 +107,14 @@ static struct crypto_alg alg = { 
	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= 1,

	.cra_type		= &crypto_blkcipher_type,

	.cra_ctxsize		= sizeof(struct chacha20_ctx),

	.cra_ctxsize		= sizeof(struct chacha_ctx),

	.cra_alignmask		= sizeof(u32) - 1,

	.cra_module		= THIS_MODULE,

	.cra_u			= {

		.blkcipher = {

			.min_keysize	= CHACHA20_KEY_SIZE,

			.max_keysize	= CHACHA20_KEY_SIZE,

			.ivsize		= CHACHA20_IV_SIZE,

			.min_keysize	= CHACHA_KEY_SIZE,

			.max_keysize	= CHACHA_KEY_SIZE,

			.ivsize		= CHACHA_IV_SIZE,

			.geniv		= "seqiv",

			.setkey		= crypto_chacha20_setkey,

			.encrypt	= chacha20_simd,

crypto/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -107,7 +107,7 @@ obj-$(CONFIG_CRYPTO_KHAZAD) += khazad.o 
obj-$(CONFIG_CRYPTO_ANUBIS) += anubis.o

obj-$(CONFIG_CRYPTO_SEED) += seed.o

obj-$(CONFIG_CRYPTO_SALSA20) += salsa20_generic.o

obj-$(CONFIG_CRYPTO_CHACHA20) += chacha20_generic.o

obj-$(CONFIG_CRYPTO_CHACHA20) += chacha_generic.o

obj-$(CONFIG_CRYPTO_POLY1305) += poly1305_generic.o

obj-$(CONFIG_CRYPTO_DEFLATE) += deflate.o

obj-$(CONFIG_CRYPTO_MICHAEL_MIC) += michael_mic.o

crypto/chacha20poly1305.c

+5 −5
Original line number Diff line number Diff line
@@ -13,7 +13,7 @@ 
#include <crypto/internal/hash.h>

#include <crypto/internal/skcipher.h>

#include <crypto/scatterwalk.h>

#include <crypto/chacha20.h>

#include <crypto/chacha.h>

#include <crypto/poly1305.h>

#include <linux/err.h>

#include <linux/init.h>
@@ -51,7 +51,7 @@ struct poly_req { 
};



struct chacha_req {

	u8 iv[CHACHA20_IV_SIZE];

	u8 iv[CHACHA_IV_SIZE];

	struct scatterlist src[1];

	struct skcipher_request req; /* must be last member */

};
@@ -91,7 +91,7 @@ static void chacha_iv(u8 *iv, struct aead_request *req, u32 icb) 
	memcpy(iv, &leicb, sizeof(leicb));

	memcpy(iv + sizeof(leicb), ctx->salt, ctx->saltlen);

	memcpy(iv + sizeof(leicb) + ctx->saltlen, req->iv,

	       CHACHA20_IV_SIZE - sizeof(leicb) - ctx->saltlen);

	       CHACHA_IV_SIZE - sizeof(leicb) - ctx->saltlen);

}



static int poly_verify_tag(struct aead_request *req)
@@ -494,7 +494,7 @@ static int chachapoly_setkey(struct crypto_aead *aead, const u8 *key, 
	struct chachapoly_ctx *ctx = crypto_aead_ctx(aead);

	int err;



	if (keylen != ctx->saltlen + CHACHA20_KEY_SIZE)

	if (keylen != ctx->saltlen + CHACHA_KEY_SIZE)

		return -EINVAL;



	keylen -= ctx->saltlen;
@@ -639,7 +639,7 @@ static int chachapoly_create(struct crypto_template *tmpl, struct rtattr **tb, 


	err = -EINVAL;

	/* Need 16-byte IV size, including Initial Block Counter value */

	if (crypto_skcipher_alg_ivsize(chacha) != CHACHA20_IV_SIZE)

	if (crypto_skcipher_alg_ivsize(chacha) != CHACHA_IV_SIZE)

		goto out_drop_chacha;

	/* Not a stream cipher? */

	if (chacha->base.cra_blocksize != 1)

crypto/chacha20_generic.c→crypto/chacha_generic.c

+66 −57
Original line number Diff line number Diff line
@@ -15,59 +15,60 @@ 
#include <linux/crypto.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <crypto/chacha20.h>

#include <crypto/chacha.h>



static void chacha20_docrypt(u32 *state, u8 *dst, const u8 *src,

			     unsigned int bytes)

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[CHACHA20_BLOCK_SIZE] __aligned(sizeof(long));

	u8 stream[CHACHA_BLOCK_SIZE] __aligned(sizeof(long));



	if (dst != src)

		memcpy(dst, src, bytes);



	while (bytes >= CHACHA20_BLOCK_SIZE) {

		chacha20_block(state, stream);

		crypto_xor(dst, stream, CHACHA20_BLOCK_SIZE);

		bytes -= CHACHA20_BLOCK_SIZE;

		dst += CHACHA20_BLOCK_SIZE;

	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) {

		chacha20_block(state, stream);

		chacha_block(state, stream, nrounds);

		crypto_xor(dst, stream, bytes);

	}

}



static int chacha20_stream_xor(struct blkcipher_desc *desc, struct scatterlist *dst,

static int chacha_stream_xor(struct blkcipher_desc *desc, struct scatterlist *dst,

			     struct scatterlist *src, unsigned int nbytes,

			       struct chacha20_ctx *ctx, u8 *iv)

			     struct chacha_ctx *ctx, u8 *iv)

{

	struct blkcipher_walk walk;

	u32 state[16];

	int err;



	blkcipher_walk_init(&walk, dst, src, nbytes);

	err = blkcipher_walk_virt_block(desc, &walk, CHACHA20_BLOCK_SIZE);

	err = blkcipher_walk_virt_block(desc, &walk, CHACHA_BLOCK_SIZE);



	crypto_chacha20_init(state, ctx, iv);

	crypto_chacha_init(state, ctx, iv);



	while (walk.nbytes >= CHACHA20_BLOCK_SIZE) {

		chacha20_docrypt(state, walk.dst.virt.addr, walk.src.virt.addr,

				 rounddown(walk.nbytes, CHACHA20_BLOCK_SIZE));

	while (walk.nbytes >= CHACHA_BLOCK_SIZE) {

		chacha_docrypt(state, walk.dst.virt.addr, walk.src.virt.addr,

			       rounddown(walk.nbytes, CHACHA_BLOCK_SIZE),

			       ctx->nrounds);

		err = blkcipher_walk_done(desc, &walk,

					  walk.nbytes % CHACHA20_BLOCK_SIZE);

					  walk.nbytes % CHACHA_BLOCK_SIZE);

	}



	if (walk.nbytes) {

		chacha20_docrypt(state, walk.dst.virt.addr, walk.src.virt.addr,

				 walk.nbytes);

		chacha_docrypt(state, walk.dst.virt.addr, walk.src.virt.addr,

			       walk.nbytes, ctx->nrounds);

		err = blkcipher_walk_done(desc, &walk, 0);

	}



	return err;

}



void crypto_chacha20_init(u32 *state, struct chacha20_ctx *ctx, u8 *iv)

void crypto_chacha_init(u32 *state, struct chacha_ctx *ctx, u8 *iv)

{

	state[0]  = 0x61707865; /* "expa" */

	state[1]  = 0x3320646e; /* "nd 3" */
@@ -86,55 +87,63 @@ void crypto_chacha20_init(u32 *state, struct chacha20_ctx *ctx, u8 *iv) 
	state[14] = get_unaligned_le32(iv +  8);

	state[15] = get_unaligned_le32(iv + 12);

}

EXPORT_SYMBOL_GPL(crypto_chacha20_init);

EXPORT_SYMBOL_GPL(crypto_chacha_init);



int crypto_chacha20_setkey(struct crypto_tfm *tfm, const u8 *key,

			   unsigned int keysize)

static int chacha_setkey(struct crypto_tfm *tfm, const u8 *key,

			 unsigned int keysize, int nrounds)

{

	struct chacha20_ctx *ctx = crypto_tfm_ctx(tfm);

	struct chacha_ctx *ctx = crypto_tfm_ctx(tfm);

	int i;



	if (keysize != CHACHA20_KEY_SIZE)

	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_tfm *tfm, const u8 *key,

			   unsigned int keysize)

{

	return chacha_setkey(tfm, key, keysize, 20);

}

EXPORT_SYMBOL_GPL(crypto_chacha20_setkey);



int crypto_chacha20_crypt(struct blkcipher_desc *desc, struct scatterlist *dst,

int crypto_chacha_crypt(struct blkcipher_desc *desc, struct scatterlist *dst,

			struct scatterlist *src, unsigned int nbytes)

{

	struct chacha20_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);

	struct chacha_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);

	u8 *iv = desc->info;



	return chacha20_stream_xor(desc, dst, src, nbytes, ctx, iv);

	return chacha_stream_xor(desc, dst, src, nbytes, ctx, iv);

}

EXPORT_SYMBOL_GPL(crypto_chacha20_crypt);

EXPORT_SYMBOL_GPL(crypto_chacha_crypt);



int crypto_xchacha20_crypt(struct blkcipher_desc *desc, struct scatterlist *dst,

int crypto_xchacha_crypt(struct blkcipher_desc *desc, struct scatterlist *dst,

			 struct scatterlist *src, unsigned int nbytes)

{

	struct chacha20_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);

	struct chacha_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);

	u8 *iv = desc->info;

	struct chacha20_ctx subctx;

	struct chacha_ctx subctx;

	u32 state[16];

	u8 real_iv[16];



	/* Compute the subkey given the original key and first 128 nonce bits */

	crypto_chacha20_init(state, ctx, iv);

	hchacha20_block(state, subctx.key);

	crypto_chacha_init(state, ctx, iv);

	hchacha_block(state, subctx.key, ctx->nrounds);

	subctx.nrounds = ctx->nrounds;



	/* Build the real IV */

	memcpy(&real_iv[0], iv + 24, 8); /* stream position */

	memcpy(&real_iv[8], iv + 16, 8); /* remaining 64 nonce bits */



	/* Generate the stream and XOR it with the data */

	return chacha20_stream_xor(desc, dst, src, nbytes, &subctx, real_iv);

	return chacha_stream_xor(desc, dst, src, nbytes, &subctx, real_iv);

}

EXPORT_SYMBOL_GPL(crypto_xchacha20_crypt);

EXPORT_SYMBOL_GPL(crypto_xchacha_crypt);



static struct crypto_alg algs[] = {

	{
@@ -144,18 +153,18 @@ static struct crypto_alg algs[] = { 
		.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

		.cra_blocksize		= 1,

		.cra_type		= &crypto_blkcipher_type,

		.cra_ctxsize		= sizeof(struct chacha20_ctx),

		.cra_ctxsize		= sizeof(struct chacha_ctx),

		.cra_alignmask		= sizeof(u32) - 1,

		.cra_module		= THIS_MODULE,

		.cra_u			= {

			.blkcipher = {

				.min_keysize	= CHACHA20_KEY_SIZE,

				.max_keysize	= CHACHA20_KEY_SIZE,

				.ivsize		= CHACHA20_IV_SIZE,

				.min_keysize	= CHACHA_KEY_SIZE,

				.max_keysize	= CHACHA_KEY_SIZE,

				.ivsize		= CHACHA_IV_SIZE,

				.geniv		= "seqiv",

				.setkey		= crypto_chacha20_setkey,

				.encrypt	= crypto_chacha20_crypt,

				.decrypt	= crypto_chacha20_crypt,

				.encrypt	= crypto_chacha_crypt,

				.decrypt	= crypto_chacha_crypt,

			},

		},

	}, {
@@ -165,39 +174,39 @@ static struct crypto_alg algs[] = { 
		.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

		.cra_blocksize		= 1,

		.cra_type		= &crypto_blkcipher_type,

		.cra_ctxsize		= sizeof(struct chacha20_ctx),

		.cra_ctxsize		= sizeof(struct chacha_ctx),

		.cra_alignmask		= sizeof(u32) - 1,

		.cra_module		= THIS_MODULE,

		.cra_u			= {

			.blkcipher = {

				.min_keysize	= CHACHA20_KEY_SIZE,

				.max_keysize	= CHACHA20_KEY_SIZE,

				.ivsize		= XCHACHA20_IV_SIZE,

				.min_keysize	= CHACHA_KEY_SIZE,

				.max_keysize	= CHACHA_KEY_SIZE,

				.ivsize		= XCHACHA_IV_SIZE,

				.geniv		= "seqiv",

				.setkey		= crypto_chacha20_setkey,

				.encrypt	= crypto_xchacha20_crypt,

				.decrypt	= crypto_xchacha20_crypt,

				.encrypt	= crypto_xchacha_crypt,

				.decrypt	= crypto_xchacha_crypt,

			},

		},

	},

};



static int __init chacha20_generic_mod_init(void)

static int __init chacha_generic_mod_init(void)

{

	return crypto_register_algs(algs, ARRAY_SIZE(algs));

}



static void __exit chacha20_generic_mod_fini(void)

static void __exit chacha_generic_mod_fini(void)

{

	crypto_unregister_algs(algs, ARRAY_SIZE(algs));

}



module_init(chacha20_generic_mod_init);

module_exit(chacha20_generic_mod_fini);

module_init(chacha_generic_mod_init);

module_exit(chacha_generic_mod_fini);



MODULE_LICENSE("GPL");

MODULE_AUTHOR("Martin Willi <martin@strongswan.org>");

MODULE_DESCRIPTION("ChaCha20 and XChaCha20 stream ciphers (generic)");

MODULE_DESCRIPTION("ChaCha and XChaCha stream ciphers (generic)");

MODULE_ALIAS_CRYPTO("chacha20");

MODULE_ALIAS_CRYPTO("chacha20-generic");

MODULE_ALIAS_CRYPTO("xchacha20");