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 "attributes.h"
26 #include "avutil.h"
27 #include "bswap.h"
28 #include "intreadwrite.h"
29 #include "ripemd.h"
30 #include "mem.h"
31 
32 /** hash context */
33 typedef struct AVRIPEMD {
34  uint8_t digest_len; ///< digest length in 32-bit words
35  uint64_t count; ///< number of bytes in buffer
36  uint8_t buffer[64]; ///< 512-bit buffer of input values used in hash updating
37  uint32_t state[10]; ///< current hash value
38  /** function used to update hash for 512-bit input block */
39  void (*transform)(uint32_t *state, const uint8_t buffer[64]);
40 } AVRIPEMD;
41 
42 const int av_ripemd_size = sizeof(AVRIPEMD);
43 
44 struct AVRIPEMD *av_ripemd_alloc(void)
45 {
46  return av_mallocz(sizeof(struct AVRIPEMD));
47 }
48 
49 static const uint32_t KA[4] = {
50  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e
51 };
52 
53 static const uint32_t KB[4] = {
54  0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9
55 };
56 
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
63 };
64 
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
71 };
72 
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
79 };
80 
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
87 };
88 
89 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
90 
91 #define ROUND128_0_TO_15(a,b,c,d,e,f,g,h) \
92  a = rol(a + (( b ^ c ^ d) + block[WA[n]]), ROTA[n]); \
93  e = rol(e + ((((f ^ g) & h) ^ g) + block[WB[n]] + KB[0]), ROTB[n]); \
94  n++
95 
96 #define ROUND128_16_TO_31(a,b,c,d,e,f,g,h) \
97  a = rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]); \
98  e = rol(e + (((~g | f) ^ h) + block[WB[n]] + KB[1]), ROTB[n]); \
99  n++
100 
101 #define ROUND128_32_TO_47(a,b,c,d,e,f,g,h) \
102  a = rol(a + (((~c | b) ^ d) + block[WA[n]] + KA[1]), ROTA[n]); \
103  e = rol(e + ((((g ^ h) & f) ^ h) + block[WB[n]] + KB[2]), ROTB[n]); \
104  n++
105 
106 #define ROUND128_48_TO_63(a,b,c,d,e,f,g,h) \
107  a = rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]); \
108  e = rol(e + (( f ^ g ^ h) + block[WB[n]]), ROTB[n]); \
109  n++
110 
111 #define R128_0 \
112  ROUND128_0_TO_15(a,b,c,d,e,f,g,h); \
113  ROUND128_0_TO_15(d,a,b,c,h,e,f,g); \
114  ROUND128_0_TO_15(c,d,a,b,g,h,e,f); \
115  ROUND128_0_TO_15(b,c,d,a,f,g,h,e)
116 
117 #define R128_16 \
118  ROUND128_16_TO_31(a,b,c,d,e,f,g,h); \
119  ROUND128_16_TO_31(d,a,b,c,h,e,f,g); \
120  ROUND128_16_TO_31(c,d,a,b,g,h,e,f); \
121  ROUND128_16_TO_31(b,c,d,a,f,g,h,e)
122 
123 #define R128_32 \
124  ROUND128_32_TO_47(a,b,c,d,e,f,g,h); \
125  ROUND128_32_TO_47(d,a,b,c,h,e,f,g); \
126  ROUND128_32_TO_47(c,d,a,b,g,h,e,f); \
127  ROUND128_32_TO_47(b,c,d,a,f,g,h,e)
128 
129 #define R128_48 \
130  ROUND128_48_TO_63(a,b,c,d,e,f,g,h); \
131  ROUND128_48_TO_63(d,a,b,c,h,e,f,g); \
132  ROUND128_48_TO_63(c,d,a,b,g,h,e,f); \
133  ROUND128_48_TO_63(b,c,d,a,f,g,h,e)
134 
135 static void ripemd128_transform(uint32_t *state, const uint8_t buffer[64])
136 {
137  uint32_t a, b, c, d, e, f, g, h, av_unused t;
138  uint32_t block[16];
139  int n;
140 
141  a = e = state[0];
142  b = f = state[1];
143  c = g = state[2];
144  d = h = state[3];
145 
146  for (n = 0; n < 16; n++)
147  block[n] = AV_RL32(buffer + 4 * n);
148  n = 0;
149 
150 #if CONFIG_SMALL
151  for (; n < 16;) {
152  ROUND128_0_TO_15(a,b,c,d,e,f,g,h);
153  t = d; d = c; c = b; b = a; a = t;
154  t = h; h = g; g = f; f = e; e = t;
155  }
156 
157  for (; n < 32;) {
158  ROUND128_16_TO_31(a,b,c,d,e,f,g,h);
159  t = d; d = c; c = b; b = a; a = t;
160  t = h; h = g; g = f; f = e; e = t;
161  }
162 
163  for (; n < 48;) {
164  ROUND128_32_TO_47(a,b,c,d,e,f,g,h);
165  t = d; d = c; c = b; b = a; a = t;
166  t = h; h = g; g = f; f = e; e = t;
167  }
168 
169  for (; n < 64;) {
170  ROUND128_48_TO_63(a,b,c,d,e,f,g,h);
171  t = d; d = c; c = b; b = a; a = t;
172  t = h; h = g; g = f; f = e; e = t;
173  }
174 #else
175 
176  R128_0; R128_0; R128_0; R128_0;
177 
178  R128_16; R128_16; R128_16; R128_16;
179 
180  R128_32; R128_32; R128_32; R128_32;
181 
182  R128_48; R128_48; R128_48; R128_48;
183 #endif
184 
185  h += c + state[1];
186  state[1] = state[2] + d + e;
187  state[2] = state[3] + a + f;
188  state[3] = state[0] + b + g;
189  state[0] = h;
190 }
191 
192 static void ripemd256_transform(uint32_t *state, const uint8_t buffer[64])
193 {
194  uint32_t a, b, c, d, e, f, g, h, av_unused t;
195  uint32_t block[16];
196  int n;
197 
198  a = state[0]; b = state[1]; c = state[2]; d = state[3];
199  e = state[4]; f = state[5]; g = state[6]; h = state[7];
200 
201  for (n = 0; n < 16; n++)
202  block[n] = AV_RL32(buffer + 4 * n);
203  n = 0;
204 
205 #if CONFIG_SMALL
206  for (; n < 16;) {
207  ROUND128_0_TO_15(a,b,c,d,e,f,g,h);
208  t = d; d = c; c = b; b = a; a = t;
209  t = h; h = g; g = f; f = e; e = t;
210  }
211  FFSWAP(uint32_t, a, e);
212 
213  for (; n < 32;) {
214  ROUND128_16_TO_31(a,b,c,d,e,f,g,h);
215  t = d; d = c; c = b; b = a; a = t;
216  t = h; h = g; g = f; f = e; e = t;
217  }
218  FFSWAP(uint32_t, b, f);
219 
220  for (; n < 48;) {
221  ROUND128_32_TO_47(a,b,c,d,e,f,g,h);
222  t = d; d = c; c = b; b = a; a = t;
223  t = h; h = g; g = f; f = e; e = t;
224  }
225  FFSWAP(uint32_t, c, g);
226 
227  for (; n < 64;) {
228  ROUND128_48_TO_63(a,b,c,d,e,f,g,h);
229  t = d; d = c; c = b; b = a; a = t;
230  t = h; h = g; g = f; f = e; e = t;
231  }
232  FFSWAP(uint32_t, d, h);
233 #else
234 
235  R128_0; R128_0; R128_0; R128_0;
236  FFSWAP(uint32_t, a, e);
237 
238  R128_16; R128_16; R128_16; R128_16;
239  FFSWAP(uint32_t, b, f);
240 
241  R128_32; R128_32; R128_32; R128_32;
242  FFSWAP(uint32_t, c, g);
243 
244  R128_48; R128_48; R128_48; R128_48;
245  FFSWAP(uint32_t, d, h);
246 #endif
247 
248  state[0] += a; state[1] += b; state[2] += c; state[3] += d;
249  state[4] += e; state[5] += f; state[6] += g; state[7] += h;
250 }
251 
252 #define ROTATE(x,y) \
253  x = rol(x, 10); \
254  y = rol(y, 10); \
255  n++
256 
257 #define ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j) \
258  a = rol(a + (( b ^ c ^ d) + block[WA[n]]), ROTA[n]) + e; \
259  f = rol(f + (((~i | h) ^ g) + block[WB[n]] + KB[0]), ROTB[n]) + j; \
260  ROTATE(c,h)
261 
262 #define ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j) \
263  a = rol(a + ((((c ^ d) & b) ^ d) + block[WA[n]] + KA[0]), ROTA[n]) + e; \
264  f = rol(f + ((((g ^ h) & i) ^ h) + block[WB[n]] + KB[1]), ROTB[n]) + j; \
265  ROTATE(c,h)
266 
267 #define ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j) \
268  a = rol(a + (((~c | b) ^ d) + block[WA[n]] + KA[1]), ROTA[n]) + e; \
269  f = rol(f + (((~h | g) ^ i) + block[WB[n]] + KB[2]), ROTB[n]) + j; \
270  ROTATE(c,h)
271 
272 #define ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j) \
273  a = rol(a + ((((b ^ c) & d) ^ c) + block[WA[n]] + KA[2]), ROTA[n]) + e; \
274  f = rol(f + ((((h ^ i) & g) ^ i) + block[WB[n]] + KB[3]), ROTB[n]) + j; \
275  ROTATE(c,h)
276 
277 #define ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j) \
278  a = rol(a + (((~d | c) ^ b) + block[WA[n]] + KA[3]), ROTA[n]) + e; \
279  f = rol(f + (( g ^ h ^ i) + block[WB[n]]), ROTB[n]) + j; \
280  ROTATE(c,h)
281 
282 #define R160_0 \
283  ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j); \
284  ROUND160_0_TO_15(e,a,b,c,d,j,f,g,h,i); \
285  ROUND160_0_TO_15(d,e,a,b,c,i,j,f,g,h); \
286  ROUND160_0_TO_15(c,d,e,a,b,h,i,j,f,g); \
287  ROUND160_0_TO_15(b,c,d,e,a,g,h,i,j,f)
288 
289 #define R160_16 \
290  ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i); \
291  ROUND160_16_TO_31(d,e,a,b,c,i,j,f,g,h); \
292  ROUND160_16_TO_31(c,d,e,a,b,h,i,j,f,g); \
293  ROUND160_16_TO_31(b,c,d,e,a,g,h,i,j,f); \
294  ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j)
295 
296 #define R160_32 \
297  ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h); \
298  ROUND160_32_TO_47(c,d,e,a,b,h,i,j,f,g); \
299  ROUND160_32_TO_47(b,c,d,e,a,g,h,i,j,f); \
300  ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j); \
301  ROUND160_32_TO_47(e,a,b,c,d,j,f,g,h,i)
302 
303 #define R160_48 \
304  ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g); \
305  ROUND160_48_TO_63(b,c,d,e,a,g,h,i,j,f); \
306  ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j); \
307  ROUND160_48_TO_63(e,a,b,c,d,j,f,g,h,i); \
308  ROUND160_48_TO_63(d,e,a,b,c,i,j,f,g,h)
309 
310 #define R160_64 \
311  ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f); \
312  ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j); \
313  ROUND160_64_TO_79(e,a,b,c,d,j,f,g,h,i); \
314  ROUND160_64_TO_79(d,e,a,b,c,i,j,f,g,h); \
315  ROUND160_64_TO_79(c,d,e,a,b,h,i,j,f,g)
316 
317 static void ripemd160_transform(uint32_t *state, const uint8_t buffer[64])
318 {
319  uint32_t a, b, c, d, e, f, g, h, i, j, av_unused t;
320  uint32_t block[16];
321  int n;
322 
323  a = f = state[0];
324  b = g = state[1];
325  c = h = state[2];
326  d = i = state[3];
327  e = j = state[4];
328 
329  for (n = 0; n < 16; n++)
330  block[n] = AV_RL32(buffer + 4 * n);
331  n = 0;
332 
333 #if CONFIG_SMALL
334  for (; n < 16;) {
335  ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
336  t = e; e = d; d = c; c = b; b = a; a = t;
337  t = j; j = i; i = h; h = g; g = f; f = t;
338  }
339 
340  for (; n < 32;) {
341  ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j);
342  t = e; e = d; d = c; c = b; b = a; a = t;
343  t = j; j = i; i = h; h = g; g = f; f = t;
344  }
345 
346  for (; n < 48;) {
347  ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j);
348  t = e; e = d; d = c; c = b; b = a; a = t;
349  t = j; j = i; i = h; h = g; g = f; f = t;
350  }
351 
352  for (; n < 64;) {
353  ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j);
354  t = e; e = d; d = c; c = b; b = a; a = t;
355  t = j; j = i; i = h; h = g; g = f; f = t;
356  }
357 
358  for (; n < 80;) {
359  ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j);
360  t = e; e = d; d = c; c = b; b = a; a = t;
361  t = j; j = i; i = h; h = g; g = f; f = t;
362  }
363 #else
364 
365  R160_0; R160_0; R160_0;
366  ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
367 
368  R160_16; R160_16; R160_16;
369  ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i);
370 
371  R160_32; R160_32; R160_32;
372  ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h);
373 
374  R160_48; R160_48; R160_48;
375  ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g);
376 
377  R160_64; R160_64; R160_64;
378  ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f);
379 #endif
380 
381  i += c + state[1];
382  state[1] = state[2] + d + j;
383  state[2] = state[3] + e + f;
384  state[3] = state[4] + a + g;
385  state[4] = state[0] + b + h;
386  state[0] = i;
387 }
388 
389 static void ripemd320_transform(uint32_t *state, const uint8_t buffer[64])
390 {
391  uint32_t a, b, c, d, e, f, g, h, i, j, av_unused t;
392  uint32_t block[16];
393  int n;
394 
395  a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4];
396  f = state[5]; g = state[6]; h = state[7]; i = state[8]; j = state[9];
397 
398  for (n = 0; n < 16; n++)
399  block[n] = AV_RL32(buffer + 4 * n);
400  n = 0;
401 
402 #if CONFIG_SMALL
403  for (; n < 16;) {
404  ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
405  t = e; e = d; d = c; c = b; b = a; a = t;
406  t = j; j = i; i = h; h = g; g = f; f = t;
407  }
408  FFSWAP(uint32_t, b, g);
409 
410  for (; n < 32;) {
411  ROUND160_16_TO_31(a,b,c,d,e,f,g,h,i,j);
412  t = e; e = d; d = c; c = b; b = a; a = t;
413  t = j; j = i; i = h; h = g; g = f; f = t;
414  }
415  FFSWAP(uint32_t, d, i);
416 
417  for (; n < 48;) {
418  ROUND160_32_TO_47(a,b,c,d,e,f,g,h,i,j);
419  t = e; e = d; d = c; c = b; b = a; a = t;
420  t = j; j = i; i = h; h = g; g = f; f = t;
421  }
422  FFSWAP(uint32_t, a, f);
423 
424  for (; n < 64;) {
425  ROUND160_48_TO_63(a,b,c,d,e,f,g,h,i,j);
426  t = e; e = d; d = c; c = b; b = a; a = t;
427  t = j; j = i; i = h; h = g; g = f; f = t;
428  }
429  FFSWAP(uint32_t, c, h);
430 
431  for (; n < 80;) {
432  ROUND160_64_TO_79(a,b,c,d,e,f,g,h,i,j);
433  t = e; e = d; d = c; c = b; b = a; a = t;
434  t = j; j = i; i = h; h = g; g = f; f = t;
435  }
436  FFSWAP(uint32_t, e, j);
437 #else
438 
439  R160_0; R160_0; R160_0;
440  ROUND160_0_TO_15(a,b,c,d,e,f,g,h,i,j);
441  FFSWAP(uint32_t, a, f);
442 
443  R160_16; R160_16; R160_16;
444  ROUND160_16_TO_31(e,a,b,c,d,j,f,g,h,i);
445  FFSWAP(uint32_t, b, g);
446 
447  R160_32; R160_32; R160_32;
448  ROUND160_32_TO_47(d,e,a,b,c,i,j,f,g,h);
449  FFSWAP(uint32_t, c, h);
450 
451  R160_48; R160_48; R160_48;
452  ROUND160_48_TO_63(c,d,e,a,b,h,i,j,f,g);
453  FFSWAP(uint32_t, d, i);
454 
455  R160_64; R160_64; R160_64;
456  ROUND160_64_TO_79(b,c,d,e,a,g,h,i,j,f);
457  FFSWAP(uint32_t, e, j);
458 #endif
459 
460  state[0] += a; state[1] += b; state[2] += c; state[3] += d; state[4] += e;
461  state[5] += f; state[6] += g; state[7] += h; state[8] += i; state[9] += j;
462 }
463 
464 av_cold int av_ripemd_init(AVRIPEMD *ctx, int bits)
465 {
466  ctx->digest_len = bits >> 5;
467  switch (bits) {
468  case 128: // RIPEMD-128
469  ctx->state[0] = 0x67452301;
470  ctx->state[1] = 0xEFCDAB89;
471  ctx->state[2] = 0x98BADCFE;
472  ctx->state[3] = 0x10325476;
473  ctx->transform = ripemd128_transform;
474  break;
475  case 160: // RIPEMD-160
476  ctx->state[0] = 0x67452301;
477  ctx->state[1] = 0xEFCDAB89;
478  ctx->state[2] = 0x98BADCFE;
479  ctx->state[3] = 0x10325476;
480  ctx->state[4] = 0xC3D2E1F0;
481  ctx->transform = ripemd160_transform;
482  break;
483  case 256: // RIPEMD-256
484  ctx->state[0] = 0x67452301;
485  ctx->state[1] = 0xEFCDAB89;
486  ctx->state[2] = 0x98BADCFE;
487  ctx->state[3] = 0x10325476;
488  ctx->state[4] = 0x76543210;
489  ctx->state[5] = 0xFEDCBA98;
490  ctx->state[6] = 0x89ABCDEF;
491  ctx->state[7] = 0x01234567;
492  ctx->transform = ripemd256_transform;
493  break;
494  case 320: // RIPEMD-320
495  ctx->state[0] = 0x67452301;
496  ctx->state[1] = 0xEFCDAB89;
497  ctx->state[2] = 0x98BADCFE;
498  ctx->state[3] = 0x10325476;
499  ctx->state[4] = 0xC3D2E1F0;
500  ctx->state[5] = 0x76543210;
501  ctx->state[6] = 0xFEDCBA98;
502  ctx->state[7] = 0x89ABCDEF;
503  ctx->state[8] = 0x01234567;
504  ctx->state[9] = 0x3C2D1E0F;
505  ctx->transform = ripemd320_transform;
506  break;
507  default:
508  return AVERROR(EINVAL);
509  }
510  ctx->count = 0;
511  return 0;
512 }
513 
514 void av_ripemd_update(AVRIPEMD* ctx, const uint8_t* data, size_t len)
515 {
516  unsigned int j;
517  size_t i;
518 
519  j = ctx->count & 63;
520  ctx->count += len;
521 #if CONFIG_SMALL
522  for (i = 0; i < len; i++) {
523  ctx->buffer[j++] = data[i];
524  if (64 == j) {
525  ctx->transform(ctx->state, ctx->buffer);
526  j = 0;
527  }
528  }
529 #else
530  if (len >= 64 - j) {
531  const uint8_t *end;
532  memcpy(&ctx->buffer[j], data, (i = 64 - j));
533  ctx->transform(ctx->state, ctx->buffer);
534  data += i;
535  len -= i;
536  end = data + (len & ~63);
537  len = len % 64;
538  for (; data < end; data += 64)
539  ctx->transform(ctx->state, data);
540  j = 0;
541  }
542  memcpy(&ctx->buffer[j], data, len);
543 #endif
544 }
545 
546 void av_ripemd_final(AVRIPEMD* ctx, uint8_t *digest)
547 {
548  int i;
549  uint64_t finalcount = av_le2ne64(ctx->count << 3);
550 
551  av_ripemd_update(ctx, "\200", 1);
552  while ((ctx->count & 63) != 56)
553  av_ripemd_update(ctx, "", 1);
554  av_ripemd_update(ctx, (uint8_t *)&finalcount, 8); /* Should cause a transform() */
555  for (i = 0; i < ctx->digest_len; i++)
556  AV_WL32(digest + i*4, ctx->state[i]);
557 }
R160_48
#define R160_48
Definition: ripemd.c:303
WA
static const int WA[80]
Definition: ripemd.c:73
ROUND160_64_TO_79
#define ROUND160_64_TO_79(a, b, c, d, e, f, g, h, i, j)
Definition: ripemd.c:277
R128_48
#define R128_48
Definition: ripemd.c:129
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:426
AVRIPEMD::state
uint32_t state[10]
current hash value
Definition: ripemd.c:37
av_ripemd_alloc
struct AVRIPEMD * av_ripemd_alloc(void)
Allocate an AVRIPEMD context.
Definition: ripemd.c:44
KB
static const uint32_t KB[4]
Definition: ripemd.c:53
ROUND160_16_TO_31
#define ROUND160_16_TO_31(a, b, c, d, e, f, g, h, i, j)
Definition: ripemd.c:262
ROUND160_48_TO_63
#define ROUND160_48_TO_63(a, b, c, d, e, f, g, h, i, j)
Definition: ripemd.c:272
av_unused
#define av_unused
Definition: attributes.h:131
R128_0
#define R128_0
Definition: ripemd.c:111
b
#define b
Definition: input.c:40
data
const char data[16]
Definition: mxf.c:143
KA
static const uint32_t KA[4]
Definition: ripemd.c:49
R160_32
#define R160_32
Definition: ripemd.c:296
R160_64
#define R160_64
Definition: ripemd.c:310
ROTB
static const int ROTB[80]
Definition: ripemd.c:65
ROTA
static const int ROTA[80]
Definition: ripemd.c:57
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:36
intreadwrite.h
g
const char * g
Definition: vf_curves.c:117
ripemd.h
ROUND128_32_TO_47
#define ROUND128_32_TO_47(a, b, c, d, e, f, g, h)
Definition: ripemd.c:101
bits
uint8_t bits
Definition: vp3data.h:141
ctx
AVFormatContext * ctx
Definition: movenc.c:48
ROUND128_0_TO_15
#define ROUND128_0_TO_15(a, b, c, d, e, f, g, h)
Definition: ripemd.c:91
f
#define f(width, name)
Definition: cbs_vp9.c:255
R128_32
#define R128_32
Definition: ripemd.c:123
ROUND160_0_TO_15
#define ROUND160_0_TO_15(a, b, c, d, e, f, g, h, i, j)
Definition: ripemd.c:257
ripemd128_transform
static void ripemd128_transform(uint32_t *state, const uint8_t buffer[64])
Definition: ripemd.c:135
WB
static const int WB[80]
Definition: ripemd.c:81
av_ripemd_init
av_cold int av_ripemd_init(AVRIPEMD *ctx, int bits)
Initialize RIPEMD hashing.
Definition: ripemd.c:464
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:97
ROUND128_48_TO_63
#define ROUND128_48_TO_63(a, b, c, d, e, f, g, h)
Definition: ripemd.c:106
ripemd160_transform
static void ripemd160_transform(uint32_t *state, const uint8_t buffer[64])
Definition: ripemd.c:317
state
static struct @320 state
av_ripemd_final
void av_ripemd_final(AVRIPEMD *ctx, uint8_t *digest)
Finish hashing and output digest value.
Definition: ripemd.c:546
R128_16
#define R128_16
Definition: ripemd.c:117
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:33
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:39
ripemd256_transform
static void ripemd256_transform(uint32_t *state, const uint8_t buffer[64])
Definition: ripemd.c:192
R160_0
#define R160_0
Definition: ripemd.c:282
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVRIPEMD::digest_len
uint8_t digest_len
digest length in 32-bit words
Definition: ripemd.c:34
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:263
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:267
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:514
avutil.h
mem.h
d
d
Definition: ffmpeg_filter.c:153
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:2038
ROUND128_16_TO_31
#define ROUND128_16_TO_31(a, b, c, d, e, f, g, h)
Definition: ripemd.c:96
av_ripemd_size
const int av_ripemd_size
Definition: ripemd.c:42
R160_16
#define R160_16
Definition: ripemd.c:289
AVRIPEMD::count
uint64_t count
number of bytes in buffer
Definition: ripemd.c:35
ripemd320_transform
static void ripemd320_transform(uint32_t *state, const uint8_t buffer[64])
Definition: ripemd.c:389
Generated on Wed Aug 24 2022 21:38:31 for FFmpeg by   doxygen 1.8.17