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

lib/crypto: mips/sha1: Migrate optimized code into library 



Instead of exposing the mips-optimized SHA-1 code via mips-specific
crypto_shash algorithms, instead just implement the sha1_blocks()
library function.  This is much simpler, it makes the SHA-1 library
functions be mips-optimized, and it fixes the longstanding issue where
the mips-optimized SHA-1 code was disabled by default.  SHA-1 still
remains available through crypto_shash, but individual architectures no
longer need to handle it.

Note: to see the diff from arch/mips/cavium-octeon/crypto/octeon-sha1.c
to lib/crypto/mips/sha1.h, view this commit with 'git show -M10'.

Reviewed-by: default avatarArd Biesheuvel <ardb@kernel.org>
Link: https://lore.kernel.org/r/20250712232329.818226-10-ebiggers@kernel.org


Signed-off-by: default avatarEric Biggers <ebiggers@kernel.org>
parent 00d549bb

arch/mips/cavium-octeon/crypto/Makefile

+0 −1
Original line number Diff line number Diff line
@@ -6,4 +6,3 @@ 
obj-y += octeon-crypto.o



obj-$(CONFIG_CRYPTO_MD5_OCTEON)		+= octeon-md5.o
 
obj-$(CONFIG_CRYPTO_SHA1_OCTEON)	+= octeon-sha1.o

arch/mips/configs/cavium_octeon_defconfig

+0 −1
Original line number Diff line number Diff line
@@ -156,7 +156,6 @@ CONFIG_SECURITY_NETWORK=y 
CONFIG_CRYPTO_CBC=y

CONFIG_CRYPTO_HMAC=y

CONFIG_CRYPTO_MD5_OCTEON=y

CONFIG_CRYPTO_SHA1_OCTEON=m

CONFIG_CRYPTO_DES=y

CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT=y

CONFIG_DEBUG_FS=y

arch/mips/crypto/Kconfig

+0 −10
Original line number Diff line number Diff line
@@ -12,14 +12,4 @@ config CRYPTO_MD5_OCTEON 


	  Architecture: mips OCTEON using crypto instructions, when available



config CRYPTO_SHA1_OCTEON

	tristate "Hash functions: SHA-1 (OCTEON)"

	depends on CPU_CAVIUM_OCTEON

	select CRYPTO_SHA1

	select CRYPTO_HASH

	help

	  SHA-1 secure hash algorithm (FIPS 180)



	  Architecture: mips OCTEON



endmenu

lib/crypto/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -148,6 +148,7 @@ config CRYPTO_LIB_SHA1_ARCH 
	depends on CRYPTO_LIB_SHA1 && !UML

	default y if ARM

	default y if ARM64 && KERNEL_MODE_NEON

	default y if MIPS && CPU_CAVIUM_OCTEON



config CRYPTO_LIB_SHA256

	tristate

arch/mips/cavium-octeon/crypto/octeon-sha1.c→lib/crypto/mips/sha1.h

+81 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/* SPDX-License-Identifier: GPL-2.0-or-later */

/*

 * Cryptographic API.

 *
@@ -15,24 +15,18 @@ 


#include <asm/octeon/crypto.h>

#include <asm/octeon/octeon.h>

#include <crypto/internal/hash.h>

#include <crypto/sha1.h>

#include <crypto/sha1_base.h>

#include <linux/errno.h>

#include <linux/kernel.h>

#include <linux/module.h>



/*

 * We pass everything as 64-bit. OCTEON can handle misaligned data.

 */



static void octeon_sha1_store_hash(struct sha1_state *sctx)

static void octeon_sha1_store_hash(struct sha1_block_state *state)

{

	u64 *hash = (u64 *)sctx->state;

	u64 *hash = (u64 *)&state->h[0];

	union {

		u32 word[2];

		u64 dword;

	} hash_tail = { { sctx->state[4], } };

	} hash_tail = { { state->h[4], } };



	write_octeon_64bit_hash_dword(hash[0], 0);

	write_octeon_64bit_hash_dword(hash[1], 1);
@@ -40,9 +34,9 @@ static void octeon_sha1_store_hash(struct sha1_state *sctx) 
	memzero_explicit(&hash_tail.word[0], sizeof(hash_tail.word[0]));

}



static void octeon_sha1_read_hash(struct sha1_state *sctx)

static void octeon_sha1_read_hash(struct sha1_block_state *state)

{

	u64 *hash = (u64 *)sctx->state;

	u64 *hash = (u64 *)&state->h[0];

	union {

		u32 word[2];

		u64 dword;
@@ -51,15 +45,24 @@ static void octeon_sha1_read_hash(struct sha1_state *sctx) 
	hash[0]		= read_octeon_64bit_hash_dword(0);

	hash[1]		= read_octeon_64bit_hash_dword(1);

	hash_tail.dword	= read_octeon_64bit_hash_dword(2);

	sctx->state[4]	= hash_tail.word[0];

	state->h[4]	= hash_tail.word[0];

	memzero_explicit(&hash_tail.dword, sizeof(hash_tail.dword));

}



static void octeon_sha1_transform(struct sha1_state *sctx, const u8 *src,

				  int blocks)

static void sha1_blocks(struct sha1_block_state *state,

			const u8 *data, size_t nblocks)

{

	struct octeon_cop2_state cop2_state;

	unsigned long flags;



	if (!octeon_has_crypto())

		return sha1_blocks_generic(state, data, nblocks);



	flags = octeon_crypto_enable(&cop2_state);

	octeon_sha1_store_hash(state);



	do {

		const u64 *block = (const u64 *)src;

		const u64 *block = (const u64 *)data;



		write_octeon_64bit_block_dword(block[0], 0);

		write_octeon_64bit_block_dword(block[1], 1);
@@ -70,77 +73,9 @@ static void octeon_sha1_transform(struct sha1_state *sctx, const u8 *src, 
		write_octeon_64bit_block_dword(block[6], 6);

		octeon_sha1_start(block[7]);



		src += SHA1_BLOCK_SIZE;

	} while (--blocks);

}

		data += SHA1_BLOCK_SIZE;

	} while (--nblocks);



static int octeon_sha1_update(struct shash_desc *desc, const u8 *data,

			unsigned int len)

{

	struct sha1_state *sctx = shash_desc_ctx(desc);

	struct octeon_cop2_state state;

	unsigned long flags;

	int remain;



	flags = octeon_crypto_enable(&state);

	octeon_sha1_store_hash(sctx);



	remain = sha1_base_do_update_blocks(desc, data, len,

					    octeon_sha1_transform);



	octeon_sha1_read_hash(sctx);

	octeon_crypto_disable(&state, flags);

	return remain;

	octeon_sha1_read_hash(state);

	octeon_crypto_disable(&cop2_state, flags);

}
 


static int octeon_sha1_finup(struct shash_desc *desc, const u8 *src,

			     unsigned int len, u8 *out)

{

	struct sha1_state *sctx = shash_desc_ctx(desc);

	struct octeon_cop2_state state;

	unsigned long flags;



	flags = octeon_crypto_enable(&state);

	octeon_sha1_store_hash(sctx);



	sha1_base_do_finup(desc, src, len, octeon_sha1_transform);



	octeon_sha1_read_hash(sctx);

	octeon_crypto_disable(&state, flags);

	return sha1_base_finish(desc, out);

}



static struct shash_alg octeon_sha1_alg = {

	.digestsize	=	SHA1_DIGEST_SIZE,

	.init		=	sha1_base_init,

	.update		=	octeon_sha1_update,

	.finup		=	octeon_sha1_finup,

	.descsize	=	SHA1_STATE_SIZE,

	.base		=	{

		.cra_name	=	"sha1",

		.cra_driver_name=	"octeon-sha1",

		.cra_priority	=	OCTEON_CR_OPCODE_PRIORITY,

		.cra_flags	=	CRYPTO_AHASH_ALG_BLOCK_ONLY,

		.cra_blocksize	=	SHA1_BLOCK_SIZE,

		.cra_module	=	THIS_MODULE,

	}

};



static int __init octeon_sha1_mod_init(void)

{

	if (!octeon_has_crypto())

		return -ENOTSUPP;

	return crypto_register_shash(&octeon_sha1_alg);

}



static void __exit octeon_sha1_mod_fini(void)

{

	crypto_unregister_shash(&octeon_sha1_alg);

}



module_init(octeon_sha1_mod_init);

module_exit(octeon_sha1_mod_fini);



MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("SHA1 Secure Hash Algorithm (OCTEON)");

MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@iki.fi>");