aboutsummaryrefslogtreecommitdiff
path: root/src/plugins/hash/rmd160extractor.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/plugins/hash/rmd160extractor.c')
-rw-r--r--src/plugins/hash/rmd160extractor.c625
1 files changed, 0 insertions, 625 deletions
diff --git a/src/plugins/hash/rmd160extractor.c b/src/plugins/hash/rmd160extractor.c
deleted file mode 100644
index f0fef3d..0000000
--- a/src/plugins/hash/rmd160extractor.c
+++ /dev/null
@@ -1,625 +0,0 @@
1/*
2 This file is part of libextractor.
3 (C) 2004 Vidyut Samanta and Christian Grothoff
4 Copyright © 1999 - Philip Howard
5
6 libextractor is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published
8 by the Free Software Foundation; either version 2, or (at your
9 option) any later version.
10
11 libextractor is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with libextractor; see the file COPYING. If not, write to the
18 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.
20
21 RMD code:
22 package rmd160
23 version 1.2.1
24 homepage http://phil.ipal.org/freeware/rmd160/
25
26 author Philip Howard
27 email phil@ipal.org
28 homepage http://phil.ipal.org/
29
30 */
31
32#include "platform.h"
33#include "extractor.h"
34
35#if ULONG_MAX>4294967295U
36#if UINT_MAX>4294967295U
37#if USHRT_MAX>4294967295U
38#if UCHAR_MAX>=4294967295U
39typedef unsigned char rmd160uint32;
40#else
41typedef unsigned short rmd160uint32;
42#endif /*UCHAR_MAX */
43#else
44typedef unsigned int rmd160uint32;
45#endif /*USHRT_MAX */
46#else
47typedef unsigned long rmd160uint32;
48#endif /*UINT_MAX */
49#else
50typedef unsigned long rmd160uint32;
51#endif
52
53struct rmd160_object
54{
55 rmd160uint32 data[16];
56 rmd160uint32 state[5];
57 rmd160uint32 len[2];
58 rmd160uint32 *wptr;
59 rmd160uint32 *wend;
60 unsigned int bpos;
61};
62typedef struct rmd160_object *RMD160;
63
64#define RMD160_OK 0
65#define RMD160_ERR_INVALID_ARG 1
66#define RMD160_ERR_READ 2
67
68
69#define RMD160_BUFSIZ 1024
70
71#define RMD160_INIT0 0x67452301UL
72#define RMD160_INIT1 0xefcdab89UL
73#define RMD160_INIT2 0x98badcfeUL
74#define RMD160_INIT3 0x10325476UL
75#define RMD160_INIT4 0xc3d2e1f0UL
76
77static int
78_rmd160_calc (rmd160uint32 * state, rmd160uint32 * data)
79{
80 rmd160uint32 x0, x1, x2, x3, x4;
81 rmd160uint32 y0, y1, y2, y3, y4;
82
83 x0 = y0 = state[0];
84 x1 = y1 = state[1];
85 x2 = y2 = state[2];
86 x3 = y3 = state[3];
87 x4 = y4 = state[4];
88
89
90#define RL(x,n) (((x) << (n)) | ((x) >> (32-(n))))
91
92#define F1(x,y,z) ((x) ^ (y) ^ (z))
93#define F2(x,y,z) (((x) & (y)) | (~(x) & (z)))
94#define F3(x,y,z) (((x) | ~(y)) ^ (z))
95#define F4(x,y,z) (((x) & (z)) | ((y) & ~(z)))
96#define F5(x,y,z) ((x) ^ ((y) | ~(z)))
97
98#define T1(a,b,c,d,e,x,s) { \
99 (a) += F1((b),(c),(d)) + (x); \
100 (a) = RL((a),(s)) + (e); \
101 (c) = RL((c),10);}
102#define T2(a,b,c,d,e,x,s) { \
103 (a) += F2((b),(c),(d)) + (x) + 0x5a827999UL; \
104 (a) = RL((a),(s)) + (e); \
105 (c) = RL((c),10);}
106#define T3(a,b,c,d,e,x,s) { \
107 (a) += F3((b),(c),(d)) + (x) + 0x6ed9eba1UL; \
108 (a) = RL((a),(s)) + (e); \
109 (c) = RL((c),10);}
110#define T4(a,b,c,d,e,x,s) { \
111 (a) += F4((b),(c),(d)) + (x) + 0x8f1bbcdcUL; \
112 (a) = RL((a),(s)) + (e); \
113 (c) = RL((c),10);}
114#define T5(a,b,c,d,e,x,s) { \
115 (a) += F5((b),(c),(d)) + (x) + 0xa953fd4eUL; \
116 (a) = RL((a),(s)) + (e); \
117 (c) = RL((c),10);}
118
119#define S1(a,b,c,d,e,x,s) { \
120 (a) += F1((b),(c),(d)) + (x); \
121 (a) = RL((a),(s)) + (e); \
122 (c) = RL((c),10);}
123#define S2(a,b,c,d,e,x,s) { \
124 (a) += F2((b),(c),(d)) + (x) + 0x7a6d76e9UL; \
125 (a) = RL((a),(s)) + (e); \
126 (c) = RL((c),10);}
127#define S3(a,b,c,d,e,x,s) { \
128 (a) += F3((b),(c),(d)) + (x) + 0x6d703ef3UL; \
129 (a) = RL((a),(s)) + (e); \
130 (c) = RL((c),10);}
131#define S4(a,b,c,d,e,x,s) { \
132 (a) += F4((b),(c),(d)) + (x) + 0x5c4dd124UL; \
133 (a) = RL((a),(s)) + (e); \
134 (c) = RL((c),10);}
135#define S5(a,b,c,d,e,x,s) { \
136 (a) += F5((b),(c),(d)) + (x) + 0x50a28be6UL; \
137 (a) = RL((a),(s)) + (e); \
138 (c) = RL((c),10);}
139
140 T1 (x0, x1, x2, x3, x4, data[0], 11);
141 T1 (x4, x0, x1, x2, x3, data[1], 14);
142 T1 (x3, x4, x0, x1, x2, data[2], 15);
143 T1 (x2, x3, x4, x0, x1, data[3], 12);
144 T1 (x1, x2, x3, x4, x0, data[4], 5);
145 T1 (x0, x1, x2, x3, x4, data[5], 8);
146 T1 (x4, x0, x1, x2, x3, data[6], 7);
147 T1 (x3, x4, x0, x1, x2, data[7], 9);
148 T1 (x2, x3, x4, x0, x1, data[8], 11);
149 T1 (x1, x2, x3, x4, x0, data[9], 13);
150 T1 (x0, x1, x2, x3, x4, data[10], 14);
151 T1 (x4, x0, x1, x2, x3, data[11], 15);
152 T1 (x3, x4, x0, x1, x2, data[12], 6);
153 T1 (x2, x3, x4, x0, x1, data[13], 7);
154 T1 (x1, x2, x3, x4, x0, data[14], 9);
155 T1 (x0, x1, x2, x3, x4, data[15], 8);
156
157 T2 (x4, x0, x1, x2, x3, data[7], 7);
158 T2 (x3, x4, x0, x1, x2, data[4], 6);
159 T2 (x2, x3, x4, x0, x1, data[13], 8);
160 T2 (x1, x2, x3, x4, x0, data[1], 13);
161 T2 (x0, x1, x2, x3, x4, data[10], 11);
162 T2 (x4, x0, x1, x2, x3, data[6], 9);
163 T2 (x3, x4, x0, x1, x2, data[15], 7);
164 T2 (x2, x3, x4, x0, x1, data[3], 15);
165 T2 (x1, x2, x3, x4, x0, data[12], 7);
166 T2 (x0, x1, x2, x3, x4, data[0], 12);
167 T2 (x4, x0, x1, x2, x3, data[9], 15);
168 T2 (x3, x4, x0, x1, x2, data[5], 9);
169 T2 (x2, x3, x4, x0, x1, data[2], 11);
170 T2 (x1, x2, x3, x4, x0, data[14], 7);
171 T2 (x0, x1, x2, x3, x4, data[11], 13);
172 T2 (x4, x0, x1, x2, x3, data[8], 12);
173
174 T3 (x3, x4, x0, x1, x2, data[3], 11);
175 T3 (x2, x3, x4, x0, x1, data[10], 13);
176 T3 (x1, x2, x3, x4, x0, data[14], 6);
177 T3 (x0, x1, x2, x3, x4, data[4], 7);
178 T3 (x4, x0, x1, x2, x3, data[9], 14);
179 T3 (x3, x4, x0, x1, x2, data[15], 9);
180 T3 (x2, x3, x4, x0, x1, data[8], 13);
181 T3 (x1, x2, x3, x4, x0, data[1], 15);
182 T3 (x0, x1, x2, x3, x4, data[2], 14);
183 T3 (x4, x0, x1, x2, x3, data[7], 8);
184 T3 (x3, x4, x0, x1, x2, data[0], 13);
185 T3 (x2, x3, x4, x0, x1, data[6], 6);
186 T3 (x1, x2, x3, x4, x0, data[13], 5);
187 T3 (x0, x1, x2, x3, x4, data[11], 12);
188 T3 (x4, x0, x1, x2, x3, data[5], 7);
189 T3 (x3, x4, x0, x1, x2, data[12], 5);
190
191 T4 (x2, x3, x4, x0, x1, data[1], 11);
192 T4 (x1, x2, x3, x4, x0, data[9], 12);
193 T4 (x0, x1, x2, x3, x4, data[11], 14);
194 T4 (x4, x0, x1, x2, x3, data[10], 15);
195 T4 (x3, x4, x0, x1, x2, data[0], 14);
196 T4 (x2, x3, x4, x0, x1, data[8], 15);
197 T4 (x1, x2, x3, x4, x0, data[12], 9);
198 T4 (x0, x1, x2, x3, x4, data[4], 8);
199 T4 (x4, x0, x1, x2, x3, data[13], 9);
200 T4 (x3, x4, x0, x1, x2, data[3], 14);
201 T4 (x2, x3, x4, x0, x1, data[7], 5);
202 T4 (x1, x2, x3, x4, x0, data[15], 6);
203 T4 (x0, x1, x2, x3, x4, data[14], 8);
204 T4 (x4, x0, x1, x2, x3, data[5], 6);
205 T4 (x3, x4, x0, x1, x2, data[6], 5);
206 T4 (x2, x3, x4, x0, x1, data[2], 12);
207
208 T5 (x1, x2, x3, x4, x0, data[4], 9);
209 T5 (x0, x1, x2, x3, x4, data[0], 15);
210 T5 (x4, x0, x1, x2, x3, data[5], 5);
211 T5 (x3, x4, x0, x1, x2, data[9], 11);
212 T5 (x2, x3, x4, x0, x1, data[7], 6);
213 T5 (x1, x2, x3, x4, x0, data[12], 8);
214 T5 (x0, x1, x2, x3, x4, data[2], 13);
215 T5 (x4, x0, x1, x2, x3, data[10], 12);
216 T5 (x3, x4, x0, x1, x2, data[14], 5);
217 T5 (x2, x3, x4, x0, x1, data[1], 12);
218 T5 (x1, x2, x3, x4, x0, data[3], 13);
219 T5 (x0, x1, x2, x3, x4, data[8], 14);
220 T5 (x4, x0, x1, x2, x3, data[11], 11);
221 T5 (x3, x4, x0, x1, x2, data[6], 8);
222 T5 (x2, x3, x4, x0, x1, data[15], 5);
223 T5 (x1, x2, x3, x4, x0, data[13], 6);
224
225 S5 (y0, y1, y2, y3, y4, data[5], 8);
226 S5 (y4, y0, y1, y2, y3, data[14], 9);
227 S5 (y3, y4, y0, y1, y2, data[7], 9);
228 S5 (y2, y3, y4, y0, y1, data[0], 11);
229 S5 (y1, y2, y3, y4, y0, data[9], 13);
230 S5 (y0, y1, y2, y3, y4, data[2], 15);
231 S5 (y4, y0, y1, y2, y3, data[11], 15);
232 S5 (y3, y4, y0, y1, y2, data[4], 5);
233 S5 (y2, y3, y4, y0, y1, data[13], 7);
234 S5 (y1, y2, y3, y4, y0, data[6], 7);
235 S5 (y0, y1, y2, y3, y4, data[15], 8);
236 S5 (y4, y0, y1, y2, y3, data[8], 11);
237 S5 (y3, y4, y0, y1, y2, data[1], 14);
238 S5 (y2, y3, y4, y0, y1, data[10], 14);
239 S5 (y1, y2, y3, y4, y0, data[3], 12);
240 S5 (y0, y1, y2, y3, y4, data[12], 6);
241
242 S4 (y4, y0, y1, y2, y3, data[6], 9);
243 S4 (y3, y4, y0, y1, y2, data[11], 13);
244 S4 (y2, y3, y4, y0, y1, data[3], 15);
245 S4 (y1, y2, y3, y4, y0, data[7], 7);
246 S4 (y0, y1, y2, y3, y4, data[0], 12);
247 S4 (y4, y0, y1, y2, y3, data[13], 8);
248 S4 (y3, y4, y0, y1, y2, data[5], 9);
249 S4 (y2, y3, y4, y0, y1, data[10], 11);
250 S4 (y1, y2, y3, y4, y0, data[14], 7);
251 S4 (y0, y1, y2, y3, y4, data[15], 7);
252 S4 (y4, y0, y1, y2, y3, data[8], 12);
253 S4 (y3, y4, y0, y1, y2, data[12], 7);
254 S4 (y2, y3, y4, y0, y1, data[4], 6);
255 S4 (y1, y2, y3, y4, y0, data[9], 15);
256 S4 (y0, y1, y2, y3, y4, data[1], 13);
257 S4 (y4, y0, y1, y2, y3, data[2], 11);
258
259 S3 (y3, y4, y0, y1, y2, data[15], 9);
260 S3 (y2, y3, y4, y0, y1, data[5], 7);
261 S3 (y1, y2, y3, y4, y0, data[1], 15);
262 S3 (y0, y1, y2, y3, y4, data[3], 11);
263 S3 (y4, y0, y1, y2, y3, data[7], 8);
264 S3 (y3, y4, y0, y1, y2, data[14], 6);
265 S3 (y2, y3, y4, y0, y1, data[6], 6);
266 S3 (y1, y2, y3, y4, y0, data[9], 14);
267 S3 (y0, y1, y2, y3, y4, data[11], 12);
268 S3 (y4, y0, y1, y2, y3, data[8], 13);
269 S3 (y3, y4, y0, y1, y2, data[12], 5);
270 S3 (y2, y3, y4, y0, y1, data[2], 14);
271 S3 (y1, y2, y3, y4, y0, data[10], 13);
272 S3 (y0, y1, y2, y3, y4, data[0], 13);
273 S3 (y4, y0, y1, y2, y3, data[4], 7);
274 S3 (y3, y4, y0, y1, y2, data[13], 5);
275
276 S2 (y2, y3, y4, y0, y1, data[8], 15);
277 S2 (y1, y2, y3, y4, y0, data[6], 5);
278 S2 (y0, y1, y2, y3, y4, data[4], 8);
279 S2 (y4, y0, y1, y2, y3, data[1], 11);
280 S2 (y3, y4, y0, y1, y2, data[3], 14);
281 S2 (y2, y3, y4, y0, y1, data[11], 14);
282 S2 (y1, y2, y3, y4, y0, data[15], 6);
283 S2 (y0, y1, y2, y3, y4, data[0], 14);
284 S2 (y4, y0, y1, y2, y3, data[5], 6);
285 S2 (y3, y4, y0, y1, y2, data[12], 9);
286 S2 (y2, y3, y4, y0, y1, data[2], 12);
287 S2 (y1, y2, y3, y4, y0, data[13], 9);
288 S2 (y0, y1, y2, y3, y4, data[9], 12);
289 S2 (y4, y0, y1, y2, y3, data[7], 5);
290 S2 (y3, y4, y0, y1, y2, data[10], 15);
291 S2 (y2, y3, y4, y0, y1, data[14], 8);
292
293 S1 (y1, y2, y3, y4, y0, data[12], 8);
294 S1 (y0, y1, y2, y3, y4, data[15], 5);
295 S1 (y4, y0, y1, y2, y3, data[10], 12);
296 S1 (y3, y4, y0, y1, y2, data[4], 9);
297 S1 (y2, y3, y4, y0, y1, data[1], 12);
298 S1 (y1, y2, y3, y4, y0, data[5], 5);
299 S1 (y0, y1, y2, y3, y4, data[8], 14);
300 S1 (y4, y0, y1, y2, y3, data[7], 6);
301 S1 (y3, y4, y0, y1, y2, data[6], 8);
302 S1 (y2, y3, y4, y0, y1, data[2], 13);
303 S1 (y1, y2, y3, y4, y0, data[13], 6);
304 S1 (y0, y1, y2, y3, y4, data[14], 5);
305 S1 (y4, y0, y1, y2, y3, data[0], 15);
306 S1 (y3, y4, y0, y1, y2, data[3], 13);
307 S1 (y2, y3, y4, y0, y1, data[9], 11);
308 S1 (y1, y2, y3, y4, y0, data[11], 11);
309
310 y3 += x2 + state[1];
311 state[1] = state[2] + x3 + y4;
312 state[2] = state[3] + x4 + y0;
313 state[3] = state[4] + x0 + y1;
314 state[4] = state[0] + x1 + y2;
315 state[0] = y3;
316
317 return RMD160_OK;
318}
319
320
321static int
322rmd160_append (RMD160 arg_obj, size_t arg_len, const unsigned char *arg_data)
323{
324 size_t alen;
325
326 rmd160uint32 *wend;
327 rmd160uint32 *wptr;
328
329 unsigned int bpos;
330
331
332 if (!arg_obj)
333 return RMD160_ERR_INVALID_ARG;
334
335 if (arg_len == 0)
336 return RMD160_OK;
337 if (!arg_data)
338 return RMD160_ERR_INVALID_ARG;
339
340 alen = arg_len;
341 wend = arg_obj->wend;
342 wptr = arg_obj->wptr;
343 bpos = arg_obj->bpos;
344
345 if (bpos)
346 {
347 register rmd160uint32 w;
348 w = *wptr;
349 if (bpos == 1)
350 {
351 w |= ((rmd160uint32) (0xff & *(arg_data++))) << 8;
352 --alen;
353 ++bpos;
354 }
355 if (bpos == 2 && alen)
356 {
357 w |= ((rmd160uint32) (0xff & *(arg_data++))) << 16;
358 --alen;
359 ++bpos;
360 }
361 if (bpos == 3 && alen)
362 {
363 w |= ((rmd160uint32) (0xff & *(arg_data++))) << 24;
364 --alen;
365 ++bpos;
366 }
367 *wptr = w;
368 if (!alen)
369 {
370 arg_obj->wptr = wptr;
371 arg_obj->bpos = bpos;
372 if ((arg_obj->len[0] = arg_len + arg_obj->len[0]) < arg_len)
373 {
374 arg_obj->len[1]++;
375 }
376 return RMD160_OK;
377 }
378 bpos = 0;
379 ++wptr;
380 }
381
382 for (;;)
383 {
384 while (alen >= 4 && wptr < wend)
385 {
386
387#if defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN
388 *wptr = *(const rmd160uint32 *) arg_data;
389#else
390 *wptr =
391 ((rmd160uint32) (0xff & arg_data[0])) |
392 ((rmd160uint32) (0xff & arg_data[1])) << 8 |
393 ((rmd160uint32) (0xff & arg_data[2])) << 16 |
394 ((rmd160uint32) (0xff & arg_data[3])) << 24;
395#endif
396
397 ++wptr;
398 arg_data += 4;
399 alen -= 4;
400 }
401 if (wptr < wend)
402 break;
403 _rmd160_calc (arg_obj->state, arg_obj->data);
404 wptr = arg_obj->data;
405 }
406
407 if (alen)
408 {
409 rmd160uint32 w;
410 w = ((rmd160uint32) (0xff & *(arg_data++)));
411 if (alen >= 2)
412 {
413 w |= ((rmd160uint32) (0xff & *(arg_data++))) << 8;
414 if (alen >= 3)
415 {
416 w |= ((rmd160uint32) (0xff & *(arg_data++))) << 16;
417 }
418 }
419 bpos = alen;
420 *wptr = w;
421 }
422
423 arg_obj->wptr = wptr;
424 arg_obj->bpos = bpos;
425 if ((arg_obj->len[0] = arg_len + arg_obj->len[0]) < arg_len)
426 {
427 arg_obj->len[1]++;
428 }
429 return RMD160_OK;
430
431}
432
433
434static int
435rmd160_destroy (RMD160 ptr)
436{
437 if (!ptr)
438 {
439 return RMD160_ERR_INVALID_ARG;
440 }
441 free (ptr);
442 return RMD160_OK;
443}
444
445
446
447static RMD160
448rmd160_copy (RMD160 target_p, RMD160 source_p)
449{
450 if (!target_p)
451 {
452 if (!
453 (target_p =
454 (struct rmd160_object *) malloc (sizeof (struct rmd160_object))))
455 {
456 return NULL;
457 }
458 }
459
460 if (source_p)
461 {
462 target_p->state[0] = source_p->state[0];
463 target_p->state[1] = source_p->state[1];
464 target_p->state[2] = source_p->state[2];
465 target_p->state[3] = source_p->state[3];
466 target_p->state[4] = source_p->state[4];
467 {
468 int i;
469 for (i = 0; i < 16; ++i)
470 {
471 target_p->data[i] = source_p->data[i];
472 }
473 }
474 target_p->len[0] = source_p->len[0];
475 target_p->len[1] = source_p->len[1];
476 target_p->bpos = source_p->bpos;
477 target_p->wptr = source_p->wptr - source_p->data + target_p->data;
478 target_p->wend = 16 + target_p->data;
479 }
480 else
481 {
482 target_p->state[0] = RMD160_INIT0;
483 target_p->state[1] = RMD160_INIT1;
484 target_p->state[2] = RMD160_INIT2;
485 target_p->state[3] = RMD160_INIT3;
486 target_p->state[4] = RMD160_INIT4;
487 {
488 int i;
489 for (i = 0; i < 16; ++i)
490 {
491 target_p->data[i] = 0U;
492 }
493 }
494 target_p->len[0] = 0U;
495 target_p->len[1] = 0U;
496 target_p->bpos = 0;
497 target_p->wptr = target_p->data;
498 target_p->wend = 16 + target_p->data;
499 }
500
501 return target_p;
502}
503
504
505
506static rmd160uint32 *
507rmd160_sum_words (RMD160 arg_handle, rmd160uint32 * arg_result_p)
508{
509 struct rmd160_object work;
510
511
512 if (!arg_handle)
513 return NULL;
514
515 if (!arg_result_p
516 && !(arg_result_p =
517 (rmd160uint32 *) malloc (5 * sizeof (rmd160uint32))))
518 {
519 return NULL;
520 }
521
522 rmd160_copy (&work, arg_handle);
523
524 {
525 rmd160uint32 *p;
526 p = work.wptr;
527 if (work.bpos)
528 ++p;
529 while (p < work.wend)
530 *(p++) = 0U;
531 }
532 *(work.wptr) |= ((rmd160uint32) 0x80) << (work.bpos << 3);
533
534 if ((work.wend - work.wptr) <= 2)
535 {
536 _rmd160_calc (work.state, work.data);
537
538 memset (work.data, 0U, 14 * sizeof (rmd160uint32));
539 }
540
541 work.data[14] = work.len[0] << 3;
542 work.data[15] = (work.len[1] << 3) | (work.len[0] >> 29);
543
544 _rmd160_calc (work.state, work.data);
545
546 memcpy (arg_result_p, work.state, 5 * sizeof (rmd160uint32));
547
548 return arg_result_p;
549
550}
551
552
553
554static void
555rmd160_sum_bytes (RMD160 arg_handle, unsigned char *result_p)
556{
557 rmd160uint32 temp[5];
558 rmd160uint32 *ptemp;
559
560 if (!rmd160_sum_words (arg_handle, temp))
561 return;
562
563 ptemp = temp;
564 {
565 int i;
566 for (i = 0; i < 5; ++i)
567 {
568 rmd160uint32 w;
569 *(result_p++) = 0xff & (w = *ptemp);
570 *(result_p++) = 0xff & (w >> 8);
571 *(result_p++) = 0xff & (w >> 16);
572 *(result_p++) = 0xff & (w >> 24);
573 ++ptemp;
574 }
575 }
576}
577
578
579
580static struct EXTRACTOR_Keywords *
581addKeyword (EXTRACTOR_KeywordList * oldhead,
582 const char *phrase, EXTRACTOR_KeywordType type)
583{
584
585 EXTRACTOR_KeywordList *keyword;
586 keyword = malloc (sizeof (EXTRACTOR_KeywordList));
587 keyword->next = oldhead;
588 keyword->keyword = strdup (phrase);
589 keyword->keywordType = type;
590 return keyword;
591}
592
593#define DIGEST_BITS 160
594#define DIGEST_HEX_BYTES (DIGEST_BITS / 4)
595#define DIGEST_BIN_BYTES (DIGEST_BITS / 8)
596#define MAX_DIGEST_BIN_BYTES DIGEST_BIN_BYTES
597#define rmd160_init(t) rmd160_copy((t),NULL)
598#define rmd160_new() rmd160_copy(NULL,NULL)
599
600
601struct EXTRACTOR_Keywords *
602libextractor_hash_rmd160_extract (const char *filename,
603 const unsigned char *data,
604 size_t size,
605 struct EXTRACTOR_Keywords *prev)
606{
607 unsigned char bin_buffer[MAX_DIGEST_BIN_BYTES];
608 char hash[8 * MAX_DIGEST_BIN_BYTES];
609 char buf[16];
610 RMD160 ptr;
611 int i;
612
613 ptr = rmd160_new ();
614 rmd160_append (ptr, size, data);
615 rmd160_sum_bytes (ptr, bin_buffer);
616 rmd160_destroy (ptr);
617 hash[0] = '\0';
618 for (i = 0; i < DIGEST_HEX_BYTES / 2; i++)
619 {
620 snprintf (buf, 16, "%02x", bin_buffer[i]);
621 strcat (hash, buf);
622 }
623 prev = addKeyword (prev, hash, EXTRACTOR_HASH_RMD160);
624 return prev;
625}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-15 02:30:09 +0000