5 * Whirlpool hash function
7 * (c) 2005 Straylight/Edgeware
10 /*----- Licensing notice --------------------------------------------------*
12 * This file is part of Catacomb.
14 * Catacomb is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU Library General Public License as
16 * published by the Free Software Foundation; either version 2 of the
17 * License, or (at your option) any later version.
19 * Catacomb is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU Library General Public License for more details.
24 * You should have received a copy of the GNU Library General Public
25 * License along with Catacomb; if not, write to the Free
26 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
30 /*----- Header files ------------------------------------------------------*/
32 #include <mLib/bits.h>
35 #include "ghash-def.h"
37 #include "whirlpool.h"
38 #include "whirlpool-tab.h"
40 #if defined(HAVE_UINT64)
44 /*----- Static variables --------------------------------------------------*/
46 static const kludge64 C
[10] = WHIRLPOOL_C
;
49 static const kludge64 T
[8][256] = WHIRLPOOL_T
;
51 static const uint32 U
[4][256] = WHIRLPOOL_U
, V
[4][256] = WHIRLPOOL_V
;
54 /*----- Main code ---------------------------------------------------------*/
56 #define DUMP(k, v) do { \
59 for (i = 0; i < 8; i++) \
60 printf(" %08x %08x : %08x %08x\n", \
61 HI64(k[i]), LO64(k[i]), \
62 HI64(v[i]), LO64(v[i])); \
65 #define OFFSET(i, n) (((i) + 16 - (n)) % 8)
71 (LO64(x) >> ((j) * 8)) : \
72 (HI64(x) >> ((j) * 8 - 32)))
74 #define TT(v, i, j) T[j][BYTE(v[OFFSET(i, j)], j)]
76 #define XROW(vv, v, i) do { \
77 XOR64(vv[i], vv[i], TT(v, i, 1)); \
78 XOR64(vv[i], vv[i], TT(v, i, 2)); \
79 XOR64(vv[i], vv[i], TT(v, i, 3)); \
80 XOR64(vv[i], vv[i], TT(v, i, 4)); \
81 XOR64(vv[i], vv[i], TT(v, i, 5)); \
82 XOR64(vv[i], vv[i], TT(v, i, 6)); \
83 XOR64(vv[i], vv[i], TT(v, i, 7)); \
86 #define ROWZ(vv, v, i) do { \
87 vv[i] = TT(v, i, 0); \
91 #define ROWK(vv, v, i, k) do { \
93 XOR64(vv[i], vv[i], TT(v, i, 0)); \
99 #define BYTE(x, j) U8((x) >> (((j) & 3) * 8))
101 #define UUL(v, i, j) U[j & 3][BYTE(v[OFFSET(i, j)].lo, j)]
102 #define VVL(v, i, j) V[j & 3][BYTE(v[OFFSET(i, j)].lo, j)]
103 #define UUH(v, i, j) U[j & 3][BYTE(v[OFFSET(i, j)].hi, j)]
104 #define VVH(v, i, j) V[j & 3][BYTE(v[OFFSET(i, j)].hi, j)]
106 #define XROW(vv, v, i) do { \
107 vv[i].lo ^= UUL(v, i, 1); vv[i].hi ^= VVL(v, i, 1); \
108 vv[i].lo ^= UUL(v, i, 2); vv[i].hi ^= VVL(v, i, 2); \
109 vv[i].lo ^= UUL(v, i, 3); vv[i].hi ^= VVL(v, i, 3); \
110 vv[i].lo ^= VVH(v, i, 4); vv[i].hi ^= UUH(v, i, 4); \
111 vv[i].lo ^= VVH(v, i, 5); vv[i].hi ^= UUH(v, i, 5); \
112 vv[i].lo ^= VVH(v, i, 6); vv[i].hi ^= UUH(v, i, 6); \
113 vv[i].lo ^= VVH(v, i, 7); vv[i].hi ^= UUH(v, i, 7); \
116 #define ROWZ(vv, v, i) do { \
117 vv[i].lo = UUL(v, i, 0); vv[i].hi = VVL(v, i, 0); \
121 #define ROWK(vv, v, i, k) do { \
123 vv[i].lo ^= UUL(v, i, 0); vv[i].hi ^= VVL(v, i, 0); \
129 #define RHO(vv, v, kk, k) do { \
130 ROWK(kk, k, 0, *c++); ROWK(vv, v, 0, kk[0]); \
131 ROWZ(kk, k, 1); ROWK(vv, v, 1, kk[1]); \
132 ROWZ(kk, k, 2); ROWK(vv, v, 2, kk[2]); \
133 ROWZ(kk, k, 3); ROWK(vv, v, 3, kk[3]); \
134 ROWZ(kk, k, 4); ROWK(vv, v, 4, kk[4]); \
135 ROWZ(kk, k, 5); ROWK(vv, v, 5, kk[5]); \
136 ROWZ(kk, k, 6); ROWK(vv, v, 6, kk[6]); \
137 ROWZ(kk, k, 7); ROWK(vv, v, 7, kk[7]); \
140 void whirlpool_compress(whirlpool_ctx
*ctx
, const void *sbuf
)
142 kludge64 m
[8], k
[8], kk
[8], v
[8], vv
[8];
143 const kludge64
*c
= C
;
144 const octet
*s
= sbuf
;
147 for (i
= 0; i
< 8; i
++) {
148 LOAD64_L_(m
[i
], &s
[i
* 8]);
149 XOR64(v
[i
], m
[i
], ctx
->s
[i
]);
152 RHO(vv
, v
, kk
, ctx
->s
);
163 for (i
= 0; i
< 8; i
++) {
164 XOR64(ctx
->s
[i
], ctx
->s
[i
], m
[i
]);
165 XOR64(ctx
->s
[i
], ctx
->s
[i
], v
[i
]);
169 /* --- @whirlpool_init@, @whirlpool256_init@ --- *
171 * Arguments: @whirlpool_ctx *ctx@ = pointer to context block to initialize
175 * Use: Initializes a context block ready for hashing.
178 void whirlpool_init(whirlpool_ctx
*ctx
)
182 for (i
= 0; i
< 8; i
++)
183 SET64(ctx
->s
[i
], 0, 0);
185 ctx
->nh
= ctx
->nl
= 0;
188 /* --- @whirlpool_set@, @whirlpool256_set@ --- *
190 * Arguments: @whirlpool_ctx *ctx@ = pointer to context block
191 * @const void *buf@ = pointer to state buffer
192 * @unsigned long count@ = current count of bytes processed
196 * Use: Initializes a context block from a given state. This is
197 * useful in cases where the initial hash state is meant to be
198 * secret, e.g., for NMAC and HMAC support.
201 void whirlpool_set(whirlpool_ctx
*ctx
, const void *buf
, unsigned long count
)
203 const octet
*p
= buf
;
206 for (i
= 0; i
< 8; i
++) {
207 LOAD64_L_(ctx
->s
[i
], p
);
211 ctx
->nl
= U32(count
);
212 ctx
->nh
= U32(((count
& ~MASK32
) >> 16) >> 16);
215 /* --- @whirlpool_hash@, @whirlpool256_hash@ --- *
217 * Arguments: @whirlpool_ctx *ctx@ = pointer to context block
218 * @const void *buf@ = buffer of data to hash
219 * @size_t sz@ = size of buffer to hash
223 * Use: Hashes a buffer of data. The buffer may be of any size and
227 void whirlpool_hash(whirlpool_ctx
*ctx
, const void *buf
, size_t sz
)
229 HASH_BUFFER(WHIRLPOOL
, whirlpool
, ctx
, buf
, sz
);
232 /* --- @whirlpool_done@, @whirlpool256_done@ --- *
234 * Arguments: @whirlpool_ctx *ctx@ = pointer to context block
235 * @void *hash@ = pointer to output buffer
239 * Use: Returns the hash of the data read so far.
242 static void final(whirlpool_ctx
*ctx
)
244 HASH_PAD(WHIRLPOOL
, whirlpool
, ctx
, 0x80, 0, 32);
245 memset(ctx
->buf
+ WHIRLPOOL_BUFSZ
- 32, 0, 24);
246 STORE32(ctx
->buf
+ WHIRLPOOL_BUFSZ
- 8, (ctx
->nl
>> 29) | (ctx
->nh
<< 3));
247 STORE32(ctx
->buf
+ WHIRLPOOL_BUFSZ
- 4, ctx
->nl
<< 3);
248 whirlpool_compress(ctx
, ctx
->buf
);
251 void whirlpool_done(whirlpool_ctx
*ctx
, void *hash
)
257 for (i
= 0; i
< 8; i
++) {
258 STORE64_L_(p
, ctx
->s
[i
]);
263 void whirlpool256_done(whirlpool256_ctx
*ctx
, void *hash
)
269 for (i
= 0; i
< 4; i
++) {
270 STORE64_L_(p
, ctx
->s
[i
]);
275 /* --- @whirlpool_state@, @whirlpool256_state@ --- *
277 * Arguments: @whirlpool_ctx *ctx@ = pointer to context
278 * @void *state@ = pointer to buffer for current state
280 * Returns: Number of bytes written to the hash function so far.
282 * Use: Returns the current state of the hash function such that
283 * it can be passed to @whirlpool_set@.
286 unsigned long whirlpool_state(whirlpool_ctx
*ctx
, void *state
)
291 for (i
= 0; i
< 8; i
++) {
292 STORE64_L_(p
, ctx
->s
[i
]);
295 return (ctx
->nl
| ((ctx
->nh
<< 16) << 16));
298 /* --- Generic interface --- */
300 GHASH_DEF(WHIRLPOOL
, whirlpool
)
302 /* --- Test code --- */
304 HASH_TEST(WHIRLPOOL
, whirlpool
)
306 /*----- That's all, folks -------------------------------------------------*/