Commit | Line | Data |
---|---|---|
2c956a60 JD |
1 | /* Copyright (C) 2016 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved. |
2 | * | |
3 | * This file is provided under a dual BSD/GPLv2 license. | |
4 | * | |
5 | * SipHash: a fast short-input PRF | |
6 | * https://131002.net/siphash/ | |
7 | * | |
1ae2324f JD |
8 | * This implementation is specifically for SipHash2-4 for a secure PRF |
9 | * and HalfSipHash1-3/SipHash1-3 for an insecure PRF only suitable for | |
10 | * hashtables. | |
2c956a60 JD |
11 | */ |
12 | ||
13 | #ifndef _LINUX_SIPHASH_H | |
14 | #define _LINUX_SIPHASH_H | |
15 | ||
16 | #include <linux/types.h> | |
17 | #include <linux/kernel.h> | |
18 | ||
19 | #define SIPHASH_ALIGNMENT __alignof__(u64) | |
20 | typedef struct { | |
21 | u64 key[2]; | |
22 | } siphash_key_t; | |
23 | ||
49ecc2e9 ED |
24 | #define siphash_aligned_key_t siphash_key_t __aligned(16) |
25 | ||
df453700 ED |
26 | static inline bool siphash_key_is_zero(const siphash_key_t *key) |
27 | { | |
28 | return !(key->key[0] | key->key[1]); | |
29 | } | |
30 | ||
2c956a60 | 31 | u64 __siphash_aligned(const void *data, size_t len, const siphash_key_t *key); |
2c956a60 | 32 | u64 __siphash_unaligned(const void *data, size_t len, const siphash_key_t *key); |
2c956a60 JD |
33 | |
34 | u64 siphash_1u64(const u64 a, const siphash_key_t *key); | |
35 | u64 siphash_2u64(const u64 a, const u64 b, const siphash_key_t *key); | |
36 | u64 siphash_3u64(const u64 a, const u64 b, const u64 c, | |
37 | const siphash_key_t *key); | |
38 | u64 siphash_4u64(const u64 a, const u64 b, const u64 c, const u64 d, | |
39 | const siphash_key_t *key); | |
40 | u64 siphash_1u32(const u32 a, const siphash_key_t *key); | |
41 | u64 siphash_3u32(const u32 a, const u32 b, const u32 c, | |
42 | const siphash_key_t *key); | |
43 | ||
44 | static inline u64 siphash_2u32(const u32 a, const u32 b, | |
45 | const siphash_key_t *key) | |
46 | { | |
47 | return siphash_1u64((u64)b << 32 | a, key); | |
48 | } | |
49 | static inline u64 siphash_4u32(const u32 a, const u32 b, const u32 c, | |
50 | const u32 d, const siphash_key_t *key) | |
51 | { | |
52 | return siphash_2u64((u64)b << 32 | a, (u64)d << 32 | c, key); | |
53 | } | |
54 | ||
55 | ||
56 | static inline u64 ___siphash_aligned(const __le64 *data, size_t len, | |
57 | const siphash_key_t *key) | |
58 | { | |
59 | if (__builtin_constant_p(len) && len == 4) | |
60 | return siphash_1u32(le32_to_cpup((const __le32 *)data), key); | |
61 | if (__builtin_constant_p(len) && len == 8) | |
62 | return siphash_1u64(le64_to_cpu(data[0]), key); | |
63 | if (__builtin_constant_p(len) && len == 16) | |
64 | return siphash_2u64(le64_to_cpu(data[0]), le64_to_cpu(data[1]), | |
65 | key); | |
66 | if (__builtin_constant_p(len) && len == 24) | |
67 | return siphash_3u64(le64_to_cpu(data[0]), le64_to_cpu(data[1]), | |
68 | le64_to_cpu(data[2]), key); | |
69 | if (__builtin_constant_p(len) && len == 32) | |
70 | return siphash_4u64(le64_to_cpu(data[0]), le64_to_cpu(data[1]), | |
71 | le64_to_cpu(data[2]), le64_to_cpu(data[3]), | |
72 | key); | |
73 | return __siphash_aligned(data, len, key); | |
74 | } | |
75 | ||
76 | /** | |
77 | * siphash - compute 64-bit siphash PRF value | |
78 | * @data: buffer to hash | |
79 | * @size: size of @data | |
80 | * @key: the siphash key | |
81 | */ | |
82 | static inline u64 siphash(const void *data, size_t len, | |
83 | const siphash_key_t *key) | |
84 | { | |
f7e5b9bf AB |
85 | if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) || |
86 | !IS_ALIGNED((unsigned long)data, SIPHASH_ALIGNMENT)) | |
2c956a60 | 87 | return __siphash_unaligned(data, len, key); |
2c956a60 JD |
88 | return ___siphash_aligned(data, len, key); |
89 | } | |
90 | ||
1ae2324f JD |
91 | #define HSIPHASH_ALIGNMENT __alignof__(unsigned long) |
92 | typedef struct { | |
93 | unsigned long key[2]; | |
94 | } hsiphash_key_t; | |
95 | ||
96 | u32 __hsiphash_aligned(const void *data, size_t len, | |
97 | const hsiphash_key_t *key); | |
1ae2324f JD |
98 | u32 __hsiphash_unaligned(const void *data, size_t len, |
99 | const hsiphash_key_t *key); | |
1ae2324f JD |
100 | |
101 | u32 hsiphash_1u32(const u32 a, const hsiphash_key_t *key); | |
102 | u32 hsiphash_2u32(const u32 a, const u32 b, const hsiphash_key_t *key); | |
103 | u32 hsiphash_3u32(const u32 a, const u32 b, const u32 c, | |
104 | const hsiphash_key_t *key); | |
105 | u32 hsiphash_4u32(const u32 a, const u32 b, const u32 c, const u32 d, | |
106 | const hsiphash_key_t *key); | |
107 | ||
108 | static inline u32 ___hsiphash_aligned(const __le32 *data, size_t len, | |
109 | const hsiphash_key_t *key) | |
110 | { | |
111 | if (__builtin_constant_p(len) && len == 4) | |
112 | return hsiphash_1u32(le32_to_cpu(data[0]), key); | |
113 | if (__builtin_constant_p(len) && len == 8) | |
114 | return hsiphash_2u32(le32_to_cpu(data[0]), le32_to_cpu(data[1]), | |
115 | key); | |
116 | if (__builtin_constant_p(len) && len == 12) | |
117 | return hsiphash_3u32(le32_to_cpu(data[0]), le32_to_cpu(data[1]), | |
118 | le32_to_cpu(data[2]), key); | |
119 | if (__builtin_constant_p(len) && len == 16) | |
120 | return hsiphash_4u32(le32_to_cpu(data[0]), le32_to_cpu(data[1]), | |
121 | le32_to_cpu(data[2]), le32_to_cpu(data[3]), | |
122 | key); | |
123 | return __hsiphash_aligned(data, len, key); | |
124 | } | |
125 | ||
126 | /** | |
127 | * hsiphash - compute 32-bit hsiphash PRF value | |
128 | * @data: buffer to hash | |
129 | * @size: size of @data | |
130 | * @key: the hsiphash key | |
131 | */ | |
132 | static inline u32 hsiphash(const void *data, size_t len, | |
133 | const hsiphash_key_t *key) | |
134 | { | |
f7e5b9bf AB |
135 | if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) || |
136 | !IS_ALIGNED((unsigned long)data, HSIPHASH_ALIGNMENT)) | |
1ae2324f | 137 | return __hsiphash_unaligned(data, len, key); |
1ae2324f JD |
138 | return ___hsiphash_aligned(data, len, key); |
139 | } | |
140 | ||
2c956a60 | 141 | #endif /* _LINUX_SIPHASH_H */ |