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

/*
 * Cryptographic API.
 *
 * SHA-3, as specified in
 * http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf
 *
 * SHA-3 code by Jeff Garzik <jeff@garzik.org>
 *               Ard Biesheuvel <ard.biesheuvel@linaro.org>
 *
 * 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 <crypto/internal/hash.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <crypto/sha3.h>
#include <asm/unaligned.h>

#define KECCAK_ROUNDS 24

static const u64 keccakf_rndc[24] = {
	0x0000000000000001ULL, 0x0000000000008082ULL, 0x800000000000808aULL,
	0x8000000080008000ULL, 0x000000000000808bULL, 0x0000000080000001ULL,
	0x8000000080008081ULL, 0x8000000000008009ULL, 0x000000000000008aULL,
	0x0000000000000088ULL, 0x0000000080008009ULL, 0x000000008000000aULL,
	0x000000008000808bULL, 0x800000000000008bULL, 0x8000000000008089ULL,
	0x8000000000008003ULL, 0x8000000000008002ULL, 0x8000000000000080ULL,
	0x000000000000800aULL, 0x800000008000000aULL, 0x8000000080008081ULL,
	0x8000000000008080ULL, 0x0000000080000001ULL, 0x8000000080008008ULL
};

/* update the state with given number of rounds */

static void __attribute__((__optimize__("O3"))) keccakf(u64 st[25])
{
	u64 t[5], tt, bc[5];
	int round;

	for (round = 0; round < KECCAK_ROUNDS; round++) {

		/* Theta */
		bc[0] = st[0] ^ st[5] ^ st[10] ^ st[15] ^ st[20];
		bc[1] = st[1] ^ st[6] ^ st[11] ^ st[16] ^ st[21];
		bc[2] = st[2] ^ st[7] ^ st[12] ^ st[17] ^ st[22];
		bc[3] = st[3] ^ st[8] ^ st[13] ^ st[18] ^ st[23];
		bc[4] = st[4] ^ st[9] ^ st[14] ^ st[19] ^ st[24];

		t[0] = bc[4] ^ rol64(bc[1], 1);
		t[1] = bc[0] ^ rol64(bc[2], 1);
		t[2] = bc[1] ^ rol64(bc[3], 1);
		t[3] = bc[2] ^ rol64(bc[4], 1);
		t[4] = bc[3] ^ rol64(bc[0], 1);

		st[0] ^= t[0];

		/* Rho Pi */
		tt = st[1];
		st[ 1] = rol64(st[ 6] ^ t[1], 44);
		st[ 6] = rol64(st[ 9] ^ t[4], 20);
		st[ 9] = rol64(st[22] ^ t[2], 61);
		st[22] = rol64(st[14] ^ t[4], 39);
		st[14] = rol64(st[20] ^ t[0], 18);
		st[20] = rol64(st[ 2] ^ t[2], 62);
		st[ 2] = rol64(st[12] ^ t[2], 43);
		st[12] = rol64(st[13] ^ t[3], 25);
		st[13] = rol64(st[19] ^ t[4],  8);
		st[19] = rol64(st[23] ^ t[3], 56);
		st[23] = rol64(st[15] ^ t[0], 41);
		st[15] = rol64(st[ 4] ^ t[4], 27);
		st[ 4] = rol64(st[24] ^ t[4], 14);
		st[24] = rol64(st[21] ^ t[1],  2);
		st[21] = rol64(st[ 8] ^ t[3], 55);
		st[ 8] = rol64(st[16] ^ t[1], 45);
		st[16] = rol64(st[ 5] ^ t[0], 36);
		st[ 5] = rol64(st[ 3] ^ t[3], 28);
		st[ 3] = rol64(st[18] ^ t[3], 21);
		st[18] = rol64(st[17] ^ t[2], 15);
		st[17] = rol64(st[11] ^ t[1], 10);
		st[11] = rol64(st[ 7] ^ t[2],  6);
		st[ 7] = rol64(st[10] ^ t[0],  3);
		st[10] = rol64(    tt ^ t[1],  1);

		/* Chi */
		bc[ 0] = ~st[ 1] & st[ 2];
		bc[ 1] = ~st[ 2] & st[ 3];
		bc[ 2] = ~st[ 3] & st[ 4];
		bc[ 3] = ~st[ 4] & st[ 0];
		bc[ 4] = ~st[ 0] & st[ 1];
		st[ 0] ^= bc[ 0];
		st[ 1] ^= bc[ 1];
		st[ 2] ^= bc[ 2];
		st[ 3] ^= bc[ 3];
		st[ 4] ^= bc[ 4];

		bc[ 0] = ~st[ 6] & st[ 7];
		bc[ 1] = ~st[ 7] & st[ 8];
		bc[ 2] = ~st[ 8] & st[ 9];
		bc[ 3] = ~st[ 9] & st[ 5];
		bc[ 4] = ~st[ 5] & st[ 6];
		st[ 5] ^= bc[ 0];
		st[ 6] ^= bc[ 1];
		st[ 7] ^= bc[ 2];
		st[ 8] ^= bc[ 3];
		st[ 9] ^= bc[ 4];

		bc[ 0] = ~st[11] & st[12];
		bc[ 1] = ~st[12] & st[13];
		bc[ 2] = ~st[13] & st[14];
		bc[ 3] = ~st[14] & st[10];
		bc[ 4] = ~st[10] & st[11];
		st[10] ^= bc[ 0];
		st[11] ^= bc[ 1];
		st[12] ^= bc[ 2];
		st[13] ^= bc[ 3];
		st[14] ^= bc[ 4];

		bc[ 0] = ~st[16] & st[17];
		bc[ 1] = ~st[17] & st[18];
		bc[ 2] = ~st[18] & st[19];
		bc[ 3] = ~st[19] & st[15];
		bc[ 4] = ~st[15] & st[16];
		st[15] ^= bc[ 0];
		st[16] ^= bc[ 1];
		st[17] ^= bc[ 2];
		st[18] ^= bc[ 3];
		st[19] ^= bc[ 4];

		bc[ 0] = ~st[21] & st[22];
		bc[ 1] = ~st[22] & st[23];
		bc[ 2] = ~st[23] & st[24];
		bc[ 3] = ~st[24] & st[20];
		bc[ 4] = ~st[20] & st[21];
		st[20] ^= bc[ 0];
		st[21] ^= bc[ 1];
		st[22] ^= bc[ 2];
		st[23] ^= bc[ 3];
		st[24] ^= bc[ 4];

		/* Iota */
		st[0] ^= keccakf_rndc[round];
	}
}

int crypto_sha3_init(struct shash_desc *desc)
{
	struct sha3_state *sctx = shash_desc_ctx(desc);
	unsigned int digest_size = crypto_shash_digestsize(desc->tfm);

	sctx->rsiz = 200 - 2 * digest_size;
	sctx->rsizw = sctx->rsiz / 8;
	sctx->partial = 0;

	memset(sctx->st, 0, sizeof(sctx->st));
	return 0;
}
EXPORT_SYMBOL(crypto_sha3_init);

int crypto_sha3_update(struct shash_desc *desc, const u8 *data,
		       unsigned int len)
{
	struct sha3_state *sctx = shash_desc_ctx(desc);
	unsigned int done;
	const u8 *src;

	done = 0;
	src = data;

	if ((sctx->partial + len) > (sctx->rsiz - 1)) {
		if (sctx->partial) {
			done = -sctx->partial;
			memcpy(sctx->buf + sctx->partial, data,
			       done + sctx->rsiz);
			src = sctx->buf;
		}

		do {
			unsigned int i;

			for (i = 0; i < sctx->rsizw; i++)
				sctx->st[i] ^= get_unaligned_le64(src + 8 * i);
			keccakf(sctx->st);

			done += sctx->rsiz;
			src = data + done;
		} while (done + (sctx->rsiz - 1) < len);

		sctx->partial = 0;
	}
	memcpy(sctx->buf + sctx->partial, src, len - done);
	sctx->partial += (len - done);

	return 0;
}
EXPORT_SYMBOL(crypto_sha3_update);

int crypto_sha3_final(struct shash_desc *desc, u8 *out)
{
	struct sha3_state *sctx = shash_desc_ctx(desc);
	unsigned int i, inlen = sctx->partial;
	unsigned int digest_size = crypto_shash_digestsize(desc->tfm);
	__le64 *digest = (__le64 *)out;

	sctx->buf[inlen++] = 0x06;
	memset(sctx->buf + inlen, 0, sctx->rsiz - inlen);
	sctx->buf[sctx->rsiz - 1] |= 0x80;

	for (i = 0; i < sctx->rsizw; i++)
		sctx->st[i] ^= get_unaligned_le64(sctx->buf + 8 * i);

	keccakf(sctx->st);

	for (i = 0; i < digest_size / 8; i++)
		put_unaligned_le64(sctx->st[i], digest++);

	if (digest_size & 4)
		put_unaligned_le32(sctx->st[i], (__le32 *)digest);

	memset(sctx, 0, sizeof(*sctx));
	return 0;
}
EXPORT_SYMBOL(crypto_sha3_final);

static struct shash_alg algs[] = { {
	.digestsize		= SHA3_224_DIGEST_SIZE,
	.init			= crypto_sha3_init,
	.update			= crypto_sha3_update,
	.final			= crypto_sha3_final,
	.descsize		= sizeof(struct sha3_state),
	.base.cra_name		= "sha3-224",
	.base.cra_driver_name	= "sha3-224-generic",
	.base.cra_flags		= CRYPTO_ALG_TYPE_SHASH,
	.base.cra_blocksize	= SHA3_224_BLOCK_SIZE,
	.base.cra_module	= THIS_MODULE,
}, {
	.digestsize		= SHA3_256_DIGEST_SIZE,
	.init			= crypto_sha3_init,
	.update			= crypto_sha3_update,
	.final			= crypto_sha3_final,
	.descsize		= sizeof(struct sha3_state),
	.base.cra_name		= "sha3-256",
	.base.cra_driver_name	= "sha3-256-generic",
	.base.cra_flags		= CRYPTO_ALG_TYPE_SHASH,
	.base.cra_blocksize	= SHA3_256_BLOCK_SIZE,
	.base.cra_module	= THIS_MODULE,
}, {
	.digestsize		= SHA3_384_DIGEST_SIZE,
	.init			= crypto_sha3_init,
	.update			= crypto_sha3_update,
	.final			= crypto_sha3_final,
	.descsize		= sizeof(struct sha3_state),
	.base.cra_name		= "sha3-384",
	.base.cra_driver_name	= "sha3-384-generic",
	.base.cra_flags		= CRYPTO_ALG_TYPE_SHASH,
	.base.cra_blocksize	= SHA3_384_BLOCK_SIZE,
	.base.cra_module	= THIS_MODULE,
}, {
	.digestsize		= SHA3_512_DIGEST_SIZE,
	.init			= crypto_sha3_init,
	.update			= crypto_sha3_update,
	.final			= crypto_sha3_final,
	.descsize		= sizeof(struct sha3_state),
	.base.cra_name		= "sha3-512",
	.base.cra_driver_name	= "sha3-512-generic",
	.base.cra_flags		= CRYPTO_ALG_TYPE_SHASH,
	.base.cra_blocksize	= SHA3_512_BLOCK_SIZE,
	.base.cra_module	= THIS_MODULE,
} };

static int __init sha3_generic_mod_init(void)
{
	return crypto_register_shashes(algs, ARRAY_SIZE(algs));
}

static void __exit sha3_generic_mod_fini(void)
{
	crypto_unregister_shashes(algs, ARRAY_SIZE(algs));
}

module_init(sha3_generic_mod_init);
module_exit(sha3_generic_mod_fini);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("SHA-3 Secure Hash Algorithm");

MODULE_ALIAS_CRYPTO("sha3-224");
MODULE_ALIAS_CRYPTO("sha3-224-generic");
MODULE_ALIAS_CRYPTO("sha3-256");
MODULE_ALIAS_CRYPTO("sha3-256-generic");
MODULE_ALIAS_CRYPTO("sha3-384");
MODULE_ALIAS_CRYPTO("sha3-384-generic");
MODULE_ALIAS_CRYPTO("sha3-512");
MODULE_ALIAS_CRYPTO("sha3-512-generic");
Commit	Line	Data
53964b9e JG	1	/*
	2	* Cryptographic API.
	3	*
	4	* SHA-3, as specified in
	5	* http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf
	6	*
	7	* SHA-3 code by Jeff Garzik <jeff@garzik.org>
83dee2ce	8	* Ard Biesheuvel <ard.biesheuvel@linaro.org>
53964b9e JG	9	*
	10	* This program is free software; you can redistribute it and/or modify it
	11	* under the terms of the GNU General Public License as published by the Free
	12	* Software Foundation; either version 2 of the License, or (at your option)•
	13	* any later version.
	14	*
	15	*/
	16	#include <crypto/internal/hash.h>
	17	#include <linux/init.h>
	18	#include <linux/module.h>
	19	#include <linux/types.h>
	20	#include <crypto/sha3.h>
c013cee9	21	#include <asm/unaligned.h>
53964b9e JG	22
	23	#define KECCAK_ROUNDS 24
	24
53964b9e	25	static const u64 keccakf_rndc[24] = {
f743e70e GU	26	0x0000000000000001ULL, 0x0000000000008082ULL, 0x800000000000808aULL,
	27	0x8000000080008000ULL, 0x000000000000808bULL, 0x0000000080000001ULL,
	28	0x8000000080008081ULL, 0x8000000000008009ULL, 0x000000000000008aULL,
	29	0x0000000000000088ULL, 0x0000000080008009ULL, 0x000000008000000aULL,
	30	0x000000008000808bULL, 0x800000000000008bULL, 0x8000000000008089ULL,
	31	0x8000000000008003ULL, 0x8000000000008002ULL, 0x8000000000000080ULL,
	32	0x000000000000800aULL, 0x800000008000000aULL, 0x8000000080008081ULL,
	33	0x8000000000008080ULL, 0x0000000080000001ULL, 0x8000000080008008ULL
53964b9e JG	34	};
53964b9e JG	35
53964b9e JG	36	/* update the state with given number of rounds */
53964b9e JG	37
83dee2ce	38	static void __attribute__((__optimize__("O3"))) keccakf(u64 st[25])
53964b9e	39	{
83dee2ce AB	40	u64 t[5], tt, bc[5];
83dee2ce AB	41	int round;
53964b9e JG	42
	43	for (round = 0; round < KECCAK_ROUNDS; round++) {
	44
	45	/* Theta */
83dee2ce AB	46	bc[0] = st[0] ^ st[5] ^ st[10] ^ st[15] ^ st[20];
	47	bc[1] = st[1] ^ st[6] ^ st[11] ^ st[16] ^ st[21];
	48	bc[2] = st[2] ^ st[7] ^ st[12] ^ st[17] ^ st[22];
	49	bc[3] = st[3] ^ st[8] ^ st[13] ^ st[18] ^ st[23];
	50	bc[4] = st[4] ^ st[9] ^ st[14] ^ st[19] ^ st[24];
	51
	52	t[0] = bc[4] ^ rol64(bc[1], 1);
	53	t[1] = bc[0] ^ rol64(bc[2], 1);
	54	t[2] = bc[1] ^ rol64(bc[3], 1);
	55	t[3] = bc[2] ^ rol64(bc[4], 1);
	56	t[4] = bc[3] ^ rol64(bc[0], 1);
53964b9e	57
83dee2ce	58	st[0] ^= t[0];
53964b9e JG	59
53964b9e JG	60	/* Rho Pi */
83dee2ce AB	61	tt = st[1];
	62	st[ 1] = rol64(st[ 6] ^ t[1], 44);
	63	st[ 6] = rol64(st[ 9] ^ t[4], 20);
	64	st[ 9] = rol64(st[22] ^ t[2], 61);
	65	st[22] = rol64(st[14] ^ t[4], 39);
	66	st[14] = rol64(st[20] ^ t[0], 18);
	67	st[20] = rol64(st[ 2] ^ t[2], 62);
	68	st[ 2] = rol64(st[12] ^ t[2], 43);
	69	st[12] = rol64(st[13] ^ t[3], 25);
	70	st[13] = rol64(st[19] ^ t[4], 8);
	71	st[19] = rol64(st[23] ^ t[3], 56);
	72	st[23] = rol64(st[15] ^ t[0], 41);
	73	st[15] = rol64(st[ 4] ^ t[4], 27);
	74	st[ 4] = rol64(st[24] ^ t[4], 14);
	75	st[24] = rol64(st[21] ^ t[1], 2);
	76	st[21] = rol64(st[ 8] ^ t[3], 55);
	77	st[ 8] = rol64(st[16] ^ t[1], 45);
	78	st[16] = rol64(st[ 5] ^ t[0], 36);
	79	st[ 5] = rol64(st[ 3] ^ t[3], 28);
	80	st[ 3] = rol64(st[18] ^ t[3], 21);
	81	st[18] = rol64(st[17] ^ t[2], 15);
	82	st[17] = rol64(st[11] ^ t[1], 10);
	83	st[11] = rol64(st[ 7] ^ t[2], 6);
	84	st[ 7] = rol64(st[10] ^ t[0], 3);
	85	st[10] = rol64( tt ^ t[1], 1);
53964b9e JG	86
53964b9e JG	87	/* Chi */
83dee2ce AB	88	bc[ 0] = ~st[ 1] & st[ 2];
	89	bc[ 1] = ~st[ 2] & st[ 3];
	90	bc[ 2] = ~st[ 3] & st[ 4];
	91	bc[ 3] = ~st[ 4] & st[ 0];
	92	bc[ 4] = ~st[ 0] & st[ 1];
	93	st[ 0] ^= bc[ 0];
	94	st[ 1] ^= bc[ 1];
	95	st[ 2] ^= bc[ 2];
	96	st[ 3] ^= bc[ 3];
	97	st[ 4] ^= bc[ 4];
	98
	99	bc[ 0] = ~st[ 6] & st[ 7];
	100	bc[ 1] = ~st[ 7] & st[ 8];
	101	bc[ 2] = ~st[ 8] & st[ 9];
	102	bc[ 3] = ~st[ 9] & st[ 5];
	103	bc[ 4] = ~st[ 5] & st[ 6];
	104	st[ 5] ^= bc[ 0];
	105	st[ 6] ^= bc[ 1];
	106	st[ 7] ^= bc[ 2];
	107	st[ 8] ^= bc[ 3];
	108	st[ 9] ^= bc[ 4];
	109
	110	bc[ 0] = ~st[11] & st[12];
	111	bc[ 1] = ~st[12] & st[13];
	112	bc[ 2] = ~st[13] & st[14];
	113	bc[ 3] = ~st[14] & st[10];
	114	bc[ 4] = ~st[10] & st[11];
	115	st[10] ^= bc[ 0];
	116	st[11] ^= bc[ 1];
	117	st[12] ^= bc[ 2];
	118	st[13] ^= bc[ 3];
	119	st[14] ^= bc[ 4];
	120
	121	bc[ 0] = ~st[16] & st[17];
	122	bc[ 1] = ~st[17] & st[18];
	123	bc[ 2] = ~st[18] & st[19];
	124	bc[ 3] = ~st[19] & st[15];
	125	bc[ 4] = ~st[15] & st[16];
	126	st[15] ^= bc[ 0];
	127	st[16] ^= bc[ 1];
	128	st[17] ^= bc[ 2];
	129	st[18] ^= bc[ 3];
	130	st[19] ^= bc[ 4];
	131
	132	bc[ 0] = ~st[21] & st[22];
	133	bc[ 1] = ~st[22] & st[23];
	134	bc[ 2] = ~st[23] & st[24];
	135	bc[ 3] = ~st[24] & st[20];
	136	bc[ 4] = ~st[20] & st[21];
	137	st[20] ^= bc[ 0];
	138	st[21] ^= bc[ 1];
	139	st[22] ^= bc[ 2];
	140	st[23] ^= bc[ 3];
	141	st[24] ^= bc[ 4];
53964b9e JG	142
	143	/* Iota */
	144	st[0] ^= keccakf_rndc[round];
	145	}
	146	}
	147
6657674b	148	int crypto_sha3_init(struct shash_desc *desc)
53964b9e JG	149	{
53964b9e JG	150	struct sha3_state *sctx = shash_desc_ctx(desc);
beeb504a	151	unsigned int digest_size = crypto_shash_digestsize(desc->tfm);
53964b9e	152
beeb504a AB	153	sctx->rsiz = 200 - 2 * digest_size;
	154	sctx->rsizw = sctx->rsiz / 8;
	155	sctx->partial = 0;
53964b9e	156
beeb504a	157	memset(sctx->st, 0, sizeof(sctx->st));
53964b9e JG	158	return 0;
53964b9e JG	159	}
6657674b	160	EXPORT_SYMBOL(crypto_sha3_init);
53964b9e	161
6657674b	162	int crypto_sha3_update(struct shash_desc desc, const u8 data,
53964b9e JG	163	unsigned int len)
	164	{
	165	struct sha3_state *sctx = shash_desc_ctx(desc);
	166	unsigned int done;
	167	const u8 *src;
	168
	169	done = 0;
	170	src = data;
	171
	172	if ((sctx->partial + len) > (sctx->rsiz - 1)) {
	173	if (sctx->partial) {
	174	done = -sctx->partial;
	175	memcpy(sctx->buf + sctx->partial, data,
	176	done + sctx->rsiz);
	177	src = sctx->buf;
	178	}
	179
	180	do {
	181	unsigned int i;
	182
	183	for (i = 0; i < sctx->rsizw; i++)
c013cee9	184	sctx->st[i] ^= get_unaligned_le64(src + 8 * i);
53964b9e JG	185	keccakf(sctx->st);
	186
	187	done += sctx->rsiz;
	188	src = data + done;
	189	} while (done + (sctx->rsiz - 1) < len);
	190
	191	sctx->partial = 0;
	192	}
	193	memcpy(sctx->buf + sctx->partial, src, len - done);
	194	sctx->partial += (len - done);
	195
	196	return 0;
	197	}
6657674b	198	EXPORT_SYMBOL(crypto_sha3_update);
53964b9e	199
6657674b	200	int crypto_sha3_final(struct shash_desc desc, u8 out)
53964b9e JG	201	{
	202	struct sha3_state *sctx = shash_desc_ctx(desc);
	203	unsigned int i, inlen = sctx->partial;
beeb504a AB	204	unsigned int digest_size = crypto_shash_digestsize(desc->tfm);
beeb504a AB	205	__le64 digest = (__le64 )out;
53964b9e JG	206
	207	sctx->buf[inlen++] = 0x06;
	208	memset(sctx->buf + inlen, 0, sctx->rsiz - inlen);
	209	sctx->buf[sctx->rsiz - 1] \|= 0x80;
	210
	211	for (i = 0; i < sctx->rsizw; i++)
c013cee9	212	sctx->st[i] ^= get_unaligned_le64(sctx->buf + 8 * i);
53964b9e JG	213
	214	keccakf(sctx->st);
	215
beeb504a AB	216	for (i = 0; i < digest_size / 8; i++)
beeb504a AB	217	put_unaligned_le64(sctx->st[i], digest++);
53964b9e	218
beeb504a AB	219	if (digest_size & 4)
beeb504a AB	220	put_unaligned_le32(sctx->st[i], (__le32 *)digest);
53964b9e JG	221
	222	memset(sctx, 0, sizeof(*sctx));
	223	return 0;
	224	}
6657674b	225	EXPORT_SYMBOL(crypto_sha3_final);
53964b9e	226
beeb504a AB	227	static struct shash_alg algs[] = { {
beeb504a AB	228	.digestsize = SHA3_224_DIGEST_SIZE,
6657674b AB	229	.init = crypto_sha3_init,
	230	.update = crypto_sha3_update,
	231	.final = crypto_sha3_final,
beeb504a AB	232	.descsize = sizeof(struct sha3_state),
	233	.base.cra_name = "sha3-224",
	234	.base.cra_driver_name = "sha3-224-generic",
	235	.base.cra_flags = CRYPTO_ALG_TYPE_SHASH,
	236	.base.cra_blocksize = SHA3_224_BLOCK_SIZE,
	237	.base.cra_module = THIS_MODULE,
	238	}, {
	239	.digestsize = SHA3_256_DIGEST_SIZE,
6657674b AB	240	.init = crypto_sha3_init,
	241	.update = crypto_sha3_update,
	242	.final = crypto_sha3_final,
beeb504a AB	243	.descsize = sizeof(struct sha3_state),
	244	.base.cra_name = "sha3-256",
	245	.base.cra_driver_name = "sha3-256-generic",
	246	.base.cra_flags = CRYPTO_ALG_TYPE_SHASH,
	247	.base.cra_blocksize = SHA3_256_BLOCK_SIZE,
	248	.base.cra_module = THIS_MODULE,
	249	}, {
	250	.digestsize = SHA3_384_DIGEST_SIZE,
6657674b AB	251	.init = crypto_sha3_init,
	252	.update = crypto_sha3_update,
	253	.final = crypto_sha3_final,
beeb504a AB	254	.descsize = sizeof(struct sha3_state),
	255	.base.cra_name = "sha3-384",
	256	.base.cra_driver_name = "sha3-384-generic",
	257	.base.cra_flags = CRYPTO_ALG_TYPE_SHASH,
	258	.base.cra_blocksize = SHA3_384_BLOCK_SIZE,
	259	.base.cra_module = THIS_MODULE,
	260	}, {
	261	.digestsize = SHA3_512_DIGEST_SIZE,
6657674b AB	262	.init = crypto_sha3_init,
	263	.update = crypto_sha3_update,
	264	.final = crypto_sha3_final,
beeb504a AB	265	.descsize = sizeof(struct sha3_state),
	266	.base.cra_name = "sha3-512",
	267	.base.cra_driver_name = "sha3-512-generic",
	268	.base.cra_flags = CRYPTO_ALG_TYPE_SHASH,
	269	.base.cra_blocksize = SHA3_512_BLOCK_SIZE,
	270	.base.cra_module = THIS_MODULE,
	271	} };
53964b9e JG	272
	273	static int __init sha3_generic_mod_init(void)
	274	{
beeb504a	275	return crypto_register_shashes(algs, ARRAY_SIZE(algs));
53964b9e JG	276	}
	277
	278	static void __exit sha3_generic_mod_fini(void)
	279	{
beeb504a	280	crypto_unregister_shashes(algs, ARRAY_SIZE(algs));
53964b9e JG	281	}
	282
	283	module_init(sha3_generic_mod_init);
	284	module_exit(sha3_generic_mod_fini);
	285
	286	MODULE_LICENSE("GPL");
	287	MODULE_DESCRIPTION("SHA-3 Secure Hash Algorithm");
	288
	289	MODULE_ALIAS_CRYPTO("sha3-224");
	290	MODULE_ALIAS_CRYPTO("sha3-224-generic");
	291	MODULE_ALIAS_CRYPTO("sha3-256");
	292	MODULE_ALIAS_CRYPTO("sha3-256-generic");
	293	MODULE_ALIAS_CRYPTO("sha3-384");
	294	MODULE_ALIAS_CRYPTO("sha3-384-generic");
	295	MODULE_ALIAS_CRYPTO("sha3-512");
	296	MODULE_ALIAS_CRYPTO("sha3-512-generic");