Commit 563f346d authored by Herbert Xu's avatar Herbert Xu
Browse files

crypto: sha-s390 - Switch to shash 



This patch converts the S390 sha algorithms to the new shash interface.

With fixes by Jan Glauber.

Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 97495986

arch/s390/crypto/sha.h

+4 −2
Original line number Diff line number Diff line
@@ -29,7 +29,9 @@ struct s390_sha_ctx { 
	int func;		/* KIMD function to use */

};



void s390_sha_update(struct crypto_tfm *tfm, const u8 *data, unsigned int len);

void s390_sha_final(struct crypto_tfm *tfm, u8 *out);

struct shash_desc;



int s390_sha_update(struct shash_desc *desc, const u8 *data, unsigned int len);

int s390_sha_final(struct shash_desc *desc, u8 *out);



#endif

arch/s390/crypto/sha1_s390.c

+21 −19
Original line number Diff line number Diff line
@@ -23,17 +23,17 @@ 
 * any later version.

 *

 */

#include <crypto/internal/hash.h>

#include <linux/init.h>

#include <linux/module.h>

#include <linux/crypto.h>

#include <crypto/sha.h>



#include "crypt_s390.h"

#include "sha.h"



static void sha1_init(struct crypto_tfm *tfm)

static int sha1_init(struct shash_desc *desc)

{

	struct s390_sha_ctx *sctx = crypto_tfm_ctx(tfm);

	struct s390_sha_ctx *sctx = shash_desc_ctx(desc);



	sctx->state[0] = SHA1_H0;

	sctx->state[1] = SHA1_H1;
@@ -42,34 +42,36 @@ static void sha1_init(struct crypto_tfm *tfm) 
	sctx->state[4] = SHA1_H4;

	sctx->count = 0;

	sctx->func = KIMD_SHA_1;



	return 0;

}



static struct crypto_alg alg = {

static struct shash_alg alg = {

	.digestsize	=	SHA1_DIGEST_SIZE,

	.init		=	sha1_init,

	.update		=	s390_sha_update,

	.final		=	s390_sha_final,

	.descsize	=	sizeof(struct s390_sha_ctx),

	.base		=	{

		.cra_name	=	"sha1",

		.cra_driver_name=	"sha1-s390",

		.cra_priority	=	CRYPT_S390_PRIORITY,

	.cra_flags	=	CRYPTO_ALG_TYPE_DIGEST,

		.cra_flags	=	CRYPTO_ALG_TYPE_SHASH,

		.cra_blocksize	=	SHA1_BLOCK_SIZE,

	.cra_ctxsize	=	sizeof(struct s390_sha_ctx),

		.cra_module	=	THIS_MODULE,

	.cra_list	=	LIST_HEAD_INIT(alg.cra_list),

	.cra_u		=	{ .digest = {

	.dia_digestsize	=	SHA1_DIGEST_SIZE,

	.dia_init	=	sha1_init,

	.dia_update	=	s390_sha_update,

	.dia_final	=	s390_sha_final } }

	}

};



static int __init sha1_s390_init(void)

{

	if (!crypt_s390_func_available(KIMD_SHA_1))

		return -EOPNOTSUPP;

	return crypto_register_alg(&alg);

	return crypto_register_shash(&alg);

}



static void __exit sha1_s390_fini(void)

{

	crypto_unregister_alg(&alg);

	crypto_unregister_shash(&alg);

}



module_init(sha1_s390_init);

arch/s390/crypto/sha256_s390.c

+21 −19
Original line number Diff line number Diff line
@@ -16,17 +16,17 @@ 
 * any later version.

 *

 */

#include <crypto/internal/hash.h>

#include <linux/init.h>

#include <linux/module.h>

#include <linux/crypto.h>

#include <crypto/sha.h>



#include "crypt_s390.h"

#include "sha.h"



static void sha256_init(struct crypto_tfm *tfm)

static int sha256_init(struct shash_desc *desc)

{

	struct s390_sha_ctx *sctx = crypto_tfm_ctx(tfm);

	struct s390_sha_ctx *sctx = shash_desc_ctx(desc);



	sctx->state[0] = SHA256_H0;

	sctx->state[1] = SHA256_H1;
@@ -38,22 +38,24 @@ static void sha256_init(struct crypto_tfm *tfm) 
	sctx->state[7] = SHA256_H7;

	sctx->count = 0;

	sctx->func = KIMD_SHA_256;



	return 0;

}



static struct crypto_alg alg = {

static struct shash_alg alg = {

	.digestsize	=	SHA256_DIGEST_SIZE,

	.init		=	sha256_init,

	.update		=	s390_sha_update,

	.final		=	s390_sha_final,

	.descsize	=	sizeof(struct s390_sha_ctx),

	.base		=	{

		.cra_name	=	"sha256",

		.cra_driver_name=	"sha256-s390",

		.cra_priority	=	CRYPT_S390_PRIORITY,

	.cra_flags	=	CRYPTO_ALG_TYPE_DIGEST,

		.cra_flags	=	CRYPTO_ALG_TYPE_SHASH,

		.cra_blocksize	=	SHA256_BLOCK_SIZE,

	.cra_ctxsize	=	sizeof(struct s390_sha_ctx),

		.cra_module	=	THIS_MODULE,

	.cra_list	=	LIST_HEAD_INIT(alg.cra_list),

	.cra_u		=	{ .digest = {

	.dia_digestsize	=	SHA256_DIGEST_SIZE,

	.dia_init	=	sha256_init,

	.dia_update	=	s390_sha_update,

	.dia_final	=	s390_sha_final } }

	}

};



static int sha256_s390_init(void)
@@ -61,12 +63,12 @@ static int sha256_s390_init(void) 
	if (!crypt_s390_func_available(KIMD_SHA_256))

		return -EOPNOTSUPP;



	return crypto_register_alg(&alg);

	return crypto_register_shash(&alg);

}



static void __exit sha256_s390_fini(void)

{

	crypto_unregister_alg(&alg);

	crypto_unregister_shash(&alg);

}



module_init(sha256_s390_init);

arch/s390/crypto/sha512_s390.c

+42 −38
Original line number Diff line number Diff line
@@ -12,16 +12,16 @@ 
 * any later version.

 *

 */

#include <crypto/internal/hash.h>

#include <linux/init.h>

#include <linux/module.h>

#include <linux/crypto.h>



#include "sha.h"

#include "crypt_s390.h"



static void sha512_init(struct crypto_tfm *tfm)

static int sha512_init(struct shash_desc *desc)

{

	struct s390_sha_ctx *ctx = crypto_tfm_ctx(tfm);

	struct s390_sha_ctx *ctx = shash_desc_ctx(desc);



	*(__u64 *)&ctx->state[0] = 0x6a09e667f3bcc908ULL;

	*(__u64 *)&ctx->state[2] = 0xbb67ae8584caa73bULL;
@@ -33,29 +33,31 @@ static void sha512_init(struct crypto_tfm *tfm) 
	*(__u64 *)&ctx->state[14] = 0x5be0cd19137e2179ULL;

	ctx->count = 0;

	ctx->func = KIMD_SHA_512;



	return 0;

}



static struct crypto_alg sha512_alg = {

static struct shash_alg sha512_alg = {

	.digestsize	=	SHA512_DIGEST_SIZE,

	.init		=	sha512_init,

	.update		=	s390_sha_update,

	.final		=	s390_sha_final,

	.descsize	=	sizeof(struct s390_sha_ctx),

	.base		=	{

		.cra_name	=	"sha512",

		.cra_driver_name=	"sha512-s390",

		.cra_priority	=	CRYPT_S390_PRIORITY,

	.cra_flags	=	CRYPTO_ALG_TYPE_DIGEST,

		.cra_flags	=	CRYPTO_ALG_TYPE_SHASH,

		.cra_blocksize	=	SHA512_BLOCK_SIZE,

	.cra_ctxsize	=	sizeof(struct s390_sha_ctx),

		.cra_module	=	THIS_MODULE,

	.cra_list	=	LIST_HEAD_INIT(sha512_alg.cra_list),

	.cra_u		=	{ .digest = {

	.dia_digestsize	=	SHA512_DIGEST_SIZE,

	.dia_init	=	sha512_init,

	.dia_update	=	s390_sha_update,

	.dia_final	=	s390_sha_final } }

	}

};



MODULE_ALIAS("sha512");



static void sha384_init(struct crypto_tfm *tfm)

static int sha384_init(struct shash_desc *desc)

{

	struct s390_sha_ctx *ctx = crypto_tfm_ctx(tfm);

	struct s390_sha_ctx *ctx = shash_desc_ctx(desc);



	*(__u64 *)&ctx->state[0] = 0xcbbb9d5dc1059ed8ULL;

	*(__u64 *)&ctx->state[2] = 0x629a292a367cd507ULL;
@@ -67,22 +69,24 @@ static void sha384_init(struct crypto_tfm *tfm) 
	*(__u64 *)&ctx->state[14] = 0x47b5481dbefa4fa4ULL;

	ctx->count = 0;

	ctx->func = KIMD_SHA_512;



	return 0;

}



static struct crypto_alg sha384_alg = {

static struct shash_alg sha384_alg = {

	.digestsize	=	SHA384_DIGEST_SIZE,

	.init		=	sha384_init,

	.update		=	s390_sha_update,

	.final		=	s390_sha_final,

	.descsize	=	sizeof(struct s390_sha_ctx),

	.base		=	{

		.cra_name	=	"sha384",

		.cra_driver_name=	"sha384-s390",

		.cra_priority	=	CRYPT_S390_PRIORITY,

	.cra_flags	=	CRYPTO_ALG_TYPE_DIGEST,

	.cra_blocksize	=	SHA384_BLOCK_SIZE,

		.cra_flags	=	CRYPTO_ALG_TYPE_SHASH,

		.cra_ctxsize	=	sizeof(struct s390_sha_ctx),

		.cra_module	=	THIS_MODULE,

	.cra_list	=	LIST_HEAD_INIT(sha384_alg.cra_list),

	.cra_u		=	{ .digest = {

	.dia_digestsize	=	SHA384_DIGEST_SIZE,

	.dia_init	=	sha384_init,

	.dia_update	=	s390_sha_update,

	.dia_final	=	s390_sha_final } }

	}

};



MODULE_ALIAS("sha384");
@@ -93,18 +97,18 @@ static int __init init(void) 


	if (!crypt_s390_func_available(KIMD_SHA_512))

		return -EOPNOTSUPP;

	if ((ret = crypto_register_alg(&sha512_alg)) < 0)

	if ((ret = crypto_register_shash(&sha512_alg)) < 0)

		goto out;

	if ((ret = crypto_register_alg(&sha384_alg)) < 0)

		crypto_unregister_alg(&sha512_alg);

	if ((ret = crypto_register_shash(&sha384_alg)) < 0)

		crypto_unregister_shash(&sha512_alg);

out:

	return ret;

}



static void __exit fini(void)

{

	crypto_unregister_alg(&sha512_alg);

	crypto_unregister_alg(&sha384_alg);

	crypto_unregister_shash(&sha512_alg);

	crypto_unregister_shash(&sha384_alg);

}



module_init(init);

arch/s390/crypto/sha_common.c

+12 −8
Original line number Diff line number Diff line
@@ -13,14 +13,14 @@ 
 *

 */



#include <linux/crypto.h>

#include <crypto/internal/hash.h>

#include "sha.h"

#include "crypt_s390.h"



void s390_sha_update(struct crypto_tfm *tfm, const u8 *data, unsigned int len)

int s390_sha_update(struct shash_desc *desc, const u8 *data, unsigned int len)

{

	struct s390_sha_ctx *ctx = crypto_tfm_ctx(tfm);

	unsigned int bsize = crypto_tfm_alg_blocksize(tfm);

	struct s390_sha_ctx *ctx = shash_desc_ctx(desc);

	unsigned int bsize = crypto_shash_blocksize(desc->tfm);

	unsigned int index;

	int ret;
@@ -51,13 +51,15 @@ void s390_sha_update(struct crypto_tfm *tfm, const u8 *data, unsigned int len) 
store:

	if (len)

		memcpy(ctx->buf + index , data, len);



	return 0;

}

EXPORT_SYMBOL_GPL(s390_sha_update);



void s390_sha_final(struct crypto_tfm *tfm, u8 *out)

int s390_sha_final(struct shash_desc *desc, u8 *out)

{

	struct s390_sha_ctx *ctx = crypto_tfm_ctx(tfm);

	unsigned int bsize = crypto_tfm_alg_blocksize(tfm);

	struct s390_sha_ctx *ctx = shash_desc_ctx(desc);

	unsigned int bsize = crypto_shash_blocksize(desc->tfm);

	u64 bits;

	unsigned int index, end, plen;

	int ret;
@@ -87,9 +89,11 @@ void s390_sha_final(struct crypto_tfm *tfm, u8 *out) 
	BUG_ON(ret != end);



	/* copy digest to out */

	memcpy(out, ctx->state, crypto_hash_digestsize(crypto_hash_cast(tfm)));

	memcpy(out, ctx->state, crypto_shash_digestsize(desc->tfm));

	/* wipe context */

	memset(ctx, 0, sizeof *ctx);



	return 0;

}

EXPORT_SYMBOL_GPL(s390_sha_final);