source: branches/samhain_3_1/src/cutest_sh_tiger0.c@ 555

Last change on this file since 555 was 444, checked in by katerina, 11 years ago

Support for sha2-256 checksum (ticket #348).
File size: 15.1 KB
Line 
1
2#include "config_xor.h"
3
4#include <string.h>
5#include <stdlib.h>
6#include <stdio.h>
7#include "CuTest.h"
8
9#include "sh_tiger.h"
10#include "sh_checksum.h"
11
12#if defined(HAVE_PTHREAD) && defined(SH_STEALTH)
13extern void sh_g_init(void);
14#endif
15
16
17static void init(void) {
18
19 extern unsigned char TcpFlag[8][PW_LEN+1];
20 extern UINT32 ErrFlag[2];
21 unsigned char * dez = NULL;
22 int i;
23
24#if defined(HAVE_PTHREAD) && defined(SH_STEALTH)
25 sh_g_init();
26#endif
27 skey = (sh_key_t *) malloc (sizeof(sh_key_t));
28 if (skey != NULL)
29 {
30 skey->mlock_failed = SL_FALSE;
31 skey->rngI = BAD;
32 /* properly initialized later
33 */
34 skey->rng0[0] = 0x03; skey->rng0[1] = 0x09; skey->rng0[2] = 0x17;
35 skey->rng1[0] = 0x03; skey->rng1[1] = 0x09; skey->rng1[2] = 0x17;
36 skey->rng2[0] = 0x03; skey->rng2[1] = 0x09; skey->rng2[2] = 0x17;
37
38 for (i = 0; i < KEY_BYT; ++i)
39 skey->poolv[i] = '\0';
40
41 skey->poolc = 0;
42
43 skey->ErrFlag[0] = ErrFlag[0];
44 ErrFlag[0] = 0;
45 skey->ErrFlag[1] = ErrFlag[1];
46 ErrFlag[1] = 0;
47
48 dez = &(TcpFlag[POS_TF-1][0]);
49 for (i = 0; i < PW_LEN; ++i)
50 {
51 skey->pw[i] = (char) (*dez);
52 (*dez) = '\0';
53 ++dez;
54 }
55
56 skey->sh_sockpass[0] = '\0';
57 skey->sigkey_old[0] = '\0';
58 skey->sigkey_new[0] = '\0';
59 skey->mailkey_old[0] = '\0';
60 skey->mailkey_new[0] = '\0';
61 skey->crypt[0] = '\0';
62 skey->session[0] = '\0';
63 skey->vernam[0] = '\0';
64 }
65 else
66 {
67 perror(_("sh_init"));
68 _exit (EXIT_FAILURE);
69 }
70
71}
72
73void Test_tiger(CuTest *tc) {
74
75 char * input;
76 char * actual;
77 char * expected;
78 char hashbuf[KEYBUF_SIZE];
79
80#if defined(HAVE_PTHREAD) && defined(SH_STEALTH)
81 sh_g_init();
82#endif
83
84 input = "";
85 actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
86 expected = "24F0130C63AC933216166E76B1BB925FF373DE2D49584E7A";
87 CuAssertStrEquals(tc, expected, actual);
88
89 input = "abc";
90 actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
91 expected = "F258C1E88414AB2A527AB541FFC5B8BF935F7B951C132951";
92 CuAssertStrEquals(tc, expected, actual);
93
94 input = "Tiger";
95 actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
96 expected = "9F00F599072300DD276ABB38C8EB6DEC37790C116F9D2BDF";
97 CuAssertStrEquals(tc, expected, actual);
98
99 input = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-";
100 actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
101 expected = "87FB2A9083851CF7470D2CF810E6DF9EB586445034A5A386";
102 CuAssertStrEquals(tc, expected, actual);
103
104 input = "ABCDEFGHIJKLMNOPQRSTUVWXYZ=abcdefghijklmnopqrstuvwxyz+0123456789";
105 actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
106 expected = "467DB80863EBCE488DF1CD1261655DE957896565975F9197";
107 CuAssertStrEquals(tc, expected, actual);
108
109 input = "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham";
110 actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
111 expected = "0C410A042968868A1671DA5A3FD29A725EC1E457D3CDB303";
112 CuAssertStrEquals(tc, expected, actual);
113
114 input = "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham, proceedings of Fast Software Encryption 3, Cambridge.";
115 actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
116 expected = "EBF591D5AFA655CE7F22894FF87F54AC89C811B6B0DA3193";
117 CuAssertStrEquals(tc, expected, actual);
118
119 input = "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham, proceedings of Fast Software Encryption 3, Cambridge, 1996.";
120 actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
121 expected = "3D9AEB03D1BD1A6357B2774DFD6D5B24DD68151D503974FC";
122 CuAssertStrEquals(tc, expected, actual);
123
124 input = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-";
125 actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
126 expected = "00B83EB4E53440C576AC6AAEE0A7485825FD15E70A59FFE4";
127 CuAssertStrEquals(tc, expected, actual);
128}
129
130void Test_tiger_file(CuTest *tc) {
131
132 SL_TICKET rval_open;
133 FILE * fp;
134 int result;
135 char * actual;
136 char * expected;
137 char hashbuf[KEYBUF_SIZE];
138 char hexdigest[SHA256_DIGEST_STRING_LENGTH];
139 UINT64 length;
140
141 init();
142
143 fp = fopen("cutest_foo", "w");
144 CuAssertPtrNotNull(tc, fp);
145
146 result = fprintf(fp, "%s\n",
147 "ABCDEFGHIJKLMNOPQRSTUVWXYZ=abcdefghijklmnopqrstuvwxyz+0123456789");
148 CuAssertTrue(tc, result >= 0);
149
150 result = fclose(fp);
151 CuAssertTrue(tc, result == 0);
152
153 result = sh_tiger_hashtype("TIGER192");
154 CuAssertTrue(tc, result == 0);
155
156 /* same result as GnuPG 1.0.6 (gpg --load-extension tiger --print-md TIGER192)
157 */
158 length = TIGER_NOLIM;
159 actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
160 expected = "0E9321614C966A33608C2A15F156E0435CACFD1213B9F095";
161 CuAssertStrEquals(tc, expected, actual);
162
163 rval_open = sl_open_fastread (__FILE__, __LINE__, "cutest_foo", SL_YESPRIV);
164 CuAssertTrue(tc, rval_open >= 0);
165
166 length = TIGER_NOLIM;
167 actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
168 expected = "0E9321614C966A33608C2A15F156E0435CACFD1213B9F095";
169 CuAssertStrEquals(tc, expected, actual);
170
171 result = sl_close(rval_open);
172 CuAssertTrue(tc, result == 0);
173
174 result = sh_tiger_hashtype("MD5");
175 CuAssertTrue(tc, result == 0);
176
177 rval_open = sl_open_fastread (__FILE__, __LINE__, "cutest_foo", SL_YESPRIV);
178 CuAssertTrue(tc, rval_open >= 0);
179
180 /* same result as GNU md5sum
181 */
182 length = TIGER_NOLIM;
183 actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
184 expected = "AEEC4DDA496BCFBA691F4E8863BA84C00000000000000000";
185 CuAssertStrEquals(tc, expected, actual);
186
187 result = sl_close(rval_open);
188 CuAssertTrue(tc, result == 0);
189
190 result = sh_tiger_hashtype("SHA1");
191 CuAssertTrue(tc, result == 0);
192
193 rval_open = sl_open_fastread (__FILE__, __LINE__, "cutest_foo", SL_YESPRIV);
194 CuAssertTrue(tc, rval_open >= 0);
195
196 /* same result as gpg --print-md SHA1
197 */
198 length = TIGER_NOLIM;
199 actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
200 expected = "2FE65D1D995B8F8BC8B13F798C07E7E935A787ED00000000";
201 CuAssertStrEquals(tc, expected, actual);
202
203 result = sl_close(rval_open);
204 CuAssertTrue(tc, result == 0);
205
206 result = sh_tiger_hashtype("SHA256");
207 CuAssertTrue(tc, result == 0);
208
209 rval_open = sl_open_fastread (__FILE__, __LINE__, "cutest_foo", SL_YESPRIV);
210 CuAssertTrue(tc, rval_open >= 0);
211
212 /* same result as gpg --print-md SHA256
213 */
214 length = TIGER_NOLIM;
215 {
216 char * tmp = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
217 actual = SHA256_Base2Hex(tmp, hexdigest);
218 }
219 expected = "235790848f95e96b2c627f1bf58a2b8c05c535ada8c0a3326aac34ce1391ad40";
220 CuAssertStrEquals(tc, expected, actual);
221
222 result = sl_close(rval_open);
223 CuAssertTrue(tc, result == 0);
224
225 result = remove("cutest_foo");
226 CuAssertTrue(tc, result == 0);
227
228 /* --------------------------------------------------- */
229
230 fp = fopen("cutest_foo", "w");
231 CuAssertPtrNotNull(tc, fp);
232
233 result = fprintf(fp, "\n");
234 CuAssertTrue(tc, result >= 0);
235
236 result = fclose(fp);
237 CuAssertTrue(tc, result == 0);
238
239 result = sh_tiger_hashtype("TIGER192");
240 CuAssertTrue(tc, result == 0);
241
242 /* same result as GnuPG 1.0.6 (gpg --load-extension tiger --print-md TIGER192)
243 */
244 length = TIGER_NOLIM;
245 actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
246 expected = "F987845A0EA784367BF9E4DB09014995810F27C99C891734";
247 CuAssertStrEquals(tc, expected, actual);
248
249 result = remove("cutest_foo");
250 CuAssertTrue(tc, result == 0);
251
252 /* --------------------------------------------------- */
253
254 fp = fopen("cutest_foo", "w");
255 CuAssertPtrNotNull(tc, fp);
256
257 result = fprintf(fp, "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham, proceedings of Fast Software Encryption 3, Cambridge, 1996.\n");
258 CuAssertTrue(tc, result >= 0);
259
260 result = fclose(fp);
261 CuAssertTrue(tc, result == 0);
262
263 result = sh_tiger_hashtype("TIGER192");
264 CuAssertTrue(tc, result == 0);
265
266 /* same result as GnuPG 1.0.6 (gpg --load-extension tiger --print-md TIGER192)
267 */
268 length = TIGER_NOLIM;
269 actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
270 expected = "75B98A7AE257A230189828A40792E30B4038D286479CC7B8";
271 CuAssertStrEquals(tc, expected, actual);
272
273 result = remove("cutest_foo");
274 CuAssertTrue(tc, result == 0);
275
276}
277
278/* test checksum of file upto some given length
279 */
280void Test_tiger_file_with_length(CuTest *tc) {
281
282 SL_TICKET rval_open;
283 FILE * fp;
284 int result;
285 char * actual;
286 char * expected;
287 char hashbuf[KEYBUF_SIZE];
288 UINT64 length;
289
290 char * teststring = "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham, proceedings of Fast Software Encryption 3, Cambridge, 1996.\n";
291 size_t testlen = strlen(teststring);
292
293 init();
294
295 fp = fopen("cutest_foo", "w");
296 CuAssertPtrNotNull(tc, fp);
297
298 result = fprintf(fp, "%s", teststring);
299 CuAssertTrue(tc, result >= 0);
300 result = fprintf(fp, "%s", teststring);
301 CuAssertTrue(tc, result >= 0);
302
303 result = fclose(fp);
304 CuAssertTrue(tc, result == 0);
305
306 result = sh_tiger_hashtype("TIGER192");
307 CuAssertTrue(tc, result == 0);
308
309 /* same as GnuPG 1.0.6 (gpg --load-extension tiger --print-md TIGER192)
310 */
311 length = 0;
312 actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
313 expected = "24F0130C63AC933216166E76B1BB925FF373DE2D49584E7A";
314 CuAssertStrEquals(tc, expected, actual);
315 CuAssertTrue(tc, 0 == length);
316
317 length = testlen;
318 actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
319 expected = "75B98A7AE257A230189828A40792E30B4038D286479CC7B8";
320 CuAssertStrEquals(tc, expected, actual);
321 CuAssertTrue(tc, testlen == length);
322
323 length = 2*testlen;
324 actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
325 expected = "B5B4FB97B01ADB58794D87A6A01B2368852FA764BD93AB90";
326 CuAssertStrEquals(tc, expected, actual);
327 CuAssertTrue(tc, 2*testlen == length);
328
329 length = TIGER_NOLIM;
330 actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
331 expected = "B5B4FB97B01ADB58794D87A6A01B2368852FA764BD93AB90";
332 CuAssertStrEquals(tc, expected, actual);
333 CuAssertTrue(tc, 2*testlen == length);
334
335 fp = fopen("cutest_foo", "a");
336 CuAssertPtrNotNull(tc, fp);
337 result = fprintf(fp, "%s", teststring);
338 CuAssertTrue(tc, result >= 0);
339 result = fclose(fp);
340 CuAssertTrue(tc, result == 0);
341
342 length = testlen;
343 actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
344 expected = "75B98A7AE257A230189828A40792E30B4038D286479CC7B8";
345 CuAssertStrEquals(tc, expected, actual);
346 CuAssertTrue(tc, testlen == length);
347
348 length = 2*testlen;
349 actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
350 expected = "B5B4FB97B01ADB58794D87A6A01B2368852FA764BD93AB90";
351 CuAssertStrEquals(tc, expected, actual);
352 CuAssertTrue(tc, 2*testlen == length);
353
354 length = 3*testlen;
355 actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
356 expected = "D0EE1A9956CAB22D84B51A5E0C093B724828C6A1F9CBDB7F";
357 CuAssertStrEquals(tc, expected, actual);
358 CuAssertTrue(tc, 3*testlen == length);
359
360 length = TIGER_NOLIM;
361 actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
362 expected = "D0EE1A9956CAB22D84B51A5E0C093B724828C6A1F9CBDB7F";
363 CuAssertStrEquals(tc, expected, actual);
364 CuAssertTrue(tc, 3*testlen == length);
365
366 length = 5;
367 actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
368 expected = "9F00F599072300DD276ABB38C8EB6DEC37790C116F9D2BDF";
369 CuAssertStrEquals(tc, expected, actual);
370 CuAssertTrue(tc, 5 == length);
371
372 /* same results as GNU md5sum */
373
374 result = sh_tiger_hashtype("MD5");
375 CuAssertTrue(tc, result == 0);
376
377 rval_open = sl_open_fastread (__FILE__, __LINE__, "cutest_foo", SL_YESPRIV);
378 CuAssertTrue(tc, rval_open >= 0);
379
380 length = testlen;
381 actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
382 expected = "11E7E7EA486136273606BEE57C71F34B0000000000000000";
383 CuAssertStrEquals(tc, expected, actual);
384 CuAssertTrue(tc, testlen == length);
385
386 result = sl_rewind(rval_open);
387 CuAssertTrue(tc, rval_open >= 0);
388
389 length = 2*testlen;
390 actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
391 expected = "D49DAD474095D467E2E5EFCB2DC23A770000000000000000";
392 CuAssertStrEquals(tc, expected, actual);
393 CuAssertTrue(tc, 2*testlen == length);
394
395 result = sl_rewind(rval_open);
396 CuAssertTrue(tc, rval_open >= 0);
397
398 length = 3*testlen;
399 actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
400 expected = "00A1F1C5EDDCCFC430D3862FDA94593E0000000000000000";
401 CuAssertStrEquals(tc, expected, actual);
402 CuAssertTrue(tc, 3*testlen == length);
403
404 result = sl_rewind(rval_open);
405 CuAssertTrue(tc, rval_open >= 0);
406
407 length = TIGER_NOLIM;
408 actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
409 expected = "00A1F1C5EDDCCFC430D3862FDA94593E0000000000000000";
410 CuAssertStrEquals(tc, expected, actual);
411 CuAssertTrue(tc, 3*testlen == length);
412
413 /* same result as gpg --print-md SHA1
414 */
415
416 result = sh_tiger_hashtype("SHA1");
417 CuAssertTrue(tc, result == 0);
418
419 result = sl_rewind(rval_open);
420 CuAssertTrue(tc, rval_open >= 0);
421
422 length = testlen;
423 actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
424 expected = "F37DB4344CCD140EE315179E9A27512FB4704F0F00000000";
425 CuAssertStrEquals(tc, expected, actual);
426 CuAssertTrue(tc, testlen == length);
427
428 result = sl_rewind(rval_open);
429 CuAssertTrue(tc, rval_open >= 0);
430
431 length = 2*testlen;
432 actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
433 expected = "D2AD5FC366452D81400BAC31F96269DEEF314BC200000000";
434 CuAssertStrEquals(tc, expected, actual);
435 CuAssertTrue(tc, 2*testlen == length);
436
437 result = sl_rewind(rval_open);
438 CuAssertTrue(tc, rval_open >= 0);
439
440 length = 3*testlen;
441 actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
442 expected = "FAA937EF3389C7E786EB0F1006D049D7AEA7B7B600000000";
443 CuAssertStrEquals(tc, expected, actual);
444 CuAssertTrue(tc, 3*testlen == length);
445
446 result = sl_rewind(rval_open);
447 CuAssertTrue(tc, rval_open >= 0);
448
449 length = TIGER_NOLIM;
450 actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
451 expected = "FAA937EF3389C7E786EB0F1006D049D7AEA7B7B600000000";
452 CuAssertStrEquals(tc, expected, actual);
453 CuAssertTrue(tc, 3*testlen == length);
454
455 result = sl_close(rval_open);
456 CuAssertTrue(tc, result == 0);
457
458 result = remove("cutest_foo");
459 CuAssertTrue(tc, result == 0);
460}
Note: See TracBrowser for help on using the repository browser.