mirror of
https://github.com/torvalds/linux.git
synced 2026-05-29 17:43:52 +02:00
crypto: powerpc/sha256 - implement library instead of shash
Instead of providing crypto_shash algorithms for the arch-optimized SHA-256 code, instead implement the SHA-256 library. This is much simpler, it makes the SHA-256 library functions be arch-optimized, and it fixes the longstanding issue where the arch-optimized SHA-256 was disabled by default. SHA-256 still remains available through crypto_shash, but individual architectures no longer need to handle it. Signed-off-by: Eric Biggers <ebiggers@google.com> Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
This commit is contained in:
Eric Biggers
Herbert Xu
parent
b67b6f9adb
commit
1a49c573bf
|
|
@ -39,17 +39,6 @@ config CRYPTO_SHA1_PPC_SPE
|
|||
Architecture: powerpc using
|
||||
- SPE (Signal Processing Engine) extensions
|
||||
|
||||
config CRYPTO_SHA256_PPC_SPE
|
||||
tristate "Hash functions: SHA-224 and SHA-256 (SPE)"
|
||||
depends on SPE
|
||||
select CRYPTO_SHA256
|
||||
select CRYPTO_HASH
|
||||
help
|
||||
SHA-224 and SHA-256 secure hash algorithms (FIPS 180)
|
||||
|
||||
Architecture: powerpc using
|
||||
- SPE (Signal Processing Engine) extensions
|
||||
|
||||
config CRYPTO_AES_PPC_SPE
|
||||
tristate "Ciphers: AES, modes: ECB/CBC/CTR/XTS (SPE)"
|
||||
depends on SPE
|
||||
|
|
|
|||
|
|
@ -9,7 +9,6 @@ obj-$(CONFIG_CRYPTO_AES_PPC_SPE) += aes-ppc-spe.o
|
|||
obj-$(CONFIG_CRYPTO_MD5_PPC) += md5-ppc.o
|
||||
obj-$(CONFIG_CRYPTO_SHA1_PPC) += sha1-powerpc.o
|
||||
obj-$(CONFIG_CRYPTO_SHA1_PPC_SPE) += sha1-ppc-spe.o
|
||||
obj-$(CONFIG_CRYPTO_SHA256_PPC_SPE) += sha256-ppc-spe.o
|
||||
obj-$(CONFIG_CRYPTO_AES_GCM_P10) += aes-gcm-p10-crypto.o
|
||||
obj-$(CONFIG_CRYPTO_DEV_VMX_ENCRYPT) += vmx-crypto.o
|
||||
obj-$(CONFIG_CRYPTO_CURVE25519_PPC64) += curve25519-ppc64le.o
|
||||
|
|
@ -18,7 +17,6 @@ aes-ppc-spe-y := aes-spe-core.o aes-spe-keys.o aes-tab-4k.o aes-spe-modes.o aes-
|
|||
md5-ppc-y := md5-asm.o md5-glue.o
|
||||
sha1-powerpc-y := sha1-powerpc-asm.o sha1.o
|
||||
sha1-ppc-spe-y := sha1-spe-asm.o sha1-spe-glue.o
|
||||
sha256-ppc-spe-y := sha256-spe-asm.o sha256-spe-glue.o
|
||||
aes-gcm-p10-crypto-y := aes-gcm-p10-glue.o aes-gcm-p10.o ghashp10-ppc.o aesp10-ppc.o
|
||||
vmx-crypto-objs := vmx.o aesp8-ppc.o ghashp8-ppc.o aes.o aes_cbc.o aes_ctr.o aes_xts.o ghash.o
|
||||
curve25519-ppc64le-y := curve25519-ppc64le-core.o curve25519-ppc64le_asm.o
|
||||
|
|
|
|||
|
|
@ -1,128 +0,0 @@
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
/*
|
||||
* Glue code for SHA-256 implementation for SPE instructions (PPC)
|
||||
*
|
||||
* Based on generic implementation. The assembler module takes care
|
||||
* about the SPE registers so it can run from interrupt context.
|
||||
*
|
||||
* Copyright (c) 2015 Markus Stockhausen <stockhausen@collogia.de>
|
||||
*/
|
||||
|
||||
#include <asm/switch_to.h>
|
||||
#include <crypto/internal/hash.h>
|
||||
#include <crypto/sha2.h>
|
||||
#include <crypto/sha256_base.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/preempt.h>
|
||||
|
||||
/*
|
||||
* MAX_BYTES defines the number of bytes that are allowed to be processed
|
||||
* between preempt_disable() and preempt_enable(). SHA256 takes ~2,000
|
||||
* operations per 64 bytes. e500 cores can issue two arithmetic instructions
|
||||
* per clock cycle using one 32/64 bit unit (SU1) and one 32 bit unit (SU2).
|
||||
* Thus 1KB of input data will need an estimated maximum of 18,000 cycles.
|
||||
* Headroom for cache misses included. Even with the low end model clocked
|
||||
* at 667 MHz this equals to a critical time window of less than 27us.
|
||||
*
|
||||
*/
|
||||
#define MAX_BYTES 1024
|
||||
|
||||
extern void ppc_spe_sha256_transform(u32 *state, const u8 *src, u32 blocks);
|
||||
|
||||
static void spe_begin(void)
|
||||
{
|
||||
/* We just start SPE operations and will save SPE registers later. */
|
||||
preempt_disable();
|
||||
enable_kernel_spe();
|
||||
}
|
||||
|
||||
static void spe_end(void)
|
||||
{
|
||||
disable_kernel_spe();
|
||||
/* reenable preemption */
|
||||
preempt_enable();
|
||||
}
|
||||
|
||||
static void ppc_spe_sha256_block(struct crypto_sha256_state *sctx,
|
||||
const u8 *src, int blocks)
|
||||
{
|
||||
do {
|
||||
/* cut input data into smaller blocks */
|
||||
int unit = min(blocks, MAX_BYTES / SHA256_BLOCK_SIZE);
|
||||
|
||||
spe_begin();
|
||||
ppc_spe_sha256_transform(sctx->state, src, unit);
|
||||
spe_end();
|
||||
|
||||
src += unit * SHA256_BLOCK_SIZE;
|
||||
blocks -= unit;
|
||||
} while (blocks);
|
||||
}
|
||||
|
||||
static int ppc_spe_sha256_update(struct shash_desc *desc, const u8 *data,
|
||||
unsigned int len)
|
||||
{
|
||||
return sha256_base_do_update_blocks(desc, data, len,
|
||||
ppc_spe_sha256_block);
|
||||
}
|
||||
|
||||
static int ppc_spe_sha256_finup(struct shash_desc *desc, const u8 *src,
|
||||
unsigned int len, u8 *out)
|
||||
{
|
||||
sha256_base_do_finup(desc, src, len, ppc_spe_sha256_block);
|
||||
return sha256_base_finish(desc, out);
|
||||
}
|
||||
|
||||
static struct shash_alg algs[2] = { {
|
||||
.digestsize = SHA256_DIGEST_SIZE,
|
||||
.init = sha256_base_init,
|
||||
.update = ppc_spe_sha256_update,
|
||||
.finup = ppc_spe_sha256_finup,
|
||||
.descsize = sizeof(struct crypto_sha256_state),
|
||||
.base = {
|
||||
.cra_name = "sha256",
|
||||
.cra_driver_name= "sha256-ppc-spe",
|
||||
.cra_priority = 300,
|
||||
.cra_flags = CRYPTO_AHASH_ALG_BLOCK_ONLY |
|
||||
CRYPTO_AHASH_ALG_FINUP_MAX,
|
||||
.cra_blocksize = SHA256_BLOCK_SIZE,
|
||||
.cra_module = THIS_MODULE,
|
||||
}
|
||||
}, {
|
||||
.digestsize = SHA224_DIGEST_SIZE,
|
||||
.init = sha224_base_init,
|
||||
.update = ppc_spe_sha256_update,
|
||||
.finup = ppc_spe_sha256_finup,
|
||||
.descsize = sizeof(struct crypto_sha256_state),
|
||||
.base = {
|
||||
.cra_name = "sha224",
|
||||
.cra_driver_name= "sha224-ppc-spe",
|
||||
.cra_priority = 300,
|
||||
.cra_flags = CRYPTO_AHASH_ALG_BLOCK_ONLY |
|
||||
CRYPTO_AHASH_ALG_FINUP_MAX,
|
||||
.cra_blocksize = SHA224_BLOCK_SIZE,
|
||||
.cra_module = THIS_MODULE,
|
||||
}
|
||||
} };
|
||||
|
||||
static int __init ppc_spe_sha256_mod_init(void)
|
||||
{
|
||||
return crypto_register_shashes(algs, ARRAY_SIZE(algs));
|
||||
}
|
||||
|
||||
static void __exit ppc_spe_sha256_mod_fini(void)
|
||||
{
|
||||
crypto_unregister_shashes(algs, ARRAY_SIZE(algs));
|
||||
}
|
||||
|
||||
module_init(ppc_spe_sha256_mod_init);
|
||||
module_exit(ppc_spe_sha256_mod_fini);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("SHA-224 and SHA-256 Secure Hash Algorithm, SPE optimized");
|
||||
|
||||
MODULE_ALIAS_CRYPTO("sha224");
|
||||
MODULE_ALIAS_CRYPTO("sha224-ppc-spe");
|
||||
MODULE_ALIAS_CRYPTO("sha256");
|
||||
MODULE_ALIAS_CRYPTO("sha256-ppc-spe");
|
||||
|
|
@ -13,3 +13,9 @@ config CRYPTO_POLY1305_P10
|
|||
default CRYPTO_LIB_POLY1305
|
||||
select CRYPTO_ARCH_HAVE_LIB_POLY1305
|
||||
select CRYPTO_LIB_POLY1305_GENERIC
|
||||
|
||||
config CRYPTO_SHA256_PPC_SPE
|
||||
tristate
|
||||
depends on SPE
|
||||
default CRYPTO_LIB_SHA256
|
||||
select CRYPTO_ARCH_HAVE_LIB_SHA256
|
||||
|
|
|
|||
|
|
@ -5,3 +5,6 @@ chacha-p10-crypto-y := chacha-p10-glue.o chacha-p10le-8x.o
|
|||
|
||||
obj-$(CONFIG_CRYPTO_POLY1305_P10) += poly1305-p10-crypto.o
|
||||
poly1305-p10-crypto-y := poly1305-p10-glue.o poly1305-p10le_64.o
|
||||
|
||||
obj-$(CONFIG_CRYPTO_SHA256_PPC_SPE) += sha256-ppc-spe.o
|
||||
sha256-ppc-spe-y := sha256.o sha256-spe-asm.o
|
||||
|
|
|
|||
70
arch/powerpc/lib/crypto/sha256.c
Normal file
70
arch/powerpc/lib/crypto/sha256.c
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
/*
|
||||
* SHA-256 Secure Hash Algorithm, SPE optimized
|
||||
*
|
||||
* Based on generic implementation. The assembler module takes care
|
||||
* about the SPE registers so it can run from interrupt context.
|
||||
*
|
||||
* Copyright (c) 2015 Markus Stockhausen <stockhausen@collogia.de>
|
||||
*/
|
||||
|
||||
#include <asm/switch_to.h>
|
||||
#include <crypto/internal/sha2.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/preempt.h>
|
||||
|
||||
/*
|
||||
* MAX_BYTES defines the number of bytes that are allowed to be processed
|
||||
* between preempt_disable() and preempt_enable(). SHA256 takes ~2,000
|
||||
* operations per 64 bytes. e500 cores can issue two arithmetic instructions
|
||||
* per clock cycle using one 32/64 bit unit (SU1) and one 32 bit unit (SU2).
|
||||
* Thus 1KB of input data will need an estimated maximum of 18,000 cycles.
|
||||
* Headroom for cache misses included. Even with the low end model clocked
|
||||
* at 667 MHz this equals to a critical time window of less than 27us.
|
||||
*
|
||||
*/
|
||||
#define MAX_BYTES 1024
|
||||
|
||||
extern void ppc_spe_sha256_transform(u32 *state, const u8 *src, u32 blocks);
|
||||
|
||||
static void spe_begin(void)
|
||||
{
|
||||
/* We just start SPE operations and will save SPE registers later. */
|
||||
preempt_disable();
|
||||
enable_kernel_spe();
|
||||
}
|
||||
|
||||
static void spe_end(void)
|
||||
{
|
||||
disable_kernel_spe();
|
||||
/* reenable preemption */
|
||||
preempt_enable();
|
||||
}
|
||||
|
||||
void sha256_blocks_arch(u32 state[SHA256_STATE_WORDS],
|
||||
const u8 *data, size_t nblocks)
|
||||
{
|
||||
do {
|
||||
/* cut input data into smaller blocks */
|
||||
u32 unit = min_t(size_t, nblocks,
|
||||
MAX_BYTES / SHA256_BLOCK_SIZE);
|
||||
|
||||
spe_begin();
|
||||
ppc_spe_sha256_transform(state, data, unit);
|
||||
spe_end();
|
||||
|
||||
data += unit * SHA256_BLOCK_SIZE;
|
||||
nblocks -= unit;
|
||||
} while (nblocks);
|
||||
}
|
||||
EXPORT_SYMBOL(sha256_blocks_arch);
|
||||
|
||||
bool sha256_is_arch_optimized(void)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
EXPORT_SYMBOL(sha256_is_arch_optimized);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("SHA-256 Secure Hash Algorithm, SPE optimized");
|
||||
Loading…
Reference in New Issue
Block a user