Context Navigation

cutest_sh_tiger0.c@ 526

Last change on this file since 526 was 481, checked in by katerina, 9 years ago
Enhancements and fixes for tickets #374, #375, #376, #377, #378, and #379.
File size: 15.1 KB

Rev	Line
[17]	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"
[444]	10	#include "sh_checksum.h"
[17]	11
[137]	12	#if defined(HAVE_PTHREAD) && defined(SH_STEALTH)
[170]	13	extern void sh_g_init(void);
[137]	14	#endif
	15
	16
[170]	17	static void init(void) {
[17]	18
	19	extern unsigned char TcpFlag[8][PW_LEN+1];
	20	extern UINT32 ErrFlag[2];
	21	unsigned char * dez = NULL;
	22	int i;
	23
[137]	24	#if defined(HAVE_PTHREAD) && defined(SH_STEALTH)
	25	sh_g_init();
	26	#endif
[17]	27	skey = (sh_key_t *) malloc (sizeof(sh_key_t));
[96]	28	if (skey != NULL)
[17]	29	{
[481]	30	skey->mlock_failed = S_FALSE;
[96]	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	{
[17]	67	perror(_("sh_init"));
	68	_exit (EXIT_FAILURE);
	69	}
	70
	71	}
	72
	73	void Test_tiger(CuTest *tc) {
	74
	75	char * input;
	76	char * actual;
	77	char * expected;
[133]	78	char hashbuf[KEYBUF_SIZE];
[17]	79
[137]	80	#if defined(HAVE_PTHREAD) && defined(SH_STEALTH)
	81	sh_g_init();
	82	#endif
	83
[17]	84	input = "";
[133]	85	actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
[17]	86	expected = "24F0130C63AC933216166E76B1BB925FF373DE2D49584E7A";
	87	CuAssertStrEquals(tc, expected, actual);
	88
	89	input = "abc";
[133]	90	actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
[17]	91	expected = "F258C1E88414AB2A527AB541FFC5B8BF935F7B951C132951";
	92	CuAssertStrEquals(tc, expected, actual);
	93
	94	input = "Tiger";
[133]	95	actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
[17]	96	expected = "9F00F599072300DD276ABB38C8EB6DEC37790C116F9D2BDF";
	97	CuAssertStrEquals(tc, expected, actual);
	98
	99	input = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-";
[133]	100	actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
[17]	101	expected = "87FB2A9083851CF7470D2CF810E6DF9EB586445034A5A386";
	102	CuAssertStrEquals(tc, expected, actual);
	103
	104	input = "ABCDEFGHIJKLMNOPQRSTUVWXYZ=abcdefghijklmnopqrstuvwxyz+0123456789";
[133]	105	actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
[17]	106	expected = "467DB80863EBCE488DF1CD1261655DE957896565975F9197";
	107	CuAssertStrEquals(tc, expected, actual);
	108
	109	input = "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham";
[133]	110	actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
[17]	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.";
[133]	115	actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
[17]	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.";
[133]	120	actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
[17]	121	expected = "3D9AEB03D1BD1A6357B2774DFD6D5B24DD68151D503974FC";
	122	CuAssertStrEquals(tc, expected, actual);
	123
	124	input = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-";
[133]	125	actual = sh_tiger_hash(input, TIGER_DATA, strlen(input), hashbuf, sizeof(hashbuf));
[17]	126	expected = "00B83EB4E53440C576AC6AAEE0A7485825FD15E70A59FFE4";
	127	CuAssertStrEquals(tc, expected, actual);
	128	}
	129
	130	void Test_tiger_file(CuTest *tc) {
	131
	132	SL_TICKET rval_open;
	133	FILE * fp;
	134	int result;
	135	char * actual;
	136	char * expected;
[133]	137	char hashbuf[KEYBUF_SIZE];
[444]	138	char hexdigest[SHA256_DIGEST_STRING_LENGTH];
[151]	139	UINT64 length;
[17]	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	*/
[151]	158	length = TIGER_NOLIM;
	159	actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
[17]	160	expected = "0E9321614C966A33608C2A15F156E0435CACFD1213B9F095";
	161	CuAssertStrEquals(tc, expected, actual);
	162
[248]	163	rval_open = sl_open_fastread (__FILE__, __LINE__, "cutest_foo", SL_YESPRIV);
[17]	164	CuAssertTrue(tc, rval_open >= 0);
	165
[151]	166	length = TIGER_NOLIM;
	167	actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
[17]	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
[248]	177	rval_open = sl_open_fastread (__FILE__, __LINE__, "cutest_foo", SL_YESPRIV);
[17]	178	CuAssertTrue(tc, rval_open >= 0);
	179
	180	/* same result as GNU md5sum
	181	*/
[151]	182	length = TIGER_NOLIM;
	183	actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
[17]	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
[248]	193	rval_open = sl_open_fastread (__FILE__, __LINE__, "cutest_foo", SL_YESPRIV);
[17]	194	CuAssertTrue(tc, rval_open >= 0);
	195
	196	/* same result as gpg --print-md SHA1
	197	*/
[151]	198	length = TIGER_NOLIM;
	199	actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
[17]	200	expected = "2FE65D1D995B8F8BC8B13F798C07E7E935A787ED00000000";
	201	CuAssertStrEquals(tc, expected, actual);
	202
	203	result = sl_close(rval_open);
	204	CuAssertTrue(tc, result == 0);
	205
[444]	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
[17]	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	*/
[151]	244	length = TIGER_NOLIM;
	245	actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
[17]	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	*/
[151]	268	length = TIGER_NOLIM;
	269	actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
[17]	270	expected = "75B98A7AE257A230189828A40792E30B4038D286479CC7B8";
	271	CuAssertStrEquals(tc, expected, actual);
	272
	273	result = remove("cutest_foo");
	274	CuAssertTrue(tc, result == 0);
	275
[19]	276	}
[17]	277
[19]	278	/* test checksum of file upto some given length
	279	*/
	280	void 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;
[133]	287	char hashbuf[KEYBUF_SIZE];
[151]	288	UINT64 length;
[19]	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";
[151]	291	size_t testlen = strlen(teststring);
[19]	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	*/
[151]	311	length = 0;
	312	actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
[107]	313	expected = "24F0130C63AC933216166E76B1BB925FF373DE2D49584E7A";
	314	CuAssertStrEquals(tc, expected, actual);
[151]	315	CuAssertTrue(tc, 0 == length);
[107]	316
[151]	317	length = testlen;
	318	actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
[19]	319	expected = "75B98A7AE257A230189828A40792E30B4038D286479CC7B8";
	320	CuAssertStrEquals(tc, expected, actual);
[151]	321	CuAssertTrue(tc, testlen == length);
[19]	322
[151]	323	length = 2*testlen;
	324	actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
[19]	325	expected = "B5B4FB97B01ADB58794D87A6A01B2368852FA764BD93AB90";
	326	CuAssertStrEquals(tc, expected, actual);
[151]	327	CuAssertTrue(tc, 2*testlen == length);
[19]	328
[151]	329	length = TIGER_NOLIM;
	330	actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
[19]	331	expected = "B5B4FB97B01ADB58794D87A6A01B2368852FA764BD93AB90";
	332	CuAssertStrEquals(tc, expected, actual);
[151]	333	CuAssertTrue(tc, 2*testlen == length);
[19]	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
[151]	342	length = testlen;
	343	actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
[19]	344	expected = "75B98A7AE257A230189828A40792E30B4038D286479CC7B8";
	345	CuAssertStrEquals(tc, expected, actual);
[151]	346	CuAssertTrue(tc, testlen == length);
[19]	347
[151]	348	length = 2*testlen;
	349	actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
[19]	350	expected = "B5B4FB97B01ADB58794D87A6A01B2368852FA764BD93AB90";
	351	CuAssertStrEquals(tc, expected, actual);
[151]	352	CuAssertTrue(tc, 2*testlen == length);
[19]	353
[151]	354	length = 3*testlen;
	355	actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
[19]	356	expected = "D0EE1A9956CAB22D84B51A5E0C093B724828C6A1F9CBDB7F";
	357	CuAssertStrEquals(tc, expected, actual);
[151]	358	CuAssertTrue(tc, 3*testlen == length);
[19]	359
[151]	360	length = TIGER_NOLIM;
	361	actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
[19]	362	expected = "D0EE1A9956CAB22D84B51A5E0C093B724828C6A1F9CBDB7F";
	363	CuAssertStrEquals(tc, expected, actual);
[151]	364	CuAssertTrue(tc, 3*testlen == length);
[19]	365
[151]	366	length = 5;
	367	actual = sh_tiger_generic_hash("cutest_foo", TIGER_FILE, &length, 0, hashbuf, sizeof(hashbuf));
[19]	368	expected = "9F00F599072300DD276ABB38C8EB6DEC37790C116F9D2BDF";
	369	CuAssertStrEquals(tc, expected, actual);
[151]	370	CuAssertTrue(tc, 5 == length);
[19]	371
	372	/* same results as GNU md5sum */
	373
	374	result = sh_tiger_hashtype("MD5");
	375	CuAssertTrue(tc, result == 0);
	376
[248]	377	rval_open = sl_open_fastread (__FILE__, __LINE__, "cutest_foo", SL_YESPRIV);
[19]	378	CuAssertTrue(tc, rval_open >= 0);
	379
[151]	380	length = testlen;
	381	actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
[19]	382	expected = "11E7E7EA486136273606BEE57C71F34B0000000000000000";
	383	CuAssertStrEquals(tc, expected, actual);
[151]	384	CuAssertTrue(tc, testlen == length);
[19]	385
	386	result = sl_rewind(rval_open);
	387	CuAssertTrue(tc, rval_open >= 0);
	388
[151]	389	length = 2*testlen;
	390	actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
[19]	391	expected = "D49DAD474095D467E2E5EFCB2DC23A770000000000000000";
	392	CuAssertStrEquals(tc, expected, actual);
[151]	393	CuAssertTrue(tc, 2*testlen == length);
[19]	394
	395	result = sl_rewind(rval_open);
	396	CuAssertTrue(tc, rval_open >= 0);
	397
[151]	398	length = 3*testlen;
	399	actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
[19]	400	expected = "00A1F1C5EDDCCFC430D3862FDA94593E0000000000000000";
	401	CuAssertStrEquals(tc, expected, actual);
[151]	402	CuAssertTrue(tc, 3*testlen == length);
[19]	403
	404	result = sl_rewind(rval_open);
	405	CuAssertTrue(tc, rval_open >= 0);
	406
[151]	407	length = TIGER_NOLIM;
	408	actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
[19]	409	expected = "00A1F1C5EDDCCFC430D3862FDA94593E0000000000000000";
	410	CuAssertStrEquals(tc, expected, actual);
[151]	411	CuAssertTrue(tc, 3*testlen == length);
[19]	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
[151]	422	length = testlen;
	423	actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
[19]	424	expected = "F37DB4344CCD140EE315179E9A27512FB4704F0F00000000";
	425	CuAssertStrEquals(tc, expected, actual);
[151]	426	CuAssertTrue(tc, testlen == length);
[19]	427
	428	result = sl_rewind(rval_open);
	429	CuAssertTrue(tc, rval_open >= 0);
	430
[151]	431	length = 2*testlen;
	432	actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
[19]	433	expected = "D2AD5FC366452D81400BAC31F96269DEEF314BC200000000";
	434	CuAssertStrEquals(tc, expected, actual);
[151]	435	CuAssertTrue(tc, 2*testlen == length);
[19]	436
	437	result = sl_rewind(rval_open);
	438	CuAssertTrue(tc, rval_open >= 0);
	439
[151]	440	length = 3*testlen;
	441	actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
[19]	442	expected = "FAA937EF3389C7E786EB0F1006D049D7AEA7B7B600000000";
	443	CuAssertStrEquals(tc, expected, actual);
[151]	444	CuAssertTrue(tc, 3*testlen == length);
[19]	445
	446	result = sl_rewind(rval_open);
	447	CuAssertTrue(tc, rval_open >= 0);
	448
[151]	449	length = TIGER_NOLIM;
	450	actual = sh_tiger_generic_hash("cutest_foo", rval_open, &length, 0, hashbuf, sizeof(hashbuf));
[19]	451	expected = "FAA937EF3389C7E786EB0F1006D049D7AEA7B7B600000000";
	452	CuAssertStrEquals(tc, expected, actual);
[151]	453	CuAssertTrue(tc, 3*testlen == length);
[19]	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.

Context Navigation

source: trunk/src/cutest_sh_tiger0.c@ 526

Download in other formats: