jsauer/torvalds-linux
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2026-01-12 01:20:14 +00:00
Code

lib/crypto: tests: Add KUnit tests for SHA-224 and SHA-256

Browse Source 
Add KUnit test suites for the SHA-224 and SHA-256 library functions,
including the corresponding HMAC support.  The core test logic is in the
previously-added hash-test-template.h.  This commit just adds the actual
KUnit suites, and it adds the generated test vectors to the tree so that
gen-hash-testvecs.py won't have to be run at build time.

Acked-by: Ard Biesheuvel <ardb@kernel.org>
Link: https://lore.kernel.org/r/20250709200112.258500-3-ebiggers@kernel.org
Signed-off-by: Eric Biggers <ebiggers@kernel.org>
This commit is contained in:
Eric Biggers 2025-07-09 13:01:10 -07:00
parent 950a81224e
commit 4dcf6cadda
8 changed files with 590 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/crypto/Kconfig
View File

@ -194,6 +194,8 @@ config CRYPTO_LIB_SHA512_ARCH
config CRYPTO_LIB_SM3
tristate
source "lib/crypto/tests/Kconfig"
if !KMSAN # avoid false positives from assembly
if ARM
source "lib/crypto/arm/Kconfig"

2
lib/crypto/Makefile
View File

@ -8,6 +8,8 @@ quiet_cmd_perlasm = PERLASM $@
quiet_cmd_perlasm_with_args = PERLASM $@
cmd_perlasm_with_args = $(PERL) $(<) void $(@)
obj-$(CONFIG_KUNIT) += tests/
obj-$(CONFIG_CRYPTO_HASH_INFO) += hash_info.o
obj-$(CONFIG_CRYPTO_LIB_UTILS) += libcryptoutils.o

29
lib/crypto/tests/Kconfig Normal file
View File

@ -0,0 +1,29 @@
# SPDX-License-Identifier: GPL-2.0-or-later
# Option is named *_SHA256_KUNIT_TEST, though both SHA-224 and SHA-256 tests are
# included, for consistency with the naming used elsewhere (e.g. CRYPTO_SHA256).
config CRYPTO_LIB_SHA256_KUNIT_TEST
tristate "KUnit tests for SHA-224 and SHA-256" if !KUNIT_ALL_TESTS
depends on KUNIT
default KUNIT_ALL_TESTS || CRYPTO_SELFTESTS
select CRYPTO_LIB_BENCHMARK_VISIBLE
select CRYPTO_LIB_SHA256
help
KUnit tests for the SHA-224 and SHA-256 cryptographic hash functions
and their corresponding HMACs.
config CRYPTO_LIB_BENCHMARK_VISIBLE
bool
config CRYPTO_LIB_BENCHMARK
bool "Include benchmarks in KUnit tests for cryptographic functions"
depends on CRYPTO_LIB_BENCHMARK_VISIBLE
help
Include benchmarks in the KUnit tests for cryptographic functions.
The benchmark results are printed to the kernel log when the
corresponding KUnit test suite runs.
This is useful for evaluating the performance of the cryptographic
functions. However, it will increase the runtime of the KUnit tests.
If you're only interested in correctness testing, leave this disabled.

3
lib/crypto/tests/Makefile Normal file
View File

@ -0,0 +1,3 @@
# SPDX-License-Identifier: GPL-2.0-or-later
obj-$(CONFIG_CRYPTO_LIB_SHA256_KUNIT_TEST) += sha224_kunit.o sha256_kunit.o

238
lib/crypto/tests/sha224-testvecs.h Normal file
View File

@ -0,0 +1,238 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/* This file was generated by: ./scripts/crypto/gen-hash-testvecs.py sha224 */
static const struct {
size_t data_len;
u8 digest[SHA224_DIGEST_SIZE];
} hash_testvecs[] = {
{
.data_len = 0,
.digest = {
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,
},
},
{
.data_len = 1,
.digest = {
0xe3, 0x4d, 0x79, 0x17, 0x75, 0x35, 0xdc, 0xd2,
0x27, 0xc9, 0x9d, 0x0b, 0x90, 0x0f, 0x21, 0x5d,
0x95, 0xfb, 0x9c, 0x6d, 0xa8, 0xec, 0x19, 0x15,
0x12, 0xef, 0xf5, 0x0f,
},
},
{
.data_len = 2,
.digest = {
0x81, 0xc7, 0x60, 0x0d, 0x6d, 0x13, 0x75, 0x70,
0x4b, 0xc0, 0xab, 0xea, 0x04, 0xe3, 0x78, 0x7e,
0x73, 0xb9, 0x0f, 0xb6, 0xae, 0x90, 0xf3, 0x94,
0xb2, 0x56, 0xda, 0xc8,
},
},
{
.data_len = 3,
.digest = {
0x24, 0xf0, 0x8c, 0x6e, 0x9d, 0xd6, 0x06, 0x80,
0x0a, 0x03, 0xee, 0x9b, 0x33, 0xec, 0x83, 0x42,
0x2c, 0x8b, 0xe7, 0xc7, 0xc6, 0x04, 0xfb, 0xc6,
0xa3, 0x3a, 0x4d, 0xc9,
},
},
{
.data_len = 16,
.digest = {
0x1c, 0x08, 0xa8, 0x55, 0x8f, 0xc6, 0x0a, 0xea,
0x2f, 0x1b, 0x54, 0xff, 0x8d, 0xd2, 0xa3, 0xc7,
0x42, 0xc2, 0x93, 0x3d, 0x73, 0x18, 0x84, 0xba,
0x75, 0x49, 0x34, 0xfd,
},
},
{
.data_len = 32,
.digest = {
0x45, 0xdd, 0xb5, 0xf0, 0x3c, 0xda, 0xe6, 0xd4,
0x6c, 0x86, 0x91, 0x29, 0x11, 0x2f, 0x88, 0x7d,
0xd8, 0x3c, 0xa3, 0xd6, 0xdd, 0x1e, 0xac, 0x98,
0xff, 0xf0, 0x14, 0x69,
},
},
{
.data_len = 48,
.digest = {
0x0b, 0xfb, 0x71, 0x4c, 0x06, 0x7a, 0xd5, 0x89,
0x76, 0x0a, 0x43, 0x8b, 0x2b, 0x47, 0x12, 0x56,
0xa7, 0x64, 0x33, 0x1d, 0xd3, 0x44, 0x17, 0x95,
0x23, 0xe7, 0x53, 0x01,
},
},
{
.data_len = 49,
.digest = {
0xc4, 0xae, 0x9c, 0x33, 0xd5, 0x1d, 0xf4, 0xa7,
0xfd, 0xb7, 0xd4, 0x6b, 0xc3, 0xeb, 0xa8, 0xbf,
0xfb, 0x07, 0x89, 0x4b, 0x07, 0x15, 0x22, 0xec,
0xe1, 0x45, 0x84, 0xba,
},
},
{
.data_len = 63,
.digest = {
0xad, 0x01, 0x34, 0x2a, 0xe2, 0x3b, 0x58, 0x06,
0x9f, 0x20, 0xc8, 0xfb, 0xf3, 0x20, 0x82, 0xa6,
0x9f, 0xee, 0x7a, 0xbe, 0xdf, 0xf3, 0x5d, 0x57,
0x9b, 0xce, 0x79, 0x96,
},
},
{
.data_len = 64,
.digest = {
0xa7, 0xa6, 0x47, 0xf7, 0xed, 0x2a, 0xe5, 0xe3,
0xc0, 0x1e, 0x7b, 0x40, 0xe4, 0xf7, 0x40, 0x65,
0x42, 0xc1, 0x6f, 0x7d, 0x8d, 0x0d, 0x17, 0x4f,
0xd3, 0xbc, 0x0d, 0x85,
},
},
{
.data_len = 65,
.digest = {
0xc4, 0x9c, 0xb5, 0x6a, 0x01, 0x2d, 0x10, 0xa9,
0x5f, 0xa4, 0x5a, 0xe1, 0xba, 0x40, 0x12, 0x09,
0x7b, 0xea, 0xdb, 0xa6, 0x7b, 0xcb, 0x56, 0xf0,
0xfd, 0x5b, 0xe2, 0xe7,
},
},
{
.data_len = 127,
.digest = {
0x14, 0xda, 0x0e, 0x01, 0xca, 0x78, 0x7d, 0x2d,
0x85, 0xa3, 0xca, 0x0e, 0x80, 0xf9, 0x95, 0x10,
0xa1, 0x7b, 0xa5, 0xaa, 0xfc, 0x95, 0x05, 0x08,
0x53, 0xda, 0x52, 0xee,
},
},
{
.data_len = 128,
.digest = {
0xa5, 0x24, 0xc4, 0x54, 0xe1, 0x50, 0xab, 0xee,
0x22, 0xc1, 0xa7, 0x27, 0x15, 0x2c, 0x6f, 0xf7,
0x4c, 0x31, 0xe5, 0x15, 0x25, 0x4e, 0x71, 0xc6,
0x7e, 0xa0, 0x11, 0x5d,
},
},
{
.data_len = 129,
.digest = {
0x73, 0xd0, 0x8c, 0xce, 0xed, 0xed, 0x9f, 0xaa,
0x21, 0xaf, 0xa2, 0x08, 0x80, 0x16, 0x15, 0x59,
0x3f, 0x1d, 0x7f, 0x0a, 0x79, 0x3d, 0x7b, 0x58,
0xf8, 0xc8, 0x5c, 0x27,
},
},
{
.data_len = 256,
.digest = {
0x31, 0xa7, 0xa1, 0xca, 0x49, 0x72, 0x75, 0xcc,
0x6e, 0x02, 0x9e, 0xad, 0xea, 0x86, 0x5c, 0x91,
0x02, 0xe4, 0xc9, 0xf9, 0xd3, 0x9e, 0x74, 0x50,
0xd8, 0x43, 0x6b, 0x85,
},
},
{
.data_len = 511,
.digest = {
0x40, 0x60, 0x8b, 0xb0, 0x03, 0xa9, 0x75, 0xab,
0x2d, 0x5b, 0x20, 0x9a, 0x05, 0x72, 0xb7, 0xa8,
0xce, 0xf2, 0x4f, 0x66, 0x62, 0xe3, 0x7e, 0x24,
0xd6, 0xe2, 0xea, 0xfa,
},
},
{
.data_len = 513,
.digest = {
0x4f, 0x5f, 0x9f, 0x1e, 0xb3, 0x66, 0x81, 0xdb,
0x41, 0x5d, 0x65, 0x97, 0x00, 0x8d, 0xdc, 0x62,
0x03, 0xb0, 0x4d, 0x6b, 0x5c, 0x7f, 0x1e, 0xa0,
0xfe, 0xfc, 0x0e, 0xb8,
},
},
{
.data_len = 1000,
.digest = {
0x08, 0xa8, 0xa1, 0xc0, 0xd8, 0xf9, 0xb4, 0xaa,
0x53, 0x22, 0xa1, 0x73, 0x0b, 0x45, 0xa0, 0x20,
0x72, 0xf3, 0xa9, 0xbc, 0x51, 0xd0, 0x20, 0x79,
0x69, 0x97, 0xf7, 0xe3,
},
},
{
.data_len = 3333,
.digest = {
0xe8, 0x60, 0x5f, 0xb9, 0x12, 0xe1, 0x6b, 0x24,
0xc5, 0xe8, 0x43, 0xa9, 0x5c, 0x3f, 0x65, 0xed,
0xbe, 0xfd, 0x77, 0xf5, 0x47, 0xf2, 0x75, 0x21,
0xc2, 0x8f, 0x54, 0x8f,
},
},
{
.data_len = 4096,
.digest = {
0xc7, 0xdf, 0x50, 0x16, 0x10, 0x01, 0xb7, 0xdf,
0x34, 0x1d, 0x18, 0xa2, 0xd5, 0xad, 0x1f, 0x50,
0xf7, 0xa8, 0x9a, 0x72, 0xfb, 0xfd, 0xd9, 0x1c,
0x57, 0xac, 0x08, 0x97,
},
},
{
.data_len = 4128,
.digest = {
0xdf, 0x16, 0x76, 0x7f, 0xc0, 0x16, 0x84, 0x63,
0xac, 0xcf, 0xd0, 0x78, 0x1e, 0x96, 0x67, 0xc5,
0x3c, 0x06, 0xe9, 0xdb, 0x6e, 0x7d, 0xd0, 0x07,
0xaa, 0xb1, 0x56, 0xc9,
},
},
{
.data_len = 4160,
.digest = {
0x49, 0xec, 0x5c, 0x18, 0xd7, 0x5b, 0xda, 0xed,
0x5b, 0x59, 0xde, 0x09, 0x34, 0xb2, 0x49, 0x43,
0x62, 0x6a, 0x0a, 0x63, 0x6a, 0x51, 0x08, 0x37,
0x8c, 0xb6, 0x29, 0x84,
},
},
{
.data_len = 4224,
.digest = {
0x3d, 0xc2, 0xc8, 0x43, 0xcf, 0xb7, 0x33, 0x14,
0x04, 0x93, 0xed, 0xe2, 0xcd, 0x8a, 0x69, 0x5c,
0x5a, 0xd5, 0x9b, 0x52, 0xdf, 0x48, 0xa7, 0xaa,
0x28, 0x2b, 0x5d, 0x27,
},
},
{
.data_len = 16384,
.digest = {
0xa7, 0xaf, 0xda, 0x92, 0xe2, 0xe7, 0x61, 0xdc,
0xa1, 0x32, 0x53, 0x2a, 0x3f, 0x41, 0x5c, 0x7e,
0xc9, 0x89, 0xda, 0x1c, 0xf7, 0x8d, 0x00, 0xbd,
0x21, 0x73, 0xb1, 0x69,
},
},
};
static const u8 hash_testvec_consolidated[SHA224_DIGEST_SIZE] = {
0x9e, 0xb8, 0x82, 0xab, 0x83, 0x37, 0xe4, 0x63,
0x84, 0xee, 0x21, 0x15, 0xc2, 0xbb, 0xa3, 0x17,
0x8f, 0xc4, 0x99, 0x33, 0xa0, 0x2c, 0x9f, 0xec,
0xca, 0xd0, 0xf3, 0x73,
};
static const u8 hmac_testvec_consolidated[SHA224_DIGEST_SIZE] = {
0x66, 0x34, 0x79, 0x92, 0x47, 0x0e, 0xcd, 0x70,
0xb0, 0x8b, 0x91, 0xcb, 0x94, 0x2f, 0x67, 0x65,
0x2f, 0xc9, 0xd2, 0x91, 0x32, 0xaf, 0xf7, 0x5f,
0xb6, 0x01, 0x5b, 0xf2,
};

39
lib/crypto/tests/sha224_kunit.c Normal file
View File

@ -0,0 +1,39 @@
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Copyright 2025 Google LLC
*/
#include <crypto/sha2.h>
#include "sha224-testvecs.h"
#define HASH sha224
#define HASH_CTX sha224_ctx
#define HASH_SIZE SHA224_DIGEST_SIZE
#define HASH_INIT sha224_init
#define HASH_UPDATE sha224_update
#define HASH_FINAL sha224_final
#define HMAC_KEY hmac_sha224_key
#define HMAC_CTX hmac_sha224_ctx
#define HMAC_PREPAREKEY hmac_sha224_preparekey
#define HMAC_INIT hmac_sha224_init
#define HMAC_UPDATE hmac_sha224_update
#define HMAC_FINAL hmac_sha224_final
#define HMAC hmac_sha224
#define HMAC_USINGRAWKEY hmac_sha224_usingrawkey
#include "hash-test-template.h"
static struct kunit_case hash_test_cases[] = {
HASH_KUNIT_CASES,
KUNIT_CASE(benchmark_hash),
{},
};
static struct kunit_suite hash_test_suite = {
.name = "sha224",
.test_cases = hash_test_cases,
.suite_init = hash_suite_init,
.suite_exit = hash_suite_exit,
};
kunit_test_suite(hash_test_suite);
MODULE_DESCRIPTION("KUnit tests and benchmark for SHA-224 and HMAC-SHA224");
MODULE_LICENSE("GPL");

238
lib/crypto/tests/sha256-testvecs.h Normal file
View File

@ -0,0 +1,238 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
/* This file was generated by: ./scripts/crypto/gen-hash-testvecs.py sha256 */
static const struct {
size_t data_len;
u8 digest[SHA256_DIGEST_SIZE];
} hash_testvecs[] = {
{
.data_len = 0,
.digest = {
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,
},
},
{
.data_len = 1,
.digest = {
0x45, 0xf8, 0x3d, 0x17, 0xe1, 0x0b, 0x34, 0xfc,
0xa0, 0x1e, 0xb8, 0xf4, 0x45, 0x4d, 0xac, 0x34,
0xa7, 0x77, 0xd9, 0x40, 0x4a, 0x46, 0x4e, 0x73,
0x2c, 0xf4, 0xab, 0xf2, 0xc0, 0xda, 0x94, 0xc4,
},
},
{
.data_len = 2,
.digest = {
0xf9, 0xd3, 0x52, 0x2f, 0xd5, 0xe0, 0x99, 0x15,
0x1c, 0xd6, 0xa9, 0x24, 0x4f, 0x40, 0xba, 0x25,
0x33, 0x43, 0x3e, 0xe1, 0x78, 0x6a, 0xfe, 0x7d,
0x07, 0xe2, 0x29, 0x7b, 0x6d, 0xc5, 0x73, 0xf5,
},
},
{
.data_len = 3,
.digest = {
0x71, 0xf7, 0xa1, 0xef, 0x69, 0x86, 0x0e, 0xe4,
0x87, 0x25, 0x58, 0x4c, 0x07, 0x2c, 0xfc, 0x60,
0xc5, 0xf6, 0xe2, 0x44, 0xaa, 0xfb, 0x41, 0xc7,
0x2b, 0xc5, 0x01, 0x8c, 0x39, 0x98, 0x30, 0x37,
},
},
{
.data_len = 16,
.digest = {
0x09, 0x95, 0x9a, 0xfa, 0x25, 0x18, 0x86, 0x06,
0xfe, 0x65, 0xc9, 0x2f, 0x91, 0x15, 0x74, 0x06,
0x6c, 0xbf, 0xef, 0x7b, 0x0b, 0xc7, 0x2c, 0x05,
0xdd, 0x17, 0x5d, 0x6f, 0x8a, 0xa5, 0xde, 0x3c,
},
},
{
.data_len = 32,
.digest = {
0xe5, 0x52, 0x3c, 0x85, 0xea, 0x1b, 0xe1, 0x6c,
0xe0, 0xdb, 0xc3, 0xef, 0xf0, 0xca, 0xc2, 0xe1,
0xb9, 0x36, 0xa1, 0x28, 0xb6, 0x9e, 0xf5, 0x6e,
0x70, 0xf7, 0xf9, 0xa7, 0x1c, 0xd3, 0x22, 0xd0,
},
},
{
.data_len = 48,
.digest = {
0x5f, 0x84, 0xd4, 0xd7, 0x2e, 0x80, 0x09, 0xef,
0x1c, 0x77, 0x7c, 0x25, 0x59, 0x63, 0x88, 0x64,
0xfd, 0x56, 0xea, 0x23, 0xf4, 0x4f, 0x2e, 0x49,
0xcd, 0xb4, 0xaa, 0xc7, 0x5c, 0x8b, 0x75, 0x84,
},
},
{
.data_len = 49,
.digest = {
0x22, 0x6e, 0xca, 0xda, 0x00, 0x2d, 0x90, 0x96,
0x24, 0xf8, 0x55, 0x17, 0x11, 0xda, 0x42, 0x1c,
0x78, 0x4e, 0xbf, 0xd9, 0xc5, 0xcf, 0xf3, 0xe3,
0xaf, 0xd3, 0x60, 0xcd, 0xaa, 0xe2, 0xc7, 0x22,
},
},
{
.data_len = 63,
.digest = {
0x97, 0xe2, 0x74, 0xdc, 0x6b, 0xa4, 0xaf, 0x32,
0x3b, 0x50, 0x6d, 0x80, 0xb5, 0xd3, 0x0c, 0x36,
0xea, 0x3f, 0x5d, 0x36, 0xa7, 0x49, 0x51, 0xf3,
0xbd, 0x69, 0x68, 0x60, 0x9b, 0xde, 0x73, 0xf5,
},
},
{
.data_len = 64,
.digest = {
0x13, 0x74, 0xb1, 0x72, 0xd6, 0x53, 0x48, 0x28,
0x42, 0xd8, 0xba, 0x64, 0x20, 0x60, 0xb6, 0x4c,
0xc3, 0xac, 0x5d, 0x93, 0x8c, 0xb9, 0xd4, 0xcc,
0xb4, 0x9f, 0x31, 0x1f, 0xeb, 0x68, 0x35, 0x58,
},
},
{
.data_len = 65,
.digest = {
0xda, 0xbe, 0xd7, 0xbc, 0x6e, 0xe6, 0x5a, 0x57,
0xeb, 0x9a, 0x93, 0xaa, 0x66, 0xd0, 0xe0, 0xc4,
0x29, 0x7f, 0xe9, 0x3b, 0x8e, 0xdf, 0x81, 0x82,
0x8d, 0x15, 0x11, 0x59, 0x4e, 0x13, 0xa5, 0x58,
},
},
{
.data_len = 127,
.digest = {
0x8c, 0x1a, 0xba, 0x40, 0x66, 0x94, 0x19, 0xf4,
0x2e, 0xa2, 0xae, 0x94, 0x53, 0x18, 0xb6, 0xfd,
0xa0, 0x12, 0xc5, 0xef, 0xd5, 0xd6, 0x1b, 0xa1,
0x37, 0xea, 0x19, 0x44, 0x35, 0x54, 0x85, 0x74,
},
},
{
.data_len = 128,
.digest = {
0xfd, 0x07, 0xd8, 0x77, 0x7d, 0x8b, 0x4f, 0xee,
0x60, 0x60, 0x26, 0xef, 0x2a, 0x86, 0xfb, 0x67,
0xeb, 0x31, 0x27, 0x03, 0x99, 0x3c, 0xde, 0xe5,
0x84, 0x72, 0x71, 0x4c, 0x33, 0x7b, 0x87, 0x13,
},
},
{
.data_len = 129,
.digest = {
0x97, 0xc5, 0x58, 0x38, 0x20, 0xc7, 0xde, 0xfa,
0xdd, 0x9b, 0x10, 0xc6, 0xc2, 0x2f, 0x94, 0xb5,
0xc0, 0x33, 0xc0, 0x20, 0x1c, 0x2f, 0xb4, 0x28,
0x5e, 0x36, 0xfa, 0x8c, 0x24, 0x1c, 0x18, 0x27,
},
},
{
.data_len = 256,
.digest = {
0x62, 0x17, 0x84, 0x26, 0x98, 0x30, 0x57, 0xca,
0x4f, 0x32, 0xd9, 0x09, 0x09, 0x34, 0xe2, 0xcb,
0x92, 0x45, 0xd5, 0xeb, 0x8b, 0x9b, 0x3c, 0xd8,
0xaa, 0xc7, 0xd2, 0x2b, 0x04, 0xab, 0xb3, 0x35,
},
},
{
.data_len = 511,
.digest = {
0x7f, 0xe1, 0x09, 0x78, 0x5d, 0x61, 0xfa, 0x5e,
0x9b, 0x8c, 0xb1, 0xa9, 0x09, 0x69, 0xb4, 0x24,
0x54, 0xf2, 0x1c, 0xc9, 0x5f, 0xfb, 0x59, 0x9d,
0x36, 0x1b, 0x37, 0x44, 0xfc, 0x64, 0x79, 0xb6,
},
},
{
.data_len = 513,
.digest = {
0xd2, 0x3b, 0x3a, 0xe7, 0x13, 0x4f, 0xbd, 0x29,
0x6b, 0xd2, 0x79, 0x26, 0x6c, 0xd2, 0x22, 0x43,
0x25, 0x34, 0x9b, 0x9b, 0x22, 0xb0, 0x9f, 0x61,
0x1d, 0xf4, 0xe2, 0x65, 0x68, 0x95, 0x02, 0x6c,
},
},
{
.data_len = 1000,
.digest = {
0x0c, 0x34, 0x53, 0x3f, 0x0f, 0x8a, 0x39, 0x8d,
0x63, 0xe4, 0x83, 0x6e, 0x11, 0x7d, 0x14, 0x8e,
0x5b, 0xf0, 0x4d, 0xca, 0x23, 0x24, 0xb5, 0xd2,
0x13, 0x3f, 0xd9, 0xde, 0x84, 0x74, 0x26, 0x59,
},
},
{
.data_len = 3333,
.digest = {
0xa8, 0xb8, 0x83, 0x01, 0x1b, 0x38, 0x7a, 0xca,
0x59, 0xe9, 0x5b, 0x37, 0x6a, 0xab, 0xb4, 0x85,
0x94, 0x73, 0x26, 0x04, 0xef, 0xed, 0xf4, 0x0d,
0xd6, 0x09, 0x21, 0x09, 0x96, 0x78, 0xe3, 0xcf,
},
},
{
.data_len = 4096,
.digest = {
0x0b, 0x12, 0x66, 0x96, 0x78, 0x4f, 0x2c, 0x35,
0xa4, 0xed, 0xbc, 0xb8, 0x30, 0xa6, 0x37, 0x9b,
0x94, 0x13, 0xae, 0x86, 0xf0, 0x20, 0xfb, 0x49,
0x8f, 0x5d, 0x20, 0x70, 0x60, 0x2b, 0x02, 0x70,
},
},
{
.data_len = 4128,
.digest = {
0xe4, 0xbd, 0xe4, 0x3b, 0x85, 0xf4, 0x6f, 0x11,
0xad, 0xc4, 0x79, 0xcc, 0x8e, 0x6d, 0x8b, 0x15,
0xbb, 0xf9, 0xd3, 0x65, 0xe1, 0xf8, 0x8d, 0x22,
0x65, 0x66, 0x66, 0xb3, 0xf5, 0xd0, 0x9c, 0xaf,
},
},
{
.data_len = 4160,
.digest = {
0x90, 0x5f, 0xe0, 0xfc, 0xb1, 0xdc, 0x38, 0x1b,
0xe5, 0x37, 0x3f, 0xd2, 0xcc, 0x48, 0xc4, 0xbc,
0xb4, 0xfd, 0xf7, 0x71, 0x5f, 0x6b, 0xf4, 0xc4,
0xa6, 0x08, 0x7e, 0xfc, 0x4e, 0x96, 0xf7, 0xc2,
},
},
{
.data_len = 4224,
.digest = {
0x1f, 0x34, 0x0a, 0x3b, 0xdb, 0xf7, 0x7a, 0xdb,
0x3d, 0x89, 0x85, 0x0c, 0xd2, 0xf0, 0x0c, 0xbd,
0x25, 0x39, 0x14, 0x06, 0x28, 0x0f, 0x6b, 0x5f,
0xe3, 0x1f, 0x2a, 0xb6, 0xca, 0x56, 0x41, 0xa1,
},
},
{
.data_len = 16384,
.digest = {
0x7b, 0x01, 0x2d, 0x84, 0x70, 0xee, 0xe0, 0x77,
0x3c, 0x17, 0x63, 0xfe, 0x40, 0xd7, 0xfd, 0xa1,
0x75, 0x90, 0xb8, 0x3e, 0x50, 0xcd, 0x06, 0xb7,
0xb9, 0xb9, 0x2b, 0x91, 0x4f, 0xba, 0xe4, 0x4c,
},
},
};
static const u8 hash_testvec_consolidated[SHA256_DIGEST_SIZE] = {
0x78, 0x1c, 0xb1, 0x9f, 0xe5, 0xe1, 0xcb, 0x41,
0x8b, 0x34, 0x00, 0x33, 0x57, 0xc3, 0x1c, 0x8f,
0x5c, 0x84, 0xc7, 0x8b, 0x87, 0x6a, 0x13, 0x29,
0x2f, 0xc4, 0x1a, 0x70, 0x5e, 0x40, 0xf2, 0xfe,
};
static const u8 hmac_testvec_consolidated[SHA256_DIGEST_SIZE] = {
0x56, 0x96, 0x2e, 0x23, 0x3f, 0x94, 0x89, 0x0d,
0x0f, 0x24, 0x36, 0x2e, 0x19, 0x3d, 0xb5, 0xac,
0xb8, 0xcd, 0xf1, 0xc9, 0xca, 0xac, 0xee, 0x9d,
0x62, 0xe6, 0x81, 0xe5, 0x96, 0xf9, 0x38, 0xf5,
};

39
lib/crypto/tests/sha256_kunit.c Normal file
View File

@ -0,0 +1,39 @@
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Copyright 2025 Google LLC
*/
#include <crypto/sha2.h>
#include "sha256-testvecs.h"
#define HASH sha256
#define HASH_CTX sha256_ctx
#define HASH_SIZE SHA256_DIGEST_SIZE
#define HASH_INIT sha256_init
#define HASH_UPDATE sha256_update
#define HASH_FINAL sha256_final
#define HMAC_KEY hmac_sha256_key
#define HMAC_CTX hmac_sha256_ctx
#define HMAC_PREPAREKEY hmac_sha256_preparekey
#define HMAC_INIT hmac_sha256_init
#define HMAC_UPDATE hmac_sha256_update
#define HMAC_FINAL hmac_sha256_final
#define HMAC hmac_sha256
#define HMAC_USINGRAWKEY hmac_sha256_usingrawkey
#include "hash-test-template.h"
static struct kunit_case hash_test_cases[] = {
HASH_KUNIT_CASES,
KUNIT_CASE(benchmark_hash),
{},
};
static struct kunit_suite hash_test_suite = {
.name = "sha256",
.test_cases = hash_test_cases,
.suite_init = hash_suite_init,
.suite_exit = hash_suite_exit,
};
kunit_test_suite(hash_test_suite);
MODULE_DESCRIPTION("KUnit tests and benchmark for SHA-256 and HMAC-SHA256");
MODULE_LICENSE("GPL");