[linux-block.git] / crypto / poly1305_generic.c

/*
 * Poly1305 authenticator algorithm, RFC7539
 *
 * Copyright (C) 2015 Martin Willi
 *
 * Based on public domain code by Andrew Moon and Daniel J. Bernstein.
 *
 * 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/algapi.h>
#include <crypto/internal/hash.h>
#include <crypto/internal/poly1305.h>
#include <linux/crypto.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <asm/unaligned.h>

static int crypto_poly1305_init(struct shash_desc *desc)
{
	struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc);

	poly1305_core_init(&dctx->h);
	dctx->buflen = 0;
	dctx->rset = 0;
	dctx->sset = false;

	return 0;
}

static void poly1305_blocks(struct poly1305_desc_ctx *dctx, const u8 *src,
			    unsigned int srclen)
{
	unsigned int datalen;

	if (unlikely(!dctx->sset)) {
		datalen = crypto_poly1305_setdesckey(dctx, src, srclen);
		src += srclen - datalen;
		srclen = datalen;
	}

	poly1305_core_blocks(&dctx->h, dctx->r, src,
			     srclen / POLY1305_BLOCK_SIZE, 1);
}

static int crypto_poly1305_update(struct shash_desc *desc,
				  const u8 *src, unsigned int srclen)
{
	struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc);
	unsigned int bytes;

	if (unlikely(dctx->buflen)) {
		bytes = min(srclen, POLY1305_BLOCK_SIZE - dctx->buflen);
		memcpy(dctx->buf + dctx->buflen, src, bytes);
		src += bytes;
		srclen -= bytes;
		dctx->buflen += bytes;

		if (dctx->buflen == POLY1305_BLOCK_SIZE) {
			poly1305_blocks(dctx, dctx->buf,
					POLY1305_BLOCK_SIZE);
			dctx->buflen = 0;
		}
	}

	if (likely(srclen >= POLY1305_BLOCK_SIZE)) {
		poly1305_blocks(dctx, src, srclen);
		src += srclen - (srclen % POLY1305_BLOCK_SIZE);
		srclen %= POLY1305_BLOCK_SIZE;
	}

	if (unlikely(srclen)) {
		dctx->buflen = srclen;
		memcpy(dctx->buf, src, srclen);
	}

	return 0;
}

static int crypto_poly1305_final(struct shash_desc *desc, u8 *dst)
{
	struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc);

	if (unlikely(!dctx->sset))
		return -ENOKEY;

	poly1305_final_generic(dctx, dst);
	return 0;
}

static struct shash_alg poly1305_alg = {
	.digestsize	= POLY1305_DIGEST_SIZE,
	.init		= crypto_poly1305_init,
	.update		= crypto_poly1305_update,
	.final		= crypto_poly1305_final,
	.descsize	= sizeof(struct poly1305_desc_ctx),
	.base		= {
		.cra_name		= "poly1305",
		.cra_driver_name	= "poly1305-generic",
		.cra_priority		= 100,
		.cra_blocksize		= POLY1305_BLOCK_SIZE,
		.cra_module		= THIS_MODULE,
	},
};

static int __init poly1305_mod_init(void)
{
	return crypto_register_shash(&poly1305_alg);
}

static void __exit poly1305_mod_exit(void)
{
	crypto_unregister_shash(&poly1305_alg);
}

subsys_initcall(poly1305_mod_init);
module_exit(poly1305_mod_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Martin Willi <martin@strongswan.org>");
MODULE_DESCRIPTION("Poly1305 authenticator");
MODULE_ALIAS_CRYPTO("poly1305");
MODULE_ALIAS_CRYPTO("poly1305-generic");
Commit	Line	Data
f979e014 MW	1	/*
	2	* Poly1305 authenticator algorithm, RFC7539
	3	*
	4	* Copyright (C) 2015 Martin Willi
	5	*
	6	* Based on public domain code by Andrew Moon and Daniel J. Bernstein.
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*/
	13
	14	#include <crypto/algapi.h>
	15	#include <crypto/internal/hash.h>
48ea8c6e	16	#include <crypto/internal/poly1305.h>
f979e014 MW	17	#include <linux/crypto.h>
	18	#include <linux/kernel.h>
	19	#include <linux/module.h>
109e23bd	20	#include <asm/unaligned.h>
f979e014	21
1b2c6a51	22	static int crypto_poly1305_init(struct shash_desc *desc)
f979e014 MW	23	{
	24	struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc);
	25
1b6fd3d5	26	poly1305_core_init(&dctx->h);
f979e014	27	dctx->buflen = 0;
ad8f5b88	28	dctx->rset = 0;
c2b7b20a	29	dctx->sset = false;
f979e014 MW	30
	31	return 0;
	32	}
	33
48ea8c6e AB	34	static void poly1305_blocks(struct poly1305_desc_ctx dctx, const u8 src,
48ea8c6e AB	35	unsigned int srclen)
1b6fd3d5 EB	36	{
	37	unsigned int datalen;
	38
	39	if (unlikely(!dctx->sset)) {
	40	datalen = crypto_poly1305_setdesckey(dctx, src, srclen);
	41	src += srclen - datalen;
	42	srclen = datalen;
	43	}
	44
ad8f5b88	45	poly1305_core_blocks(&dctx->h, dctx->r, src,
48ea8c6e	46	srclen / POLY1305_BLOCK_SIZE, 1);
f979e014 MW	47	}
f979e014 MW	48
1b2c6a51 AB	49	static int crypto_poly1305_update(struct shash_desc *desc,
1b2c6a51 AB	50	const u8 *src, unsigned int srclen)
f979e014 MW	51	{
f979e014 MW	52	struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc);
f979e014 MW	53	unsigned int bytes;
	54
	55	if (unlikely(dctx->buflen)) {
	56	bytes = min(srclen, POLY1305_BLOCK_SIZE - dctx->buflen);
	57	memcpy(dctx->buf + dctx->buflen, src, bytes);
	58	src += bytes;
	59	srclen -= bytes;
	60	dctx->buflen += bytes;
	61
	62	if (dctx->buflen == POLY1305_BLOCK_SIZE) {
c2b7b20a	63	poly1305_blocks(dctx, dctx->buf,
48ea8c6e	64	POLY1305_BLOCK_SIZE);
f979e014 MW	65	dctx->buflen = 0;
	66	}
	67	}
	68
	69	if (likely(srclen >= POLY1305_BLOCK_SIZE)) {
48ea8c6e	70	poly1305_blocks(dctx, src, srclen);
1b6fd3d5 EB	71	src += srclen - (srclen % POLY1305_BLOCK_SIZE);
1b6fd3d5 EB	72	srclen %= POLY1305_BLOCK_SIZE;
f979e014 MW	73	}
	74
	75	if (unlikely(srclen)) {
	76	dctx->buflen = srclen;
	77	memcpy(dctx->buf, src, srclen);
	78	}
	79
	80	return 0;
	81	}
	82
1b2c6a51	83	static int crypto_poly1305_final(struct shash_desc desc, u8 dst)
1b6fd3d5 EB	84	{
1b6fd3d5 EB	85	struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc);
1b6fd3d5 EB	86
	87	if (unlikely(!dctx->sset))
	88	return -ENOKEY;
	89
a1d93064	90	poly1305_final_generic(dctx, dst);
f979e014 MW	91	return 0;
	92	}
	93
	94	static struct shash_alg poly1305_alg = {
	95	.digestsize = POLY1305_DIGEST_SIZE,
2546f811 MW	96	.init = crypto_poly1305_init,
	97	.update = crypto_poly1305_update,
	98	.final = crypto_poly1305_final,
f979e014 MW	99	.descsize = sizeof(struct poly1305_desc_ctx),
	100	.base = {
	101	.cra_name = "poly1305",
	102	.cra_driver_name = "poly1305-generic",
	103	.cra_priority = 100,
f979e014	104	.cra_blocksize = POLY1305_BLOCK_SIZE,
f979e014 MW	105	.cra_module = THIS_MODULE,
	106	},
	107	};
	108
	109	static int __init poly1305_mod_init(void)
	110	{
	111	return crypto_register_shash(&poly1305_alg);
	112	}
	113
	114	static void __exit poly1305_mod_exit(void)
	115	{
	116	crypto_unregister_shash(&poly1305_alg);
	117	}
	118
c4741b23	119	subsys_initcall(poly1305_mod_init);
f979e014 MW	120	module_exit(poly1305_mod_exit);
	121
	122	MODULE_LICENSE("GPL");
	123	MODULE_AUTHOR("Martin Willi <martin@strongswan.org>");
	124	MODULE_DESCRIPTION("Poly1305 authenticator");
	125	MODULE_ALIAS_CRYPTO("poly1305");
	126	MODULE_ALIAS_CRYPTO("poly1305-generic");