]> Git Repo - cpuminer-multi.git/blame - sha3/sph_ripemd.c
projects / cpuminer-multi.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
update build.sh
[cpuminer-multi.git] / sha3 / sph_ripemd.c
CommitLineData
f9345a59
TP		 1/* $Id: ripemd.c 216 2010-06-08 09:46:57Z tp $ */
2/*
3 * RIPEMD-160 implementation.
4 *
5 * ==========================(LICENSE BEGIN)============================
6 *
7 * Copyright (c) 2007-2010 Projet RNRT SAPHIR
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining
10 * a copy of this software and associated documentation files (the
11 * "Software"), to deal in the Software without restriction, including
12 * without limitation the rights to use, copy, modify, merge, publish,
13 * distribute, sublicense, and/or sell copies of the Software, and to
14 * permit persons to whom the Software is furnished to do so, subject to
15 * the following conditions:
16 *
17 * The above copyright notice and this permission notice shall be
18 * included in all copies or substantial portions of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
24 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 *
28 * ===========================(LICENSE END)=============================
29 *
30 * @author Thomas Pornin <[email protected]>
31 */
32
33#include <stddef.h>
34#include <string.h>
35
36#include "sph_ripemd.h"
37
38/*
39 * Round functions for RIPEMD (original).
40 */
41#define F(x, y, z) ((((y) ^ (z)) & (x)) ^ (z))
42#define G(x, y, z) (((x) & (y)) | (((x) | (y)) & (z)))
43#define H(x, y, z) ((x) ^ (y) ^ (z))
44
45static const sph_u32 oIV[5] = {
46 SPH_C32(0x67452301), SPH_C32(0xEFCDAB89),
47 SPH_C32(0x98BADCFE), SPH_C32(0x10325476)
48};
49
50/*
51 * Round functions for RIPEMD-128 and RIPEMD-160.
52 */
53#define F1(x, y, z) ((x) ^ (y) ^ (z))
54#define F2(x, y, z) ((((y) ^ (z)) & (x)) ^ (z))
55#define F3(x, y, z) (((x) | ~(y)) ^ (z))
56#define F4(x, y, z) ((((x) ^ (y)) & (z)) ^ (y))
57#define F5(x, y, z) ((x) ^ ((y) | ~(z)))
58
59static const sph_u32 IV[5] = {
60 SPH_C32(0x67452301), SPH_C32(0xEFCDAB89), SPH_C32(0x98BADCFE),
61 SPH_C32(0x10325476), SPH_C32(0xC3D2E1F0)
62};
63
64#define ROTL SPH_ROTL32
65
66/* ===================================================================== */
67/*
68 * RIPEMD (original hash, deprecated).
69 */
70
71#define FF1(A, B, C, D, X, s) do { \
72 sph_u32 tmp = SPH_T32((A) + F(B, C, D) + (X)); \
73 (A) = ROTL(tmp, (s)); \
74 } while (0)
75
76#define GG1(A, B, C, D, X, s) do { \
77 sph_u32 tmp = SPH_T32((A) + G(B, C, D) \
78 + (X) + SPH_C32(0x5A827999)); \
79 (A) = ROTL(tmp, (s)); \
80 } while (0)
81
82#define HH1(A, B, C, D, X, s) do { \
83 sph_u32 tmp = SPH_T32((A) + H(B, C, D) \
84 + (X) + SPH_C32(0x6ED9EBA1)); \
85 (A) = ROTL(tmp, (s)); \
86 } while (0)
87
88#define FF2(A, B, C, D, X, s) do { \
89 sph_u32 tmp = SPH_T32((A) + F(B, C, D) \
90 + (X) + SPH_C32(0x50A28BE6)); \
91 (A) = ROTL(tmp, (s)); \
92 } while (0)
93
94#define GG2(A, B, C, D, X, s) do { \
95 sph_u32 tmp = SPH_T32((A) + G(B, C, D) + (X)); \
96 (A) = ROTL(tmp, (s)); \
97 } while (0)
98
99#define HH2(A, B, C, D, X, s) do { \
100 sph_u32 tmp = SPH_T32((A) + H(B, C, D) \
101 + (X) + SPH_C32(0x5C4DD124)); \
102 (A) = ROTL(tmp, (s)); \
103 } while (0)
104
105#define RIPEMD_ROUND_BODY(in, h) do { \
106 sph_u32 A1, B1, C1, D1; \
107 sph_u32 A2, B2, C2, D2; \
108 sph_u32 tmp; \
109 \
110 A1 = A2 = (h)[0]; \
111 B1 = B2 = (h)[1]; \
112 C1 = C2 = (h)[2]; \
113 D1 = D2 = (h)[3]; \
114 \
115 FF1(A1, B1, C1, D1, in( 0), 11); \
116 FF1(D1, A1, B1, C1, in( 1), 14); \
117 FF1(C1, D1, A1, B1, in( 2), 15); \
118 FF1(B1, C1, D1, A1, in( 3), 12); \
119 FF1(A1, B1, C1, D1, in( 4), 5); \
120 FF1(D1, A1, B1, C1, in( 5), 8); \
121 FF1(C1, D1, A1, B1, in( 6), 7); \
122 FF1(B1, C1, D1, A1, in( 7), 9); \
123 FF1(A1, B1, C1, D1, in( 8), 11); \
124 FF1(D1, A1, B1, C1, in( 9), 13); \
125 FF1(C1, D1, A1, B1, in(10), 14); \
126 FF1(B1, C1, D1, A1, in(11), 15); \
127 FF1(A1, B1, C1, D1, in(12), 6); \
128 FF1(D1, A1, B1, C1, in(13), 7); \
129 FF1(C1, D1, A1, B1, in(14), 9); \
130 FF1(B1, C1, D1, A1, in(15), 8); \
131 \
132 GG1(A1, B1, C1, D1, in( 7), 7); \
133 GG1(D1, A1, B1, C1, in( 4), 6); \
134 GG1(C1, D1, A1, B1, in(13), 8); \
135 GG1(B1, C1, D1, A1, in( 1), 13); \
136 GG1(A1, B1, C1, D1, in(10), 11); \
137 GG1(D1, A1, B1, C1, in( 6), 9); \
138 GG1(C1, D1, A1, B1, in(15), 7); \
139 GG1(B1, C1, D1, A1, in( 3), 15); \
140 GG1(A1, B1, C1, D1, in(12), 7); \
141 GG1(D1, A1, B1, C1, in( 0), 12); \
142 GG1(C1, D1, A1, B1, in( 9), 15); \
143 GG1(B1, C1, D1, A1, in( 5), 9); \
144 GG1(A1, B1, C1, D1, in(14), 7); \
145 GG1(D1, A1, B1, C1, in( 2), 11); \
146 GG1(C1, D1, A1, B1, in(11), 13); \
147 GG1(B1, C1, D1, A1, in( 8), 12); \
148 \
149 HH1(A1, B1, C1, D1, in( 3), 11); \
150 HH1(D1, A1, B1, C1, in(10), 13); \
151 HH1(C1, D1, A1, B1, in( 2), 14); \
152 HH1(B1, C1, D1, A1, in( 4), 7); \
153 HH1(A1, B1, C1, D1, in( 9), 14); \
154 HH1(D1, A1, B1, C1, in(15), 9); \
155 HH1(C1, D1, A1, B1, in( 8), 13); \
156 HH1(B1, C1, D1, A1, in( 1), 15); \
157 HH1(A1, B1, C1, D1, in(14), 6); \
158 HH1(D1, A1, B1, C1, in( 7), 8); \
159 HH1(C1, D1, A1, B1, in( 0), 13); \
160 HH1(B1, C1, D1, A1, in( 6), 6); \
161 HH1(A1, B1, C1, D1, in(11), 12); \
162 HH1(D1, A1, B1, C1, in(13), 5); \
163 HH1(C1, D1, A1, B1, in( 5), 7); \
164 HH1(B1, C1, D1, A1, in(12), 5); \
165 \
166 FF2(A2, B2, C2, D2, in( 0), 11); \
167 FF2(D2, A2, B2, C2, in( 1), 14); \
168 FF2(C2, D2, A2, B2, in( 2), 15); \
169 FF2(B2, C2, D2, A2, in( 3), 12); \
170 FF2(A2, B2, C2, D2, in( 4), 5); \
171 FF2(D2, A2, B2, C2, in( 5), 8); \
172 FF2(C2, D2, A2, B2, in( 6), 7); \
173 FF2(B2, C2, D2, A2, in( 7), 9); \
174 FF2(A2, B2, C2, D2, in( 8), 11); \
175 FF2(D2, A2, B2, C2, in( 9), 13); \
176 FF2(C2, D2, A2, B2, in(10), 14); \
177 FF2(B2, C2, D2, A2, in(11), 15); \
178 FF2(A2, B2, C2, D2, in(12), 6); \
179 FF2(D2, A2, B2, C2, in(13), 7); \
180 FF2(C2, D2, A2, B2, in(14), 9); \
181 FF2(B2, C2, D2, A2, in(15), 8); \
182 \
183 GG2(A2, B2, C2, D2, in( 7), 7); \
184 GG2(D2, A2, B2, C2, in( 4), 6); \
185 GG2(C2, D2, A2, B2, in(13), 8); \
186 GG2(B2, C2, D2, A2, in( 1), 13); \
187 GG2(A2, B2, C2, D2, in(10), 11); \
188 GG2(D2, A2, B2, C2, in( 6), 9); \
189 GG2(C2, D2, A2, B2, in(15), 7); \
190 GG2(B2, C2, D2, A2, in( 3), 15); \
191 GG2(A2, B2, C2, D2, in(12), 7); \
192 GG2(D2, A2, B2, C2, in( 0), 12); \
193 GG2(C2, D2, A2, B2, in( 9), 15); \
194 GG2(B2, C2, D2, A2, in( 5), 9); \
195 GG2(A2, B2, C2, D2, in(14), 7); \
196 GG2(D2, A2, B2, C2, in( 2), 11); \
197 GG2(C2, D2, A2, B2, in(11), 13); \
198 GG2(B2, C2, D2, A2, in( 8), 12); \
199 \
200 HH2(A2, B2, C2, D2, in( 3), 11); \
201 HH2(D2, A2, B2, C2, in(10), 13); \
202 HH2(C2, D2, A2, B2, in( 2), 14); \
203 HH2(B2, C2, D2, A2, in( 4), 7); \
204 HH2(A2, B2, C2, D2, in( 9), 14); \
205 HH2(D2, A2, B2, C2, in(15), 9); \
206 HH2(C2, D2, A2, B2, in( 8), 13); \
207 HH2(B2, C2, D2, A2, in( 1), 15); \
208 HH2(A2, B2, C2, D2, in(14), 6); \
209 HH2(D2, A2, B2, C2, in( 7), 8); \
210 HH2(C2, D2, A2, B2, in( 0), 13); \
211 HH2(B2, C2, D2, A2, in( 6), 6); \
212 HH2(A2, B2, C2, D2, in(11), 12); \
213 HH2(D2, A2, B2, C2, in(13), 5); \
214 HH2(C2, D2, A2, B2, in( 5), 7); \
215 HH2(B2, C2, D2, A2, in(12), 5); \
216 \
217 tmp = SPH_T32((h)[1] + C1 + D2); \
218 (h)[1] = SPH_T32((h)[2] + D1 + A2); \
219 (h)[2] = SPH_T32((h)[3] + A1 + B2); \
220 (h)[3] = SPH_T32((h)[0] + B1 + C2); \
221 (h)[0] = tmp; \
222 } while (0)
223
224/*
225 * One round of RIPEMD. The data must be aligned for 32-bit access.
226 */
227static void
228ripemd_round(const unsigned char *data, sph_u32 r[5])
229{
230#if SPH_LITTLE_FAST
231
232#define RIPEMD_IN(x) sph_dec32le_aligned(data + (4 * (x)))
233
234#else
235
236 sph_u32 X_var[16];
237 int i;
238
239 for (i = 0; i < 16; i ++)
240 X_var[i] = sph_dec32le_aligned(data + 4 * i);
241#define RIPEMD_IN(x) X_var[x]
242
243#endif
244 RIPEMD_ROUND_BODY(RIPEMD_IN, r);
245#undef RIPEMD_IN
246}
247
248/* see sph_ripemd.h */
249void
250sph_ripemd_init(void *cc)
251{
252 sph_ripemd_context *sc;
253
254 sc = (sph_ripemd_context*)cc;
255 memcpy(sc->val, oIV, sizeof sc->val);
256#if SPH_64
257 sc->count = 0;
258#else
259 sc->count_high = sc->count_low = 0;
260#endif
261}
262
263#define RFUN ripemd_round
264#define HASH ripemd
265#define LE32 1
266#include "md_helper.c"
267#undef RFUN
268#undef HASH
269#undef LE32
270
271/* see sph_ripemd.h */
272void
273sph_ripemd_close(void *cc, void *dst)
274{
275 ripemd_close(cc, dst, 4);
276 sph_ripemd_init(cc);
277}
278
279/* see sph_ripemd.h */
280void
281sph_ripemd_comp(const sph_u32 msg[16], sph_u32 val[4])
282{
283#define RIPEMD_IN(x) msg[x]
284 RIPEMD_ROUND_BODY(RIPEMD_IN, val);
285#undef RIPEMD_IN
286}
287
288/* ===================================================================== */
289/*
290 * RIPEMD-128.
291 */
292
293/*
294 * Round constants for RIPEMD-128.
295 */
296#define sK11 SPH_C32(0x00000000)
297#define sK12 SPH_C32(0x5A827999)
298#define sK13 SPH_C32(0x6ED9EBA1)
299#define sK14 SPH_C32(0x8F1BBCDC)
300
301#define sK21 SPH_C32(0x50A28BE6)
302#define sK22 SPH_C32(0x5C4DD124)
303#define sK23 SPH_C32(0x6D703EF3)
304#define sK24 SPH_C32(0x00000000)
305
306#define sRR(a, b, c, d, f, s, r, k) do { \
307 a = ROTL(SPH_T32(a + f(b, c, d) + r + k), s); \
308 } while (0)
309
310#define sROUND1(a, b, c, d, f, s, r, k) \
311 sRR(a ## 1, b ## 1, c ## 1, d ## 1, f, s, r, sK1 ## k)
312
313#define sROUND2(a, b, c, d, f, s, r, k) \
314 sRR(a ## 2, b ## 2, c ## 2, d ## 2, f, s, r, sK2 ## k)
315
316/*
317 * This macro defines the body for a RIPEMD-128 compression function
318 * implementation. The "in" parameter should evaluate, when applied to a
319 * numerical input parameter from 0 to 15, to an expression which yields
320 * the corresponding input block. The "h" parameter should evaluate to
321 * an array or pointer expression designating the array of 4 words which
322 * contains the input and output of the compression function.
323 */
324
325#define RIPEMD128_ROUND_BODY(in, h) do { \
326 sph_u32 A1, B1, C1, D1; \
327 sph_u32 A2, B2, C2, D2; \
328 sph_u32 tmp; \
329 \
330 A1 = A2 = (h)[0]; \
331 B1 = B2 = (h)[1]; \
332 C1 = C2 = (h)[2]; \
333 D1 = D2 = (h)[3]; \
334 \
335 sROUND1(A, B, C, D, F1, 11, in( 0), 1); \
336 sROUND1(D, A, B, C, F1, 14, in( 1), 1); \
337 sROUND1(C, D, A, B, F1, 15, in( 2), 1); \
338 sROUND1(B, C, D, A, F1, 12, in( 3), 1); \
339 sROUND1(A, B, C, D, F1, 5, in( 4), 1); \
340 sROUND1(D, A, B, C, F1, 8, in( 5), 1); \
341 sROUND1(C, D, A, B, F1, 7, in( 6), 1); \
342 sROUND1(B, C, D, A, F1, 9, in( 7), 1); \
343 sROUND1(A, B, C, D, F1, 11, in( 8), 1); \
344 sROUND1(D, A, B, C, F1, 13, in( 9), 1); \
345 sROUND1(C, D, A, B, F1, 14, in(10), 1); \
346 sROUND1(B, C, D, A, F1, 15, in(11), 1); \
347 sROUND1(A, B, C, D, F1, 6, in(12), 1); \
348 sROUND1(D, A, B, C, F1, 7, in(13), 1); \
349 sROUND1(C, D, A, B, F1, 9, in(14), 1); \
350 sROUND1(B, C, D, A, F1, 8, in(15), 1); \
351 \
352 sROUND1(A, B, C, D, F2, 7, in( 7), 2); \
353 sROUND1(D, A, B, C, F2, 6, in( 4), 2); \
354 sROUND1(C, D, A, B, F2, 8, in(13), 2); \
355 sROUND1(B, C, D, A, F2, 13, in( 1), 2); \
356 sROUND1(A, B, C, D, F2, 11, in(10), 2); \
357 sROUND1(D, A, B, C, F2, 9, in( 6), 2); \
358 sROUND1(C, D, A, B, F2, 7, in(15), 2); \
359 sROUND1(B, C, D, A, F2, 15, in( 3), 2); \
360 sROUND1(A, B, C, D, F2, 7, in(12), 2); \
361 sROUND1(D, A, B, C, F2, 12, in( 0), 2); \
362 sROUND1(C, D, A, B, F2, 15, in( 9), 2); \
363 sROUND1(B, C, D, A, F2, 9, in( 5), 2); \
364 sROUND1(A, B, C, D, F2, 11, in( 2), 2); \
365 sROUND1(D, A, B, C, F2, 7, in(14), 2); \
366 sROUND1(C, D, A, B, F2, 13, in(11), 2); \
367 sROUND1(B, C, D, A, F2, 12, in( 8), 2); \
368 \
369 sROUND1(A, B, C, D, F3, 11, in( 3), 3); \
370 sROUND1(D, A, B, C, F3, 13, in(10), 3); \
371 sROUND1(C, D, A, B, F3, 6, in(14), 3); \
372 sROUND1(B, C, D, A, F3, 7, in( 4), 3); \
373 sROUND1(A, B, C, D, F3, 14, in( 9), 3); \
374 sROUND1(D, A, B, C, F3, 9, in(15), 3); \
375 sROUND1(C, D, A, B, F3, 13, in( 8), 3); \
376 sROUND1(B, C, D, A, F3, 15, in( 1), 3); \
377 sROUND1(A, B, C, D, F3, 14, in( 2), 3); \
378 sROUND1(D, A, B, C, F3, 8, in( 7), 3); \
379 sROUND1(C, D, A, B, F3, 13, in( 0), 3); \
380 sROUND1(B, C, D, A, F3, 6, in( 6), 3); \
381 sROUND1(A, B, C, D, F3, 5, in(13), 3); \
382 sROUND1(D, A, B, C, F3, 12, in(11), 3); \
383 sROUND1(C, D, A, B, F3, 7, in( 5), 3); \
384 sROUND1(B, C, D, A, F3, 5, in(12), 3); \
385 \
386 sROUND1(A, B, C, D, F4, 11, in( 1), 4); \
387 sROUND1(D, A, B, C, F4, 12, in( 9), 4); \
388 sROUND1(C, D, A, B, F4, 14, in(11), 4); \
389 sROUND1(B, C, D, A, F4, 15, in(10), 4); \
390 sROUND1(A, B, C, D, F4, 14, in( 0), 4); \
391 sROUND1(D, A, B, C, F4, 15, in( 8), 4); \
392 sROUND1(C, D, A, B, F4, 9, in(12), 4); \
393 sROUND1(B, C, D, A, F4, 8, in( 4), 4); \
394 sROUND1(A, B, C, D, F4, 9, in(13), 4); \
395 sROUND1(D, A, B, C, F4, 14, in( 3), 4); \
396 sROUND1(C, D, A, B, F4, 5, in( 7), 4); \
397 sROUND1(B, C, D, A, F4, 6, in(15), 4); \
398 sROUND1(A, B, C, D, F4, 8, in(14), 4); \
399 sROUND1(D, A, B, C, F4, 6, in( 5), 4); \
400 sROUND1(C, D, A, B, F4, 5, in( 6), 4); \
401 sROUND1(B, C, D, A, F4, 12, in( 2), 4); \
402 \
403 sROUND2(A, B, C, D, F4, 8, in( 5), 1); \
404 sROUND2(D, A, B, C, F4, 9, in(14), 1); \
405 sROUND2(C, D, A, B, F4, 9, in( 7), 1); \
406 sROUND2(B, C, D, A, F4, 11, in( 0), 1); \
407 sROUND2(A, B, C, D, F4, 13, in( 9), 1); \
408 sROUND2(D, A, B, C, F4, 15, in( 2), 1); \
409 sROUND2(C, D, A, B, F4, 15, in(11), 1); \
410 sROUND2(B, C, D, A, F4, 5, in( 4), 1); \
411 sROUND2(A, B, C, D, F4, 7, in(13), 1); \
412 sROUND2(D, A, B, C, F4, 7, in( 6), 1); \
413 sROUND2(C, D, A, B, F4, 8, in(15), 1); \
414 sROUND2(B, C, D, A, F4, 11, in( 8), 1); \
415 sROUND2(A, B, C, D, F4, 14, in( 1), 1); \
416 sROUND2(D, A, B, C, F4, 14, in(10), 1); \
417 sROUND2(C, D, A, B, F4, 12, in( 3), 1); \
418 sROUND2(B, C, D, A, F4, 6, in(12), 1); \
419 \
420 sROUND2(A, B, C, D, F3, 9, in( 6), 2); \
421 sROUND2(D, A, B, C, F3, 13, in(11), 2); \
422 sROUND2(C, D, A, B, F3, 15, in( 3), 2); \
423 sROUND2(B, C, D, A, F3, 7, in( 7), 2); \
424 sROUND2(A, B, C, D, F3, 12, in( 0), 2); \
425 sROUND2(D, A, B, C, F3, 8, in(13), 2); \
426 sROUND2(C, D, A, B, F3, 9, in( 5), 2); \
427 sROUND2(B, C, D, A, F3, 11, in(10), 2); \
428 sROUND2(A, B, C, D, F3, 7, in(14), 2); \
429 sROUND2(D, A, B, C, F3, 7, in(15), 2); \
430 sROUND2(C, D, A, B, F3, 12, in( 8), 2); \
431 sROUND2(B, C, D, A, F3, 7, in(12), 2); \
432 sROUND2(A, B, C, D, F3, 6, in( 4), 2); \
433 sROUND2(D, A, B, C, F3, 15, in( 9), 2); \
434 sROUND2(C, D, A, B, F3, 13, in( 1), 2); \
435 sROUND2(B, C, D, A, F3, 11, in( 2), 2); \
436 \
437 sROUND2(A, B, C, D, F2, 9, in(15), 3); \
438 sROUND2(D, A, B, C, F2, 7, in( 5), 3); \
439 sROUND2(C, D, A, B, F2, 15, in( 1), 3); \
440 sROUND2(B, C, D, A, F2, 11, in( 3), 3); \
441 sROUND2(A, B, C, D, F2, 8, in( 7), 3); \
442 sROUND2(D, A, B, C, F2, 6, in(14), 3); \
443 sROUND2(C, D, A, B, F2, 6, in( 6), 3); \
444 sROUND2(B, C, D, A, F2, 14, in( 9), 3); \
445 sROUND2(A, B, C, D, F2, 12, in(11), 3); \
446 sROUND2(D, A, B, C, F2, 13, in( 8), 3); \
447 sROUND2(C, D, A, B, F2, 5, in(12), 3); \
448 sROUND2(B, C, D, A, F2, 14, in( 2), 3); \
449 sROUND2(A, B, C, D, F2, 13, in(10), 3); \
450 sROUND2(D, A, B, C, F2, 13, in( 0), 3); \
451 sROUND2(C, D, A, B, F2, 7, in( 4), 3); \
452 sROUND2(B, C, D, A, F2, 5, in(13), 3); \
453 \
454 sROUND2(A, B, C, D, F1, 15, in( 8), 4); \
455 sROUND2(D, A, B, C, F1, 5, in( 6), 4); \
456 sROUND2(C, D, A, B, F1, 8, in( 4), 4); \
457 sROUND2(B, C, D, A, F1, 11, in( 1), 4); \
458 sROUND2(A, B, C, D, F1, 14, in( 3), 4); \
459 sROUND2(D, A, B, C, F1, 14, in(11), 4); \
460 sROUND2(C, D, A, B, F1, 6, in(15), 4); \
461 sROUND2(B, C, D, A, F1, 14, in( 0), 4); \
462 sROUND2(A, B, C, D, F1, 6, in( 5), 4); \
463 sROUND2(D, A, B, C, F1, 9, in(12), 4); \
464 sROUND2(C, D, A, B, F1, 12, in( 2), 4); \
465 sROUND2(B, C, D, A, F1, 9, in(13), 4); \
466 sROUND2(A, B, C, D, F1, 12, in( 9), 4); \
467 sROUND2(D, A, B, C, F1, 5, in( 7), 4); \
468 sROUND2(C, D, A, B, F1, 15, in(10), 4); \
469 sROUND2(B, C, D, A, F1, 8, in(14), 4); \
470 \
471 tmp = SPH_T32((h)[1] + C1 + D2); \
472 (h)[1] = SPH_T32((h)[2] + D1 + A2); \
473 (h)[2] = SPH_T32((h)[3] + A1 + B2); \
474 (h)[3] = SPH_T32((h)[0] + B1 + C2); \
475 (h)[0] = tmp; \
476 } while (0)
477
478/*
479 * One round of RIPEMD-128. The data must be aligned for 32-bit access.
480 */
481static void
482ripemd128_round(const unsigned char *data, sph_u32 r[5])
483{
484#if SPH_LITTLE_FAST
485
486#define RIPEMD128_IN(x) sph_dec32le_aligned(data + (4 * (x)))
487
488#else
489
490 sph_u32 X_var[16];
491 int i;
492
493 for (i = 0; i < 16; i ++)
494 X_var[i] = sph_dec32le_aligned(data + 4 * i);
495#define RIPEMD128_IN(x) X_var[x]
496
497#endif
498 RIPEMD128_ROUND_BODY(RIPEMD128_IN, r);
499#undef RIPEMD128_IN
500}
501
502/* see sph_ripemd.h */
503void
504sph_ripemd128_init(void *cc)
505{
506 sph_ripemd128_context *sc;
507
508 sc = (sph_ripemd128_context*)cc;
509 memcpy(sc->val, IV, sizeof sc->val);
510#if SPH_64
511 sc->count = 0;
512#else
513 sc->count_high = sc->count_low = 0;
514#endif
515}
516
517#define RFUN ripemd128_round
518#define HASH ripemd128
519#define LE32 1
520#include "md_helper.c"
521#undef RFUN
522#undef HASH
523#undef LE32
524
525/* see sph_ripemd.h */
526void
527sph_ripemd128_close(void *cc, void *dst)
528{
529 ripemd128_close(cc, dst, 4);
530 sph_ripemd128_init(cc);
531}
532
533/* see sph_ripemd.h */
534void
535sph_ripemd128_comp(const sph_u32 msg[16], sph_u32 val[4])
536{
537#define RIPEMD128_IN(x) msg[x]
538 RIPEMD128_ROUND_BODY(RIPEMD128_IN, val);
539#undef RIPEMD128_IN
540}
541
542/* ===================================================================== */
543/*
544 * RIPEMD-160.
545 */
546
547/*
548 * Round constants for RIPEMD-160.
549 */
550#define K11 SPH_C32(0x00000000)
551#define K12 SPH_C32(0x5A827999)
552#define K13 SPH_C32(0x6ED9EBA1)
553#define K14 SPH_C32(0x8F1BBCDC)
554#define K15 SPH_C32(0xA953FD4E)
555
556#define K21 SPH_C32(0x50A28BE6)
557#define K22 SPH_C32(0x5C4DD124)
558#define K23 SPH_C32(0x6D703EF3)
559#define K24 SPH_C32(0x7A6D76E9)
560#define K25 SPH_C32(0x00000000)
561
562#define RR(a, b, c, d, e, f, s, r, k) do { \
563 a = SPH_T32(ROTL(SPH_T32(a + f(b, c, d) + r + k), s) + e); \
564 c = ROTL(c, 10); \
565 } while (0)
566
567#define ROUND1(a, b, c, d, e, f, s, r, k) \
568 RR(a ## 1, b ## 1, c ## 1, d ## 1, e ## 1, f, s, r, K1 ## k)
569
570#define ROUND2(a, b, c, d, e, f, s, r, k) \
571 RR(a ## 2, b ## 2, c ## 2, d ## 2, e ## 2, f, s, r, K2 ## k)
572
573/*
574 * This macro defines the body for a RIPEMD-160 compression function
575 * implementation. The "in" parameter should evaluate, when applied to a
576 * numerical input parameter from 0 to 15, to an expression which yields
577 * the corresponding input block. The "h" parameter should evaluate to
578 * an array or pointer expression designating the array of 5 words which
579 * contains the input and output of the compression function.
580 */
581
582#define RIPEMD160_ROUND_BODY(in, h) do { \
583 sph_u32 A1, B1, C1, D1, E1; \
584 sph_u32 A2, B2, C2, D2, E2; \
585 sph_u32 tmp; \
586 \
587 A1 = A2 = (h)[0]; \
588 B1 = B2 = (h)[1]; \
589 C1 = C2 = (h)[2]; \
590 D1 = D2 = (h)[3]; \
591 E1 = E2 = (h)[4]; \
592 \
593 ROUND1(A, B, C, D, E, F1, 11, in( 0), 1); \
594 ROUND1(E, A, B, C, D, F1, 14, in( 1), 1); \
595 ROUND1(D, E, A, B, C, F1, 15, in( 2), 1); \
596 ROUND1(C, D, E, A, B, F1, 12, in( 3), 1); \
597 ROUND1(B, C, D, E, A, F1, 5, in( 4), 1); \
598 ROUND1(A, B, C, D, E, F1, 8, in( 5), 1); \
599 ROUND1(E, A, B, C, D, F1, 7, in( 6), 1); \
600 ROUND1(D, E, A, B, C, F1, 9, in( 7), 1); \
601 ROUND1(C, D, E, A, B, F1, 11, in( 8), 1); \
602 ROUND1(B, C, D, E, A, F1, 13, in( 9), 1); \
603 ROUND1(A, B, C, D, E, F1, 14, in(10), 1); \
604 ROUND1(E, A, B, C, D, F1, 15, in(11), 1); \
605 ROUND1(D, E, A, B, C, F1, 6, in(12), 1); \
606 ROUND1(C, D, E, A, B, F1, 7, in(13), 1); \
607 ROUND1(B, C, D, E, A, F1, 9, in(14), 1); \
608 ROUND1(A, B, C, D, E, F1, 8, in(15), 1); \
609 \
610 ROUND1(E, A, B, C, D, F2, 7, in( 7), 2); \
611 ROUND1(D, E, A, B, C, F2, 6, in( 4), 2); \
612 ROUND1(C, D, E, A, B, F2, 8, in(13), 2); \
613 ROUND1(B, C, D, E, A, F2, 13, in( 1), 2); \
614 ROUND1(A, B, C, D, E, F2, 11, in(10), 2); \
615 ROUND1(E, A, B, C, D, F2, 9, in( 6), 2); \
616 ROUND1(D, E, A, B, C, F2, 7, in(15), 2); \
617 ROUND1(C, D, E, A, B, F2, 15, in( 3), 2); \
618 ROUND1(B, C, D, E, A, F2, 7, in(12), 2); \
619 ROUND1(A, B, C, D, E, F2, 12, in( 0), 2); \
620 ROUND1(E, A, B, C, D, F2, 15, in( 9), 2); \
621 ROUND1(D, E, A, B, C, F2, 9, in( 5), 2); \
622 ROUND1(C, D, E, A, B, F2, 11, in( 2), 2); \
623 ROUND1(B, C, D, E, A, F2, 7, in(14), 2); \
624 ROUND1(A, B, C, D, E, F2, 13, in(11), 2); \
625 ROUND1(E, A, B, C, D, F2, 12, in( 8), 2); \
626 \
627 ROUND1(D, E, A, B, C, F3, 11, in( 3), 3); \
628 ROUND1(C, D, E, A, B, F3, 13, in(10), 3); \
629 ROUND1(B, C, D, E, A, F3, 6, in(14), 3); \
630 ROUND1(A, B, C, D, E, F3, 7, in( 4), 3); \
631 ROUND1(E, A, B, C, D, F3, 14, in( 9), 3); \
632 ROUND1(D, E, A, B, C, F3, 9, in(15), 3); \
633 ROUND1(C, D, E, A, B, F3, 13, in( 8), 3); \
634 ROUND1(B, C, D, E, A, F3, 15, in( 1), 3); \
635 ROUND1(A, B, C, D, E, F3, 14, in( 2), 3); \
636 ROUND1(E, A, B, C, D, F3, 8, in( 7), 3); \
637 ROUND1(D, E, A, B, C, F3, 13, in( 0), 3); \
638 ROUND1(C, D, E, A, B, F3, 6, in( 6), 3); \
639 ROUND1(B, C, D, E, A, F3, 5, in(13), 3); \
640 ROUND1(A, B, C, D, E, F3, 12, in(11), 3); \
641 ROUND1(E, A, B, C, D, F3, 7, in( 5), 3); \
642 ROUND1(D, E, A, B, C, F3, 5, in(12), 3); \
643 \
644 ROUND1(C, D, E, A, B, F4, 11, in( 1), 4); \
645 ROUND1(B, C, D, E, A, F4, 12, in( 9), 4); \
646 ROUND1(A, B, C, D, E, F4, 14, in(11), 4); \
647 ROUND1(E, A, B, C, D, F4, 15, in(10), 4); \
648 ROUND1(D, E, A, B, C, F4, 14, in( 0), 4); \
649 ROUND1(C, D, E, A, B, F4, 15, in( 8), 4); \
650 ROUND1(B, C, D, E, A, F4, 9, in(12), 4); \
651 ROUND1(A, B, C, D, E, F4, 8, in( 4), 4); \
652 ROUND1(E, A, B, C, D, F4, 9, in(13), 4); \
653 ROUND1(D, E, A, B, C, F4, 14, in( 3), 4); \
654 ROUND1(C, D, E, A, B, F4, 5, in( 7), 4); \
655 ROUND1(B, C, D, E, A, F4, 6, in(15), 4); \
656 ROUND1(A, B, C, D, E, F4, 8, in(14), 4); \
657 ROUND1(E, A, B, C, D, F4, 6, in( 5), 4); \
658 ROUND1(D, E, A, B, C, F4, 5, in( 6), 4); \
659 ROUND1(C, D, E, A, B, F4, 12, in( 2), 4); \
660 \
661 ROUND1(B, C, D, E, A, F5, 9, in( 4), 5); \
662 ROUND1(A, B, C, D, E, F5, 15, in( 0), 5); \
663 ROUND1(E, A, B, C, D, F5, 5, in( 5), 5); \
664 ROUND1(D, E, A, B, C, F5, 11, in( 9), 5); \
665 ROUND1(C, D, E, A, B, F5, 6, in( 7), 5); \
666 ROUND1(B, C, D, E, A, F5, 8, in(12), 5); \
667 ROUND1(A, B, C, D, E, F5, 13, in( 2), 5); \
668 ROUND1(E, A, B, C, D, F5, 12, in(10), 5); \
669 ROUND1(D, E, A, B, C, F5, 5, in(14), 5); \
670 ROUND1(C, D, E, A, B, F5, 12, in( 1), 5); \
671 ROUND1(B, C, D, E, A, F5, 13, in( 3), 5); \
672 ROUND1(A, B, C, D, E, F5, 14, in( 8), 5); \
673 ROUND1(E, A, B, C, D, F5, 11, in(11), 5); \
674 ROUND1(D, E, A, B, C, F5, 8, in( 6), 5); \
675 ROUND1(C, D, E, A, B, F5, 5, in(15), 5); \
676 ROUND1(B, C, D, E, A, F5, 6, in(13), 5); \
677 \
678 ROUND2(A, B, C, D, E, F5, 8, in( 5), 1); \
679 ROUND2(E, A, B, C, D, F5, 9, in(14), 1); \
680 ROUND2(D, E, A, B, C, F5, 9, in( 7), 1); \
681 ROUND2(C, D, E, A, B, F5, 11, in( 0), 1); \
682 ROUND2(B, C, D, E, A, F5, 13, in( 9), 1); \
683 ROUND2(A, B, C, D, E, F5, 15, in( 2), 1); \
684 ROUND2(E, A, B, C, D, F5, 15, in(11), 1); \
685 ROUND2(D, E, A, B, C, F5, 5, in( 4), 1); \
686 ROUND2(C, D, E, A, B, F5, 7, in(13), 1); \
687 ROUND2(B, C, D, E, A, F5, 7, in( 6), 1); \
688 ROUND2(A, B, C, D, E, F5, 8, in(15), 1); \
689 ROUND2(E, A, B, C, D, F5, 11, in( 8), 1); \
690 ROUND2(D, E, A, B, C, F5, 14, in( 1), 1); \
691 ROUND2(C, D, E, A, B, F5, 14, in(10), 1); \
692 ROUND2(B, C, D, E, A, F5, 12, in( 3), 1); \
693 ROUND2(A, B, C, D, E, F5, 6, in(12), 1); \
694 \
695 ROUND2(E, A, B, C, D, F4, 9, in( 6), 2); \
696 ROUND2(D, E, A, B, C, F4, 13, in(11), 2); \
697 ROUND2(C, D, E, A, B, F4, 15, in( 3), 2); \
698 ROUND2(B, C, D, E, A, F4, 7, in( 7), 2); \
699 ROUND2(A, B, C, D, E, F4, 12, in( 0), 2); \
700 ROUND2(E, A, B, C, D, F4, 8, in(13), 2); \
701 ROUND2(D, E, A, B, C, F4, 9, in( 5), 2); \
702 ROUND2(C, D, E, A, B, F4, 11, in(10), 2); \
703 ROUND2(B, C, D, E, A, F4, 7, in(14), 2); \
704 ROUND2(A, B, C, D, E, F4, 7, in(15), 2); \
705 ROUND2(E, A, B, C, D, F4, 12, in( 8), 2); \
706 ROUND2(D, E, A, B, C, F4, 7, in(12), 2); \
707 ROUND2(C, D, E, A, B, F4, 6, in( 4), 2); \
708 ROUND2(B, C, D, E, A, F4, 15, in( 9), 2); \
709 ROUND2(A, B, C, D, E, F4, 13, in( 1), 2); \
710 ROUND2(E, A, B, C, D, F4, 11, in( 2), 2); \
711 \
712 ROUND2(D, E, A, B, C, F3, 9, in(15), 3); \
713 ROUND2(C, D, E, A, B, F3, 7, in( 5), 3); \
714 ROUND2(B, C, D, E, A, F3, 15, in( 1), 3); \
715 ROUND2(A, B, C, D, E, F3, 11, in( 3), 3); \
716 ROUND2(E, A, B, C, D, F3, 8, in( 7), 3); \
717 ROUND2(D, E, A, B, C, F3, 6, in(14), 3); \
718 ROUND2(C, D, E, A, B, F3, 6, in( 6), 3); \
719 ROUND2(B, C, D, E, A, F3, 14, in( 9), 3); \
720 ROUND2(A, B, C, D, E, F3, 12, in(11), 3); \
721 ROUND2(E, A, B, C, D, F3, 13, in( 8), 3); \
722 ROUND2(D, E, A, B, C, F3, 5, in(12), 3); \
723 ROUND2(C, D, E, A, B, F3, 14, in( 2), 3); \
724 ROUND2(B, C, D, E, A, F3, 13, in(10), 3); \
725 ROUND2(A, B, C, D, E, F3, 13, in( 0), 3); \
726 ROUND2(E, A, B, C, D, F3, 7, in( 4), 3); \
727 ROUND2(D, E, A, B, C, F3, 5, in(13), 3); \
728 \
729 ROUND2(C, D, E, A, B, F2, 15, in( 8), 4); \
730 ROUND2(B, C, D, E, A, F2, 5, in( 6), 4); \
731 ROUND2(A, B, C, D, E, F2, 8, in( 4), 4); \
732 ROUND2(E, A, B, C, D, F2, 11, in( 1), 4); \
733 ROUND2(D, E, A, B, C, F2, 14, in( 3), 4); \
734 ROUND2(C, D, E, A, B, F2, 14, in(11), 4); \
735 ROUND2(B, C, D, E, A, F2, 6, in(15), 4); \
736 ROUND2(A, B, C, D, E, F2, 14, in( 0), 4); \
737 ROUND2(E, A, B, C, D, F2, 6, in( 5), 4); \
738 ROUND2(D, E, A, B, C, F2, 9, in(12), 4); \
739 ROUND2(C, D, E, A, B, F2, 12, in( 2), 4); \
740 ROUND2(B, C, D, E, A, F2, 9, in(13), 4); \
741 ROUND2(A, B, C, D, E, F2, 12, in( 9), 4); \
742 ROUND2(E, A, B, C, D, F2, 5, in( 7), 4); \
743 ROUND2(D, E, A, B, C, F2, 15, in(10), 4); \
744 ROUND2(C, D, E, A, B, F2, 8, in(14), 4); \
745 \
746 ROUND2(B, C, D, E, A, F1, 8, in(12), 5); \
747 ROUND2(A, B, C, D, E, F1, 5, in(15), 5); \
748 ROUND2(E, A, B, C, D, F1, 12, in(10), 5); \
749 ROUND2(D, E, A, B, C, F1, 9, in( 4), 5); \
750 ROUND2(C, D, E, A, B, F1, 12, in( 1), 5); \
751 ROUND2(B, C, D, E, A, F1, 5, in( 5), 5); \
752 ROUND2(A, B, C, D, E, F1, 14, in( 8), 5); \
753 ROUND2(E, A, B, C, D, F1, 6, in( 7), 5); \
754 ROUND2(D, E, A, B, C, F1, 8, in( 6), 5); \
755 ROUND2(C, D, E, A, B, F1, 13, in( 2), 5); \
756 ROUND2(B, C, D, E, A, F1, 6, in(13), 5); \
757 ROUND2(A, B, C, D, E, F1, 5, in(14), 5); \
758 ROUND2(E, A, B, C, D, F1, 15, in( 0), 5); \
759 ROUND2(D, E, A, B, C, F1, 13, in( 3), 5); \
760 ROUND2(C, D, E, A, B, F1, 11, in( 9), 5); \
761 ROUND2(B, C, D, E, A, F1, 11, in(11), 5); \
762 \
763 tmp = SPH_T32((h)[1] + C1 + D2); \
764 (h)[1] = SPH_T32((h)[2] + D1 + E2); \
765 (h)[2] = SPH_T32((h)[3] + E1 + A2); \
766 (h)[3] = SPH_T32((h)[4] + A1 + B2); \
767 (h)[4] = SPH_T32((h)[0] + B1 + C2); \
768 (h)[0] = tmp; \
769 } while (0)
770
771/*
772 * One round of RIPEMD-160. The data must be aligned for 32-bit access.
773 */
774static void
775ripemd160_round(const unsigned char *data, sph_u32 r[5])
776{
777#if SPH_LITTLE_FAST
778
779#define RIPEMD160_IN(x) sph_dec32le_aligned(data + (4 * (x)))
780
781#else
782
783 sph_u32 X_var[16];
784 int i;
785
786 for (i = 0; i < 16; i ++)
787 X_var[i] = sph_dec32le_aligned(data + 4 * i);
788#define RIPEMD160_IN(x) X_var[x]
789
790#endif
791 RIPEMD160_ROUND_BODY(RIPEMD160_IN, r);
792#undef RIPEMD160_IN
793}
794
795/* see sph_ripemd.h */
796void
797sph_ripemd160_init(void *cc)
798{
799 sph_ripemd160_context *sc;
800
801 sc = (sph_ripemd160_context*)cc;
802 memcpy(sc->val, IV, sizeof sc->val);
803#if SPH_64
804 sc->count = 0;
805#else
806 sc->count_high = sc->count_low = 0;
807#endif
808}
809
810#define RFUN ripemd160_round
811#define HASH ripemd160
812#define LE32 1
813#include "md_helper.c"
814#undef RFUN
815#undef HASH
816#undef LE32
817
818/* see sph_ripemd.h */
819void
820sph_ripemd160_close(void *cc, void *dst)
821{
822 ripemd160_close(cc, dst, 5);
823 sph_ripemd160_init(cc);
824}
825
826/* see sph_ripemd.h */
827void
828sph_ripemd160_comp(const sph_u32 msg[16], sph_u32 val[5])
829{
830#define RIPEMD160_IN(x) msg[x]
831 RIPEMD160_ROUND_BODY(RIPEMD160_IN, val);
832#undef RIPEMD160_IN
833}
834
Empty description
This page took 0.102168 seconds and 4 git commands to generate.