Commit 1f81c582 authored by Eric Biggers's avatar Eric Biggers Committed by Herbert Xu
Browse files

crypto: arm/poly1305 - remove redundant shash algorithm 



Since crypto/poly1305.c now registers a poly1305-$(ARCH) shash algorithm
that uses the architecture's Poly1305 library functions, individual
architectures no longer need to do the same.  Therefore, remove the
redundant shash algorithm from the arch-specific code and leave just the
library functions there.

Signed-off-by: default avatarEric Biggers <ebiggers@google.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent ecaa4be1

arch/arm/crypto/Kconfig

+0 −6
Original line number Diff line number Diff line
@@ -48,14 +48,8 @@ config CRYPTO_NHPOLY1305_NEON 


config CRYPTO_POLY1305_ARM

	tristate

	select CRYPTO_HASH

	select CRYPTO_ARCH_HAVE_LIB_POLY1305

	default CRYPTO_LIB_POLY1305_INTERNAL

	help

	  Poly1305 authenticator algorithm (RFC7539)



	  Architecture: arm optionally using

	  - NEON (Advanced SIMD) extensions



config CRYPTO_BLAKE2S_ARM

	bool "Hash functions: BLAKE2s"

arch/arm/crypto/poly1305-glue.c

+3 −164
Original line number Diff line number Diff line
@@ -8,15 +8,12 @@ 
#include <asm/hwcap.h>

#include <asm/neon.h>

#include <asm/simd.h>

#include <linux/unaligned.h>

#include <crypto/algapi.h>

#include <crypto/internal/hash.h>

#include <crypto/internal/poly1305.h>

#include <crypto/poly1305.h>

#include <crypto/internal/simd.h>

#include <linux/cpufeature.h>

#include <linux/crypto.h>

#include <linux/jump_label.h>

#include <linux/module.h>

#include <linux/unaligned.h>



void poly1305_init_arm(void *state, const u8 *key);

void poly1305_blocks_arm(void *state, const u8 *src, u32 len, u32 hibit);
@@ -40,102 +37,6 @@ void poly1305_init_arch(struct poly1305_desc_ctx *dctx, const u8 key[POLY1305_KE 
}

EXPORT_SYMBOL(poly1305_init_arch);



static int arm_poly1305_init(struct shash_desc *desc)

{

	struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc);



	dctx->buflen = 0;

	dctx->rset = 0;

	dctx->sset = false;



	return 0;

}



static void arm_poly1305_blocks(struct poly1305_desc_ctx *dctx, const u8 *src,

				 u32 len, u32 hibit, bool do_neon)

{

	if (unlikely(!dctx->sset)) {

		if (!dctx->rset) {

			poly1305_init_arm(&dctx->h, src);

			src += POLY1305_BLOCK_SIZE;

			len -= POLY1305_BLOCK_SIZE;

			dctx->rset = 1;

		}

		if (len >= POLY1305_BLOCK_SIZE) {

			dctx->s[0] = get_unaligned_le32(src +  0);

			dctx->s[1] = get_unaligned_le32(src +  4);

			dctx->s[2] = get_unaligned_le32(src +  8);

			dctx->s[3] = get_unaligned_le32(src + 12);

			src += POLY1305_BLOCK_SIZE;

			len -= POLY1305_BLOCK_SIZE;

			dctx->sset = true;

		}

		if (len < POLY1305_BLOCK_SIZE)

			return;

	}



	len &= ~(POLY1305_BLOCK_SIZE - 1);



	if (static_branch_likely(&have_neon) && likely(do_neon))

		poly1305_blocks_neon(&dctx->h, src, len, hibit);

	else

		poly1305_blocks_arm(&dctx->h, src, len, hibit);

}



static void arm_poly1305_do_update(struct poly1305_desc_ctx *dctx,

				    const u8 *src, u32 len, bool do_neon)

{

	if (unlikely(dctx->buflen)) {

		u32 bytes = min(len, POLY1305_BLOCK_SIZE - dctx->buflen);



		memcpy(dctx->buf + dctx->buflen, src, bytes);

		src += bytes;

		len -= bytes;

		dctx->buflen += bytes;



		if (dctx->buflen == POLY1305_BLOCK_SIZE) {

			arm_poly1305_blocks(dctx, dctx->buf,

					    POLY1305_BLOCK_SIZE, 1, false);

			dctx->buflen = 0;

		}

	}



	if (likely(len >= POLY1305_BLOCK_SIZE)) {

		arm_poly1305_blocks(dctx, src, len, 1, do_neon);

		src += round_down(len, POLY1305_BLOCK_SIZE);

		len %= POLY1305_BLOCK_SIZE;

	}



	if (unlikely(len)) {

		dctx->buflen = len;

		memcpy(dctx->buf, src, len);

	}

}



static int arm_poly1305_update(struct shash_desc *desc,

			       const u8 *src, unsigned int srclen)

{

	struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc);



	arm_poly1305_do_update(dctx, src, srclen, false);

	return 0;

}



static int __maybe_unused arm_poly1305_update_neon(struct shash_desc *desc,

						   const u8 *src,

						   unsigned int srclen)

{

	struct poly1305_desc_ctx *dctx = shash_desc_ctx(desc);

	bool do_neon = crypto_simd_usable() && srclen > 128;



	if (static_branch_likely(&have_neon) && do_neon)

		kernel_neon_begin();

	arm_poly1305_do_update(dctx, src, srclen, do_neon);

	if (static_branch_likely(&have_neon) && do_neon)

		kernel_neon_end();

	return 0;

}



void poly1305_update_arch(struct poly1305_desc_ctx *dctx, const u8 *src,

			  unsigned int nbytes)

{
@@ -199,45 +100,6 @@ void poly1305_final_arch(struct poly1305_desc_ctx *dctx, u8 *dst) 
}

EXPORT_SYMBOL(poly1305_final_arch);



static int arm_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_arch(dctx, dst);

	return 0;

}



static struct shash_alg arm_poly1305_algs[] = {{

	.init			= arm_poly1305_init,

	.update			= arm_poly1305_update,

	.final			= arm_poly1305_final,

	.digestsize		= POLY1305_DIGEST_SIZE,

	.descsize		= sizeof(struct poly1305_desc_ctx),



	.base.cra_name		= "poly1305",

	.base.cra_driver_name	= "poly1305-arm-old",

	.base.cra_priority	= 150,

	.base.cra_blocksize	= POLY1305_BLOCK_SIZE,

	.base.cra_module	= THIS_MODULE,

#ifdef CONFIG_KERNEL_MODE_NEON

}, {

	.init			= arm_poly1305_init,

	.update			= arm_poly1305_update_neon,

	.final			= arm_poly1305_final,

	.digestsize		= POLY1305_DIGEST_SIZE,

	.descsize		= sizeof(struct poly1305_desc_ctx),



	.base.cra_name		= "poly1305",

	.base.cra_driver_name	= "poly1305-neon",

	.base.cra_priority	= 200,

	.base.cra_blocksize	= POLY1305_BLOCK_SIZE,

	.base.cra_module	= THIS_MODULE,

#endif

}};



bool poly1305_is_arch_optimized(void)

{

	/* We always can use at least the ARM scalar implementation. */
@@ -250,32 +112,9 @@ static int __init arm_poly1305_mod_init(void) 
	if (IS_ENABLED(CONFIG_KERNEL_MODE_NEON) &&

	    (elf_hwcap & HWCAP_NEON))

		static_branch_enable(&have_neon);

	else if (IS_REACHABLE(CONFIG_CRYPTO_HASH))

		/* register only the first entry */

		return crypto_register_shash(&arm_poly1305_algs[0]);



	return IS_REACHABLE(CONFIG_CRYPTO_HASH) ?

		crypto_register_shashes(arm_poly1305_algs,

					ARRAY_SIZE(arm_poly1305_algs)) : 0;

}



static void __exit arm_poly1305_mod_exit(void)

{

	if (!IS_REACHABLE(CONFIG_CRYPTO_HASH))

		return;

	if (!static_branch_likely(&have_neon)) {

		crypto_unregister_shash(&arm_poly1305_algs[0]);

		return;

	}

	crypto_unregister_shashes(arm_poly1305_algs,

				  ARRAY_SIZE(arm_poly1305_algs));

	return 0;

}



arch_initcall(arm_poly1305_mod_init);

module_exit(arm_poly1305_mod_exit);



MODULE_DESCRIPTION("Accelerated Poly1305 transform for ARM");

MODULE_LICENSE("GPL v2");
 
MODULE_ALIAS_CRYPTO("poly1305");

MODULE_ALIAS_CRYPTO("poly1305-arm");

MODULE_ALIAS_CRYPTO("poly1305-neon");