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

crypto: s390/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: default avatarEric Biggers <ebiggers@google.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent bf52d938

arch/s390/configs/debug_defconfig

+0 −1
Original line number Diff line number Diff line
@@ -795,7 +795,6 @@ CONFIG_CRYPTO_USER_API_RNG=m 
CONFIG_CRYPTO_USER_API_AEAD=m

CONFIG_CRYPTO_SHA512_S390=m

CONFIG_CRYPTO_SHA1_S390=m

CONFIG_CRYPTO_SHA256_S390=m

CONFIG_CRYPTO_SHA3_256_S390=m

CONFIG_CRYPTO_SHA3_512_S390=m

CONFIG_CRYPTO_GHASH_S390=m

arch/s390/configs/defconfig

+0 −1
Original line number Diff line number Diff line
@@ -782,7 +782,6 @@ CONFIG_CRYPTO_USER_API_RNG=m 
CONFIG_CRYPTO_USER_API_AEAD=m

CONFIG_CRYPTO_SHA512_S390=m

CONFIG_CRYPTO_SHA1_S390=m

CONFIG_CRYPTO_SHA256_S390=m

CONFIG_CRYPTO_SHA3_256_S390=m

CONFIG_CRYPTO_SHA3_512_S390=m

CONFIG_CRYPTO_GHASH_S390=m

arch/s390/crypto/Kconfig

+0 −10
Original line number Diff line number Diff line
@@ -22,16 +22,6 @@ config CRYPTO_SHA1_S390 


	  It is available as of z990.



config CRYPTO_SHA256_S390

	tristate "Hash functions: SHA-224 and SHA-256"

	select CRYPTO_HASH

	help

	  SHA-224 and SHA-256 secure hash algorithms (FIPS 180)



	  Architecture: s390



	  It is available as of z9.



config CRYPTO_SHA3_256_S390

	tristate "Hash functions: SHA3-224 and SHA3-256"

	select CRYPTO_HASH

arch/s390/crypto/Makefile

+0 −1
Original line number Diff line number Diff line
@@ -4,7 +4,6 @@ 
#



obj-$(CONFIG_CRYPTO_SHA1_S390) += sha1_s390.o sha_common.o

obj-$(CONFIG_CRYPTO_SHA256_S390) += sha256_s390.o sha_common.o

obj-$(CONFIG_CRYPTO_SHA512_S390) += sha512_s390.o sha_common.o

obj-$(CONFIG_CRYPTO_SHA3_256_S390) += sha3_256_s390.o sha_common.o

obj-$(CONFIG_CRYPTO_SHA3_512_S390) += sha3_512_s390.o sha_common.o

arch/s390/crypto/sha256_s390.c

deleted100644 → 0
+0 −144
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0+

/*

 * Cryptographic API.

 *

 * s390 implementation of the SHA256 and SHA224 Secure Hash Algorithm.

 *

 * s390 Version:

 *   Copyright IBM Corp. 2005, 2011

 *   Author(s): Jan Glauber (jang@de.ibm.com)

 */

#include <asm/cpacf.h>

#include <crypto/internal/hash.h>

#include <crypto/sha2.h>

#include <linux/cpufeature.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/string.h>



#include "sha.h"



static int s390_sha256_init(struct shash_desc *desc)

{

	struct s390_sha_ctx *sctx = shash_desc_ctx(desc);



	sctx->state[0] = SHA256_H0;

	sctx->state[1] = SHA256_H1;

	sctx->state[2] = SHA256_H2;

	sctx->state[3] = SHA256_H3;

	sctx->state[4] = SHA256_H4;

	sctx->state[5] = SHA256_H5;

	sctx->state[6] = SHA256_H6;

	sctx->state[7] = SHA256_H7;

	sctx->count = 0;

	sctx->func = CPACF_KIMD_SHA_256;



	return 0;

}



static int sha256_export(struct shash_desc *desc, void *out)

{

	struct s390_sha_ctx *sctx = shash_desc_ctx(desc);

	struct crypto_sha256_state *octx = out;



	octx->count = sctx->count;

	memcpy(octx->state, sctx->state, sizeof(octx->state));

	return 0;

}



static int sha256_import(struct shash_desc *desc, const void *in)

{

	struct s390_sha_ctx *sctx = shash_desc_ctx(desc);

	const struct crypto_sha256_state *ictx = in;



	sctx->count = ictx->count;

	memcpy(sctx->state, ictx->state, sizeof(ictx->state));

	sctx->func = CPACF_KIMD_SHA_256;

	return 0;

}



static struct shash_alg sha256_alg = {

	.digestsize	=	SHA256_DIGEST_SIZE,

	.init		=	s390_sha256_init,

	.update		=	s390_sha_update_blocks,

	.finup		=	s390_sha_finup,

	.export		=	sha256_export,

	.import		=	sha256_import,

	.descsize	=	S390_SHA_CTX_SIZE,

	.statesize	=	sizeof(struct crypto_sha256_state),

	.base		=	{

		.cra_name	=	"sha256",

		.cra_driver_name=	"sha256-s390",

		.cra_priority	=	300,

		.cra_flags	=	CRYPTO_AHASH_ALG_BLOCK_ONLY,

		.cra_blocksize	=	SHA256_BLOCK_SIZE,

		.cra_module	=	THIS_MODULE,

	}

};



static int s390_sha224_init(struct shash_desc *desc)

{

	struct s390_sha_ctx *sctx = shash_desc_ctx(desc);



	sctx->state[0] = SHA224_H0;

	sctx->state[1] = SHA224_H1;

	sctx->state[2] = SHA224_H2;

	sctx->state[3] = SHA224_H3;

	sctx->state[4] = SHA224_H4;

	sctx->state[5] = SHA224_H5;

	sctx->state[6] = SHA224_H6;

	sctx->state[7] = SHA224_H7;

	sctx->count = 0;

	sctx->func = CPACF_KIMD_SHA_256;



	return 0;

}



static struct shash_alg sha224_alg = {

	.digestsize	=	SHA224_DIGEST_SIZE,

	.init		=	s390_sha224_init,

	.update		=	s390_sha_update_blocks,

	.finup		=	s390_sha_finup,

	.export		=	sha256_export,

	.import		=	sha256_import,

	.descsize	=	S390_SHA_CTX_SIZE,

	.statesize	=	sizeof(struct crypto_sha256_state),

	.base		=	{

		.cra_name	=	"sha224",

		.cra_driver_name=	"sha224-s390",

		.cra_priority	=	300,

		.cra_flags	=	CRYPTO_AHASH_ALG_BLOCK_ONLY,

		.cra_blocksize	=	SHA224_BLOCK_SIZE,

		.cra_module	=	THIS_MODULE,

	}

};



static int __init sha256_s390_init(void)

{

	int ret;



	if (!cpacf_query_func(CPACF_KIMD, CPACF_KIMD_SHA_256))

		return -ENODEV;

	ret = crypto_register_shash(&sha256_alg);

	if (ret < 0)

		goto out;

	ret = crypto_register_shash(&sha224_alg);

	if (ret < 0)

		crypto_unregister_shash(&sha256_alg);

out:

	return ret;

}



static void __exit sha256_s390_fini(void)

{

	crypto_unregister_shash(&sha224_alg);

	crypto_unregister_shash(&sha256_alg);

}



module_cpu_feature_match(S390_CPU_FEATURE_MSA, sha256_s390_init);

module_exit(sha256_s390_fini);



MODULE_ALIAS_CRYPTO("sha256");

MODULE_ALIAS_CRYPTO("sha224");

MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("SHA256 and SHA224 Secure Hash Algorithm");