source: trunk/src/cutest_sh_tiger0.c @ 137

Last change on this file since 137 was 137, checked in by rainer, 14 years ago

Fix compile errors.

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