2 * Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
3 * Copyright (C) 2013 James Almer
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 #include "attributes.h"
27 #include "intreadwrite.h"
32 typedef struct AVRIPEMD {
33 uint8_t digest_len; ///< digest length in 32-bit words
34 uint64_t count; ///< number of bytes in buffer
35 uint8_t buffer[64]; ///< 512-bit buffer of input values used in hash updating
36 uint32_t state[10]; ///< current hash value
37 uint8_t ext; ///< extension (0 for 128 and 160, 1 for 256 and 320)
38 /** function used to update hash for 512-bit input block */
39 void (*transform)(uint32_t *state, const uint8_t buffer[64], int ext);
42 const int av_ripemd_size = sizeof(AVRIPEMD);
44 struct AVRIPEMD *av_ripemd_alloc(void)
46 return av_mallocz(sizeof(struct AVRIPEMD));
49 static const uint32_t KA[4] = {
50 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e
53 static const uint32_t KB[4] = {
54 0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9
57 static const int ROTA[80] = {
58 11, 14, 15, 12, 5, 8, 7 , 9, 11, 13, 14, 15, 6, 7, 9, 8,
59 7 , 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
60 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
61 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
62 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
65 static const int ROTB[80] = {
66 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
67 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
68 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
69 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
70 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
73 static const int WA[80] = {
74 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
75 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
76 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
77 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
78 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
81 static const int WB[80] = {
82 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
83 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
84 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
85 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
86 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
89 #define rol(value, bits) ((value << bits) | (value >> (32 - bits)))
91 #define SWAP(a,b) if (ext) { int t = a; a = b; b = t; }
93 #define ROUND128_0_TO_15(a,b,c,d,e,f,g,h) \
94 a = rol(a + (( b ^ c ^ d) + block[WA[n]]), ROTA[n]); \
95 e = rol(e + ((((f ^ g) & h) ^ g) + block[WB[n]] + KB[0]), ROTB[n]); \
98 #define ROUND128_16_TO_31(a,b,c,d,e,f,g,h) \
99 a = rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]); \
100 e = rol(e + (((~g | f) ^ h) + block[WB[n]] + KB[1]), ROTB[n]); \
103 #define ROUND128_32_TO_47(a,b,c,d,e,f,g,h) \
104 a = rol(a + (((~c | b) ^ d) + block[WA[n]] + KA[1]), ROTA[n]); \
105 e = rol(e + ((((g ^ h) & f) ^ h) + block[WB[n]] + KB[2]), ROTB[n]); \
108 #define ROUND128_48_TO_63(a,b,c,d,e,f,g,h) \
109 a = rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]); \
110 e = rol(e + (( f ^ g ^ h) + block[WB[n]]), ROTB[n]); \
113 static void ripemd128_transform(uint32_t *state, const uint8_t buffer[64], int ext)
115 uint32_t a, b, c, d, e, f, g, h;
120 a = state[0]; b = state[1]; c = state[2]; d = state[3];
121 e = state[4]; f = state[5]; g = state[6]; h = state[7];
129 for (n = 0; n < 16; n++)
130 block[n] = AV_RL32(buffer + 4 * n);
132 for (n = 0; n < 16;) {
133 ROUND128_0_TO_15(a,b,c,d,e,f,g,h);
134 ROUND128_0_TO_15(d,a,b,c,h,e,f,g);
135 ROUND128_0_TO_15(c,d,a,b,g,h,e,f);
136 ROUND128_0_TO_15(b,c,d,a,f,g,h,e);
141 ROUND128_16_TO_31(a,b,c,d,e,f,g,h);
142 ROUND128_16_TO_31(d,a,b,c,h,e,f,g);
143 ROUND128_16_TO_31(c,d,a,b,g,h,e,f);
144 ROUND128_16_TO_31(b,c,d,a,f,g,h,e);
149 ROUND128_32_TO_47(a,b,c,d,e,f,g,h);
150 ROUND128_32_TO_47(d,a,b,c,h,e,f,g);
151 ROUND128_32_TO_47(c,d,a,b,g,h,e,f);
152 ROUND128_32_TO_47(b,c,d,a,f,g,h,e);
157 ROUND128_48_TO_63(a,b,c,d,e,f,g,h);
158 ROUND128_48_TO_63(d,a,b,c,h,e,f,g);
159 ROUND128_48_TO_63(c,d,a,b,g,h,e,f);
160 ROUND128_48_TO_63(b,c,d,a,f,g,h,e);
165 state[0] += a; state[1] += b; state[2] += c; state[3] += d;
166 state[4] += e; state[5] += f; state[6] += g; state[7] += h;
169 state[1] = state[2] + d + e;
170 state[2] = state[3] + a + f;
171 state[3] = state[0] + b + g;
176 #define ROTATE(x,y) \
181 #define ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j) \
182 a = rol(a + (( b ^ c ^ d) + block[WA[n]]), ROTA[n]) + e; \
183 f = rol(f + (((~i | h) ^ g) + block[WB[n]] + KB[0]), ROTB[n]) + j; \
186 #define ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j) \
187 a = rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]) + e; \
188 f = rol(f + ((((g ^ h) & i) ^ h) + block[WB[n]] + KB[1]), ROTB[n]) + j; \
191 #define ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j) \
192 a = rol(a + (((~c | b) ^ d) + block[WA[n]] + KA[1]), ROTA[n]) + e; \
193 f = rol(f + (((~h | g) ^ i) + block[WB[n]] + KB[2]), ROTB[n]) + j; \
196 #define ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j) \
197 a = rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]) + e; \
198 f = rol(f + ((((h ^ i) & g) ^ i) + block[WB[n]] + KB[3]), ROTB[n]) + j; \
201 #define ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j) \
202 a = rol(a + (((~d | c) ^ b) + block[WA[n]] + KA[3]), ROTA[n]) + e; \
203 f = rol(f + (( g ^ h ^ i) + block[WB[n]]), ROTB[n]) + j; \
206 static void ripemd160_transform(uint32_t *state, const uint8_t buffer[64], int ext)
208 uint32_t a, b, c, d, e, f, g, h, i, j;
213 a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4];
214 f = state[5]; g = state[6]; h = state[7]; i = state[8]; j = state[9];
223 for (n = 0; n < 16; n++)
224 block[n] = AV_RL32(buffer + 4 * n);
226 for (n = 0; n < 16 - 1;) {
227 ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
228 ROUND160_0_TO_15(e,a,b,c,d,j,f,g,h,i);
229 ROUND160_0_TO_15(d,e,a,b,c,i,j,f,g,h);
230 ROUND160_0_TO_15(c,d,e,a,b,h,i,j,f,g);
231 ROUND160_0_TO_15(b,c,d,e,a,g,h,i,j,f);
233 ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
236 for (; n < 32 - 1;) {
237 ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i);
238 ROUND160_16_TO_31(d,e,a,b,c,i,j,f,g,h);
239 ROUND160_16_TO_31(c,d,e,a,b,h,i,j,f,g);
240 ROUND160_16_TO_31(b,c,d,e,a,g,h,i,j,f);
241 ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j);
243 ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i);
246 for (; n < 48 - 1;) {
247 ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h);
248 ROUND160_32_TO_47(c,d,e,a,b,h,i,j,f,g);
249 ROUND160_32_TO_47(b,c,d,e,a,g,h,i,j,f);
250 ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j);
251 ROUND160_32_TO_47(e,a,b,c,d,j,f,g,h,i);
253 ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h);
256 for (; n < 64 - 1;) {
257 ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g);
258 ROUND160_48_TO_63(b,c,d,e,a,g,h,i,j,f);
259 ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j);
260 ROUND160_48_TO_63(e,a,b,c,d,j,f,g,h,i);
261 ROUND160_48_TO_63(d,e,a,b,c,i,j,f,g,h);
263 ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g);
267 ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f);
268 ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j);
269 ROUND160_64_TO_79(e,a,b,c,d,j,f,g,h,i);
270 ROUND160_64_TO_79(d,e,a,b,c,i,j,f,g,h);
271 ROUND160_64_TO_79(c,d,e,a,b,h,i,j,f,g);
273 ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f);
277 state[0] += a; state[1] += b; state[2] += c; state[3] += d; state[4] += e;
278 state[5] += f; state[6] += g; state[7] += h; state[8] += i; state[9] += j;
281 state[1] = state[2] + d + j;
282 state[2] = state[3] + e + f;
283 state[3] = state[4] + a + g;
284 state[4] = state[0] + b + h;
289 av_cold int av_ripemd_init(AVRIPEMD *ctx, int bits)
291 ctx->digest_len = bits >> 5;
293 case 128: // RIPEMD-128
294 ctx->state[0] = 0x67452301;
295 ctx->state[1] = 0xEFCDAB89;
296 ctx->state[2] = 0x98BADCFE;
297 ctx->state[3] = 0x10325476;
298 ctx->transform = ripemd128_transform;
301 case 160: // RIPEMD-160
302 ctx->state[0] = 0x67452301;
303 ctx->state[1] = 0xEFCDAB89;
304 ctx->state[2] = 0x98BADCFE;
305 ctx->state[3] = 0x10325476;
306 ctx->state[4] = 0xC3D2E1F0;
307 ctx->transform = ripemd160_transform;
310 case 256: // RIPEMD-256
311 ctx->state[0] = 0x67452301;
312 ctx->state[1] = 0xEFCDAB89;
313 ctx->state[2] = 0x98BADCFE;
314 ctx->state[3] = 0x10325476;
315 ctx->state[4] = 0x76543210;
316 ctx->state[5] = 0xFEDCBA98;
317 ctx->state[6] = 0x89ABCDEF;
318 ctx->state[7] = 0x01234567;
319 ctx->transform = ripemd128_transform;
322 case 320: // RIPEMD-320
323 ctx->state[0] = 0x67452301;
324 ctx->state[1] = 0xEFCDAB89;
325 ctx->state[2] = 0x98BADCFE;
326 ctx->state[3] = 0x10325476;
327 ctx->state[4] = 0xC3D2E1F0;
328 ctx->state[5] = 0x76543210;
329 ctx->state[6] = 0xFEDCBA98;
330 ctx->state[7] = 0x89ABCDEF;
331 ctx->state[8] = 0x01234567;
332 ctx->state[9] = 0x3C2D1E0F;
333 ctx->transform = ripemd160_transform;
343 void av_ripemd_update(AVRIPEMD* ctx, const uint8_t* data, unsigned int len)
350 for (i = 0; i < len; i++) {
351 ctx->buffer[j++] = data[i];
353 ctx->transform(ctx->state, ctx->buffer, ctx->ext);
358 if ((j + len) > 63) {
359 memcpy(&ctx->buffer[j], data, (i = 64 - j));
360 ctx->transform(ctx->state, ctx->buffer, ctx->ext);
361 for (; i + 63 < len; i += 64)
362 ctx->transform(ctx->state, &data[i], ctx->ext);
366 memcpy(&ctx->buffer[j], &data[i], len - i);
370 void av_ripemd_final(AVRIPEMD* ctx, uint8_t *digest)
373 uint64_t finalcount = av_le2ne64(ctx->count << 3);
375 av_ripemd_update(ctx, "\200", 1);
376 while ((ctx->count & 63) != 56)
377 av_ripemd_update(ctx, "", 1);
378 av_ripemd_update(ctx, (uint8_t *)&finalcount, 8); /* Should cause a transform() */
379 for (i = 0; i < ctx->digest_len; i++)
380 AV_WL32(digest + i*4, ctx->state[i]);
390 unsigned char digest[40];
391 const int lengths[4] = { 128, 160, 256, 320 };
393 for (j = 0; j < 4; j++) {
394 printf("Testing RIPEMD-%d\n", lengths[j]);
395 for (k = 0; k < 3; k++) {
396 av_ripemd_init(&ctx, lengths[j]);
398 av_ripemd_update(&ctx, "abc", 3);
400 av_ripemd_update(&ctx, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56);
402 for (i = 0; i < 1000*1000; i++)
403 av_ripemd_update(&ctx, "a", 1);
404 av_ripemd_final(&ctx, digest);
405 for (i = 0; i < lengths[j] >> 3; i++)
406 printf("%02X", digest[i]);
409 switch (j) { //test vectors (from ISO:IEC 10118-3 (2004) and http://homes.esat.kuleuven.be/~bosselae/ripemd160.html)
411 printf("c14a1219 9c66e4ba 84636b0f 69144c77\n"
412 "a1aa0689 d0fafa2d dc22e88b 49133a06\n"
413 "4a7f5723 f954eba1 216c9d8f 6320431f\n");
416 printf("8eb208f7 e05d987a 9b044a8e 98c6b087 f15a0bfc\n"
417 "12a05338 4a9c0c88 e405a06c 27dcf49a da62eb2b\n"
418 "52783243 c1697bdb e16d37f9 7f68f083 25dc1528\n");
421 printf("afbd6e22 8b9d8cbb cef5ca2d 03e6dba1 0ac0bc7d cbe4680e 1e42d2e9 75459b65\n"
422 "38430455 83aac6c8 c8d91285 73e7a980 9afb2a0f 34ccc36e a9e72f16 f6368e3f\n"
423 "ac953744 e10e3151 4c150d4d 8d7b6773 42e33399 788296e4 3ae4850c e4f97978\n");
426 printf("de4c01b3 054f8930 a79d09ae 738e9230 1e5a1708 5beffdc1 b8d11671 3e74f82f a942d64c dbc4682d\n"
427 "d034a795 0cf72202 1ba4b84d f769a5de 2060e259 df4c9bb4 a4268c0e 935bbc74 70a969c9 d072a1ac\n"
428 "bdee37f4 371e2064 6b8b0d86 2dda1629 2ae36f40 965e8c85 09e63d1d bddecc50 3e2b63eb 9245bb66\n");