tests.c

来自「使用visual studio 2005 开发的开源文件、磁盘加密软件。这是6.」· C语言 代码 · 共 1,169 行 · 第 1/5 页

	"Jefe",
	"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
};

char *hmac_sha1_test_data[] =
{
	// Deprecated/legacy
	"Sample #3",
	"Hi There",
	"what do ya want for nothing?",
	"\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
      "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
	"\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
};

char *hmac_sha1_test_vectors[] =
{
	// Deprecated/legacy
	"\xbc\xf4\x1e\xab\x8b\xb2\xd8\x02\xf3\xd0\x5c\xaf\x7c\xb0\x92\xec\xf8\xd1\xa3\xaa",
	"\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00",
	"\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79",
	"\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3"
};

char *hmac_ripemd160_test_keys[] =
{
	"\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xaa\xbb\xcc\xdd\xee\xff\x01\x23\x45\x67",
	"\x01\x23\x45\x67\x89\xab\xcd\xef\xfe\xdc\xba\x98\x76\x54\x32\x10\x00\x11\x22\x33",
};

char *hmac_ripemd160_test_data[] =
{
	"message digest",
	"12345678901234567890123456789012345678901234567890123456789012345678901234567890",
};

char *hmac_ripemd160_test_vectors[] =
{
	"\xf8\x36\x62\xcc\x8d\x33\x9c\x22\x7e\x60\x0f\xcd\x63\x6c\x57\xd2\x57\x1b\x1c\x34",
	"\x85\xf1\x64\x70\x3e\x61\xa6\x31\x31\xbe\x7e\x45\x95\x8e\x07\x94\x12\x39\x04\xf9",
};

char *hmac_whirlpool_test_key =
{
	"\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x01\x23\x45\x67\x89\xAB\xCD\xEF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x01\x23\x45\x67\x89\xAB\xCD\xEF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF"
};

char *hmac_whirlpool_test_data =
{
	"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
};

char *hmac_whirlpool_test_vectors =
{
	"\x03\x91\xd2\x80\x00\xb6\x62\xbb\xb8\xe6\x23\x3e\xe8\x6c\xf2\xb2\x84\x74\x4c\x73"
	"\x8b\x58\x00\xba\x28\x12\xed\x52\x6f\xe3\x15\x3a\xb1\xba\xe7\xe2\x36\xbe\x96\x54"
	"\x49\x3f\x19\xfa\xce\xa6\x44\x1f\x60\xf5\xf0\x18\x93\x09\x11\xa5\xe5\xce\xd8\xf2"
	"\x6a\xbf\xa4\x02"
};

unsigned char ks_tmp[MAX_EXPANDED_KEY]; 

void CipherInit2(int cipher, void* key, void* ks, int key_len) 
{
	switch (cipher)
	{
	case BLOWFISH:
		/* Deprecated/legacy */
		BlowfishSetKey (ks, key_len,  key); 
		break;

	case AES:
		CipherInit(cipher,key,ks);
		break;

	case CAST:
		/* Deprecated/legacy */
		CipherInit(cipher,key,ks);
		break;

	case SERPENT:
		CipherInit(cipher,key,ks);
		break;

	case TRIPLEDES:
		/* Deprecated/legacy */
		CipherInit(cipher,key,ks);
		break;

	case TWOFISH:
		CipherInit(cipher,key,ks);
		break;

	default:			
		/* Unknown/wrong ID */
		TC_THROW_FATAL_EXCEPTION;
	}
}


/* Deprecated/legacy */
typedef struct {
	unsigned __int8 key1[32];
	unsigned __int8 key2[16];
	unsigned __int8 index[16];
	unsigned __int8 plaintext[16];
	unsigned __int8 ciphertext[16];
} LRW_TEST;

#define LRW_TEST_COUNT 2

/* Deprecated/legacy */
LRW_TEST lrw_vectors[LRW_TEST_COUNT] = {
	{
		{ 0xf8, 0xd4, 0x76, 0xff, 0xd6, 0x46, 0xee, 0x6c, 0x23, 0x84, 0xcb, 0x1c, 0x77, 0xd6, 0x19, 0x5d,
		  0xfe, 0xf1, 0xa9, 0xf3, 0x7b, 0xbc, 0x8d, 0x21, 0xa7, 0x9c, 0x21, 0xf8, 0xcb, 0x90, 0x02, 0x89 },
		{ 0xa8, 0x45, 0x34, 0x8e, 0xc8, 0xc5, 0xb5, 0xf1, 0x26, 0xf5, 0x0e, 0x76, 0xfe, 0xfd, 0x1b, 0x1e },
		{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
		{ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46 },
		{ 0xbd, 0x06, 0xb8, 0xe1, 0xdb, 0x98, 0x89, 0x9e, 0xc4, 0x98, 0xe4, 0x91, 0xcf, 0x1c, 0x70, 0x2b }
	},
	{
		{ 0xfb, 0x76, 0x15, 0xb2, 0x3d, 0x80, 0x89, 0x1d, 0xd4, 0x70, 0x98, 0x0b, 0xc7, 0x95, 0x84, 0xc8,
		  0xb2, 0xfb, 0x64, 0xce, 0x60, 0x97, 0x87, 0x8d, 0x17, 0xfc, 0xe4, 0x5a, 0x49, 0xe8, 0x30, 0xb7 },
		{ 0x6e, 0x78, 0x17, 0xe7, 0x2d, 0x5e, 0x12, 0xd4, 0x60, 0x64, 0x04, 0x7a, 0xf1, 0x2f, 0x9e, 0x0c },
		{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 },
		{ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46 },
		{ 0x5b, 0x90, 0x8e, 0xc1, 0xab, 0xdd, 0x67, 0x5f, 0x3d, 0x69, 0x8a, 0x95, 0x53, 0xc8, 0x9c, 0xe5 }
	}
};


BOOL LRWAesTest (PCRYPTO_INFO ci)
{
	/* Deprecated/legacy */

	unsigned __int8 p[16];
	int i;

	for (i = 0; i < LRW_TEST_COUNT; i++)
	{
		ci->ea = EAGetByName ("AES");
		if (ci->ea == 0)
			return FALSE;

		ci->mode = LRW;

		if (EAInit (ci->ea, lrw_vectors[i].key1, ci->ks) != ERR_SUCCESS)
			return FALSE;

		memcpy (&ci->k2, lrw_vectors[i].key2, sizeof (lrw_vectors[i].key2));
		if (!EAInitMode (ci))
			return FALSE;

		memcpy (p, lrw_vectors[i].plaintext, sizeof (p));

		EncryptBufferLRW128 (p, sizeof (p), BE64(((unsigned __int64 *)(lrw_vectors[i].index))[1]), ci);

		if (memcmp (lrw_vectors[i].ciphertext, p, sizeof (p)) != 0)
			return FALSE;
	}

	return TRUE;
}


BOOL TestSectorBufEncryption (PCRYPTO_INFO ci)
{
	unsigned char buf [ENCRYPTION_DATA_UNIT_SIZE * 4];
	unsigned int i;
	char name[64];
	unsigned __int32 crc;
	UINT64_STRUCT unitNo;
	TC_LARGEST_COMPILER_UINT nbrUnits;
	unsigned __int64 writeOffset;
	int testCase = 0;
	int nTestsPerformed = 0;

	static unsigned char key1[] =
	{ 
		0x27, 0x18, 0x28, 0x18, 0x28, 0x45, 0x90, 0x45, 0x23, 0x53, 0x60, 0x28, 0x74, 0x71, 0x35, 0x26, 0x62, 0x49, 0x77, 0x57, 0x24, 0x70, 0x93, 0x69, 0x99, 0x59, 0x57, 0x49, 0x66, 0x96, 0x76, 0x27,
		0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95, 0x02, 0x88, 0x41, 0x97, 0x16, 0x93, 0x99, 0x37, 0x51, 0x05, 0x82, 0x09, 0x74, 0x94, 0x45, 0x92,
		0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13
	};

	if (!TestLegacySectorBufEncryption (ci))
		return FALSE;


	/* Encryption/decryption of data units (typically, volume data sectors) */

	nbrUnits = sizeof (buf) / ENCRYPTION_DATA_UNIT_SIZE;

	ci->mode = XTS;	// Other modes of operation are tested in TestLegacySectorBufEncryption()

	/* The buffer can accommodate 4 data units and we'll test 4 cases by "scrolling". The data unit 0xFFFFFFFFFF
	will "move" from the start of the buffer to its end. For a 512-byte data unit, the byte offset 562949953420800
	corresponds to the data unit 0xFFFFFFFFFF. */
	for (writeOffset = 562949953420800LL; 
		writeOffset > 562949953420800LL - nbrUnits * ENCRYPTION_DATA_UNIT_SIZE; 
		writeOffset -= ENCRYPTION_DATA_UNIT_SIZE)
	{
		unitNo.Value = writeOffset / ENCRYPTION_DATA_UNIT_SIZE;

		// Test all EAs that support this mode of operation
		for (ci->ea = EAGetFirst (); ci->ea != 0; ci->ea = EAGetNext (ci->ea))
		{
			if (!EAIsModeSupported (ci->ea, ci->mode))
				continue;

			EAGetName (name, ci->ea);

			if (EAInit (ci->ea, key1, ci->ks) != ERR_SUCCESS)
				return FALSE;

			for (i = 0; i < sizeof (ci->k2); i++)
				ci->k2[i] = (unsigned char) i;

			memcpy (&ci->k2, XTS_vectors[XTS_TEST_COUNT-1].key2, sizeof (XTS_vectors[XTS_TEST_COUNT-1].key2));

			if (!EAInitMode (ci))
				return FALSE;

			// Each data unit will contain the same plaintext
			for (i = 0; i < nbrUnits; i++)
			{
				memcpy ((unsigned char *) buf + i * ENCRYPTION_DATA_UNIT_SIZE, 
					XTS_vectors[XTS_TEST_COUNT-1].plaintext, 
					ENCRYPTION_DATA_UNIT_SIZE);
			}

			EncryptDataUnits (buf, &unitNo, nbrUnits, ci);

			crc = GetCrc32 (buf, sizeof (buf));