projects/linux·blob master · refs

134 lines · 4.1 KiB

1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright 2025 Google LLC
4 */
5#include <crypto/blake2b.h>
6#include "blake2b-testvecs.h"
7
8/*
9 * The following are compatibility functions that present BLAKE2b as an unkeyed
10 * hash function that produces hashes of fixed length BLAKE2B_HASH_SIZE, so that
11 * hash-test-template.h can be reused to test it.
12 */
13
14static void blake2b_default(const u8 *data, size_t len,
15 u8 out[BLAKE2B_HASH_SIZE])
16{
17 blake2b(NULL, 0, data, len, out, BLAKE2B_HASH_SIZE);
18}
19
20static void blake2b_init_default(struct blake2b_ctx *ctx)
21{
22 blake2b_init(ctx, BLAKE2B_HASH_SIZE);
23}
24
25/*
26 * Generate the HASH_KUNIT_CASES using hash-test-template.h. These test BLAKE2b
27 * with a key length of 0 and a hash length of BLAKE2B_HASH_SIZE.
28 */
29#define HASH blake2b_default
30#define HASH_CTX blake2b_ctx
31#define HASH_SIZE BLAKE2B_HASH_SIZE
32#define HASH_INIT blake2b_init_default
33#define HASH_UPDATE blake2b_update
34#define HASH_FINAL blake2b_final
35#include "hash-test-template.h"
36
37/*
38 * BLAKE2b specific test case which tests all possible combinations of key
39 * length and hash length.
40 */
41static void test_blake2b_all_key_and_hash_lens(struct kunit *test)
42{
43 const size_t data_len = 100;
44 u8 *data = alloc_buf(test, data_len);
45 u8 *key = alloc_buf(test, BLAKE2B_KEY_SIZE);
46 u8 *hash = alloc_buf(test, BLAKE2B_HASH_SIZE);
47 struct blake2b_ctx main_ctx;
48 u8 main_hash[BLAKE2B_HASH_SIZE];
49
50 rand_bytes_seeded_from_len(data, data_len);
51 blake2b_init(&main_ctx, BLAKE2B_HASH_SIZE);
52 for (int key_len = 0; key_len <= BLAKE2B_KEY_SIZE; key_len++) {
53 rand_bytes_seeded_from_len(key, key_len);
54 for (int out_len = 1; out_len <= BLAKE2B_HASH_SIZE; out_len++) {
55 blake2b(key, key_len, data, data_len, hash, out_len);
56 blake2b_update(&main_ctx, hash, out_len);
57 }
58 }
59 blake2b_final(&main_ctx, main_hash);
60 KUNIT_ASSERT_MEMEQ(test, main_hash, blake2b_keyed_testvec_consolidated,
61 BLAKE2B_HASH_SIZE);
62}
63
64/*
65 * BLAKE2b specific test case which tests using a guarded buffer for all allowed
66 * key lengths. Also tests both blake2b() and blake2b_init_key().
67 */
68static void test_blake2b_with_guarded_key_buf(struct kunit *test)
69{
70 const size_t data_len = 100;
71 u8 *data = alloc_buf(test, data_len);
72 u8 *guarded_key_buf = alloc_guarded_buf(test, BLAKE2B_KEY_SIZE);
73
74 rand_bytes(data, data_len);
75 for (int key_len = 0; key_len <= BLAKE2B_KEY_SIZE; key_len++) {
76 u8 key[BLAKE2B_KEY_SIZE];
77 u8 *guarded_key = &guarded_key_buf[BLAKE2B_KEY_SIZE - key_len];
78 u8 hash1[BLAKE2B_HASH_SIZE];
79 u8 hash2[BLAKE2B_HASH_SIZE];
80 struct blake2b_ctx ctx;
81
82 rand_bytes(key, key_len);
83 memcpy(guarded_key, key, key_len);
84
85 blake2b(key, key_len, data, data_len, hash1, BLAKE2B_HASH_SIZE);
86 blake2b(guarded_key, key_len, data, data_len, hash2,
87 BLAKE2B_HASH_SIZE);
88 KUNIT_ASSERT_MEMEQ(test, hash1, hash2, BLAKE2B_HASH_SIZE);
89
90 blake2b_init_key(&ctx, BLAKE2B_HASH_SIZE, guarded_key, key_len);
91 blake2b_update(&ctx, data, data_len);
92 blake2b_final(&ctx, hash2);
93 KUNIT_ASSERT_MEMEQ(test, hash1, hash2, BLAKE2B_HASH_SIZE);
94 }
95}
96
97/*
98 * BLAKE2b specific test case which tests using a guarded output buffer for all
99 * allowed output lengths.
100 */
101static void test_blake2b_with_guarded_out_buf(struct kunit *test)
102{
103 const size_t data_len = 100;
104 u8 *data = alloc_buf(test, data_len);
105 u8 *out_buf = alloc_guarded_buf(test, BLAKE2B_HASH_SIZE);
106
107 rand_bytes(data, data_len);
108 for (int out_len = 1; out_len <= BLAKE2B_HASH_SIZE; out_len++) {
109 u8 hash[BLAKE2B_HASH_SIZE];
110 u8 *guarded_hash = &out_buf[BLAKE2B_HASH_SIZE - out_len];
111
112 blake2b(NULL, 0, data, data_len, hash, out_len);
113 blake2b(NULL, 0, data, data_len, guarded_hash, out_len);
114 KUNIT_ASSERT_MEMEQ(test, hash, guarded_hash, out_len);
115 }
116}
117
118static struct kunit_case blake2b_test_cases[] = {
119 HASH_KUNIT_CASES,
120 KUNIT_CASE(test_blake2b_all_key_and_hash_lens),
121 KUNIT_CASE(test_blake2b_with_guarded_key_buf),
122 KUNIT_CASE(test_blake2b_with_guarded_out_buf),
123 KUNIT_CASE(benchmark_hash),
124 {},
125};
126
127static struct kunit_suite blake2b_test_suite = {
128 .name = "blake2b",
129 .test_cases = blake2b_test_cases,
130};
131kunit_test_suite(blake2b_test_suite);
132
133MODULE_DESCRIPTION("KUnit tests and benchmark for BLAKE2b");
134MODULE_LICENSE("GPL");