/src/expat/expat/lib/siphash.h
Line | Count | Source (jump to first uncovered line) |
1 | | /* ========================================================================== |
2 | | * siphash.h - SipHash-2-4 in a single header file |
3 | | * -------------------------------------------------------------------------- |
4 | | * Derived by William Ahern from the reference implementation[1] published[2] |
5 | | * by Jean-Philippe Aumasson and Daniel J. Berstein. |
6 | | * Minimal changes by Sebastian Pipping and Victor Stinner on top, see below. |
7 | | * Licensed under the CC0 Public Domain Dedication license. |
8 | | * |
9 | | * 1. https://www.131002.net/siphash/siphash24.c |
10 | | * 2. https://www.131002.net/siphash/ |
11 | | * -------------------------------------------------------------------------- |
12 | | * HISTORY: |
13 | | * |
14 | | * 2020-10-03 (Sebastian Pipping) |
15 | | * - Drop support for Visual Studio 9.0/2008 and earlier |
16 | | * |
17 | | * 2019-08-03 (Sebastian Pipping) |
18 | | * - Mark part of sip24_valid as to be excluded from clang-format |
19 | | * - Re-format code using clang-format 9 |
20 | | * |
21 | | * 2018-07-08 (Anton Maklakov) |
22 | | * - Add "fall through" markers for GCC's -Wimplicit-fallthrough |
23 | | * |
24 | | * 2017-11-03 (Sebastian Pipping) |
25 | | * - Hide sip_tobin and sip_binof unless SIPHASH_TOBIN macro is defined |
26 | | * |
27 | | * 2017-07-25 (Vadim Zeitlin) |
28 | | * - Fix use of SIPHASH_MAIN macro |
29 | | * |
30 | | * 2017-07-05 (Sebastian Pipping) |
31 | | * - Use _SIP_ULL macro to not require a C++11 compiler if compiled as C++ |
32 | | * - Add const qualifiers at two places |
33 | | * - Ensure <=80 characters line length (assuming tab width 4) |
34 | | * |
35 | | * 2017-06-23 (Victor Stinner) |
36 | | * - Address Win64 compile warnings |
37 | | * |
38 | | * 2017-06-18 (Sebastian Pipping) |
39 | | * - Clarify license note in the header |
40 | | * - Address C89 issues: |
41 | | * - Stop using inline keyword (and let compiler decide) |
42 | | * - Replace _Bool by int |
43 | | * - Turn macro siphash24 into a function |
44 | | * - Address invalid conversion (void pointer) by explicit cast |
45 | | * - Address lack of stdint.h for Visual Studio 2003 to 2008 |
46 | | * - Always expose sip24_valid (for self-tests) |
47 | | * |
48 | | * 2012-11-04 - Born. (William Ahern) |
49 | | * -------------------------------------------------------------------------- |
50 | | * USAGE: |
51 | | * |
52 | | * SipHash-2-4 takes as input two 64-bit words as the key, some number of |
53 | | * message bytes, and outputs a 64-bit word as the message digest. This |
54 | | * implementation employs two data structures: a struct sipkey for |
55 | | * representing the key, and a struct siphash for representing the hash |
56 | | * state. |
57 | | * |
58 | | * For converting a 16-byte unsigned char array to a key, use either the |
59 | | * macro sip_keyof or the routine sip_tokey. The former instantiates a |
60 | | * compound literal key, while the latter requires a key object as a |
61 | | * parameter. |
62 | | * |
63 | | * unsigned char secret[16]; |
64 | | * arc4random_buf(secret, sizeof secret); |
65 | | * struct sipkey *key = sip_keyof(secret); |
66 | | * |
67 | | * For hashing a message, use either the convenience macro siphash24 or the |
68 | | * routines sip24_init, sip24_update, and sip24_final. |
69 | | * |
70 | | * struct siphash state; |
71 | | * void *msg; |
72 | | * size_t len; |
73 | | * uint64_t hash; |
74 | | * |
75 | | * sip24_init(&state, key); |
76 | | * sip24_update(&state, msg, len); |
77 | | * hash = sip24_final(&state); |
78 | | * |
79 | | * or |
80 | | * |
81 | | * hash = siphash24(msg, len, key); |
82 | | * |
83 | | * To convert the 64-bit hash value to a canonical 8-byte little-endian |
84 | | * binary representation, use either the macro sip_binof or the routine |
85 | | * sip_tobin. The former instantiates and returns a compound literal array, |
86 | | * while the latter requires an array object as a parameter. |
87 | | * -------------------------------------------------------------------------- |
88 | | * NOTES: |
89 | | * |
90 | | * o Neither sip_keyof, sip_binof, nor siphash24 will work with compilers |
91 | | * lacking compound literal support. Instead, you must use the lower-level |
92 | | * interfaces which take as parameters the temporary state objects. |
93 | | * |
94 | | * o Uppercase macros may evaluate parameters more than once. Lowercase |
95 | | * macros should not exhibit any such side effects. |
96 | | * ========================================================================== |
97 | | */ |
98 | | #ifndef SIPHASH_H |
99 | | #define SIPHASH_H |
100 | | |
101 | | #include <stddef.h> /* size_t */ |
102 | | #include <stdint.h> /* uint64_t uint32_t uint8_t */ |
103 | | |
104 | | /* |
105 | | * Workaround to not require a C++11 compiler for using ULL suffix |
106 | | * if this code is included and compiled as C++; related GCC warning is: |
107 | | * warning: use of C++11 long long integer constant [-Wlong-long] |
108 | | */ |
109 | 38.7M | #define SIP_ULL(high, low) ((((uint64_t)high) << 32) | (low)) |
110 | | |
111 | 3.03G | #define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b)))) |
112 | | |
113 | | #define SIP_U32TO8_LE(p, v) \ |
114 | | (p)[0] = (uint8_t)((v) >> 0); \ |
115 | | (p)[1] = (uint8_t)((v) >> 8); \ |
116 | | (p)[2] = (uint8_t)((v) >> 16); \ |
117 | | (p)[3] = (uint8_t)((v) >> 24); |
118 | | |
119 | | #define SIP_U64TO8_LE(p, v) \ |
120 | | SIP_U32TO8_LE((p) + 0, (uint32_t)((v) >> 0)); \ |
121 | | SIP_U32TO8_LE((p) + 4, (uint32_t)((v) >> 32)); |
122 | | |
123 | | #define SIP_U8TO64_LE(p) \ |
124 | 224M | (((uint64_t)((p)[0]) << 0) | ((uint64_t)((p)[1]) << 8) \ |
125 | 224M | | ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24) \ |
126 | 224M | | ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40) \ |
127 | 224M | | ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56)) |
128 | | |
129 | 94.5k | #define SIPHASH_INITIALIZER {0, 0, 0, 0, {0}, 0, 0} |
130 | | |
131 | | struct siphash { |
132 | | uint64_t v0, v1, v2, v3; |
133 | | |
134 | | unsigned char buf[8], *p; |
135 | | uint64_t c; |
136 | | }; /* struct siphash */ |
137 | | |
138 | | #define SIP_KEYLEN 16 |
139 | | |
140 | | struct sipkey { |
141 | | uint64_t k[2]; |
142 | | }; /* struct sipkey */ |
143 | | |
144 | 94.5k | #define sip_keyof(k) sip_tokey(&(struct sipkey){{0}}, (k)) |
145 | | |
146 | | static struct sipkey * |
147 | 94.5k | sip_tokey(struct sipkey *key, const void *src) { |
148 | 94.5k | key->k[0] = SIP_U8TO64_LE((const unsigned char *)src); |
149 | 94.5k | key->k[1] = SIP_U8TO64_LE((const unsigned char *)src + 8); |
150 | 94.5k | return key; |
151 | 94.5k | } /* sip_tokey() */ xml_parse_fuzzer.c:sip_tokey Line | Count | Source | 147 | 94.5k | sip_tokey(struct sipkey *key, const void *src) { | 148 | 94.5k | key->k[0] = SIP_U8TO64_LE((const unsigned char *)src); | 149 | 94.5k | key->k[1] = SIP_U8TO64_LE((const unsigned char *)src + 8); | 150 | 94.5k | return key; | 151 | 94.5k | } /* sip_tokey() */ |
Unexecuted instantiation: xmlparse.c:sip_tokey |
152 | | |
153 | | #ifdef SIPHASH_TOBIN |
154 | | |
155 | | # define sip_binof(v) sip_tobin((unsigned char[8]){0}, (v)) |
156 | | |
157 | | static void * |
158 | | sip_tobin(void *dst, uint64_t u64) { |
159 | | SIP_U64TO8_LE((unsigned char *)dst, u64); |
160 | | return dst; |
161 | | } /* sip_tobin() */ |
162 | | |
163 | | #endif /* SIPHASH_TOBIN */ |
164 | | |
165 | | static void |
166 | 243M | sip_round(struct siphash *H, const int rounds) { |
167 | 243M | int i; |
168 | | |
169 | 750M | for (i = 0; i < rounds; i++) { |
170 | 506M | H->v0 += H->v1; |
171 | 506M | H->v1 = SIP_ROTL(H->v1, 13); |
172 | 506M | H->v1 ^= H->v0; |
173 | 506M | H->v0 = SIP_ROTL(H->v0, 32); |
174 | | |
175 | 506M | H->v2 += H->v3; |
176 | 506M | H->v3 = SIP_ROTL(H->v3, 16); |
177 | 506M | H->v3 ^= H->v2; |
178 | | |
179 | 506M | H->v0 += H->v3; |
180 | 506M | H->v3 = SIP_ROTL(H->v3, 21); |
181 | 506M | H->v3 ^= H->v0; |
182 | | |
183 | 506M | H->v2 += H->v1; |
184 | 506M | H->v1 = SIP_ROTL(H->v1, 17); |
185 | 506M | H->v1 ^= H->v2; |
186 | 506M | H->v2 = SIP_ROTL(H->v2, 32); |
187 | 506M | } |
188 | 243M | } /* sip_round() */ xml_parse_fuzzer.c:sip_round Line | Count | Source | 166 | 203M | sip_round(struct siphash *H, const int rounds) { | 167 | 203M | int i; | 168 | | | 169 | 609M | for (i = 0; i < rounds; i++) { | 170 | 406M | H->v0 += H->v1; | 171 | 406M | H->v1 = SIP_ROTL(H->v1, 13); | 172 | 406M | H->v1 ^= H->v0; | 173 | 406M | H->v0 = SIP_ROTL(H->v0, 32); | 174 | | | 175 | 406M | H->v2 += H->v3; | 176 | 406M | H->v3 = SIP_ROTL(H->v3, 16); | 177 | 406M | H->v3 ^= H->v2; | 178 | | | 179 | 406M | H->v0 += H->v3; | 180 | 406M | H->v3 = SIP_ROTL(H->v3, 21); | 181 | 406M | H->v3 ^= H->v0; | 182 | | | 183 | 406M | H->v2 += H->v1; | 184 | 406M | H->v1 = SIP_ROTL(H->v1, 17); | 185 | 406M | H->v1 ^= H->v2; | 186 | 406M | H->v2 = SIP_ROTL(H->v2, 32); | 187 | 406M | } | 188 | 203M | } /* sip_round() */ |
Line | Count | Source | 166 | 40.5M | sip_round(struct siphash *H, const int rounds) { | 167 | 40.5M | int i; | 168 | | | 169 | 140M | for (i = 0; i < rounds; i++) { | 170 | 100M | H->v0 += H->v1; | 171 | 100M | H->v1 = SIP_ROTL(H->v1, 13); | 172 | 100M | H->v1 ^= H->v0; | 173 | 100M | H->v0 = SIP_ROTL(H->v0, 32); | 174 | | | 175 | 100M | H->v2 += H->v3; | 176 | 100M | H->v3 = SIP_ROTL(H->v3, 16); | 177 | 100M | H->v3 ^= H->v2; | 178 | | | 179 | 100M | H->v0 += H->v3; | 180 | 100M | H->v3 = SIP_ROTL(H->v3, 21); | 181 | 100M | H->v3 ^= H->v0; | 182 | | | 183 | 100M | H->v2 += H->v1; | 184 | 100M | H->v1 = SIP_ROTL(H->v1, 17); | 185 | 100M | H->v1 ^= H->v2; | 186 | 100M | H->v2 = SIP_ROTL(H->v2, 32); | 187 | 100M | } | 188 | 40.5M | } /* sip_round() */ |
|
189 | | |
190 | | static struct siphash * |
191 | 9.69M | sip24_init(struct siphash *H, const struct sipkey *key) { |
192 | 9.69M | H->v0 = SIP_ULL(0x736f6d65U, 0x70736575U) ^ key->k[0]; |
193 | 9.69M | H->v1 = SIP_ULL(0x646f7261U, 0x6e646f6dU) ^ key->k[1]; |
194 | 9.69M | H->v2 = SIP_ULL(0x6c796765U, 0x6e657261U) ^ key->k[0]; |
195 | 9.69M | H->v3 = SIP_ULL(0x74656462U, 0x79746573U) ^ key->k[1]; |
196 | | |
197 | 9.69M | H->p = H->buf; |
198 | 9.69M | H->c = 0; |
199 | | |
200 | 9.69M | return H; |
201 | 9.69M | } /* sip24_init() */ xml_parse_fuzzer.c:sip24_init Line | Count | Source | 191 | 94.5k | sip24_init(struct siphash *H, const struct sipkey *key) { | 192 | 94.5k | H->v0 = SIP_ULL(0x736f6d65U, 0x70736575U) ^ key->k[0]; | 193 | 94.5k | H->v1 = SIP_ULL(0x646f7261U, 0x6e646f6dU) ^ key->k[1]; | 194 | 94.5k | H->v2 = SIP_ULL(0x6c796765U, 0x6e657261U) ^ key->k[0]; | 195 | 94.5k | H->v3 = SIP_ULL(0x74656462U, 0x79746573U) ^ key->k[1]; | 196 | | | 197 | 94.5k | H->p = H->buf; | 198 | 94.5k | H->c = 0; | 199 | | | 200 | 94.5k | return H; | 201 | 94.5k | } /* sip24_init() */ |
Line | Count | Source | 191 | 9.60M | sip24_init(struct siphash *H, const struct sipkey *key) { | 192 | 9.60M | H->v0 = SIP_ULL(0x736f6d65U, 0x70736575U) ^ key->k[0]; | 193 | 9.60M | H->v1 = SIP_ULL(0x646f7261U, 0x6e646f6dU) ^ key->k[1]; | 194 | 9.60M | H->v2 = SIP_ULL(0x6c796765U, 0x6e657261U) ^ key->k[0]; | 195 | 9.60M | H->v3 = SIP_ULL(0x74656462U, 0x79746573U) ^ key->k[1]; | 196 | | | 197 | 9.60M | H->p = H->buf; | 198 | 9.60M | H->c = 0; | 199 | | | 200 | 9.60M | return H; | 201 | 9.60M | } /* sip24_init() */ |
|
202 | | |
203 | 2.27G | #define sip_endof(a) (&(a)[sizeof(a) / sizeof *(a)]) |
204 | | |
205 | | static struct siphash * |
206 | 10.1M | sip24_update(struct siphash *H, const void *src, size_t len) { |
207 | 10.1M | const unsigned char *p = (const unsigned char *)src, *pe = p + len; |
208 | 10.1M | uint64_t m; |
209 | | |
210 | 233M | do { |
211 | 2.04G | while (p < pe && H->p < sip_endof(H->buf)) |
212 | 1.81G | *H->p++ = *p++; |
213 | | |
214 | 233M | if (H->p < sip_endof(H->buf)) |
215 | 9.36M | break; |
216 | | |
217 | 224M | m = SIP_U8TO64_LE(H->buf); |
218 | 224M | H->v3 ^= m; |
219 | 224M | sip_round(H, 2); |
220 | 224M | H->v0 ^= m; |
221 | | |
222 | 224M | H->p = H->buf; |
223 | 224M | H->c += 8; |
224 | 224M | } while (p < pe); |
225 | | |
226 | 0 | return H; |
227 | 10.1M | } /* sip24_update() */ xml_parse_fuzzer.c:sip24_update Line | Count | Source | 206 | 94.5k | sip24_update(struct siphash *H, const void *src, size_t len) { | 207 | 94.5k | const unsigned char *p = (const unsigned char *)src, *pe = p + len; | 208 | 94.5k | uint64_t m; | 209 | | | 210 | 202M | do { | 211 | 1.82G | while (p < pe && H->p < sip_endof(H->buf)) | 212 | 1.62G | *H->p++ = *p++; | 213 | | | 214 | 202M | if (H->p < sip_endof(H->buf)) | 215 | 81.1k | break; | 216 | | | 217 | 202M | m = SIP_U8TO64_LE(H->buf); | 218 | 202M | H->v3 ^= m; | 219 | 202M | sip_round(H, 2); | 220 | 202M | H->v0 ^= m; | 221 | | | 222 | 202M | H->p = H->buf; | 223 | 202M | H->c += 8; | 224 | 202M | } while (p < pe); | 225 | | | 226 | 0 | return H; | 227 | 94.5k | } /* sip24_update() */ |
Line | Count | Source | 206 | 10.0M | sip24_update(struct siphash *H, const void *src, size_t len) { | 207 | 10.0M | const unsigned char *p = (const unsigned char *)src, *pe = p + len; | 208 | 10.0M | uint64_t m; | 209 | | | 210 | 30.6M | do { | 211 | 223M | while (p < pe && H->p < sip_endof(H->buf)) | 212 | 192M | *H->p++ = *p++; | 213 | | | 214 | 30.6M | if (H->p < sip_endof(H->buf)) | 215 | 9.28M | break; | 216 | | | 217 | 21.3M | m = SIP_U8TO64_LE(H->buf); | 218 | 21.3M | H->v3 ^= m; | 219 | 21.3M | sip_round(H, 2); | 220 | 21.3M | H->v0 ^= m; | 221 | | | 222 | 21.3M | H->p = H->buf; | 223 | 21.3M | H->c += 8; | 224 | 21.3M | } while (p < pe); | 225 | | | 226 | 0 | return H; | 227 | 10.0M | } /* sip24_update() */ |
|
228 | | |
229 | | static uint64_t |
230 | 9.69M | sip24_final(struct siphash *H) { |
231 | 9.69M | const char left = (char)(H->p - H->buf); |
232 | 9.69M | uint64_t b = (H->c + left) << 56; |
233 | | |
234 | 9.69M | switch (left) { |
235 | 56.2k | case 7: |
236 | 56.2k | b |= (uint64_t)H->buf[6] << 48; |
237 | | /* fall through */ |
238 | 1.99M | case 6: |
239 | 1.99M | b |= (uint64_t)H->buf[5] << 40; |
240 | | /* fall through */ |
241 | 2.05M | case 5: |
242 | 2.05M | b |= (uint64_t)H->buf[4] << 32; |
243 | | /* fall through */ |
244 | 2.51M | case 4: |
245 | 2.51M | b |= (uint64_t)H->buf[3] << 24; |
246 | | /* fall through */ |
247 | 2.69M | case 3: |
248 | 2.69M | b |= (uint64_t)H->buf[2] << 16; |
249 | | /* fall through */ |
250 | 3.63M | case 2: |
251 | 3.63M | b |= (uint64_t)H->buf[1] << 8; |
252 | | /* fall through */ |
253 | 9.04M | case 1: |
254 | 9.04M | b |= (uint64_t)H->buf[0] << 0; |
255 | | /* fall through */ |
256 | 9.69M | case 0: |
257 | 9.69M | break; |
258 | 9.69M | } |
259 | | |
260 | 9.69M | H->v3 ^= b; |
261 | 9.69M | sip_round(H, 2); |
262 | 9.69M | H->v0 ^= b; |
263 | 9.69M | H->v2 ^= 0xff; |
264 | 9.69M | sip_round(H, 4); |
265 | | |
266 | 9.69M | return H->v0 ^ H->v1 ^ H->v2 ^ H->v3; |
267 | 9.69M | } /* sip24_final() */ xml_parse_fuzzer.c:sip24_final Line | Count | Source | 230 | 94.5k | sip24_final(struct siphash *H) { | 231 | 94.5k | const char left = (char)(H->p - H->buf); | 232 | 94.5k | uint64_t b = (H->c + left) << 56; | 233 | | | 234 | 94.5k | switch (left) { | 235 | 8.46k | case 7: | 236 | 8.46k | b |= (uint64_t)H->buf[6] << 48; | 237 | | /* fall through */ | 238 | 21.9k | case 6: | 239 | 21.9k | b |= (uint64_t)H->buf[5] << 40; | 240 | | /* fall through */ | 241 | 32.0k | case 5: | 242 | 32.0k | b |= (uint64_t)H->buf[4] << 32; | 243 | | /* fall through */ | 244 | 47.4k | case 4: | 245 | 47.4k | b |= (uint64_t)H->buf[3] << 24; | 246 | | /* fall through */ | 247 | 57.7k | case 3: | 248 | 57.7k | b |= (uint64_t)H->buf[2] << 16; | 249 | | /* fall through */ | 250 | 72.0k | case 2: | 251 | 72.0k | b |= (uint64_t)H->buf[1] << 8; | 252 | | /* fall through */ | 253 | 81.1k | case 1: | 254 | 81.1k | b |= (uint64_t)H->buf[0] << 0; | 255 | | /* fall through */ | 256 | 94.5k | case 0: | 257 | 94.5k | break; | 258 | 94.5k | } | 259 | | | 260 | 94.5k | H->v3 ^= b; | 261 | 94.5k | sip_round(H, 2); | 262 | 94.5k | H->v0 ^= b; | 263 | 94.5k | H->v2 ^= 0xff; | 264 | 94.5k | sip_round(H, 4); | 265 | | | 266 | 94.5k | return H->v0 ^ H->v1 ^ H->v2 ^ H->v3; | 267 | 94.5k | } /* sip24_final() */ |
Line | Count | Source | 230 | 9.60M | sip24_final(struct siphash *H) { | 231 | 9.60M | const char left = (char)(H->p - H->buf); | 232 | 9.60M | uint64_t b = (H->c + left) << 56; | 233 | | | 234 | 9.60M | switch (left) { | 235 | 47.7k | case 7: | 236 | 47.7k | b |= (uint64_t)H->buf[6] << 48; | 237 | | /* fall through */ | 238 | 1.97M | case 6: | 239 | 1.97M | b |= (uint64_t)H->buf[5] << 40; | 240 | | /* fall through */ | 241 | 2.02M | case 5: | 242 | 2.02M | b |= (uint64_t)H->buf[4] << 32; | 243 | | /* fall through */ | 244 | 2.46M | case 4: | 245 | 2.46M | b |= (uint64_t)H->buf[3] << 24; | 246 | | /* fall through */ | 247 | 2.64M | case 3: | 248 | 2.64M | b |= (uint64_t)H->buf[2] << 16; | 249 | | /* fall through */ | 250 | 3.56M | case 2: | 251 | 3.56M | b |= (uint64_t)H->buf[1] << 8; | 252 | | /* fall through */ | 253 | 8.95M | case 1: | 254 | 8.95M | b |= (uint64_t)H->buf[0] << 0; | 255 | | /* fall through */ | 256 | 9.60M | case 0: | 257 | 9.60M | break; | 258 | 9.60M | } | 259 | | | 260 | 9.60M | H->v3 ^= b; | 261 | 9.60M | sip_round(H, 2); | 262 | 9.60M | H->v0 ^= b; | 263 | 9.60M | H->v2 ^= 0xff; | 264 | 9.60M | sip_round(H, 4); | 265 | | | 266 | 9.60M | return H->v0 ^ H->v1 ^ H->v2 ^ H->v3; | 267 | 9.60M | } /* sip24_final() */ |
|
268 | | |
269 | | static uint64_t |
270 | 94.5k | siphash24(const void *src, size_t len, const struct sipkey *key) { |
271 | 94.5k | struct siphash state = SIPHASH_INITIALIZER; |
272 | 94.5k | return sip24_final(sip24_update(sip24_init(&state, key), src, len)); |
273 | 94.5k | } /* siphash24() */ xml_parse_fuzzer.c:siphash24 Line | Count | Source | 270 | 94.5k | siphash24(const void *src, size_t len, const struct sipkey *key) { | 271 | 94.5k | struct siphash state = SIPHASH_INITIALIZER; | 272 | 94.5k | return sip24_final(sip24_update(sip24_init(&state, key), src, len)); | 273 | 94.5k | } /* siphash24() */ |
Unexecuted instantiation: xmlparse.c:siphash24 |
274 | | |
275 | | /* |
276 | | * SipHash-2-4 output with |
277 | | * k = 00 01 02 ... |
278 | | * and |
279 | | * in = (empty string) |
280 | | * in = 00 (1 byte) |
281 | | * in = 00 01 (2 bytes) |
282 | | * in = 00 01 02 (3 bytes) |
283 | | * ... |
284 | | * in = 00 01 02 ... 3e (63 bytes) |
285 | | */ |
286 | | static int |
287 | 0 | sip24_valid(void) { |
288 | | /* clang-format off */ |
289 | 0 | static const unsigned char vectors[64][8] = { |
290 | 0 | { 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, }, |
291 | 0 | { 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, }, |
292 | 0 | { 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, }, |
293 | 0 | { 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, }, |
294 | 0 | { 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, }, |
295 | 0 | { 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, }, |
296 | 0 | { 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, }, |
297 | 0 | { 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, }, |
298 | 0 | { 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, }, |
299 | 0 | { 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, }, |
300 | 0 | { 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, }, |
301 | 0 | { 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, }, |
302 | 0 | { 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, }, |
303 | 0 | { 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, }, |
304 | 0 | { 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, }, |
305 | 0 | { 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, }, |
306 | 0 | { 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, }, |
307 | 0 | { 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, }, |
308 | 0 | { 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, }, |
309 | 0 | { 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, }, |
310 | 0 | { 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, }, |
311 | 0 | { 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, }, |
312 | 0 | { 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, }, |
313 | 0 | { 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, }, |
314 | 0 | { 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, }, |
315 | 0 | { 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, }, |
316 | 0 | { 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, }, |
317 | 0 | { 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, }, |
318 | 0 | { 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, }, |
319 | 0 | { 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, }, |
320 | 0 | { 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, }, |
321 | 0 | { 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, }, |
322 | 0 | { 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, }, |
323 | 0 | { 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, }, |
324 | 0 | { 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, }, |
325 | 0 | { 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, }, |
326 | 0 | { 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, }, |
327 | 0 | { 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, }, |
328 | 0 | { 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, }, |
329 | 0 | { 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, }, |
330 | 0 | { 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, }, |
331 | 0 | { 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, }, |
332 | 0 | { 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, }, |
333 | 0 | { 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, }, |
334 | 0 | { 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, }, |
335 | 0 | { 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, }, |
336 | 0 | { 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, }, |
337 | 0 | { 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, }, |
338 | 0 | { 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, }, |
339 | 0 | { 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, }, |
340 | 0 | { 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, }, |
341 | 0 | { 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, }, |
342 | 0 | { 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, }, |
343 | 0 | { 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, }, |
344 | 0 | { 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, }, |
345 | 0 | { 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, }, |
346 | 0 | { 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, }, |
347 | 0 | { 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, }, |
348 | 0 | { 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, }, |
349 | 0 | { 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, }, |
350 | 0 | { 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, }, |
351 | 0 | { 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, }, |
352 | 0 | { 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, }, |
353 | 0 | { 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, } |
354 | 0 | }; |
355 | | /* clang-format on */ |
356 | |
|
357 | 0 | unsigned char in[64]; |
358 | 0 | struct sipkey k; |
359 | 0 | size_t i; |
360 | |
|
361 | 0 | sip_tokey(&k, "\000\001\002\003\004\005\006\007\010\011" |
362 | 0 | "\012\013\014\015\016\017"); |
363 | |
|
364 | 0 | for (i = 0; i < sizeof in; ++i) { |
365 | 0 | in[i] = (unsigned char)i; |
366 | |
|
367 | 0 | if (siphash24(in, i, &k) != SIP_U8TO64_LE(vectors[i])) |
368 | 0 | return 0; |
369 | 0 | } |
370 | | |
371 | 0 | return 1; |
372 | 0 | } /* sip24_valid() */ Unexecuted instantiation: xml_parse_fuzzer.c:sip24_valid Unexecuted instantiation: xmlparse.c:sip24_valid |
373 | | |
374 | | #ifdef SIPHASH_MAIN |
375 | | |
376 | | # include <stdio.h> |
377 | | |
378 | | int |
379 | | main(void) { |
380 | | const int ok = sip24_valid(); |
381 | | |
382 | | if (ok) |
383 | | puts("OK"); |
384 | | else |
385 | | puts("FAIL"); |
386 | | |
387 | | return ! ok; |
388 | | } /* main() */ |
389 | | |
390 | | #endif /* SIPHASH_MAIN */ |
391 | | |
392 | | #endif /* SIPHASH_H */ |