]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/test/test-siphash24.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 #include "memory-util.h"
6 #define ITERATIONS 10000000ULL
8 static void do_test(const uint8_t *in
, size_t len
, const uint8_t *key
) {
9 struct siphash state
= {};
13 out
= siphash24(in
, len
, key
);
14 assert_se(out
== 0xa129ca6149be45e5);
16 /* verify the internal state as given in the above paper */
17 siphash24_init(&state
, key
);
18 assert_se(state
.v0
== 0x7469686173716475);
19 assert_se(state
.v1
== 0x6b617f6d656e6665);
20 assert_se(state
.v2
== 0x6b7f62616d677361);
21 assert_se(state
.v3
== 0x7b6b696e727e6c7b);
22 siphash24_compress(in
, len
, &state
);
23 assert_se(state
.v0
== 0x4a017198de0a59e0);
24 assert_se(state
.v1
== 0x0d52f6f62a4f59a4);
25 assert_se(state
.v2
== 0x634cb3577b01fd3d);
26 assert_se(state
.v3
== 0xa5224d6f55c7d9c8);
27 out
= siphash24_finalize(&state
);
28 assert_se(out
== 0xa129ca6149be45e5);
29 assert_se(state
.v0
== 0xf6bcd53893fecff1);
30 assert_se(state
.v1
== 0x54b9964c7ea0d937);
31 assert_se(state
.v2
== 0x1b38329c099bb55a);
32 assert_se(state
.v3
== 0x1814bb89ad7be679);
34 /* verify that decomposing the input in three chunks gives the
36 for (i
= 0; i
< len
; i
++) {
37 for (j
= i
; j
< len
; j
++) {
38 siphash24_init(&state
, key
);
39 siphash24_compress(in
, i
, &state
);
40 siphash24_compress(&in
[i
], j
- i
, &state
);
41 siphash24_compress(&in
[j
], len
- j
, &state
);
42 out
= siphash24_finalize(&state
);
43 assert_se(out
== 0xa129ca6149be45e5);
48 static void test_short_hashes(void) {
49 const uint8_t one
[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
50 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
51 const uint8_t key
[16] = { 0x22, 0x24, 0x41, 0x22, 0x55, 0x77, 0x88, 0x07,
52 0x23, 0x09, 0x23, 0x14, 0x0c, 0x33, 0x0e, 0x0f};
53 uint8_t two
[sizeof one
] = {};
55 struct siphash state1
= {}, state2
= {};
58 siphash24_init(&state1
, key
);
59 siphash24_init(&state2
, key
);
61 /* hashing 1, 2, 3, 4, 5, ..., 16 bytes, with the byte after the buffer different */
62 for (i
= 1; i
<= sizeof one
; i
++) {
63 siphash24_compress(one
, i
, &state1
);
66 siphash24_compress(two
, i
, &state2
);
68 assert_se(memcmp(&state1
, &state2
, sizeof state1
) == 0);
71 /* hashing n and 1, n and 2, n and 3, ..., n-1 and 1, n-2 and 2, ... */
72 for (i
= sizeof one
; i
> 0; i
--) {
75 for (j
= 1; j
<= sizeof one
; j
++) {
76 siphash24_compress(one
, i
, &state1
);
77 siphash24_compress(one
, j
, &state1
);
79 siphash24_compress(one
, i
, &state2
);
81 siphash24_compress(two
, j
, &state2
);
83 assert_se(memcmp(&state1
, &state2
, sizeof state1
) == 0);
88 /* see https://131002.net/siphash/siphash.pdf, Appendix A */
89 int main(int argc
, char *argv
[]) {
90 const uint8_t in
[15] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
91 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e };
92 const uint8_t key
[16] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
93 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
96 /* Test with same input but different alignments. */
97 memcpy(in_buf
, in
, sizeof(in
));
98 do_test(in_buf
, sizeof(in
), key
);
99 memcpy(in_buf
+ 1, in
, sizeof(in
));
100 do_test(in_buf
+ 1, sizeof(in
), key
);
101 memcpy(in_buf
+ 2, in
, sizeof(in
));
102 do_test(in_buf
+ 2, sizeof(in
), key
);
103 memcpy(in_buf
+ 4, in
, sizeof(in
));
104 do_test(in_buf
+ 4, sizeof(in
), key
);