FFmpeg
ripemd.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
3  * Copyright (C) 2013 James Almer
4  *
5  * This file is part of FFmpeg.
6  *
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.
11  *
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.
16  *
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
20  */
21 
22 #include <stddef.h>
23 #include <string.h>
24 
25 #include "config.h"
26 #include "attributes.h"
27 #include "bswap.h"
28 #include "error.h"
29 #include "intreadwrite.h"
30 #include "macros.h"
31 #include "ripemd.h"
32 #include "mem.h"
33 
34 /** hash context */
35 typedef struct AVRIPEMD {
36  uint8_t digest_len; ///< digest length in 32-bit words
37  uint64_t count; ///< number of bytes in buffer
38  uint8_t buffer[64]; ///< 512-bit buffer of input values used in hash updating
39  uint32_t state[10]; ///< current hash value
40  /** function used to update hash for 512-bit input block */
41  void (*transform)(uint32_t *state, const uint8_t buffer[64]);
42 } AVRIPEMD;
43 
44 const int av_ripemd_size = sizeof(AVRIPEMD);
45 
47 {
48  return av_mallocz(sizeof(struct AVRIPEMD));
49 }
50 
51 static const uint32_t KA[4] = {
52  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e
53 };
54 
55 static const uint32_t KB[4] = {
56  0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9
57 };
58 
59 static const int ROTA[80] = {
60  11, 14, 15, 12, 5, 8, 7 , 9, 11, 13, 14, 15, 6, 7, 9, 8,
61  7 , 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
62  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
63  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
64  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
65 };
66 
67 static const int ROTB[80] = {
68  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
69  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
70  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
71  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
72  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
73 };
74 
75 static const int WA[80] = {
76  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
77  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
78  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
79  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
80  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
81 };
82 
83 static const int WB[80] = {
84  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
85  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
86  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
87  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
88  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
89 };
90 
91 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
92 
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]); \
96  n++
97 
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]); \
101  n++
102 
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]); \
106  n++
107 
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]); \
111  n++
112 
113 #define R128_0 \
114  ROUND128_0_TO_15(a,b,c,d,e,f,g,h); \
115  ROUND128_0_TO_15(d,a,b,c,h,e,f,g); \
116  ROUND128_0_TO_15(c,d,a,b,g,h,e,f); \
117  ROUND128_0_TO_15(b,c,d,a,f,g,h,e)
118 
119 #define R128_16 \
120  ROUND128_16_TO_31(a,b,c,d,e,f,g,h); \
121  ROUND128_16_TO_31(d,a,b,c,h,e,f,g); \
122  ROUND128_16_TO_31(c,d,a,b,g,h,e,f); \
123  ROUND128_16_TO_31(b,c,d,a,f,g,h,e)
124 
125 #define R128_32 \
126  ROUND128_32_TO_47(a,b,c,d,e,f,g,h); \
127  ROUND128_32_TO_47(d,a,b,c,h,e,f,g); \
128  ROUND128_32_TO_47(c,d,a,b,g,h,e,f); \
129  ROUND128_32_TO_47(b,c,d,a,f,g,h,e)
130 
131 #define R128_48 \
132  ROUND128_48_TO_63(a,b,c,d,e,f,g,h); \
133  ROUND128_48_TO_63(d,a,b,c,h,e,f,g); \
134  ROUND128_48_TO_63(c,d,a,b,g,h,e,f); \
135  ROUND128_48_TO_63(b,c,d,a,f,g,h,e)
136 
137 static void ripemd128_transform(uint32_t *state, const uint8_t buffer[64])
138 {
139  uint32_t a, b, c, d, e, f, g, h, av_unused t;
140  uint32_t block[16];
141  int n;
142 
143  a = e = state[0];
144  b = f = state[1];
145  c = g = state[2];
146  d = h = state[3];
147 
148  for (n = 0; n < 16; n++)
149  block[n] = AV_RL32(buffer + 4 * n);
150  n = 0;
151 
152 #if CONFIG_SMALL
153  for (; n < 16;) {
154  ROUND128_0_TO_15(a,b,c,d,e,f,g,h);
155  t = d; d = c; c = b; b = a; a = t;
156  t = h; h = g; g = f; f = e; e = t;
157  }
158 
159  for (; n < 32;) {
160  ROUND128_16_TO_31(a,b,c,d,e,f,g,h);
161  t = d; d = c; c = b; b = a; a = t;
162  t = h; h = g; g = f; f = e; e = t;
163  }
164 
165  for (; n < 48;) {
166  ROUND128_32_TO_47(a,b,c,d,e,f,g,h);
167  t = d; d = c; c = b; b = a; a = t;
168  t = h; h = g; g = f; f = e; e = t;
169  }
170 
171  for (; n < 64;) {
172  ROUND128_48_TO_63(a,b,c,d,e,f,g,h);
173  t = d; d = c; c = b; b = a; a = t;
174  t = h; h = g; g = f; f = e; e = t;
175  }
176 #else
177 
179 
181 
183 
185 #endif
186 
187  h += c + state[1];
188  state[1] = state[2] + d + e;
189  state[2] = state[3] + a + f;
190  state[3] = state[0] + b + g;
191  state[0] = h;
192 }
193 
194 static void ripemd256_transform(uint32_t *state, const uint8_t buffer[64])
195 {
196  uint32_t a, b, c, d, e, f, g, h, av_unused t;
197  uint32_t block[16];
198  int n;
199 
200  a = state[0]; b = state[1]; c = state[2]; d = state[3];
201  e = state[4]; f = state[5]; g = state[6]; h = state[7];
202 
203  for (n = 0; n < 16; n++)
204  block[n] = AV_RL32(buffer + 4 * n);
205  n = 0;
206 
207 #if CONFIG_SMALL
208  for (; n < 16;) {
209  ROUND128_0_TO_15(a,b,c,d,e,f,g,h);
210  t = d; d = c; c = b; b = a; a = t;
211  t = h; h = g; g = f; f = e; e = t;
212  }
213  FFSWAP(uint32_t, a, e);
214 
215  for (; n < 32;) {
216  ROUND128_16_TO_31(a,b,c,d,e,f,g,h);
217  t = d; d = c; c = b; b = a; a = t;
218  t = h; h = g; g = f; f = e; e = t;
219  }
220  FFSWAP(uint32_t, b, f);
221 
222  for (; n < 48;) {
223  ROUND128_32_TO_47(a,b,c,d,e,f,g,h);
224  t = d; d = c; c = b; b = a; a = t;
225  t = h; h = g; g = f; f = e; e = t;
226  }
227  FFSWAP(uint32_t, c, g);
228 
229  for (; n < 64;) {
230  ROUND128_48_TO_63(a,b,c,d,e,f,g,h);
231  t = d; d = c; c = b; b = a; a = t;
232  t = h; h = g; g = f; f = e; e = t;
233  }
234  FFSWAP(uint32_t, d, h);
235 #else
236 
238  FFSWAP(uint32_t, a, e);
239 
241  FFSWAP(uint32_t, b, f);
242 
244  FFSWAP(uint32_t, c, g);
245 
247  FFSWAP(uint32_t, d, h);
248 #endif
249 
250  state[0] += a; state[1] += b; state[2] += c; state[3] += d;
251  state[4] += e; state[5] += f; state[6] += g; state[7] += h;
252 }
253 
254 #define ROTATE(x,y) \
255  x = rol(x, 10); \
256  y = rol(y, 10); \
257  n++
258 
259 #define ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j) \
260  a = rol(a + (( b ^ c ^ d) + block[WA[n]]), ROTA[n]) + e; \
261  f = rol(f + (((~i | h) ^ g) + block[WB[n]] + KB[0]), ROTB[n]) + j; \
262  ROTATE(c,h)
263 
264 #define ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j) \
265  a = rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]) + e; \
266  f = rol(f + ((((g ^ h) & i) ^ h) + block[WB[n]] + KB[1]), ROTB[n]) + j; \
267  ROTATE(c,h)
268 
269 #define ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j) \
270  a = rol(a + (((~c | b) ^ d) + block[WA[n]] + KA[1]), ROTA[n]) + e; \
271  f = rol(f + (((~h | g) ^ i) + block[WB[n]] + KB[2]), ROTB[n]) + j; \
272  ROTATE(c,h)
273 
274 #define ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j) \
275  a = rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]) + e; \
276  f = rol(f + ((((h ^ i) & g) ^ i) + block[WB[n]] + KB[3]), ROTB[n]) + j; \
277  ROTATE(c,h)
278 
279 #define ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j) \
280  a = rol(a + (((~d | c) ^ b) + block[WA[n]] + KA[3]), ROTA[n]) + e; \
281  f = rol(f + (( g ^ h ^ i) + block[WB[n]]), ROTB[n]) + j; \
282  ROTATE(c,h)
283 
284 #define R160_0 \
285  ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j); \
286  ROUND160_0_TO_15(e,a,b,c,d,j,f,g,h,i); \
287  ROUND160_0_TO_15(d,e,a,b,c,i,j,f,g,h); \
288  ROUND160_0_TO_15(c,d,e,a,b,h,i,j,f,g); \
289  ROUND160_0_TO_15(b,c,d,e,a,g,h,i,j,f)
290 
291 #define R160_16 \
292  ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i); \
293  ROUND160_16_TO_31(d,e,a,b,c,i,j,f,g,h); \
294  ROUND160_16_TO_31(c,d,e,a,b,h,i,j,f,g); \
295  ROUND160_16_TO_31(b,c,d,e,a,g,h,i,j,f); \
296  ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j)
297 
298 #define R160_32 \
299  ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h); \
300  ROUND160_32_TO_47(c,d,e,a,b,h,i,j,f,g); \
301  ROUND160_32_TO_47(b,c,d,e,a,g,h,i,j,f); \
302  ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j); \
303  ROUND160_32_TO_47(e,a,b,c,d,j,f,g,h,i)
304 
305 #define R160_48 \
306  ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g); \
307  ROUND160_48_TO_63(b,c,d,e,a,g,h,i,j,f); \
308  ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j); \
309  ROUND160_48_TO_63(e,a,b,c,d,j,f,g,h,i); \
310  ROUND160_48_TO_63(d,e,a,b,c,i,j,f,g,h)
311 
312 #define R160_64 \
313  ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f); \
314  ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j); \
315  ROUND160_64_TO_79(e,a,b,c,d,j,f,g,h,i); \
316  ROUND160_64_TO_79(d,e,a,b,c,i,j,f,g,h); \
317  ROUND160_64_TO_79(c,d,e,a,b,h,i,j,f,g)
318 
319 static void ripemd160_transform(uint32_t *state, const uint8_t buffer[64])
320 {
321  uint32_t a, b, c, d, e, f, g, h, i, j, av_unused t;
322  uint32_t block[16];
323  int n;
324 
325  a = f = state[0];
326  b = g = state[1];
327  c = h = state[2];
328  d = i = state[3];
329  e = j = state[4];
330 
331  for (n = 0; n < 16; n++)
332  block[n] = AV_RL32(buffer + 4 * n);
333  n = 0;
334 
335 #if CONFIG_SMALL
336  for (; n < 16;) {
337  ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
338  t = e; e = d; d = c; c = b; b = a; a = t;
339  t = j; j = i; i = h; h = g; g = f; f = t;
340  }
341 
342  for (; n < 32;) {
343  ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j);
344  t = e; e = d; d = c; c = b; b = a; a = t;
345  t = j; j = i; i = h; h = g; g = f; f = t;
346  }
347 
348  for (; n < 48;) {
349  ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j);
350  t = e; e = d; d = c; c = b; b = a; a = t;
351  t = j; j = i; i = h; h = g; g = f; f = t;
352  }
353 
354  for (; n < 64;) {
355  ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j);
356  t = e; e = d; d = c; c = b; b = a; a = t;
357  t = j; j = i; i = h; h = g; g = f; f = t;
358  }
359 
360  for (; n < 80;) {
361  ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j);
362  t = e; e = d; d = c; c = b; b = a; a = t;
363  t = j; j = i; i = h; h = g; g = f; f = t;
364  }
365 #else
366 
367  R160_0; R160_0; R160_0;
368  ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
369 
371  ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i);
372 
374  ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h);
375 
377  ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g);
378 
380  ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f);
381 #endif
382 
383  i += c + state[1];
384  state[1] = state[2] + d + j;
385  state[2] = state[3] + e + f;
386  state[3] = state[4] + a + g;
387  state[4] = state[0] + b + h;
388  state[0] = i;
389 }
390 
391 static void ripemd320_transform(uint32_t *state, const uint8_t buffer[64])
392 {
393  uint32_t a, b, c, d, e, f, g, h, i, j, av_unused t;
394  uint32_t block[16];
395  int n;
396 
397  a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4];
398  f = state[5]; g = state[6]; h = state[7]; i = state[8]; j = state[9];
399 
400  for (n = 0; n < 16; n++)
401  block[n] = AV_RL32(buffer + 4 * n);
402  n = 0;
403 
404 #if CONFIG_SMALL
405  for (; n < 16;) {
406  ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
407  t = e; e = d; d = c; c = b; b = a; a = t;
408  t = j; j = i; i = h; h = g; g = f; f = t;
409  }
410  FFSWAP(uint32_t, b, g);
411 
412  for (; n < 32;) {
413  ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j);
414  t = e; e = d; d = c; c = b; b = a; a = t;
415  t = j; j = i; i = h; h = g; g = f; f = t;
416  }
417  FFSWAP(uint32_t, d, i);
418 
419  for (; n < 48;) {
420  ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j);
421  t = e; e = d; d = c; c = b; b = a; a = t;
422  t = j; j = i; i = h; h = g; g = f; f = t;
423  }
424  FFSWAP(uint32_t, a, f);
425 
426  for (; n < 64;) {
427  ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j);
428  t = e; e = d; d = c; c = b; b = a; a = t;
429  t = j; j = i; i = h; h = g; g = f; f = t;
430  }
431  FFSWAP(uint32_t, c, h);
432 
433  for (; n < 80;) {
434  ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j);
435  t = e; e = d; d = c; c = b; b = a; a = t;
436  t = j; j = i; i = h; h = g; g = f; f = t;
437  }
438  FFSWAP(uint32_t, e, j);
439 #else
440 
441  R160_0; R160_0; R160_0;
442  ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
443  FFSWAP(uint32_t, a, f);
444 
446  ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i);
447  FFSWAP(uint32_t, b, g);
448 
450  ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h);
451  FFSWAP(uint32_t, c, h);
452 
454  ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g);
455  FFSWAP(uint32_t, d, i);
456 
458  ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f);
459  FFSWAP(uint32_t, e, j);
460 #endif
461 
462  state[0] += a; state[1] += b; state[2] += c; state[3] += d; state[4] += e;
463  state[5] += f; state[6] += g; state[7] += h; state[8] += i; state[9] += j;
464 }
465 
467 {
468  ctx->digest_len = bits >> 5;
469  switch (bits) {
470  case 128: // RIPEMD-128
471  ctx->state[0] = 0x67452301;
472  ctx->state[1] = 0xEFCDAB89;
473  ctx->state[2] = 0x98BADCFE;
474  ctx->state[3] = 0x10325476;
475  ctx->transform = ripemd128_transform;
476  break;
477  case 160: // RIPEMD-160
478  ctx->state[0] = 0x67452301;
479  ctx->state[1] = 0xEFCDAB89;
480  ctx->state[2] = 0x98BADCFE;
481  ctx->state[3] = 0x10325476;
482  ctx->state[4] = 0xC3D2E1F0;
483  ctx->transform = ripemd160_transform;
484  break;
485  case 256: // RIPEMD-256
486  ctx->state[0] = 0x67452301;
487  ctx->state[1] = 0xEFCDAB89;
488  ctx->state[2] = 0x98BADCFE;
489  ctx->state[3] = 0x10325476;
490  ctx->state[4] = 0x76543210;
491  ctx->state[5] = 0xFEDCBA98;
492  ctx->state[6] = 0x89ABCDEF;
493  ctx->state[7] = 0x01234567;
494  ctx->transform = ripemd256_transform;
495  break;
496  case 320: // RIPEMD-320
497  ctx->state[0] = 0x67452301;
498  ctx->state[1] = 0xEFCDAB89;
499  ctx->state[2] = 0x98BADCFE;
500  ctx->state[3] = 0x10325476;
501  ctx->state[4] = 0xC3D2E1F0;
502  ctx->state[5] = 0x76543210;
503  ctx->state[6] = 0xFEDCBA98;
504  ctx->state[7] = 0x89ABCDEF;
505  ctx->state[8] = 0x01234567;
506  ctx->state[9] = 0x3C2D1E0F;
507  ctx->transform = ripemd320_transform;
508  break;
509  default:
510  return AVERROR(EINVAL);
511  }
512  ctx->count = 0;
513  return 0;
514 }
515 
516 void av_ripemd_update(AVRIPEMD* ctx, const uint8_t* data, size_t len)
517 {
518  unsigned int j;
519  size_t i;
520 
521  j = ctx->count & 63;
522  ctx->count += len;
523 #if CONFIG_SMALL
524  for (i = 0; i < len; i++) {
525  ctx->buffer[j++] = data[i];
526  if (64 == j) {
527  ctx->transform(ctx->state, ctx->buffer);
528  j = 0;
529  }
530  }
531 #else
532  if (len >= 64 - j) {
533  const uint8_t *end;
534  memcpy(&ctx->buffer[j], data, (i = 64 - j));
535  ctx->transform(ctx->state, ctx->buffer);
536  data += i;
537  len -= i;
538  end = data + (len & ~63);
539  len = len % 64;
540  for (; data < end; data += 64)
541  ctx->transform(ctx->state, data);
542  j = 0;
543  }
544  memcpy(&ctx->buffer[j], data, len);
545 #endif
546 }
547 
548 void av_ripemd_final(AVRIPEMD* ctx, uint8_t *digest)
549 {
550  int i;
551  uint64_t finalcount = av_le2ne64(ctx->count << 3);
552 
553  av_ripemd_update(ctx, "\200", 1);
554  while ((ctx->count & 63) != 56)
555  av_ripemd_update(ctx, "", 1);
556  av_ripemd_update(ctx, (uint8_t *)&finalcount, 8); /* Should cause a transform() */
557  for (i = 0; i < ctx->digest_len; i++)
558  AV_WL32(digest + i*4, ctx->state[i]);
559 }
R160_48
#define R160_48
Definition: ripemd.c:305
WA
static const int WA[80]
Definition: ripemd.c:75
ROUND160_64_TO_79
#define ROUND160_64_TO_79(a, b, c, d, e, f, g, h, i, j)
Definition: ripemd.c:279
R128_48
#define R128_48
Definition: ripemd.c:131
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:422
AVRIPEMD::state
uint32_t state[10]
current hash value
Definition: ripemd.c:39
av_ripemd_alloc
struct AVRIPEMD * av_ripemd_alloc(void)
Allocate an AVRIPEMD context.
Definition: ripemd.c:46
KB
static const uint32_t KB[4]
Definition: ripemd.c:55
ROUND160_16_TO_31
#define ROUND160_16_TO_31(a, b, c, d, e, f, g, h, i, j)
Definition: ripemd.c:264
ROUND160_48_TO_63
#define ROUND160_48_TO_63(a, b, c, d, e, f, g, h, i, j)
Definition: ripemd.c:274
av_unused
#define av_unused
Definition: attributes.h:131
R128_0
#define R128_0
Definition: ripemd.c:113
b
#define b
Definition: input.c:41
data
const char data[16]
Definition: mxf.c:149
state
static struct @464 state
KA
static const uint32_t KA[4]
Definition: ripemd.c:51
R160_32
#define R160_32
Definition: ripemd.c:298
R160_64
#define R160_64
Definition: ripemd.c:312
macros.h
ROTB
static const int ROTB[80]
Definition: ripemd.c:67
ROTA
static const int ROTA[80]
Definition: ripemd.c:59
av_cold
#define av_cold
Definition: attributes.h:90
AVRIPEMD::buffer
uint8_t buffer[64]
512-bit buffer of input values used in hash updating
Definition: ripemd.c:38
intreadwrite.h
g
const char * g
Definition: vf_curves.c:128
ripemd.h
ROUND128_32_TO_47
#define ROUND128_32_TO_47(a, b, c, d, e, f, g, h)
Definition: ripemd.c:103
bits
uint8_t bits
Definition: vp3data.h:128
ctx
AVFormatContext * ctx
Definition: movenc.c:49
ROUND128_0_TO_15
#define ROUND128_0_TO_15(a, b, c, d, e, f, g, h)
Definition: ripemd.c:93
R128_32
#define R128_32
Definition: ripemd.c:125
ROUND160_0_TO_15
#define ROUND160_0_TO_15(a, b, c, d, e, f, g, h, i, j)
Definition: ripemd.c:259
ripemd128_transform
static void ripemd128_transform(uint32_t *state, const uint8_t buffer[64])
Definition: ripemd.c:137
WB
static const int WB[80]
Definition: ripemd.c:83
av_ripemd_init
av_cold int av_ripemd_init(AVRIPEMD *ctx, int bits)
Initialize RIPEMD hashing.
Definition: ripemd.c:466
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
av_le2ne64
#define av_le2ne64(x)
Definition: bswap.h:93
error.h
ROUND128_48_TO_63
#define ROUND128_48_TO_63(a, b, c, d, e, f, g, h)
Definition: ripemd.c:108
ripemd160_transform
static void ripemd160_transform(uint32_t *state, const uint8_t buffer[64])
Definition: ripemd.c:319
f
f
Definition: af_crystalizer.c:122
av_ripemd_final
void av_ripemd_final(AVRIPEMD *ctx, uint8_t *digest)
Finish hashing and output digest value.
Definition: ripemd.c:548
R128_16
#define R128_16
Definition: ripemd.c:119
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
attributes.h
AVRIPEMD
hash context
Definition: ripemd.c:35
AVRIPEMD::transform
void(* transform)(uint32_t *state, const uint8_t buffer[64])
function used to update hash for 512-bit input block
Definition: ripemd.c:41
ripemd256_transform
static void ripemd256_transform(uint32_t *state, const uint8_t buffer[64])
Definition: ripemd.c:194
R160_0
#define R160_0
Definition: ripemd.c:284
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVRIPEMD::digest_len
uint8_t digest_len
digest length in 32-bit words
Definition: ripemd.c:36
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
len
int len
Definition: vorbis_enc_data.h:426
ROUND160_32_TO_47
#define ROUND160_32_TO_47(a, b, c, d, e, f, g, h, i, j)
Definition: ripemd.c:269
bswap.h
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
av_ripemd_update
void av_ripemd_update(AVRIPEMD *ctx, const uint8_t *data, size_t len)
Update hash value.
Definition: ripemd.c:516
mem.h
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
h
h
Definition: vp9dsp_template.c:2070
ROUND128_16_TO_31
#define ROUND128_16_TO_31(a, b, c, d, e, f, g, h)
Definition: ripemd.c:98
av_ripemd_size
const int av_ripemd_size
Definition: ripemd.c:44
R160_16
#define R160_16
Definition: ripemd.c:291
AVRIPEMD::count
uint64_t count
number of bytes in buffer
Definition: ripemd.c:37
ripemd320_transform
static void ripemd320_transform(uint32_t *state, const uint8_t buffer[64])
Definition: ripemd.c:391