1 /* This file was automatically imported with
2 import_gcry.py. Please don't modify it */
3 /* rmd160.c - RIPE-MD160
4 * Copyright (C) 1998, 2001, 2002, 2003 Free Software Foundation, Inc.
6 * This file is part of Libgcrypt.
8 * Libgcrypt is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as
10 * published by the Free Software Foundation; either version 2.1 of
11 * the License, or (at your option) any later version.
13 * Libgcrypt is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
27 #include "cipher.h" /* Only used for the rmd160_hash_buffer() prototype. */
31 /*********************************
32 * RIPEMD-160 is not patented, see (as of 25.10.97)
33 * http://www.esat.kuleuven.ac.be/~bosselae/ripemd160.html
34 * Note that the code uses Little Endian byteorder, which is good for
35 * 386 etc, but we must add some conversion when used on a big endian box.
38 * Pseudo-code for RIPEMD-160
40 * RIPEMD-160 is an iterative hash function that operates on 32-bit words.
41 * The round function takes as input a 5-word chaining variable and a 16-word
42 * message block and maps this to a new chaining variable. All operations are
43 * defined on 32-bit words. Padding is identical to that of MD4.
46 * RIPEMD-160: definitions
49 * nonlinear functions at bit level: exor, mux, -, mux, -
51 * f(j, x, y, z) = x XOR y XOR z (0 <= j <= 15)
52 * f(j, x, y, z) = (x AND y) OR (NOT(x) AND z) (16 <= j <= 31)
53 * f(j, x, y, z) = (x OR NOT(y)) XOR z (32 <= j <= 47)
54 * f(j, x, y, z) = (x AND z) OR (y AND NOT(z)) (48 <= j <= 63)
55 * f(j, x, y, z) = x XOR (y OR NOT(z)) (64 <= j <= 79)
58 * added constants (hexadecimal)
60 * K(j) = 0x00000000 (0 <= j <= 15)
61 * K(j) = 0x5A827999 (16 <= j <= 31) int(2**30 x sqrt(2))
62 * K(j) = 0x6ED9EBA1 (32 <= j <= 47) int(2**30 x sqrt(3))
63 * K(j) = 0x8F1BBCDC (48 <= j <= 63) int(2**30 x sqrt(5))
64 * K(j) = 0xA953FD4E (64 <= j <= 79) int(2**30 x sqrt(7))
65 * K'(j) = 0x50A28BE6 (0 <= j <= 15) int(2**30 x cbrt(2))
66 * K'(j) = 0x5C4DD124 (16 <= j <= 31) int(2**30 x cbrt(3))
67 * K'(j) = 0x6D703EF3 (32 <= j <= 47) int(2**30 x cbrt(5))
68 * K'(j) = 0x7A6D76E9 (48 <= j <= 63) int(2**30 x cbrt(7))
69 * K'(j) = 0x00000000 (64 <= j <= 79)
72 * selection of message word
74 * r(j) = j (0 <= j <= 15)
75 * r(16..31) = 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8
76 * r(32..47) = 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12
77 * r(48..63) = 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2
78 * r(64..79) = 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
79 * r0(0..15) = 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12
80 * r0(16..31)= 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2
81 * r0(32..47)= 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13
82 * r0(48..63)= 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14
83 * r0(64..79)= 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
86 * amount for rotate left (rol)
88 * s(0..15) = 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8
89 * s(16..31) = 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12
90 * s(32..47) = 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5
91 * s(48..63) = 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12
92 * s(64..79) = 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
93 * s'(0..15) = 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6
94 * s'(16..31)= 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11
95 * s'(32..47)= 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5
96 * s'(48..63)= 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8
97 * s'(64..79)= 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
100 * initial value (hexadecimal)
102 * h0 = 0x67452301; h1 = 0xEFCDAB89; h2 = 0x98BADCFE; h3 = 0x10325476;
106 * RIPEMD-160: pseudo-code
108 * It is assumed that the message after padding consists of t 16-word blocks
109 * that will be denoted with X[i][j], with 0 <= i <= t-1 and 0 <= j <= 15.
110 * The symbol [+] denotes addition modulo 2**32 and rol_s denotes cyclic left
111 * shift (rotate) over s positions.
114 * for i := 0 to t-1 {
115 * A := h0; B := h1; C := h2; D = h3; E = h4;
116 * A' := h0; B' := h1; C' := h2; D' = h3; E' = h4;
118 * T := rol_s(j)(A [+] f(j, B, C, D) [+] X[i][r(j)] [+] K(j)) [+] E;
119 * A := E; E := D; D := rol_10(C); C := B; B := T;
120 * T := rol_s'(j)(A' [+] f(79-j, B', C', D') [+] X[i][r'(j)]
122 * A' := E'; E' := D'; D' := rol_10(C'); C' := B'; B' := T;
124 * T := h1 [+] C [+] D'; h1 := h2 [+] D [+] E'; h2 := h3 [+] E [+] A';
125 * h3 := h4 [+] A [+] B'; h4 := h0 [+] B [+] C'; h0 := T;
130 * "" 9c1185a5c5e9fc54612808977ee8f548b2258d31
131 * "a" 0bdc9d2d256b3ee9daae347be6f4dc835a467ffe
132 * "abc" 8eb208f7e05d987a9b044a8e98c6b087f15a0bfc
133 * "message digest" 5d0689ef49d2fae572b881b123a85ffa21595f36
134 * "a...z" f71c27109c692c1b56bbdceb5b9d2865b3708dbc
135 * "abcdbcde...nopq" 12a053384a9c0c88e405a06c27dcf49ada62eb2b
136 * "A...Za...z0...9" b0e20b6e3116640286ed3a87a5713079b21f5189
137 * 8 times "1234567890" 9b752e45573d4b39f4dbd3323cab82bf63326bfb
138 * 1 million times "a" 52783243c1697bdbe16d37f97f68f08325dc1528
143 _gcry_rmd160_init (void *context
)
145 RMD160_CONTEXT
*hd
= context
;
159 * Transform the message X which consists of 16 32-bit-words
162 transform ( RMD160_CONTEXT
*hd
, const unsigned char *data
)
164 register u32 a
,b
,c
,d
,e
;
165 u32 aa
,bb
,cc
,dd
,ee
,t
;
166 #ifdef WORDS_BIGENDIAN
171 for (i
=0, p1
=data
, p2
=(byte
*)x
; i
< 16; i
++, p2
+= 4 )
180 /* This version is better because it is always aligned;
181 * The performance penalty on a 586-100 is about 6% which
182 * is acceptable - because the data is more local it might
183 * also be possible that this is faster on some machines.
184 * This function (when compiled with -02 on gcc 2.7.2)
185 * executes on a 586-100 (39.73 bogomips) at about 1900kb/sec;
186 * [measured with a 4MB data and "gpgm --print-md rmd160"] */
188 memcpy( x
, data
, 64 );
192 #define K0 0x00000000
193 #define K1 0x5A827999
194 #define K2 0x6ED9EBA1
195 #define K3 0x8F1BBCDC
196 #define K4 0xA953FD4E
197 #define KK0 0x50A28BE6
198 #define KK1 0x5C4DD124
199 #define KK2 0x6D703EF3
200 #define KK3 0x7A6D76E9
201 #define KK4 0x00000000
202 #define F0(x,y,z) ( (x) ^ (y) ^ (z) )
203 #define F1(x,y,z) ( ((x) & (y)) | (~(x) & (z)) )
204 #define F2(x,y,z) ( ((x) | ~(y)) ^ (z) )
205 #define F3(x,y,z) ( ((x) & (z)) | ((y) & ~(z)) )
206 #define F4(x,y,z) ( (x) ^ ((y) | ~(z)) )
207 #define R(a,b,c,d,e,f,k,r,s) do { t = a + f(b,c,d) + k + x[r]; \
218 R( a
, b
, c
, d
, e
, F0
, K0
, 0, 11 );
219 R( e
, a
, b
, c
, d
, F0
, K0
, 1, 14 );
220 R( d
, e
, a
, b
, c
, F0
, K0
, 2, 15 );
221 R( c
, d
, e
, a
, b
, F0
, K0
, 3, 12 );
222 R( b
, c
, d
, e
, a
, F0
, K0
, 4, 5 );
223 R( a
, b
, c
, d
, e
, F0
, K0
, 5, 8 );
224 R( e
, a
, b
, c
, d
, F0
, K0
, 6, 7 );
225 R( d
, e
, a
, b
, c
, F0
, K0
, 7, 9 );
226 R( c
, d
, e
, a
, b
, F0
, K0
, 8, 11 );
227 R( b
, c
, d
, e
, a
, F0
, K0
, 9, 13 );
228 R( a
, b
, c
, d
, e
, F0
, K0
, 10, 14 );
229 R( e
, a
, b
, c
, d
, F0
, K0
, 11, 15 );
230 R( d
, e
, a
, b
, c
, F0
, K0
, 12, 6 );
231 R( c
, d
, e
, a
, b
, F0
, K0
, 13, 7 );
232 R( b
, c
, d
, e
, a
, F0
, K0
, 14, 9 );
233 R( a
, b
, c
, d
, e
, F0
, K0
, 15, 8 );
234 R( e
, a
, b
, c
, d
, F1
, K1
, 7, 7 );
235 R( d
, e
, a
, b
, c
, F1
, K1
, 4, 6 );
236 R( c
, d
, e
, a
, b
, F1
, K1
, 13, 8 );
237 R( b
, c
, d
, e
, a
, F1
, K1
, 1, 13 );
238 R( a
, b
, c
, d
, e
, F1
, K1
, 10, 11 );
239 R( e
, a
, b
, c
, d
, F1
, K1
, 6, 9 );
240 R( d
, e
, a
, b
, c
, F1
, K1
, 15, 7 );
241 R( c
, d
, e
, a
, b
, F1
, K1
, 3, 15 );
242 R( b
, c
, d
, e
, a
, F1
, K1
, 12, 7 );
243 R( a
, b
, c
, d
, e
, F1
, K1
, 0, 12 );
244 R( e
, a
, b
, c
, d
, F1
, K1
, 9, 15 );
245 R( d
, e
, a
, b
, c
, F1
, K1
, 5, 9 );
246 R( c
, d
, e
, a
, b
, F1
, K1
, 2, 11 );
247 R( b
, c
, d
, e
, a
, F1
, K1
, 14, 7 );
248 R( a
, b
, c
, d
, e
, F1
, K1
, 11, 13 );
249 R( e
, a
, b
, c
, d
, F1
, K1
, 8, 12 );
250 R( d
, e
, a
, b
, c
, F2
, K2
, 3, 11 );
251 R( c
, d
, e
, a
, b
, F2
, K2
, 10, 13 );
252 R( b
, c
, d
, e
, a
, F2
, K2
, 14, 6 );
253 R( a
, b
, c
, d
, e
, F2
, K2
, 4, 7 );
254 R( e
, a
, b
, c
, d
, F2
, K2
, 9, 14 );
255 R( d
, e
, a
, b
, c
, F2
, K2
, 15, 9 );
256 R( c
, d
, e
, a
, b
, F2
, K2
, 8, 13 );
257 R( b
, c
, d
, e
, a
, F2
, K2
, 1, 15 );
258 R( a
, b
, c
, d
, e
, F2
, K2
, 2, 14 );
259 R( e
, a
, b
, c
, d
, F2
, K2
, 7, 8 );
260 R( d
, e
, a
, b
, c
, F2
, K2
, 0, 13 );
261 R( c
, d
, e
, a
, b
, F2
, K2
, 6, 6 );
262 R( b
, c
, d
, e
, a
, F2
, K2
, 13, 5 );
263 R( a
, b
, c
, d
, e
, F2
, K2
, 11, 12 );
264 R( e
, a
, b
, c
, d
, F2
, K2
, 5, 7 );
265 R( d
, e
, a
, b
, c
, F2
, K2
, 12, 5 );
266 R( c
, d
, e
, a
, b
, F3
, K3
, 1, 11 );
267 R( b
, c
, d
, e
, a
, F3
, K3
, 9, 12 );
268 R( a
, b
, c
, d
, e
, F3
, K3
, 11, 14 );
269 R( e
, a
, b
, c
, d
, F3
, K3
, 10, 15 );
270 R( d
, e
, a
, b
, c
, F3
, K3
, 0, 14 );
271 R( c
, d
, e
, a
, b
, F3
, K3
, 8, 15 );
272 R( b
, c
, d
, e
, a
, F3
, K3
, 12, 9 );
273 R( a
, b
, c
, d
, e
, F3
, K3
, 4, 8 );
274 R( e
, a
, b
, c
, d
, F3
, K3
, 13, 9 );
275 R( d
, e
, a
, b
, c
, F3
, K3
, 3, 14 );
276 R( c
, d
, e
, a
, b
, F3
, K3
, 7, 5 );
277 R( b
, c
, d
, e
, a
, F3
, K3
, 15, 6 );
278 R( a
, b
, c
, d
, e
, F3
, K3
, 14, 8 );
279 R( e
, a
, b
, c
, d
, F3
, K3
, 5, 6 );
280 R( d
, e
, a
, b
, c
, F3
, K3
, 6, 5 );
281 R( c
, d
, e
, a
, b
, F3
, K3
, 2, 12 );
282 R( b
, c
, d
, e
, a
, F4
, K4
, 4, 9 );
283 R( a
, b
, c
, d
, e
, F4
, K4
, 0, 15 );
284 R( e
, a
, b
, c
, d
, F4
, K4
, 5, 5 );
285 R( d
, e
, a
, b
, c
, F4
, K4
, 9, 11 );
286 R( c
, d
, e
, a
, b
, F4
, K4
, 7, 6 );
287 R( b
, c
, d
, e
, a
, F4
, K4
, 12, 8 );
288 R( a
, b
, c
, d
, e
, F4
, K4
, 2, 13 );
289 R( e
, a
, b
, c
, d
, F4
, K4
, 10, 12 );
290 R( d
, e
, a
, b
, c
, F4
, K4
, 14, 5 );
291 R( c
, d
, e
, a
, b
, F4
, K4
, 1, 12 );
292 R( b
, c
, d
, e
, a
, F4
, K4
, 3, 13 );
293 R( a
, b
, c
, d
, e
, F4
, K4
, 8, 14 );
294 R( e
, a
, b
, c
, d
, F4
, K4
, 11, 11 );
295 R( d
, e
, a
, b
, c
, F4
, K4
, 6, 8 );
296 R( c
, d
, e
, a
, b
, F4
, K4
, 15, 5 );
297 R( b
, c
, d
, e
, a
, F4
, K4
, 13, 6 );
299 aa
= a
; bb
= b
; cc
= c
; dd
= d
; ee
= e
;
307 R( a
, b
, c
, d
, e
, F4
, KK0
, 5, 8);
308 R( e
, a
, b
, c
, d
, F4
, KK0
, 14, 9);
309 R( d
, e
, a
, b
, c
, F4
, KK0
, 7, 9);
310 R( c
, d
, e
, a
, b
, F4
, KK0
, 0, 11);
311 R( b
, c
, d
, e
, a
, F4
, KK0
, 9, 13);
312 R( a
, b
, c
, d
, e
, F4
, KK0
, 2, 15);
313 R( e
, a
, b
, c
, d
, F4
, KK0
, 11, 15);
314 R( d
, e
, a
, b
, c
, F4
, KK0
, 4, 5);
315 R( c
, d
, e
, a
, b
, F4
, KK0
, 13, 7);
316 R( b
, c
, d
, e
, a
, F4
, KK0
, 6, 7);
317 R( a
, b
, c
, d
, e
, F4
, KK0
, 15, 8);
318 R( e
, a
, b
, c
, d
, F4
, KK0
, 8, 11);
319 R( d
, e
, a
, b
, c
, F4
, KK0
, 1, 14);
320 R( c
, d
, e
, a
, b
, F4
, KK0
, 10, 14);
321 R( b
, c
, d
, e
, a
, F4
, KK0
, 3, 12);
322 R( a
, b
, c
, d
, e
, F4
, KK0
, 12, 6);
323 R( e
, a
, b
, c
, d
, F3
, KK1
, 6, 9);
324 R( d
, e
, a
, b
, c
, F3
, KK1
, 11, 13);
325 R( c
, d
, e
, a
, b
, F3
, KK1
, 3, 15);
326 R( b
, c
, d
, e
, a
, F3
, KK1
, 7, 7);
327 R( a
, b
, c
, d
, e
, F3
, KK1
, 0, 12);
328 R( e
, a
, b
, c
, d
, F3
, KK1
, 13, 8);
329 R( d
, e
, a
, b
, c
, F3
, KK1
, 5, 9);
330 R( c
, d
, e
, a
, b
, F3
, KK1
, 10, 11);
331 R( b
, c
, d
, e
, a
, F3
, KK1
, 14, 7);
332 R( a
, b
, c
, d
, e
, F3
, KK1
, 15, 7);
333 R( e
, a
, b
, c
, d
, F3
, KK1
, 8, 12);
334 R( d
, e
, a
, b
, c
, F3
, KK1
, 12, 7);
335 R( c
, d
, e
, a
, b
, F3
, KK1
, 4, 6);
336 R( b
, c
, d
, e
, a
, F3
, KK1
, 9, 15);
337 R( a
, b
, c
, d
, e
, F3
, KK1
, 1, 13);
338 R( e
, a
, b
, c
, d
, F3
, KK1
, 2, 11);
339 R( d
, e
, a
, b
, c
, F2
, KK2
, 15, 9);
340 R( c
, d
, e
, a
, b
, F2
, KK2
, 5, 7);
341 R( b
, c
, d
, e
, a
, F2
, KK2
, 1, 15);
342 R( a
, b
, c
, d
, e
, F2
, KK2
, 3, 11);
343 R( e
, a
, b
, c
, d
, F2
, KK2
, 7, 8);
344 R( d
, e
, a
, b
, c
, F2
, KK2
, 14, 6);
345 R( c
, d
, e
, a
, b
, F2
, KK2
, 6, 6);
346 R( b
, c
, d
, e
, a
, F2
, KK2
, 9, 14);
347 R( a
, b
, c
, d
, e
, F2
, KK2
, 11, 12);
348 R( e
, a
, b
, c
, d
, F2
, KK2
, 8, 13);
349 R( d
, e
, a
, b
, c
, F2
, KK2
, 12, 5);
350 R( c
, d
, e
, a
, b
, F2
, KK2
, 2, 14);
351 R( b
, c
, d
, e
, a
, F2
, KK2
, 10, 13);
352 R( a
, b
, c
, d
, e
, F2
, KK2
, 0, 13);
353 R( e
, a
, b
, c
, d
, F2
, KK2
, 4, 7);
354 R( d
, e
, a
, b
, c
, F2
, KK2
, 13, 5);
355 R( c
, d
, e
, a
, b
, F1
, KK3
, 8, 15);
356 R( b
, c
, d
, e
, a
, F1
, KK3
, 6, 5);
357 R( a
, b
, c
, d
, e
, F1
, KK3
, 4, 8);
358 R( e
, a
, b
, c
, d
, F1
, KK3
, 1, 11);
359 R( d
, e
, a
, b
, c
, F1
, KK3
, 3, 14);
360 R( c
, d
, e
, a
, b
, F1
, KK3
, 11, 14);
361 R( b
, c
, d
, e
, a
, F1
, KK3
, 15, 6);
362 R( a
, b
, c
, d
, e
, F1
, KK3
, 0, 14);
363 R( e
, a
, b
, c
, d
, F1
, KK3
, 5, 6);
364 R( d
, e
, a
, b
, c
, F1
, KK3
, 12, 9);
365 R( c
, d
, e
, a
, b
, F1
, KK3
, 2, 12);
366 R( b
, c
, d
, e
, a
, F1
, KK3
, 13, 9);
367 R( a
, b
, c
, d
, e
, F1
, KK3
, 9, 12);
368 R( e
, a
, b
, c
, d
, F1
, KK3
, 7, 5);
369 R( d
, e
, a
, b
, c
, F1
, KK3
, 10, 15);
370 R( c
, d
, e
, a
, b
, F1
, KK3
, 14, 8);
371 R( b
, c
, d
, e
, a
, F0
, KK4
, 12, 8);
372 R( a
, b
, c
, d
, e
, F0
, KK4
, 15, 5);
373 R( e
, a
, b
, c
, d
, F0
, KK4
, 10, 12);
374 R( d
, e
, a
, b
, c
, F0
, KK4
, 4, 9);
375 R( c
, d
, e
, a
, b
, F0
, KK4
, 1, 12);
376 R( b
, c
, d
, e
, a
, F0
, KK4
, 5, 5);
377 R( a
, b
, c
, d
, e
, F0
, KK4
, 8, 14);
378 R( e
, a
, b
, c
, d
, F0
, KK4
, 7, 6);
379 R( d
, e
, a
, b
, c
, F0
, KK4
, 6, 8);
380 R( c
, d
, e
, a
, b
, F0
, KK4
, 2, 13);
381 R( b
, c
, d
, e
, a
, F0
, KK4
, 13, 6);
382 R( a
, b
, c
, d
, e
, F0
, KK4
, 14, 5);
383 R( e
, a
, b
, c
, d
, F0
, KK4
, 0, 15);
384 R( d
, e
, a
, b
, c
, F0
, KK4
, 3, 13);
385 R( c
, d
, e
, a
, b
, F0
, KK4
, 9, 11);
386 R( b
, c
, d
, e
, a
, F0
, KK4
, 11, 11);
390 hd
->h1
= hd
->h2
+ e
+ dd
;
391 hd
->h2
= hd
->h3
+ a
+ ee
;
392 hd
->h3
= hd
->h4
+ b
+ aa
;
393 hd
->h4
= hd
->h0
+ c
+ bb
;
398 /* Update the message digest with the contents
399 * of INBUF with length INLEN.
402 rmd160_write ( void *context
, const void *inbuf_arg
, size_t inlen
)
404 const unsigned char *inbuf
= inbuf_arg
;
405 RMD160_CONTEXT
*hd
= context
;
407 if( hd
->count
== 64 ) /* flush the buffer */
409 transform( hd
, hd
->buf
);
410 _gcry_burn_stack (108+5*sizeof(void*));
418 for( ; inlen
&& hd
->count
< 64; inlen
-- )
419 hd
->buf
[hd
->count
++] = *inbuf
++;
420 rmd160_write( hd
, NULL
, 0 );
427 transform( hd
, inbuf
);
433 _gcry_burn_stack (108+5*sizeof(void*));
434 for( ; inlen
&& hd
->count
< 64; inlen
-- )
435 hd
->buf
[hd
->count
++] = *inbuf
++;
439 * Apply the rmd160 transform function on the buffer which must have
440 * a length 64 bytes. Do not use this function together with the
441 * other functions, use rmd160_init to initialize internal variables.
442 * Returns: 16 bytes in buffer with the mixed contentes of buffer.
445 _gcry_rmd160_mixblock ( RMD160_CONTEXT
*hd
, void *blockof64byte
)
447 char *p
= blockof64byte
;
449 transform ( hd
, blockof64byte
);
450 #define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
460 /* The routine terminates the computation
464 rmd160_final( void *context
)
466 RMD160_CONTEXT
*hd
= context
;
470 rmd160_write(hd
, NULL
, 0); /* flush */;
473 /* multiply by 64 to make a byte count */
478 if( (lsb
+= hd
->count
) < t
)
480 /* multiply by 8 to make a bit count */
486 if( hd
->count
< 56 ) /* enough room */
488 hd
->buf
[hd
->count
++] = 0x80; /* pad */
489 while( hd
->count
< 56 )
490 hd
->buf
[hd
->count
++] = 0; /* pad */
492 else /* need one extra block */
494 hd
->buf
[hd
->count
++] = 0x80; /* pad character */
495 while( hd
->count
< 64 )
496 hd
->buf
[hd
->count
++] = 0;
497 rmd160_write(hd
, NULL
, 0); /* flush */;
498 memset(hd
->buf
, 0, 56 ); /* fill next block with zeroes */
500 /* append the 64 bit count */
502 hd
->buf
[57] = lsb
>> 8;
503 hd
->buf
[58] = lsb
>> 16;
504 hd
->buf
[59] = lsb
>> 24;
506 hd
->buf
[61] = msb
>> 8;
507 hd
->buf
[62] = msb
>> 16;
508 hd
->buf
[63] = msb
>> 24;
509 transform( hd
, hd
->buf
);
510 _gcry_burn_stack (108+5*sizeof(void*));
513 #ifdef WORDS_BIGENDIAN
514 #define X(a) do { *p++ = hd->h##a ; *p++ = hd->h##a >> 8; \
515 *p++ = hd->h##a >> 16; *p++ = hd->h##a >> 24; } while(0)
516 #else /* little endian */
517 #define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
528 rmd160_read( void *context
)
530 RMD160_CONTEXT
*hd
= context
;
538 * Shortcut functions which puts the hash value of the supplied buffer
539 * into outbuf which must have a size of 20 bytes.
542 static byte asn
[15] = /* Object ID is 1.3.36.3.2.1 */
543 { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
544 0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
546 static gcry_md_oid_spec_t oid_spec_rmd160
[] =
548 /* rsaSignatureWithripemd160 */
549 { "1.3.36.3.3.1.2" },
550 /* TeleTrust hash algorithm. */
555 gcry_md_spec_t _gcry_digest_spec_rmd160
=
557 "RIPEMD160", asn
, DIM (asn
), oid_spec_rmd160
, 20,
558 _gcry_rmd160_init
, rmd160_write
, rmd160_final
, rmd160_read
,
559 sizeof (RMD160_CONTEXT
)
565 GRUB_MOD_INIT(gcry_rmd160
)
567 grub_md_register (&_gcry_digest_spec_rmd160
);
570 GRUB_MOD_FINI(gcry_rmd160
)
572 grub_md_unregister (&_gcry_digest_spec_rmd160
);