* [PATCH bpf-next 2/4] selftests/bpf: Add tests for SHA hash kfuncs
[not found] <20251117211413.1394-1-git@danielhodges.dev>
@ 2025-11-17 21:13 ` Daniel Hodges
2025-11-18 13:45 ` Vadim Fedorenko
2025-11-17 21:14 ` [PATCH bpf-next 4/4] selftests/bpf: Add tests for ECDSA signature verification kfuncs Daniel Hodges
1 sibling, 1 reply; 3+ messages in thread
From: Daniel Hodges @ 2025-11-17 21:13 UTC (permalink / raw)
To: Andrii Nakryiko, Eduard Zingerman, Alexei Starovoitov,
Daniel Borkmann, Martin KaFai Lau, Song Liu, Yonghong Song,
John Fastabend, KP Singh, Stanislav Fomichev, Hao Luo, Jiri Olsa,
Shuah Khan, Daniel Hodges, open list,
open list:BPF [SELFTESTS] (Test Runners & Infrastructure),
open list:KERNEL SELFTEST FRAMEWORK
Add selftests to validate the SHA-256, SHA-384, and SHA-512 hash kfuncs
introduced in the BPF crypto subsystem. 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@danielhodges.dev>
---
.../selftests/bpf/prog_tests/crypto_hash.c | 129 ++++++++++++++++++
.../testing/selftests/bpf/progs/crypto_hash.c | 83 +++++++++++
2 files changed, 212 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/prog_tests/crypto_hash.c b/tools/testing/selftests/bpf/prog_tests/crypto_hash.c
new file mode 100644
index 000000000000..4600dad693d4
--- /dev/null
+++ b/tools/testing/selftests/bpf/prog_tests/crypto_hash.c
@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <test_progs.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 (!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 (!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 (!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 (!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..d01f23557411
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/crypto_hash.c
@@ -0,0 +1,83 @@
+// 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 SHA hash kfuncs */
+extern int bpf_sha256_hash(const struct bpf_dynptr *data, const struct bpf_dynptr *out) __ksym;
+extern int bpf_sha384_hash(const struct bpf_dynptr *data, const struct bpf_dynptr *out) __ksym;
+extern int bpf_sha512_hash(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;
+
+ 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_sha256_hash(&input_ptr, &output_ptr);
+ return 0;
+}
+
+SEC("syscall")
+int test_sha384(void *ctx)
+{
+ struct bpf_dynptr input_ptr, output_ptr;
+
+ 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_sha384_hash(&input_ptr, &output_ptr);
+ return 0;
+}
+
+SEC("syscall")
+int test_sha512(void *ctx)
+{
+ struct bpf_dynptr input_ptr, output_ptr;
+
+ 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_sha512_hash(&input_ptr, &output_ptr);
+ return 0;
+}
+
+SEC("syscall")
+int test_sha256_zero_len(void *ctx)
+{
+ struct bpf_dynptr input_ptr, output_ptr;
+ int ret;
+
+ bpf_dynptr_from_mem(test_input, 0, 0, &input_ptr);
+ bpf_dynptr_from_mem(sha256_output, sizeof(sha256_output), 0, &output_ptr);
+
+ ret = bpf_sha256_hash(&input_ptr, &output_ptr);
+ sha256_status = (ret == -22) ? 0 : ret;
+ return 0;
+}
+
+char __license[] SEC("license") = "GPL";
--
2.51.0
^ permalink raw reply related [flat|nested] 3+ messages in thread* [PATCH bpf-next 4/4] selftests/bpf: Add tests for ECDSA signature verification kfuncs
[not found] <20251117211413.1394-1-git@danielhodges.dev>
2025-11-17 21:13 ` [PATCH bpf-next 2/4] selftests/bpf: Add tests for SHA hash kfuncs Daniel Hodges
@ 2025-11-17 21:14 ` Daniel Hodges
1 sibling, 0 replies; 3+ messages in thread
From: Daniel Hodges @ 2025-11-17 21:14 UTC (permalink / raw)
To: Andrii Nakryiko, Eduard Zingerman, Alexei Starovoitov,
Daniel Borkmann, Martin KaFai Lau, Song Liu, Yonghong Song,
John Fastabend, KP Singh, Stanislav Fomichev, Hao Luo, Jiri Olsa,
Shuah Khan, Daniel Hodges, open list,
open list:BPF [SELFTESTS] (Test Runners & Infrastructure),
open list:KERNEL SELFTEST FRAMEWORK
Add selftests to validate the ECDSA signature verification kfuncs
introduced in the BPF crypto subsystem. The tests verify both valid
signature acceptance and invalid signature rejection using the
context-based ECDSA API.
The tests use RFC 6979 test vectors for NIST P-256 (secp256r1) with
well-known valid signatures. The algorithm "p1363(ecdsa-nist-p256)"
is used to handle standard r||s signature format.
Signed-off-by: Daniel Hodges <git@danielhodges.dev>
---
.../selftests/bpf/prog_tests/ecdsa_verify.c | 96 ++++++++
.../selftests/bpf/progs/ecdsa_verify.c | 228 ++++++++++++++++++
2 files changed, 324 insertions(+)
create mode 100644 tools/testing/selftests/bpf/prog_tests/ecdsa_verify.c
create mode 100644 tools/testing/selftests/bpf/progs/ecdsa_verify.c
diff --git a/tools/testing/selftests/bpf/prog_tests/ecdsa_verify.c b/tools/testing/selftests/bpf/prog_tests/ecdsa_verify.c
new file mode 100644
index 000000000000..d1f83ce08ad6
--- /dev/null
+++ b/tools/testing/selftests/bpf/prog_tests/ecdsa_verify.c
@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <test_progs.h>
+#include "ecdsa_verify.skel.h"
+
+static void test_ecdsa_verify_valid_signature(void)
+{
+ struct ecdsa_verify *skel;
+ int err, prog_fd;
+
+ LIBBPF_OPTS(bpf_test_run_opts, topts);
+
+ skel = ecdsa_verify__open_and_load();
+ if (!ASSERT_OK_PTR(skel, "ecdsa_verify__open_and_load"))
+ return;
+
+ prog_fd = bpf_program__fd(skel->progs.test_ecdsa_verify_valid);
+ err = bpf_prog_test_run_opts(prog_fd, &topts);
+ ASSERT_OK(err, "test_ecdsa_verify_valid");
+ ASSERT_EQ(skel->data->ctx_create_status, 0, "ctx_create_status");
+ ASSERT_EQ(skel->data->verify_result, 0, "verify_valid_signature");
+
+ ecdsa_verify__destroy(skel);
+}
+
+static void test_ecdsa_verify_invalid_signature(void)
+{
+ struct ecdsa_verify *skel;
+ int err, prog_fd;
+
+ LIBBPF_OPTS(bpf_test_run_opts, topts);
+
+ skel = ecdsa_verify__open_and_load();
+ if (!ASSERT_OK_PTR(skel, "ecdsa_verify__open_and_load"))
+ return;
+
+ prog_fd = bpf_program__fd(skel->progs.test_ecdsa_verify_invalid);
+ err = bpf_prog_test_run_opts(prog_fd, &topts);
+ ASSERT_OK(err, "test_ecdsa_verify_invalid");
+ ASSERT_NEQ(skel->data->verify_invalid_result, 0, "verify_invalid_signature_rejected");
+
+ ecdsa_verify__destroy(skel);
+}
+
+static void test_ecdsa_sign_and_verify(void)
+{
+ struct ecdsa_verify *skel;
+ int err, prog_fd;
+
+ LIBBPF_OPTS(bpf_test_run_opts, topts);
+
+ skel = ecdsa_verify__open_and_load();
+ if (!ASSERT_OK_PTR(skel, "ecdsa_verify__open_and_load"))
+ return;
+
+ prog_fd = bpf_program__fd(skel->progs.test_ecdsa_sign_verify);
+ err = bpf_prog_test_run_opts(prog_fd, &topts);
+ ASSERT_OK(err, "test_ecdsa_sign_verify");
+ ASSERT_GT(skel->data->sign_result, 0, "sign_returns_signature_size");
+ ASSERT_EQ(skel->data->sign_verify_result, 0, "verify_generated_signature");
+
+ ecdsa_verify__destroy(skel);
+}
+
+static void test_ecdsa_size_queries(void)
+{
+ struct ecdsa_verify *skel;
+ int err, prog_fd;
+
+ LIBBPF_OPTS(bpf_test_run_opts, topts);
+
+ skel = ecdsa_verify__open_and_load();
+ if (!ASSERT_OK_PTR(skel, "ecdsa_verify__open_and_load"))
+ return;
+
+ prog_fd = bpf_program__fd(skel->progs.test_ecdsa_size_queries);
+ err = bpf_prog_test_run_opts(prog_fd, &topts);
+ ASSERT_OK(err, "test_ecdsa_size_queries");
+ ASSERT_EQ(skel->data->keysize_result, 256, "keysize_p256");
+ ASSERT_EQ(skel->data->digestsize_result, 64, "digestsize_p256");
+ ASSERT_EQ(skel->data->maxsize_result, 64, "maxsize_p256");
+
+ ecdsa_verify__destroy(skel);
+}
+
+void test_ecdsa_verify(void)
+{
+ if (test__start_subtest("verify_valid_signature"))
+ test_ecdsa_verify_valid_signature();
+ if (test__start_subtest("verify_invalid_signature"))
+ test_ecdsa_verify_invalid_signature();
+ if (test__start_subtest("sign_and_verify"))
+ test_ecdsa_sign_and_verify();
+ if (test__start_subtest("size_queries"))
+ test_ecdsa_size_queries();
+}
diff --git a/tools/testing/selftests/bpf/progs/ecdsa_verify.c b/tools/testing/selftests/bpf/progs/ecdsa_verify.c
new file mode 100644
index 000000000000..fb24baf6c437
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/ecdsa_verify.c
@@ -0,0 +1,228 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include "vmlinux.h"
+#include <bpf/bpf_helpers.h>
+#include "bpf_misc.h"
+
+struct bpf_ecdsa_ctx;
+extern struct bpf_ecdsa_ctx *
+bpf_ecdsa_ctx_create(const struct bpf_dynptr *algo_name,
+ const struct bpf_dynptr *public_key, int *err) __ksym;
+extern struct bpf_ecdsa_ctx *
+bpf_ecdsa_ctx_create_with_privkey(const struct bpf_dynptr *algo_name,
+ const struct bpf_dynptr *private_key, int *err) __ksym;
+extern int bpf_ecdsa_verify(struct bpf_ecdsa_ctx *ctx,
+ const struct bpf_dynptr *message,
+ const struct bpf_dynptr *signature) __ksym;
+extern int bpf_ecdsa_sign(struct bpf_ecdsa_ctx *ctx,
+ const struct bpf_dynptr *message,
+ const struct bpf_dynptr *signature) __ksym;
+extern int bpf_ecdsa_keysize(struct bpf_ecdsa_ctx *ctx) __ksym;
+extern int bpf_ecdsa_digestsize(struct bpf_ecdsa_ctx *ctx) __ksym;
+extern int bpf_ecdsa_maxsize(struct bpf_ecdsa_ctx *ctx) __ksym;
+extern void bpf_ecdsa_ctx_release(struct bpf_ecdsa_ctx *ctx) __ksym;
+
+/* NIST P-256 test vector
+ * This is a known valid ECDSA signature for testing purposes
+ */
+
+/* Algorithm name for P-256 with p1363 format (standard r||s signature) */
+char algo_p256[] = "p1363(ecdsa-nist-p256)";
+
+/* Public key in uncompressed format: 0x04 || x || y (65 bytes) */
+unsigned char pubkey_p256[65] = {
+ 0x04, /* Uncompressed point indicator */
+ /* X coordinate (32 bytes) */
+ 0x60, 0xfe, 0xd4, 0xba, 0x25, 0x5a, 0x9d, 0x31,
+ 0xc9, 0x61, 0xeb, 0x74, 0xc6, 0x35, 0x6d, 0x68,
+ 0xc0, 0x49, 0xb8, 0x92, 0x3b, 0x61, 0xfa, 0x6c,
+ 0xe6, 0x69, 0x62, 0x2e, 0x60, 0xf2, 0x9f, 0xb6,
+ /* Y coordinate (32 bytes) */
+ 0x79, 0x03, 0xfe, 0x10, 0x08, 0xb8, 0xbc, 0x99,
+ 0xa4, 0x1a, 0xe9, 0xe9, 0x56, 0x28, 0xbc, 0x64,
+ 0xf2, 0xf1, 0xb2, 0x0c, 0x2d, 0x7e, 0x9f, 0x51,
+ 0x77, 0xa3, 0xc2, 0x94, 0xd4, 0x46, 0x22, 0x99
+};
+
+/* Message hash (32 bytes) - SHA-256 of "sample" */
+unsigned char message_hash[32] = {
+ 0xaf, 0x2b, 0xdb, 0xe1, 0xaa, 0x9b, 0x6e, 0xc1,
+ 0xe2, 0xad, 0xe1, 0xd6, 0x94, 0xf4, 0x1f, 0xc7,
+ 0x1a, 0x83, 0x1d, 0x02, 0x68, 0xe9, 0x89, 0x15,
+ 0x62, 0x11, 0x3d, 0x8a, 0x62, 0xad, 0xd1, 0xbf
+};
+
+/* Valid signature r || s (64 bytes) */
+unsigned char valid_signature[64] = {
+ /* r component (32 bytes) */
+ 0xef, 0xd4, 0x8b, 0x2a, 0xac, 0xb6, 0xa8, 0xfd,
+ 0x11, 0x40, 0xdd, 0x9c, 0xd4, 0x5e, 0x81, 0xd6,
+ 0x9d, 0x2c, 0x87, 0x7b, 0x56, 0xaa, 0xf9, 0x91,
+ 0xc3, 0x4d, 0x0e, 0xa8, 0x4e, 0xaf, 0x37, 0x16,
+ /* s component (32 bytes) */
+ 0xf7, 0xcb, 0x1c, 0x94, 0x2d, 0x65, 0x7c, 0x41,
+ 0xd4, 0x36, 0xc7, 0xa1, 0xb6, 0xe2, 0x9f, 0x65,
+ 0xf3, 0xe9, 0x00, 0xdb, 0xb9, 0xaf, 0xf4, 0x06,
+ 0x4d, 0xc4, 0xab, 0x2f, 0x84, 0x3a, 0xcd, 0xa8
+};
+
+/* Invalid signature (modified r component) for negative test */
+unsigned char invalid_signature[64] = {
+ /* r component (32 bytes) - first byte modified */
+ 0xff, 0xd4, 0x8b, 0x2a, 0xac, 0xb6, 0xa8, 0xfd,
+ 0x11, 0x40, 0xdd, 0x9c, 0xd4, 0x5e, 0x81, 0xd6,
+ 0x9d, 0x2c, 0x87, 0x7b, 0x56, 0xaa, 0xf9, 0x91,
+ 0xc3, 0x4d, 0x0e, 0xa8, 0x4e, 0xaf, 0x37, 0x16,
+ /* s component (32 bytes) */
+ 0xf7, 0xcb, 0x1c, 0x94, 0x2d, 0x65, 0x7c, 0x41,
+ 0xd4, 0x36, 0xc7, 0xa1, 0xb6, 0xe2, 0x9f, 0x65,
+ 0xf3, 0xe9, 0x00, 0xdb, 0xb9, 0xaf, 0xf4, 0x06,
+ 0x4d, 0xc4, 0xab, 0x2f, 0x84, 0x3a, 0xcd, 0xa8
+};
+
+/* Private key for signing (32 bytes) - matches the public key above */
+unsigned char privkey_p256[32] = {
+ 0xc9, 0xaf, 0xa9, 0xd8, 0x45, 0xba, 0x75, 0x16,
+ 0x6b, 0x5c, 0x21, 0x57, 0x67, 0xb1, 0xd6, 0x93,
+ 0x4e, 0x50, 0xc3, 0xdb, 0x36, 0xe8, 0x9b, 0x12,
+ 0x7b, 0x8a, 0x62, 0x2b, 0x12, 0x0f, 0x67, 0x21
+};
+
+/* Test results */
+int verify_result = -1;
+int verify_invalid_result = -1;
+int ctx_create_status = -1;
+int sign_result = -1;
+int sign_verify_result = -1;
+int keysize_result = -1;
+int digestsize_result = -1;
+int maxsize_result = -1;
+unsigned char generated_signature[64] = {0};
+
+SEC("syscall")
+int test_ecdsa_verify_valid(void *ctx)
+{
+ struct bpf_ecdsa_ctx *ecdsa_ctx;
+ struct bpf_dynptr algo_ptr, key_ptr, msg_ptr, sig_ptr;
+ int err = 0;
+
+ bpf_dynptr_from_mem(algo_p256, sizeof(algo_p256) - 1, 0, &algo_ptr);
+ bpf_dynptr_from_mem(pubkey_p256, sizeof(pubkey_p256), 0, &key_ptr);
+
+ ecdsa_ctx = bpf_ecdsa_ctx_create(&algo_ptr, &key_ptr, &err);
+ if (!ecdsa_ctx) {
+ ctx_create_status = err;
+ return 0;
+ }
+ ctx_create_status = 0;
+
+ bpf_dynptr_from_mem(message_hash, sizeof(message_hash), 0, &msg_ptr);
+ bpf_dynptr_from_mem(valid_signature, sizeof(valid_signature), 0, &sig_ptr);
+
+ verify_result = bpf_ecdsa_verify(ecdsa_ctx, &msg_ptr, &sig_ptr);
+
+ bpf_ecdsa_ctx_release(ecdsa_ctx);
+
+ return 0;
+}
+
+SEC("syscall")
+int test_ecdsa_verify_invalid(void *ctx)
+{
+ struct bpf_ecdsa_ctx *ecdsa_ctx;
+ struct bpf_dynptr algo_ptr, key_ptr, msg_ptr, sig_ptr;
+ int err = 0;
+
+ bpf_dynptr_from_mem(algo_p256, sizeof(algo_p256) - 1, 0, &algo_ptr);
+ bpf_dynptr_from_mem(pubkey_p256, sizeof(pubkey_p256), 0, &key_ptr);
+
+ ecdsa_ctx = bpf_ecdsa_ctx_create(&algo_ptr, &key_ptr, &err);
+ if (!ecdsa_ctx)
+ return 0;
+
+ bpf_dynptr_from_mem(message_hash, sizeof(message_hash), 0, &msg_ptr);
+ bpf_dynptr_from_mem(invalid_signature, sizeof(invalid_signature), 0, &sig_ptr);
+
+ verify_invalid_result = bpf_ecdsa_verify(ecdsa_ctx, &msg_ptr, &sig_ptr);
+
+ bpf_ecdsa_ctx_release(ecdsa_ctx);
+
+ return 0;
+}
+
+SEC("syscall")
+int test_ecdsa_sign_verify(void *ctx)
+{
+ struct bpf_ecdsa_ctx *sign_ctx, *verify_ctx;
+ struct bpf_dynptr algo_ptr, privkey_ptr, pubkey_ptr, msg_ptr, sig_ptr;
+ int err = 0;
+
+ /* Create signing context with private key */
+ bpf_dynptr_from_mem(algo_p256, sizeof(algo_p256) - 1, 0, &algo_ptr);
+ bpf_dynptr_from_mem(privkey_p256, sizeof(privkey_p256), 0, &privkey_ptr);
+
+ sign_ctx = bpf_ecdsa_ctx_create_with_privkey(&algo_ptr, &privkey_ptr, &err);
+ if (!sign_ctx) {
+ sign_result = err;
+ return 0;
+ }
+
+ /* Sign the message */
+ bpf_dynptr_from_mem(message_hash, sizeof(message_hash), 0, &msg_ptr);
+ bpf_dynptr_from_mem(generated_signature, sizeof(generated_signature), 0, &sig_ptr);
+
+ sign_result = bpf_ecdsa_sign(sign_ctx, &msg_ptr, &sig_ptr);
+
+ bpf_ecdsa_ctx_release(sign_ctx);
+
+ /* If signing succeeded, verify the generated signature */
+ if (sign_result > 0 && sign_result <= (int)sizeof(generated_signature)) {
+ unsigned int sig_size;
+
+ /* Explicitly bound the value for the verifier */
+ sig_size = sign_result & 0x3F; /* Max 64 bytes */
+
+ bpf_dynptr_from_mem(algo_p256, sizeof(algo_p256) - 1, 0, &algo_ptr);
+ bpf_dynptr_from_mem(pubkey_p256, sizeof(pubkey_p256), 0, &pubkey_ptr);
+
+ verify_ctx = bpf_ecdsa_ctx_create(&algo_ptr, &pubkey_ptr, &err);
+ if (!verify_ctx) {
+ sign_verify_result = err;
+ return 0;
+ }
+
+ bpf_dynptr_from_mem(message_hash, sizeof(message_hash), 0, &msg_ptr);
+ bpf_dynptr_from_mem(generated_signature, sig_size, 0, &sig_ptr);
+
+ sign_verify_result = bpf_ecdsa_verify(verify_ctx, &msg_ptr, &sig_ptr);
+
+ bpf_ecdsa_ctx_release(verify_ctx);
+ }
+
+ return 0;
+}
+
+SEC("syscall")
+int test_ecdsa_size_queries(void *ctx)
+{
+ struct bpf_ecdsa_ctx *ecdsa_ctx;
+ struct bpf_dynptr algo_ptr, key_ptr;
+ int err = 0;
+
+ bpf_dynptr_from_mem(algo_p256, sizeof(algo_p256) - 1, 0, &algo_ptr);
+ bpf_dynptr_from_mem(pubkey_p256, sizeof(pubkey_p256), 0, &key_ptr);
+
+ ecdsa_ctx = bpf_ecdsa_ctx_create(&algo_ptr, &key_ptr, &err);
+ if (!ecdsa_ctx)
+ return 0;
+
+ keysize_result = bpf_ecdsa_keysize(ecdsa_ctx);
+ digestsize_result = bpf_ecdsa_digestsize(ecdsa_ctx);
+ maxsize_result = bpf_ecdsa_maxsize(ecdsa_ctx);
+
+ bpf_ecdsa_ctx_release(ecdsa_ctx);
+
+ return 0;
+}
+
+char __license[] SEC("license") = "GPL";
--
2.51.0
^ permalink raw reply related [flat|nested] 3+ messages in thread