| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <20251205173923.31740-4-git@danielhodges.dev>
Date: Fri, 5 Dec 2025 12:39:21 -0500
From: Daniel Hodges <git@...ielhodges.dev>
To: ast@...nel.org,
daniel@...earbox.net,
andrii@...nel.org,
vadim.fedorenko@...ux.dev
Cc: martin.lau@...ux.dev,
eddyz87@...il.com,
song@...nel.org,
yonghong.song@...ux.dev,
john.fastabend@...il.com,
kpsingh@...nel.org,
sdf@...ichev.me,
haoluo@...gle.com,
jolsa@...nel.org,
herbert@...dor.apana.org.au,
davem@...emloft.net,
shuah@...nel.org,
bpf@...r.kernel.org,
linux-crypto@...r.kernel.org,
linux-kselftest@...r.kernel.org,
linux-kernel@...r.kernel.org,
Daniel Hodges <git@...ielhodges.dev>
Subject: [PATCH bpf-next v2 3/5] selftests/bpf: Add tests for bpf_crypto_hash kfunc
Add selftests to validate the bpf_crypto_hash works properly. The tests
verify both correct functionality and proper error handling.
Test Data:
All tests use the well-known NIST test vector input "abc" and validate
against the standardized expected outputs for each algorithm. This ensures
the BPF kfunc wrappers correctly delegate to the kernel crypto library.
Signed-off-by: Daniel Hodges <git@...ielhodges.dev>
---
tools/testing/selftests/bpf/config | 2 +
.../selftests/bpf/prog_tests/crypto_hash.c | 158 ++++++++++++++++++
.../testing/selftests/bpf/progs/crypto_hash.c | 141 ++++++++++++++++
3 files changed, 301 insertions(+)
create mode 100644 tools/testing/selftests/bpf/prog_tests/crypto_hash.c
create mode 100644 tools/testing/selftests/bpf/progs/crypto_hash.c
diff --git a/tools/testing/selftests/bpf/config b/tools/testing/selftests/bpf/config
index 558839e3c185..d168b3073cba 100644
--- a/tools/testing/selftests/bpf/config
+++ b/tools/testing/selftests/bpf/config
@@ -12,7 +12,9 @@ CONFIG_BPF_SYSCALL=y
# CONFIG_BPF_UNPRIV_DEFAULT_OFF is not set
CONFIG_CGROUP_BPF=y
CONFIG_CRYPTO_HMAC=y
+CONFIG_CRYPTO_HASH2=y
CONFIG_CRYPTO_SHA256=y
+CONFIG_CRYPTO_SHA512=y
CONFIG_CRYPTO_USER_API=y
CONFIG_CRYPTO_USER_API_HASH=y
CONFIG_CRYPTO_USER_API_SKCIPHER=y
diff --git a/tools/testing/selftests/bpf/prog_tests/crypto_hash.c b/tools/testing/selftests/bpf/prog_tests/crypto_hash.c
new file mode 100644
index 000000000000..f1495ea85aae
--- /dev/null
+++ b/tools/testing/selftests/bpf/prog_tests/crypto_hash.c
@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <test_progs.h>
+#include <errno.h>
+#include "crypto_hash.skel.h"
+
+/* NIST test vectors for SHA-256("abc") */
+static const unsigned char expected_sha256[32] = {
+ 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea,
+ 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23,
+ 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c,
+ 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad
+};
+
+/* NIST test vectors for SHA-384("abc") */
+static const unsigned char expected_sha384[48] = {
+ 0xcb, 0x00, 0x75, 0x3f, 0x45, 0xa3, 0x5e, 0x8b,
+ 0xb5, 0xa0, 0x3d, 0x69, 0x9a, 0xc6, 0x50, 0x07,
+ 0x27, 0x2c, 0x32, 0xab, 0x0e, 0xde, 0xd1, 0x63,
+ 0x1a, 0x8b, 0x60, 0x5a, 0x43, 0xff, 0x5b, 0xed,
+ 0x80, 0x86, 0x07, 0x2b, 0xa1, 0xe7, 0xcc, 0x23,
+ 0x58, 0xba, 0xec, 0xa1, 0x34, 0xc8, 0x25, 0xa7
+};
+
+/* NIST test vectors for SHA-512("abc") */
+static const unsigned char expected_sha512[64] = {
+ 0xdd, 0xaf, 0x35, 0xa1, 0x93, 0x61, 0x7a, 0xba,
+ 0xcc, 0x41, 0x73, 0x49, 0xae, 0x20, 0x41, 0x31,
+ 0x12, 0xe6, 0xfa, 0x4e, 0x89, 0xa9, 0x7e, 0xa2,
+ 0x0a, 0x9e, 0xee, 0xe6, 0x4b, 0x55, 0xd3, 0x9a,
+ 0x21, 0x92, 0x99, 0x2a, 0x27, 0x4f, 0xc1, 0xa8,
+ 0x36, 0xba, 0x3c, 0x23, 0xa3, 0xfe, 0xeb, 0xbd,
+ 0x45, 0x4d, 0x44, 0x23, 0x64, 0x3c, 0xe8, 0x0e,
+ 0x2a, 0x9a, 0xc9, 0x4f, 0xa5, 0x4c, 0xa4, 0x9f
+};
+
+static void test_sha256_basic(void)
+{
+ struct crypto_hash *skel;
+ int err, prog_fd;
+
+ LIBBPF_OPTS(bpf_test_run_opts, topts);
+
+ skel = crypto_hash__open_and_load();
+ if (!skel) {
+ /* Skip if kfuncs not available (CONFIG_CRYPTO_HASH2 not set) */
+ if (errno == ENOENT || errno == EINVAL) {
+ test__skip();
+ return;
+ }
+ ASSERT_OK_PTR(skel, "crypto_hash__open_and_load");
+ return;
+ }
+
+ prog_fd = bpf_program__fd(skel->progs.test_sha256);
+ err = bpf_prog_test_run_opts(prog_fd, &topts);
+ ASSERT_OK(err, "test_sha256");
+ ASSERT_EQ(skel->data->sha256_status, 0, "sha256_status");
+ ASSERT_EQ(memcmp(skel->bss->sha256_output, expected_sha256, 32), 0,
+ "sha256_output_match");
+
+ crypto_hash__destroy(skel);
+}
+
+static void test_sha384_basic(void)
+{
+ struct crypto_hash *skel;
+ int err, prog_fd;
+
+ LIBBPF_OPTS(bpf_test_run_opts, topts);
+
+ skel = crypto_hash__open_and_load();
+ if (!skel) {
+ /* Skip if kfuncs not available (CONFIG_CRYPTO_HASH2 not set) */
+ if (errno == ENOENT || errno == EINVAL) {
+ test__skip();
+ return;
+ }
+ ASSERT_OK_PTR(skel, "crypto_hash__open_and_load");
+ return;
+ }
+
+ /* Run SHA-384 test */
+ prog_fd = bpf_program__fd(skel->progs.test_sha384);
+ err = bpf_prog_test_run_opts(prog_fd, &topts);
+ ASSERT_OK(err, "test_sha384");
+ ASSERT_EQ(skel->data->sha384_status, 0, "sha384_status");
+ ASSERT_EQ(memcmp(skel->bss->sha384_output, expected_sha384, 48), 0,
+ "sha384_output_match");
+
+ crypto_hash__destroy(skel);
+}
+
+static void test_sha512_basic(void)
+{
+ struct crypto_hash *skel;
+ int err, prog_fd;
+
+ LIBBPF_OPTS(bpf_test_run_opts, topts);
+
+ skel = crypto_hash__open_and_load();
+ if (!skel) {
+ /* Skip if kfuncs not available (CONFIG_CRYPTO_HASH2 not set) */
+ if (errno == ENOENT || errno == EINVAL) {
+ test__skip();
+ return;
+ }
+ ASSERT_OK_PTR(skel, "crypto_hash__open_and_load");
+ return;
+ }
+
+ prog_fd = bpf_program__fd(skel->progs.test_sha512);
+ err = bpf_prog_test_run_opts(prog_fd, &topts);
+ ASSERT_OK(err, "test_sha512");
+ ASSERT_EQ(skel->data->sha512_status, 0, "sha512_status");
+ ASSERT_EQ(memcmp(skel->bss->sha512_output, expected_sha512, 64), 0,
+ "sha512_output_match");
+
+ crypto_hash__destroy(skel);
+}
+
+static void test_sha256_invalid_params(void)
+{
+ struct crypto_hash *skel;
+ int err, prog_fd;
+
+ LIBBPF_OPTS(bpf_test_run_opts, topts);
+
+ skel = crypto_hash__open_and_load();
+ if (!skel) {
+ /* Skip if kfuncs not available (CONFIG_CRYPTO_HASH2 not set) */
+ if (errno == ENOENT || errno == EINVAL) {
+ test__skip();
+ return;
+ }
+ ASSERT_OK_PTR(skel, "crypto_hash__open_and_load");
+ return;
+ }
+
+ prog_fd = bpf_program__fd(skel->progs.test_sha256_zero_len);
+ err = bpf_prog_test_run_opts(prog_fd, &topts);
+ ASSERT_OK(err, "test_zero_len");
+ ASSERT_EQ(skel->data->sha256_status, 0, "zero_len_rejected");
+
+ crypto_hash__destroy(skel);
+}
+
+void test_crypto_hash(void)
+{
+ if (test__start_subtest("sha256_basic"))
+ test_sha256_basic();
+ if (test__start_subtest("sha384_basic"))
+ test_sha384_basic();
+ if (test__start_subtest("sha512_basic"))
+ test_sha512_basic();
+ if (test__start_subtest("sha256_invalid_params"))
+ test_sha256_invalid_params();
+}
diff --git a/tools/testing/selftests/bpf/progs/crypto_hash.c b/tools/testing/selftests/bpf/progs/crypto_hash.c
new file mode 100644
index 000000000000..cbb9ccecc697
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/crypto_hash.c
@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include "vmlinux.h"
+#include <bpf/bpf_helpers.h>
+#include "bpf_misc.h"
+#include "bpf_kfuncs.h"
+
+unsigned char test_input[3] = "abc";
+
+/* Expected SHA-256 hash of "abc" */
+/* ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad */
+unsigned char expected_sha256[32] = {
+ 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea,
+ 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23,
+ 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c,
+ 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad
+};
+
+/* Output buffers for test results */
+unsigned char sha256_output[32] = {};
+unsigned char sha384_output[48] = {};
+unsigned char sha512_output[64] = {};
+
+int sha256_status = -1;
+int sha384_status = -1;
+int sha512_status = -1;
+
+/* Declare the crypto kfuncs */
+extern struct bpf_crypto_ctx *bpf_crypto_ctx_create(const struct bpf_crypto_params *params,
+ u32 params__sz, int *err) __ksym;
+extern void bpf_crypto_ctx_release(struct bpf_crypto_ctx *ctx) __ksym;
+extern int bpf_crypto_hash(struct bpf_crypto_ctx *ctx, const struct bpf_dynptr *data,
+ const struct bpf_dynptr *out) __ksym;
+
+SEC("syscall")
+int test_sha256(void *ctx)
+{
+ struct bpf_dynptr input_ptr, output_ptr;
+ struct bpf_crypto_ctx *hash_ctx;
+ struct bpf_crypto_params params = {
+ .type = "hash",
+ .algo = "sha256",
+ .key_len = 0,
+ };
+ int err = 0;
+
+ hash_ctx = bpf_crypto_ctx_create(¶ms, sizeof(params), &err);
+ if (!hash_ctx) {
+ sha256_status = err;
+ return 0;
+ }
+
+ bpf_dynptr_from_mem(test_input, sizeof(test_input), 0, &input_ptr);
+ bpf_dynptr_from_mem(sha256_output, sizeof(sha256_output), 0, &output_ptr);
+
+ sha256_status = bpf_crypto_hash(hash_ctx, &input_ptr, &output_ptr);
+ bpf_crypto_ctx_release(hash_ctx);
+ return 0;
+}
+
+SEC("syscall")
+int test_sha384(void *ctx)
+{
+ struct bpf_dynptr input_ptr, output_ptr;
+ struct bpf_crypto_ctx *hash_ctx;
+ struct bpf_crypto_params params = {
+ .type = "hash",
+ .algo = "sha384",
+ .key_len = 0,
+ };
+ int err = 0;
+
+ hash_ctx = bpf_crypto_ctx_create(¶ms, sizeof(params), &err);
+ if (!hash_ctx) {
+ sha384_status = err;
+ return 0;
+ }
+
+ bpf_dynptr_from_mem(test_input, sizeof(test_input), 0, &input_ptr);
+ bpf_dynptr_from_mem(sha384_output, sizeof(sha384_output), 0, &output_ptr);
+
+ sha384_status = bpf_crypto_hash(hash_ctx, &input_ptr, &output_ptr);
+ bpf_crypto_ctx_release(hash_ctx);
+ return 0;
+}
+
+SEC("syscall")
+int test_sha512(void *ctx)
+{
+ struct bpf_dynptr input_ptr, output_ptr;
+ struct bpf_crypto_ctx *hash_ctx;
+ struct bpf_crypto_params params = {
+ .type = "hash",
+ .algo = "sha512",
+ .key_len = 0,
+ };
+ int err = 0;
+
+ hash_ctx = bpf_crypto_ctx_create(¶ms, sizeof(params), &err);
+ if (!hash_ctx) {
+ sha512_status = err;
+ return 0;
+ }
+
+ bpf_dynptr_from_mem(test_input, sizeof(test_input), 0, &input_ptr);
+ bpf_dynptr_from_mem(sha512_output, sizeof(sha512_output), 0, &output_ptr);
+
+ sha512_status = bpf_crypto_hash(hash_ctx, &input_ptr, &output_ptr);
+ bpf_crypto_ctx_release(hash_ctx);
+ return 0;
+}
+
+SEC("syscall")
+int test_sha256_zero_len(void *ctx)
+{
+ struct bpf_dynptr input_ptr, output_ptr;
+ struct bpf_crypto_ctx *hash_ctx;
+ struct bpf_crypto_params params = {
+ .type = "hash",
+ .algo = "sha256",
+ .key_len = 0,
+ };
+ int err = 0;
+ int ret;
+
+ hash_ctx = bpf_crypto_ctx_create(¶ms, sizeof(params), &err);
+ if (!hash_ctx) {
+ sha256_status = err;
+ return 0;
+ }
+
+ bpf_dynptr_from_mem(test_input, 0, 0, &input_ptr);
+ bpf_dynptr_from_mem(sha256_output, sizeof(sha256_output), 0, &output_ptr);
+
+ ret = bpf_crypto_hash(hash_ctx, &input_ptr, &output_ptr);
+ sha256_status = (ret == -22) ? 0 : ret;
+ bpf_crypto_ctx_release(hash_ctx);
+ return 0;
+}
+
+char __license[] SEC("license") = "GPL";
--
2.51.0
Powered by blists - more mailing lists