tst2fish.c

嵌入环境下Blowfish加密算法的实现

		AES_FileIO(debugTD->f,s,0);
		debugTD->gotDebugIO=1;
		}
	else
		printf(s);
	}

/*
+*****************************************************************************
*
* Function Name:	AES_Test_VK
*
* Function:			Run variable key test
*
* Arguments:		fname	=	file name to produce
*
* Return:			None.
*
* Notes:
*
-****************************************************************************/
void AES_Test_VK(CONST char *fname)
	{
	testData t;

	memset(t.ki.keyMaterial,'0',MAX_KEY_SIZE);

	t.f=AES_PutFileHeader(fname,
			  "Electronic Codebook (ECB) Mode\nVariable Key Known Answer Tests");

	if (cipherInit(&t.ci,MODE_ECB,NULL) != TRUE)
		FatalError("cipherInit error during %s test",fname);

	for (t.keySize=KEY_BITS_0;t.keySize<=MAX_KEY_BITS;t.keySize+=STEP_KEY_BITS)
		{
		ClearTestData(&t);
		AES_printf(&t,"S\nP\n");	/* output key size, plaintext */
		for (t.I=1;t.I<=t.keySize;t.I++)
			{
			t.ki.keyMaterial[(t.I-1)/4]='0' + (8 >> ((t.I-1) & 3));
			if (makeKey(&t.ki,DIR_ENCRYPT,t.keySize,t.ki.keyMaterial) != TRUE)
				FatalError("Error parsing key during %s test",fname);
			if (blockEncrypt(&t.ci,&t.ki,t.pt,BLOCK_SIZE,t.ct) != BLOCK_SIZE)
				FatalError("blockEncrypt return during %s test",fname);
			AES_printf(&t,"IKC\n");	/* output I, KEY, CT, newline */

			t.ki.keyMaterial[(t.I-1)/4]='0';	/* rezero the key bit */
			}
		AES_EndSection(&t);
		}

	AES_Close(&t);
	}

/*
+*****************************************************************************
*
* Function Name:	AES_Test_Intermediate
*
* Function:			Run intermediate value test
*
* Arguments:		fname	=	file name to produce
*
* Return:			None.
*
* Notes:
*
-****************************************************************************/
void AES_Test_Intermediate(CONST char *fname)
	{
	testData t;

	if ((useAsm) || (!debugCompile))
		{
		if (!quietVerify) printf("WARNING: Skipping %s test\n",fname);
		return;
		}

	memset(t.ki.keyMaterial,'0',MAX_KEY_SIZE);

	t.f=AES_PutFileHeader(fname,
			  "Electronic Codebook (ECB) Mode\nIntermediate Value Tests");

	if (cipherInit(&t.ci,MODE_ECB,NULL) != TRUE)
		FatalError("cipherInit error during %s test",fname);

	for (t.keySize=KEY_BITS_0;t.keySize<=MAX_KEY_BITS;t.keySize+=STEP_KEY_BITS)
		{
		ClearTestData(&t);
		debugTD=&t;
		debug=1;

		if (t.keySize > KEY_BITS_0)
			memcpy(t.ki.keyMaterial,hexString,sizeof(t.ki.keyMaterial));
		debug=0;
		if (makeKey(&t.ki,DIR_ENCRYPT,t.keySize,t.ki.keyMaterial) != TRUE)
			FatalError("Error parsing key during %s test",fname);
		debug=1;
		AES_printf(&t,"S\nK\n");	/* output key size, key */
		if (makeKey(&t.ki,DIR_ENCRYPT,t.keySize,t.ki.keyMaterial) != TRUE)
			FatalError("Error parsing key during %s test",fname);

		AES_printf(&t,"P\n");		/* output plaintext */
		AES_FileIO(t.f,"Encrypt()\n",0);

		if (blockEncrypt(&t.ci,&t.ki,t.pt,BLOCK_SIZE,t.ct) != BLOCK_SIZE)
			FatalError("blockEncrypt return during %s test",fname);
		AES_printf(&t,"\nC\n");	/* output CT, newline */

		AES_FileIO(t.f,"Decrypt()\n",0);
		AES_printf(&t,"\nC\n");	/* output CT, newline */
		if (blockDecrypt(&t.ci,&t.ki,t.ct,BLOCK_SIZE,t.pt) != BLOCK_SIZE)
			FatalError("blockDecrypt return during %s test",fname);
		AES_printf(&t,"\nP\n");	/* output PT, newline */

		AES_EndSection(&t);
		if (!t.gotDebugIO)
			FatalError("Need to run DEBUG version to test %s",fname);
		debug=0;
		debugTD=NULL;
		}

	AES_Close(&t);
	}


/*
+*****************************************************************************
*
* Function Name:	AES_Test_VT
*
* Function:			Run variable text test
*
* Arguments:		fname	=	file name to produce
*
* Return:			None.
*
* Notes:
*
-****************************************************************************/
void AES_Test_VT(CONST char *fname)
	{
	testData t;

	memset(	t.ki.keyMaterial,'0',MAX_KEY_SIZE);

	t.f=AES_PutFileHeader(fname,
			  "Electronic Codebook (ECB) Mode\nVariable Text Known Answer Tests");

	if (cipherInit(&t.ci,MODE_ECB,NULL) != TRUE)
		FatalError("cipherInit error during %s test",fname);

	for (t.keySize=KEY_BITS_0;t.keySize<=MAX_KEY_BITS;t.keySize+=STEP_KEY_BITS)
		{
		ClearTestData(&t);
		if (makeKey(&t.ki,DIR_ENCRYPT,t.keySize,t.ki.keyMaterial) != TRUE)
			FatalError("Error parsing key during %s test",fname);

		AES_printf(&t,"S\nK\n");	/* output key size, key */
		for (t.I=1;t.I<=BLOCK_SIZE;t.I++)
			{
			t.pt[(t.I-1)/8] = 0x80 >> ((t.I-1) & 7);
			if (blockEncrypt(&t.ci,&t.ki,t.pt,BLOCK_SIZE,t.ct) != BLOCK_SIZE)
				FatalError("blockEncrypt return during %s test",fname);
			AES_printf(&t,"IPC\n");	/* output I, PT, CT, newline */
			t.pt[(t.I-1)/8] = 0;
			}
		AES_EndSection(&t);
		}
	AES_Close(&t);
	}

/*
+*****************************************************************************
*
* Function Name:	AES_Test_TBL
*
* Function:			Run tabl test
*
* Arguments:		fname	=	file name to produce
*
* Return:			None.
*
* Notes:
*
-****************************************************************************/
void AES_Test_TBL(CONST char *fname)
	{
	int i;
	testData t;

	t.f=AES_PutFileHeader(fname,
			"Electronic Codebook (ECB) Mode\nTables Known Answer Test\n"
			"Tests permutation tables and MDS matrix multiply tables.");

	for (t.keySize=KEY_BITS_0;t.keySize <= MAX_KEY_BITS;t.keySize+=STEP_KEY_BITS)
		{
		AES_printf(&t,"S\n");	/* output key size */
		TableOp(TAB_ENABLE);
		TableOp(TAB_RESET);

		ClearTestData(&t);
		if (cipherInit(&t.ci,MODE_ECB,NULL) != TRUE)
			FatalError("Error cipherInit() during %s test",fname);

		for (t.I=1;TableOp(TAB_QUERY) == FALSE;t.I++)
			{
			if (makeKey(&t.ki,DIR_ENCRYPT,t.keySize,t.ki.keyMaterial) != TRUE)
				FatalError("Error parsing key during %s test",fname);
			if (blockEncrypt(&t.ci,&t.ki,t.pt,BLOCK_SIZE,t.ct) != BLOCK_SIZE)
				FatalError("blockEncrypt during %s test",fname);
			AES_printf(&t,"IKPC\n");		/* show the 'vector' */
			memcpy(t.ki.keyMaterial+MAX_KEY_SIZE/2,t.ki.keyMaterial,MAX_KEY_SIZE/2);
			for (i=0;i<MAX_KEY_SIZE/2;i+=2)	/* make new key from old paintext */
				{
				t.ki.keyMaterial[i  ]=hexTab[t.pt[i/2] >> 4];
				t.ki.keyMaterial[i+1]=hexTab[t.pt[i/2] &0xF];
				}
			memcpy(t.pt,t.ct,BLOCK_SIZE/8);	/* use ciphertext as new plaintext */
			}
		TableOp(TAB_DISABLE);
		AES_EndSection(&t);		/* output separator */
		if (!quietVerify) printf("  [%d,%3d]",t.keySize,t.I);
		}
	if (!quietVerify) printf("\n");
	AES_Close(&t);
	}

/*
+*****************************************************************************
*
* Function Name:	AES_Test_ECB_E_MCT
*
* Function:			Run ECB Monte Carlo test for ECB encryption
*
* Arguments:		fname	=	file name to produce
*
* Return:			None.
*
* Notes:
*
-****************************************************************************/
void AES_Test_ECB_E_MCT(CONST char *fname)
	{
	int i,j,q;
	testData t;

	t.f=AES_PutFileHeader(fname,
				"Electronic Codebook (ECB) Mode - ENCRYPTION\nMonte Carlo Test");

	if (cipherInit(&t.ci,MODE_ECB,NULL) != TRUE)
		FatalError("cipherInit error during %s test",fname);

	for (t.keySize=KEY_BITS_0,q=0;t.keySize<=MAX_KEY_BITS;t.keySize+=STEP_KEY_BITS,q+=2)
		{
		AES_printf(&t,"S\n");			/* output key size */
		if (!quietVerify) printf("  keyLen = %3d. ",t.keySize);

		ClearTestData(&t);				/* start with all zeroes */
		if (makeKey(&t.ki,DIR_ENCRYPT,t.keySize,t.ki.keyMaterial) != TRUE)
			FatalError("Error parsing key during %s test",fname);

		for (t.I=0;t.I<mctOuter;t.I++)
			{
			AES_printf(&t,"IKP");
			if (!quietVerify) printf("%3d\b\b\b",t.I);
			for (j=0;j<mctInner;j++)
				{
				if (blockEncrypt(&t.ci,&t.ki,t.pt,BLOCK_SIZE,t.ct) != BLOCK_SIZE)
					FatalError("blockEncrypt return during %s test",fname);
				if (j == mctInner-1)	/* xor the key for next outer loop */
					for (i=0;i<t.keySize/32;i++)
						t.ki.key32[i] ^=
							Bswap((i>=q) ? ((DWORD *)t.ct)[i-q] :
										   ((DWORD *)t.pt)[BLOCK_SIZE/32-q+i]);
				BlockCopy(t.pt,t.ct);
				}
			AES_printf(&t,"C\n");
			if (reKey(&t.ki) != TRUE)
				FatalError("reKey return during %s test",fname);
			}
		AES_EndSection(&t);
		}
	if (!quietVerify) printf("   \n");
	AES_Close(&t);
	}

/*
+*****************************************************************************
*
* Function Name:	AES_Test_ECB_D_MCT
*
* Function:			Run ECB Monte Carlo test for ECB decryption
*
* Arguments:		fname	=	file name to produce
*
* Return:			None.
*
* Notes:
*
-****************************************************************************/
void AES_Test_ECB_D_MCT(CONST char *fname)
	{
	int i,j,q;
	testData t;

	t.f=AES_PutFileHeader(fname,
				"Electronic Codebook (ECB) Mode - DECRYPTION\nMonte Carlo Test");

	if (cipherInit(&t.ci,MODE_ECB,NULL) != TRUE)
		FatalError("cipherInit error during %s test",fname);

	for (t.keySize=KEY_BITS_0,q=0;t.keySize <= MAX_KEY_BITS;t.keySize+=STEP_KEY_BITS,q+=2)
		{
		AES_printf(&t,"S\n");			/* output key size */
		if (!quietVerify) printf("  keyLen = %3d. ",t.keySize);

		ClearTestData(&t);				/* start with all zeroes */
		if (makeKey(&t.ki,DIR_DECRYPT,t.keySize,t.ki.keyMaterial) != TRUE)
			FatalError("Error parsing key during %s test",fname);

		for (t.I=0;t.I<mctOuter;t.I++)
			{
			AES_printf(&t,"IKC");
			if (!quietVerify) printf("%3d\b\b\b",t.I);
			for (j=0;j<mctInner;j++)
				{
				if (blockDecrypt(&t.ci,&t.ki,t.ct,BLOCK_SIZE,t.pt) != BLOCK_SIZE)
					FatalError("blockDecrypt return during %s test",fname);
				if (j == mctInner-1)	/* xor the key for next outer loop */
					for (i=0;i<t.keySize/32;i++)
						t.ki.key32[i] ^=
							Bswap((i>=q) ? ((DWORD *)t.pt)[i-q] :
									       ((DWORD *)t.ct)[BLOCK_SIZE/32-q+i]);
				BlockCopy(t.ct,t.pt);
				}
			AES_printf(&t,"P\n");
			if (reKey(&t.ki) != TRUE)
				FatalError("reKey return during %s test",fname);
			}
		AES_EndSection(&t);
		}
	if (!quietVerify) printf("   \n");
	AES_Close(&t);
	}

/*
+*****************************************************************************
*
* Function Name:	AES_Test_CBC_E_MCT
*
* Function:			Run ECB Monte Carlo test for CBC encryption
*
* Arguments:		fname	=	file name to produce
*
* Return:			None.
*
* Notes:
*
-****************************************************************************/
void AES_Test_CBC_E_MCT(CONST char *fname)
	{
	int i,j,q;
	testData t;
	BYTE ctPrev[BLOCK_SIZE/8];
	BYTE IV[BLOCK_SIZE/8];
#define	CV	t.ci.IV						/* use t.ci.IV as CV */

	t.f=AES_PutFileHeader(fname,
			"Cipher Block Chaining (CBC) Mode - ENCRYPTION\nMonte Carlo Test");

	if (cipherInit(&t.ci,MODE_ECB,NULL) != TRUE)
		FatalError("cipherInit error during %s test",fname);

	for (t.keySize=KEY_BITS_0,q=0;t.keySize<=MAX_KEY_BITS;t.keySize+=STEP_KEY_BITS,q+=2)
		{
		AES_printf(&t,"S\n");			/* output key size */
		if (!quietVerify) printf("  keyLen = %3d. ",t.keySize);

		ClearTestData(&t);				/* start with all zeroes */
		memset(IV,0,sizeof(IV));
		if (makeKey(&t.ki,DIR_ENCRYPT,t.keySize,t.ki.keyMaterial)	 != TRUE)
			FatalError("Error parsing key during %s test",fname);

		BlockCopy(CV,IV);				
		for (t.I=0;t.I<mctOuter;t.I++)
			{
			AES_printf(&t,"IKvP");
			if (!quietVerify) printf("%3d\b\b\b",t.I);
			for (j=0;j<mctInner;j++)
				{
				for (i=0;i<BLOCK_SIZE/8;i++)
					t.pt[i]  ^= CV[i];		/* IB = PT ^ CV */
				BlockCopy(ctPrev,t.ct);		/* save previous ct */

				if (blockEncrypt(&t.ci,&t.ki,t.pt,BLOCK_SIZE,t.ct) != BLOCK_SIZE)
					FatalError("blockEncrypt return during %s test",fname);
				BlockCopy(t.pt,(j)? ctPrev : CV);
				BlockCopy(CV,t.ct);
				}
			AES_printf(&t,"C\n");

			for (i=0;i<t.keySize/32;i++)
				t.ki.key32[i] ^=
					Bswap((i>=q) ? ((DWORD *)t.ct  )[i-q] :
								   ((DWORD *)ctPrev)[BLOCK_SIZE/32-q+i]);
			BlockCopy(t.pt,ctPrev);
			BlockCopy(CV,t.ct);

			if (reKey(&t.ki) != TRUE)
				FatalError("reKey return during %s test",fname);
			}
		AES_EndSection(&t);
		}
	if (!quietVerify) printf("   \n");
	AES_Close(&t);
	}

/*
+*****************************************************************************