[linux.git] / crypto / sha256_generic.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Crypto API wrapper for the generic SHA256 code from lib/crypto/sha256.c
 *
 * Copyright (c) Jean-Luc Cooke <[email protected]>
 * Copyright (c) Andrew McDonald <[email protected]>
 * Copyright (c) 2002 James Morris <[email protected]>
 * SHA224 Support Copyright 2007 Intel Corporation <[email protected]>
 */
#include <crypto/internal/hash.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/mm.h>
#include <linux/types.h>
#include <crypto/sha2.h>
#include <crypto/sha256_base.h>
#include <asm/byteorder.h>
#include <asm/unaligned.h>

const u8 sha224_zero_message_hash[SHA224_DIGEST_SIZE] = {
	0xd1, 0x4a, 0x02, 0x8c, 0x2a, 0x3a, 0x2b, 0xc9, 0x47,
	0x61, 0x02, 0xbb, 0x28, 0x82, 0x34, 0xc4, 0x15, 0xa2,
	0xb0, 0x1f, 0x82, 0x8e, 0xa6, 0x2a, 0xc5, 0xb3, 0xe4,
	0x2f
};
EXPORT_SYMBOL_GPL(sha224_zero_message_hash);

const u8 sha256_zero_message_hash[SHA256_DIGEST_SIZE] = {
	0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14,
	0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24,
	0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c,
	0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55
};
EXPORT_SYMBOL_GPL(sha256_zero_message_hash);

static int crypto_sha256_init(struct shash_desc *desc)
{
	sha256_init(shash_desc_ctx(desc));
	return 0;
}

static int crypto_sha224_init(struct shash_desc *desc)
{
	sha224_init(shash_desc_ctx(desc));
	return 0;
}

int crypto_sha256_update(struct shash_desc *desc, const u8 *data,
			  unsigned int len)
{
	sha256_update(shash_desc_ctx(desc), data, len);
	return 0;
}
EXPORT_SYMBOL(crypto_sha256_update);

static int crypto_sha256_final(struct shash_desc *desc, u8 *out)
{
	if (crypto_shash_digestsize(desc->tfm) == SHA224_DIGEST_SIZE)
		sha224_final(shash_desc_ctx(desc), out);
	else
		sha256_final(shash_desc_ctx(desc), out);
	return 0;
}

int crypto_sha256_finup(struct shash_desc *desc, const u8 *data,
			unsigned int len, u8 *hash)
{
	sha256_update(shash_desc_ctx(desc), data, len);
	return crypto_sha256_final(desc, hash);
}
EXPORT_SYMBOL(crypto_sha256_finup);

static struct shash_alg sha256_algs[2] = { {
	.digestsize	=	SHA256_DIGEST_SIZE,
	.init		=	crypto_sha256_init,
	.update		=	crypto_sha256_update,
	.final		=	crypto_sha256_final,
	.finup		=	crypto_sha256_finup,
	.descsize	=	sizeof(struct sha256_state),
	.base		=	{
		.cra_name	=	"sha256",
		.cra_driver_name=	"sha256-generic",
		.cra_priority	=	100,
		.cra_blocksize	=	SHA256_BLOCK_SIZE,
		.cra_module	=	THIS_MODULE,
	}
}, {
	.digestsize	=	SHA224_DIGEST_SIZE,
	.init		=	crypto_sha224_init,
	.update		=	crypto_sha256_update,
	.final		=	crypto_sha256_final,
	.finup		=	crypto_sha256_finup,
	.descsize	=	sizeof(struct sha256_state),
	.base		=	{
		.cra_name	=	"sha224",
		.cra_driver_name=	"sha224-generic",
		.cra_priority	=	100,
		.cra_blocksize	=	SHA224_BLOCK_SIZE,
		.cra_module	=	THIS_MODULE,
	}
} };

static int __init sha256_generic_mod_init(void)
{
	return crypto_register_shashes(sha256_algs, ARRAY_SIZE(sha256_algs));
}

static void __exit sha256_generic_mod_fini(void)
{
	crypto_unregister_shashes(sha256_algs, ARRAY_SIZE(sha256_algs));
}

subsys_initcall(sha256_generic_mod_init);
module_exit(sha256_generic_mod_fini);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("SHA-224 and SHA-256 Secure Hash Algorithm");

MODULE_ALIAS_CRYPTO("sha224");
MODULE_ALIAS_CRYPTO("sha224-generic");
MODULE_ALIAS_CRYPTO("sha256");
MODULE_ALIAS_CRYPTO("sha256-generic");
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4	2	/*
08c327f6	3	* Crypto API wrapper for the generic SHA256 code from lib/crypto/sha256.c
1da177e4 LT	4	*
	5	* Copyright (c) Jean-Luc Cooke <[email protected]>
	6	* Copyright (c) Andrew McDonald <[email protected]>
	7	* Copyright (c) 2002 James Morris <[email protected]>
cd12fb90	8	* SHA224 Support Copyright 2007 Intel Corporation <[email protected]>
1da177e4	9	*/
50e109b5	10	#include <crypto/internal/hash.h>
1da177e4 LT	11	#include <linux/init.h>
	12	#include <linux/module.h>
	13	#include <linux/mm.h>
06ace7a9	14	#include <linux/types.h>
a24d22b2	15	#include <crypto/sha2.h>
a2e5ba4f	16	#include <crypto/sha256_base.h>
1da177e4	17	#include <asm/byteorder.h>
be34c4ef	18	#include <asm/unaligned.h>
1da177e4	19
0c4c78de LC	20	const u8 sha224_zero_message_hash[SHA224_DIGEST_SIZE] = {
	21	0xd1, 0x4a, 0x02, 0x8c, 0x2a, 0x3a, 0x2b, 0xc9, 0x47,
	22	0x61, 0x02, 0xbb, 0x28, 0x82, 0x34, 0xc4, 0x15, 0xa2,
	23	0xb0, 0x1f, 0x82, 0x8e, 0xa6, 0x2a, 0xc5, 0xb3, 0xe4,
	24	0x2f
	25	};
	26	EXPORT_SYMBOL_GPL(sha224_zero_message_hash);
	27
	28	const u8 sha256_zero_message_hash[SHA256_DIGEST_SIZE] = {
	29	0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14,
	30	0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24,
	31	0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c,
	32	0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55
	33	};
	34	EXPORT_SYMBOL_GPL(sha256_zero_message_hash);
	35
08c327f6	36	static int crypto_sha256_init(struct shash_desc *desc)
1da177e4	37	{
13855fd8 EB	38	sha256_init(shash_desc_ctx(desc));
13855fd8 EB	39	return 0;
1da177e4 LT	40	}
1da177e4 LT	41
08c327f6	42	static int crypto_sha224_init(struct shash_desc *desc)
1da177e4	43	{
13855fd8 EB	44	sha224_init(shash_desc_ctx(desc));
13855fd8 EB	45	return 0;
1da177e4 LT	46	}
1da177e4 LT	47
35d2c9d0	48	int crypto_sha256_update(struct shash_desc desc, const u8 data,
6c2bb98b	49	unsigned int len)
1da177e4	50	{
13855fd8 EB	51	sha256_update(shash_desc_ctx(desc), data, len);
13855fd8 EB	52	return 0;
1da177e4	53	}
35d2c9d0	54	EXPORT_SYMBOL(crypto_sha256_update);
1da177e4	55
08c327f6	56	static int crypto_sha256_final(struct shash_desc desc, u8 out)
1da177e4	57	{
08c327f6	58	if (crypto_shash_digestsize(desc->tfm) == SHA224_DIGEST_SIZE)
13855fd8	59	sha224_final(shash_desc_ctx(desc), out);
08c327f6	60	else
13855fd8 EB	61	sha256_final(shash_desc_ctx(desc), out);
13855fd8 EB	62	return 0;
1da177e4 LT	63	}
1da177e4 LT	64
a2e5ba4f AB	65	int crypto_sha256_finup(struct shash_desc desc, const u8 data,
a2e5ba4f AB	66	unsigned int len, u8 *hash)
cd12fb90	67	{
08c327f6 HG	68	sha256_update(shash_desc_ctx(desc), data, len);
08c327f6 HG	69	return crypto_sha256_final(desc, hash);
9b2fda7b	70	}
a2e5ba4f	71	EXPORT_SYMBOL(crypto_sha256_finup);
9b2fda7b	72
6aeb49bc	73	static struct shash_alg sha256_algs[2] = { {
50e109b5	74	.digestsize = SHA256_DIGEST_SIZE,
08c327f6	75	.init = crypto_sha256_init,
35d2c9d0	76	.update = crypto_sha256_update,
08c327f6	77	.final = crypto_sha256_final,
a2e5ba4f	78	.finup = crypto_sha256_finup,
9b2fda7b	79	.descsize = sizeof(struct sha256_state),
50e109b5 AKR	80	.base = {
	81	.cra_name = "sha256",
	82	.cra_driver_name= "sha256-generic",
b73b7ac0	83	.cra_priority = 100,
50e109b5 AKR	84	.cra_blocksize = SHA256_BLOCK_SIZE,
	85	.cra_module = THIS_MODULE,
	86	}
6aeb49bc	87	}, {
50e109b5	88	.digestsize = SHA224_DIGEST_SIZE,
08c327f6	89	.init = crypto_sha224_init,
35d2c9d0	90	.update = crypto_sha256_update,
08c327f6	91	.final = crypto_sha256_final,
a2e5ba4f	92	.finup = crypto_sha256_finup,
9b2fda7b	93	.descsize = sizeof(struct sha256_state),
50e109b5 AKR	94	.base = {
	95	.cra_name = "sha224",
	96	.cra_driver_name= "sha224-generic",
b73b7ac0	97	.cra_priority = 100,
50e109b5 AKR	98	.cra_blocksize = SHA224_BLOCK_SIZE,
	99	.cra_module = THIS_MODULE,
	100	}
6aeb49bc	101	} };
1da177e4	102
3af5b90b	103	static int __init sha256_generic_mod_init(void)
1da177e4	104	{
6aeb49bc	105	return crypto_register_shashes(sha256_algs, ARRAY_SIZE(sha256_algs));
1da177e4 LT	106	}
1da177e4 LT	107
3af5b90b	108	static void __exit sha256_generic_mod_fini(void)
1da177e4	109	{
6aeb49bc	110	crypto_unregister_shashes(sha256_algs, ARRAY_SIZE(sha256_algs));
1da177e4 LT	111	}
1da177e4 LT	112
c4741b23	113	subsys_initcall(sha256_generic_mod_init);
3af5b90b	114	module_exit(sha256_generic_mod_fini);
1da177e4 LT	115
1da177e4 LT	116	MODULE_LICENSE("GPL");
cd12fb90	117	MODULE_DESCRIPTION("SHA-224 and SHA-256 Secure Hash Algorithm");
b3be9a6d	118
5d26a105	119	MODULE_ALIAS_CRYPTO("sha224");
3e14dcf7	120	MODULE_ALIAS_CRYPTO("sha224-generic");
5d26a105	121	MODULE_ALIAS_CRYPTO("sha256");
3e14dcf7	122	MODULE_ALIAS_CRYPTO("sha256-generic");