1 /* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2 /* test shs code */
3
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <time.h>
7 #include "shs.h"
8
9 static void process(void);
10 static void test1(void);
11 static void test2(void);
12 static void test3(void);
13 static void test4(void);
14 static void test5(void);
15 static void test6(void);
16 static void test7(void);
17
18 /* When run on a little-endian CPU we need to perform byte reversal on an
19 array of longwords. It is possible to make the code endianness-
20 independent by fiddling around with data at the byte level, but this
21 makes for very slow code, so we rely on the user to sort out endianness
22 at compile time */
23
longReverse(SHS_LONG * buffer,int byteCount)24 static void longReverse( SHS_LONG *buffer, int byteCount )
25 {
26 SHS_LONG value;
27 static int init = 0;
28 char *cp;
29
30 switch (init) {
31 case 0:
32 init=1;
33 cp = (char *) &init;
34 if (*cp == 1) {
35 init=2;
36 break;
37 }
38 init=1;
39 /* fall through - MSB */
40 case 1:
41 return;
42 }
43
44 byteCount /= sizeof( SHS_LONG );
45 while( byteCount-- ) {
46 value = *buffer;
47 value = ( ( value & 0xFF00FF00L ) >> 8 ) |
48 ( ( value & 0x00FF00FFL ) << 8 );
49 *buffer++ = ( value << 16 ) | ( value >> 16 );
50 }
51 }
52
53 int rc;
54 int mode;
55 int Dflag;
56
57 int
main(int argc,char ** argv)58 main(int argc, char **argv)
59 {
60 char *argp;
61
62 while (--argc > 0) if (*(argp = *++argv)=='-')
63 while (*++argp) switch(*argp)
64 {
65 case '1':
66 case '2':
67 case '3':
68 case '4':
69 case '5':
70 case '6':
71 case '7':
72 if (mode) goto Usage;
73 mode = *argp;
74 break;
75 case 'D':
76 if (argc <= 1) goto Usage;
77 --argc;
78 Dflag = atoi(*++argv);
79 break;
80 case '-':
81 break;
82 default:
83 fprintf (stderr,"Bad switch char <%c>\n", *argp);
84 Usage:
85 fprintf(stderr, "Usage: t_shs [-1234567] [-D #]\n");
86 exit(1);
87 }
88 else goto Usage;
89
90 process();
91 exit(rc);
92 }
93
process(void)94 static void process(void)
95 {
96 switch(mode)
97 {
98 case '1':
99 test1();
100 break;
101 case '2':
102 test2();
103 break;
104 case '3':
105 test3();
106 break;
107 case '4':
108 test4();
109 break;
110 case '5':
111 test5();
112 break;
113 case '6':
114 test6();
115 break;
116 case '7':
117 test7();
118 break;
119 default:
120 test1();
121 test2();
122 test3();
123 test4();
124 test5();
125 test6();
126 test7();
127 }
128 }
129
130 #ifndef shsDigest
131 static unsigned char *
shsDigest(SHS_INFO * si)132 shsDigest(SHS_INFO *si)
133 {
134 longReverse(si->digest, SHS_DIGESTSIZE);
135 return (unsigned char*) si->digest;
136 }
137 #endif
138
139 unsigned char results1[SHS_DIGESTSIZE] = {
140 0xa9,0x99,0x3e,0x36,0x47,0x06,0x81,0x6a,0xba,0x3e,
141 0x25,0x71,0x78,0x50,0xc2,0x6c,0x9c,0xd0,0xd8,0x9d};
142
test1(void)143 static void test1(void)
144 {
145 SHS_INFO si[1];
146 unsigned char digest[SHS_DIGESTSIZE];
147 int failed;
148 int i;
149
150 printf("Running SHS test 1 ...\n");
151 shsInit(si);
152 shsUpdate(si, (SHS_BYTE *) "abc", 3);
153 shsFinal(si);
154 memcpy(digest, shsDigest(si), SHS_DIGESTSIZE);
155 if ((failed = memcmp(digest, results1, SHS_DIGESTSIZE)) != 0)
156 {
157 fprintf(stderr,"SHS test 1 failed!\n");
158 rc = 1;
159 }
160 printf ("%s, results = ", failed ? "Failed" : "Passed");
161 for (i = 0; i < SHS_DIGESTSIZE; ++i)
162 printf("%02x",digest[i]);
163 if (failed)
164 {
165 printf ("\n, expected ");
166 for (i = 0; i < SHS_DIGESTSIZE; ++i)
167 printf("%02x",results1[i]);
168 }
169 printf("\n");
170 }
171
172 unsigned char results2[SHS_DIGESTSIZE] = {
173 0x84,0x98,0x3e,0x44,0x1c,0x3b,0xd2,0x6e,0xba,0xae,
174 0x4a,0xa1,0xf9,0x51,0x29,0xe5,0xe5,0x46,0x70,0xf1};
175
test2(void)176 static void test2(void)
177 {
178 SHS_INFO si[1];
179 unsigned char digest[SHS_DIGESTSIZE];
180 int failed;
181 int i;
182
183 printf("Running SHS test 2 ...\n");
184 shsInit(si);
185 shsUpdate(si,
186 (SHS_BYTE *) "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
187 56);
188 shsFinal(si);
189 memcpy(digest, shsDigest(si), SHS_DIGESTSIZE);
190 if ((failed = memcmp(digest, results2, SHS_DIGESTSIZE)) != 0)
191 {
192 fprintf(stderr,"SHS test 2 failed!\n");
193 rc = 1;
194 }
195 printf ("%s, results = ", failed ? "Failed" : "Passed");
196 for (i = 0; i < SHS_DIGESTSIZE; ++i)
197 printf("%02x",digest[i]);
198 if (failed)
199 {
200 printf ("\n, expected ");
201 for (i = 0; i < SHS_DIGESTSIZE; ++i)
202 printf("%02x",results2[i]);
203 }
204 printf("\n");
205 }
206
207 unsigned char results3[SHS_DIGESTSIZE] = {
208 0x34,0xaa,0x97,0x3c,0xd4,0xc4,0xda,0xa4,0xf6,0x1e,
209 0xeb,0x2b,0xdb,0xad,0x27,0x31,0x65,0x34,0x01,0x6f};
210
test3(void)211 static void test3(void)
212 {
213 SHS_INFO si[1];
214 unsigned char digest[SHS_DIGESTSIZE];
215 int failed;
216 int i;
217
218 printf("Running SHS test 3 ...\n");
219 shsInit(si);
220 for (i = 0; i < 15625; ++i)
221 shsUpdate(si,
222 (SHS_BYTE *) "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
223 64);
224 shsFinal(si);
225 memcpy(digest, shsDigest(si), SHS_DIGESTSIZE);
226 if ((failed = memcmp(digest, results3, SHS_DIGESTSIZE)) != 0)
227 {
228 fprintf(stderr,"SHS test 3 failed!\n");
229 rc = 1;
230 }
231 printf ("%s, results = ", failed ? "Failed" : "Passed");
232 for (i = 0; i < SHS_DIGESTSIZE; ++i)
233 printf("%02x",digest[i]);
234 if (failed)
235 {
236 printf ("\n, expected ");
237 for (i = 0; i < SHS_DIGESTSIZE; ++i)
238 printf("%02x",results3[i]);
239 }
240 printf("\n");
241 }
242
243 unsigned char randdata[] = {
244 0xfe,0x28,0x79,0x25,0xf5,0x03,0xf9,0x1c,0xcd,0x70,0x7b,0xb0,0x42,0x02,0xb8,0x2f,
245 0xf3,0x63,0xa2,0x79,0x8e,0x9b,0x33,0xd7,0x2b,0xc4,0xb4,0xd2,0xcb,0x61,0xec,0xbb,
246 0x94,0xe1,0x8f,0x53,0x80,0x55,0xd9,0x90,0xb2,0x03,0x58,0xfa,0xa6,0xe5,0x18,0x57,
247 0x68,0x04,0x24,0x98,0x41,0x7e,0x84,0xeb,0xc1,0x39,0xbc,0x1d,0xf7,0x4e,0x92,0x72,
248 0x1a,0x5b,0xb6,0x99,0x43,0xa5,0x0a,0x45,0x73,0x55,0xfd,0x57,0x83,0x45,0x36,0x5c,
249 0xfd,0x39,0x08,0x6e,0xe2,0x01,0x9a,0x8c,0x4e,0x39,0xd2,0x0d,0x5f,0x0e,0x35,0x15,
250 0xb9,0xac,0x5f,0xa1,0x8a,0xe6,0xdd,0x6e,0x68,0x9d,0xf6,0x29,0x95,0xf6,0x7d,0x7b,
251 0xd9,0x5e,0xf4,0x67,0x25,0xbd,0xee,0xed,0x53,0x60,0xb0,0x47,0xdf,0xef,0xf4,0x41,
252 0xbd,0x45,0xcf,0x5c,0x93,0x41,0x87,0x97,0x82,0x39,0x20,0x66,0xb4,0xda,0xcb,0x66,
253 0x93,0x02,0x2e,0x7f,0x94,0x4c,0xc7,0x3b,0x2c,0xcf,0xf6,0x99,0x6f,0x13,0xf1,0xc5,
254 0x28,0x2b,0xa6,0x6c,0x39,0x26,0x7f,0x76,0x24,0x4a,0x6e,0x01,0x40,0x63,0xf8,0x00,
255 0x06,0x23,0x5a,0xaa,0xa6,0x2f,0xd1,0x37,0xc7,0xcc,0x76,0xe9,0x54,0x1e,0x57,0x73,
256 0xf5,0x33,0xaa,0x96,0xbe,0x35,0xcd,0x1d,0xd5,0x7d,0xac,0x50,0xd5,0xf8,0x47,0x2d,
257 0xd6,0x93,0x5f,0x6e,0x38,0xd3,0xac,0xd0,0x7e,0xad,0x9e,0xf8,0x87,0x95,0x63,0x15,
258 0x65,0xa3,0xd4,0xb3,0x9a,0x6c,0xac,0xcd,0x2a,0x54,0x83,0x13,0xc4,0xb4,0x94,0xfa,
259 0x76,0x87,0xc5,0x8b,0x4a,0x10,0x92,0x05,0xd1,0x0e,0x97,0xfd,0xc8,0xfb,0xc5,0xdc,
260 0x21,0x4c,0xc8,0x77,0x5c,0xed,0x32,0x22,0x77,0xc1,0x38,0x30,0xd7,0x8e,0x2a,0x70,
261 0x72,0x67,0x13,0xe4,0xb7,0x18,0xd4,0x76,0xdd,0x32,0x12,0xf4,0x5d,0xc9,0xec,0xc1,
262 0x2c,0x8a,0xfe,0x08,0x6c,0xea,0xf6,0xab,0x5a,0x0e,0x8e,0x81,0x1d,0xc8,0x5a,0x4b,
263 0xed,0xb9,0x7f,0x4b,0x67,0xe3,0x65,0x46,0xc9,0xf2,0xab,0x37,0x0a,0x98,0x67,0x5b,
264 0xb1,0x3b,0x02,0x91,0x38,0x71,0xea,0x62,0x88,0xae,0xb6,0xdb,0xfc,0x55,0x79,0x33,
265 0x69,0x95,0x51,0xb6,0xe1,0x3b,0xab,0x22,0x68,0x54,0xf9,0x89,0x9c,0x94,0xe0,0xe3,
266 0xd3,0x48,0x5c,0xe9,0x78,0x5b,0xb3,0x4b,0xba,0xd8,0x48,0xd8,0xaf,0x91,0x4e,0x23,
267 0x38,0x23,0x23,0x6c,0xdf,0x2e,0xf0,0xff,0xac,0x1d,0x2d,0x27,0x10,0x45,0xa3,0x2d,
268 0x8b,0x00,0xcd,0xe2,0xfc,0xb7,0xdb,0x52,0x13,0xb7,0x66,0x79,0xd9,0xd8,0x29,0x0e,
269 0x32,0xbd,0x52,0x6b,0x75,0x71,0x08,0x83,0x1b,0x67,0x28,0x93,0x97,0x97,0x32,0xff,
270 0x8b,0xd3,0x98,0xa3,0xce,0x2b,0x88,0x37,0x1c,0xcc,0xa0,0xd1,0x19,0x9b,0xe6,0x11,
271 0xfc,0xc0,0x3c,0x4e,0xe1,0x35,0x49,0x29,0x19,0xcf,0x1d,0xe1,0x60,0x74,0xc0,0xe9,
272 0xf7,0xb4,0x99,0xa0,0x23,0x50,0x51,0x78,0xcf,0xc0,0xe5,0xc2,0x1c,0x16,0xd2,0x24,
273 0x5a,0x63,0x54,0x83,0xaa,0x74,0x3d,0x41,0x0d,0x52,0xee,0xfe,0x0f,0x4d,0x13,0xe1,
274 0x27,0x00,0xc4,0xf3,0x2b,0x55,0xe0,0x9c,0x81,0xe0,0xfc,0xc2,0x13,0xd4,0x39,0x09
275 };
276
277 unsigned char results4[SHS_DIGESTSIZE] = {
278 0x13,0x62,0xfc,0x87,0x68,0x33,0xd5,0x1d,0x2f,0x0c,
279 0x73,0xe3,0xfb,0x87,0x6a,0x6b,0xc3,0x25,0x54,0xfc};
280
test4(void)281 static void test4(void)
282 {
283 SHS_INFO si[1];
284 unsigned char digest[SHS_DIGESTSIZE];
285 int failed;
286 int i;
287
288 printf("Running SHS test 4 ...\n");
289 shsInit(si);
290 shsUpdate(si, randdata, 19);
291 shsFinal(si);
292 memcpy(digest, shsDigest(si), SHS_DIGESTSIZE);
293 if ((failed = memcmp(digest, results4, SHS_DIGESTSIZE)) != 0)
294 {
295 fprintf(stderr,"SHS test 4 failed!\n");
296 rc = 1;
297 }
298 printf ("%s, results = ", failed ? "Failed" : "Passed");
299 for (i = 0; i < SHS_DIGESTSIZE; ++i)
300 printf("%02x",digest[i]);
301 if (failed)
302 {
303 printf ("\n, expected ");
304 for (i = 0; i < SHS_DIGESTSIZE; ++i)
305 printf("%02x",results4[i]);
306 }
307 printf("\n");
308 }
309
310 unsigned char results5[SHS_DIGESTSIZE] = {
311 0x19,0x4d,0xf6,0xeb,0x8e,0x02,0x6d,0x37,0x58,0x64,
312 0xe5,0x95,0x19,0x2a,0xdd,0x1c,0xc4,0x3c,0x24,0x86};
313
test5(void)314 static void test5(void)
315 {
316 SHS_INFO si[1];
317 unsigned char digest[SHS_DIGESTSIZE];
318 int failed;
319 int i;
320
321 printf("Running SHS test 5 ...\n");
322 shsInit(si);
323 shsUpdate(si, randdata, 19);
324 shsUpdate(si, randdata+32, 15);
325 shsFinal(si);
326 memcpy(digest, shsDigest(si), SHS_DIGESTSIZE);
327 if ((failed = memcmp(digest, results5, SHS_DIGESTSIZE)) != 0)
328 {
329 fprintf(stderr,"SHS test 5 failed!\n");
330 rc = 1;
331 }
332 printf ("%s, results = ", failed ? "Failed" : "Passed");
333 for (i = 0; i < SHS_DIGESTSIZE; ++i)
334 printf("%02x",digest[i]);
335 if (failed)
336 {
337 printf ("\n, expected ");
338 for (i = 0; i < SHS_DIGESTSIZE; ++i)
339 printf("%02x",results5[i]);
340 }
341 printf("\n");
342 }
343
344 unsigned char results6[SHS_DIGESTSIZE] = {
345 0x4e,0x16,0x57,0x9d,0x4b,0x48,0xa9,0x1c,0x88,0x72,
346 0x83,0xdb,0x88,0xd1,0xea,0x3a,0x45,0xdf,0xa1,0x10};
347
test6(void)348 static void test6(void)
349 {
350 struct {
351 unsigned long pad1;
352 SHS_INFO si1;
353 unsigned long pad2;
354 SHS_INFO si2;
355 unsigned long pad3;
356 } sdata;
357 unsigned char digest[SHS_DIGESTSIZE];
358 int failed;
359 unsigned int i, j;
360
361 printf("Running SHS test 6 ...\n");
362 sdata.pad1 = 0x12345678;
363 sdata.pad2 = 0x87654321;
364 sdata.pad3 = 0x78563412;
365 shsInit((&sdata.si2));
366 if (sdata.pad2 != 0x87654321) {
367 printf ("Overrun #20 %#lx\n",
368 sdata.pad2);
369 sdata.pad2 = 0x87654321;
370 }
371 if (sdata.pad3 != 0x78563412) {
372 printf ("Overrun #21 %#lx\n",
373 sdata.pad3);
374 sdata.pad3 = 0x78563412;
375 }
376 for (i = 0; i < 400; ++i)
377 {
378 shsInit(&sdata.si1);
379 if (sdata.pad1 != 0x12345678) {
380 printf ("Overrun #22 %#lx at %d\n",
381 sdata.pad1, i);
382 sdata.pad1 = 0x12345678;
383 }
384 if (sdata.pad2 != 0x87654321) {
385 printf ("Overrun #23 %#lx at %d\n",
386 sdata.pad2, i);
387 sdata.pad2 = 0x87654321;
388 }
389 shsUpdate(&sdata.si1, (randdata+sizeof(randdata))-i, i);
390 if (sdata.pad1 != 0x12345678) {
391 printf ("Overrun #24 %#lx at %d\n",
392 sdata.pad1, i);
393 sdata.pad1 = 0x12345678;
394 }
395 if (sdata.pad2 != 0x87654321) {
396 printf ("Overrun #25 %#lx at %d\n",
397 sdata.pad2, i);
398 sdata.pad2 = 0x87654321;
399 }
400 shsFinal(&sdata.si1);
401 if (sdata.pad1 != 0x12345678) {
402 printf ("Overrun #26 %#lx at %d\n",
403 sdata.pad1, i);
404 sdata.pad1 = 0x12345678;
405 }
406 if (sdata.pad2 != 0x87654321) {
407 printf ("Overrun #27 %#lx at %d\n",
408 sdata.pad2, i);
409 sdata.pad2 = 0x87654321;
410 }
411 memcpy(digest, shsDigest(&sdata.si1), SHS_DIGESTSIZE);
412 if (Dflag & 1)
413 {
414 printf ("%d: ", i);
415 for (j = 0; j < SHS_DIGESTSIZE; ++j)
416 printf("%02x",digest[j]);
417 printf("\n");
418 }
419 shsUpdate((&sdata.si2), digest, SHS_DIGESTSIZE);
420 if (sdata.pad2 != 0x87654321) {
421 printf ("Overrun #28 %#lx at %d\n",
422 sdata.pad2, i);
423 sdata.pad2 = 0x87654321;
424 }
425 if (sdata.pad3 != 0x78563412) {
426 printf ("Overrun #29 %#lx at %d\n",
427 sdata.pad3, i);
428 sdata.pad3 = 0x78563412;
429 }
430 if (Dflag & 2)
431 printf ("%d: %08lx%08lx%08lx%08lx%08lx\n",
432 i,
433 (unsigned long) sdata.si2.digest[0],
434 (unsigned long) sdata.si2.digest[1],
435 (unsigned long) sdata.si2.digest[2],
436 (unsigned long) sdata.si2.digest[3],
437 (unsigned long) sdata.si2.digest[4]);
438 }
439 shsFinal((&sdata.si2));
440 if (sdata.pad2 != 0x87654321) {
441 printf ("Overrun #30 %#lx\n",
442 sdata.pad2);
443 sdata.pad2 = 0x87654321;
444 }
445 if (sdata.pad3 != 0x78563412) {
446 printf ("Overrun #31 %#lx\n",
447 sdata.pad3);
448 sdata.pad3 = 0x78563412;
449 }
450 memcpy(digest, shsDigest((&sdata.si2)), SHS_DIGESTSIZE);
451 if ((failed = memcmp(digest, results6, SHS_DIGESTSIZE)) != 0)
452 {
453 fprintf(stderr,"SHS test 6 failed!\n");
454 rc = 1;
455 }
456 printf ("%s, results = ", failed ? "Failed" : "Passed");
457 for (i = 0; i < SHS_DIGESTSIZE; ++i)
458 printf("%02x",digest[i]);
459 if (failed)
460 {
461 printf ("\n, expected ");
462 for (i = 0; i < SHS_DIGESTSIZE; ++i)
463 printf("%02x",results6[i]);
464 }
465 printf("\n");
466 }
467
468 unsigned char results7[SHS_DIGESTSIZE] = {
469 0x89,0x41,0x65,0xce,0x76,0xc1,0xd1,0xd1,0xc3,0x6f,
470 0xab,0x92,0x79,0x30,0x01,0x71,0x63,0x1f,0x74,0xfe};
471
472 unsigned int jfsize[] = {0,1,31,32,
473 33,55,56,63,
474 64,65,71,72,
475 73,95,96,97,
476 119,120,123,127};
477 unsigned int kfsize[] = {0,1,31,32,33,55,56,63};
478
test7(void)479 static void test7(void)
480 {
481 struct {
482 unsigned long pad1;
483 SHS_INFO si1;
484 unsigned long pad2;
485 SHS_INFO si2;
486 unsigned long pad3;
487 } sdata;
488 unsigned char digest[SHS_DIGESTSIZE];
489 int failed;
490 unsigned int i, j, k, l;
491
492 printf("Running SHS test 7 ...\n");
493 sdata.pad1 = 0x12345678;
494 sdata.pad2 = 0x87654321;
495 sdata.pad3 = 0x78563412;
496 shsInit((&sdata.si2));
497 for (i = 1; i <= 128; ++i)
498 for (j = 0; j < 20; ++j)
499 for (k = 0; k < 8; ++k)
500 {
501 shsInit(&sdata.si1);
502 shsUpdate(&sdata.si1, (randdata+80+j), i);
503 if (sdata.pad1 != 0x12345678) {
504 printf ("Overrun #1 %#lx at %d,%d,%d\n",
505 sdata.pad1, i,j,k);
506 sdata.pad1 = 0x12345678;
507 }
508 if (sdata.pad2 != 0x87654321) {
509 printf ("Overrun #2 %#lx at %d,%d,%d\n",
510 sdata.pad2, i,j,k);
511 sdata.pad2 = 0x87654321;
512 }
513 shsUpdate(&sdata.si1, randdata+i, jfsize[j]);
514 if (sdata.pad1 != 0x12345678) {
515 printf ("Overrun #3 %#lx at %d,%d,%d\n",
516 sdata.pad1, i,j,k);
517 sdata.pad1 = 0x12345678;
518 }
519 if (sdata.pad2 != 0x87654321) {
520 printf ("Overrun #4 %#lx at %d,%d,%d\n",
521 sdata.pad2, i,j,k);
522 sdata.pad2 = 0x87654321;
523 }
524 if (k) shsUpdate(&sdata.si1, randdata+(i^j), kfsize[k]);
525 if (sdata.pad1 != 0x12345678) {
526 printf ("Overrun #5 %#lx at %d,%d,%d\n",
527 sdata.pad1, i,j,k);
528 sdata.pad1 = 0x12345678;
529 }
530 if (sdata.pad2 != 0x87654321) {
531 printf ("Overrun #6 %#lx at %d,%d,%d\n",
532 sdata.pad2, i,j,k);
533 sdata.pad2 = 0x87654321;
534 }
535 shsFinal(&sdata.si1);
536 if (sdata.pad1 != 0x12345678) {
537 printf ("Overrun #7 %#lx at %d,%d,%d\n",
538 sdata.pad1, i,j,k);
539 sdata.pad1 = 0x12345678;
540 }
541 if (sdata.pad2 != 0x87654321) {
542 printf ("Overrun #8 %#lx at %d,%d,%d\n",
543 sdata.pad2, i,j,k);
544 sdata.pad2 = 0x87654321;
545 }
546 memcpy(digest, shsDigest(&sdata.si1), SHS_DIGESTSIZE);
547 if (Dflag & 1)
548 {
549 printf ("%d,%d,%d: ", i, j, k);
550 for (l = 0; l < SHS_DIGESTSIZE; ++l)
551 printf("%02x",digest[l]);
552 printf("\n");
553 }
554 shsUpdate((&sdata.si2), digest, SHS_DIGESTSIZE);
555 if (sdata.pad2 != 0x87654321) {
556 printf ("Overrun #9 %#lx at %d,%d,%d\n",
557 sdata.pad2, i,j,k);
558 sdata.pad2 = 0x87654321;
559 }
560 if (sdata.pad3 != 0x78563412) {
561 printf ("Overrun #10 %#lx at %d,%d,%d\n",
562 sdata.pad3, i,j,k);
563 sdata.pad3 = 0x78563412;
564 }
565 if (Dflag & 2)
566 printf ("%d,%d,%d: %08lx%08lx%08lx%08lx%08lx\n",
567 i,j,k,
568 (unsigned long) sdata.si2.digest[0],
569 (unsigned long) sdata.si2.digest[1],
570 (unsigned long) sdata.si2.digest[2],
571 (unsigned long) sdata.si2.digest[3],
572 (unsigned long) sdata.si2.digest[4]);
573 }
574 shsFinal((&sdata.si2));
575 memcpy(digest, shsDigest((&sdata.si2)), SHS_DIGESTSIZE);
576 if ((failed = memcmp(digest, results7, SHS_DIGESTSIZE)) != 0)
577 {
578 fprintf(stderr,"SHS test 7 failed!\n");
579 rc = 1;
580 }
581 printf ("%s, results = ", failed ? "Failed" : "Passed");
582 for (i = 0; i < SHS_DIGESTSIZE; ++i)
583 printf("%02x",digest[i]);
584 if (failed)
585 {
586 printf ("\n, expected ");
587 for (i = 0; i < SHS_DIGESTSIZE; ++i)
588 printf("%02x",results7[i]);
589 }
590 printf("\n");
591 }
592