test.c

来自「C语言环境下的AES加密算法」· C语言 代码 · 共 549 行 · 第 1/2 页

		else
			PrintBYTE(stdout, "DT", DecText, DecLen);
	}
}

/**************************************************************************
*
*/
void	SpeedTest()
{
#define DATA_LEN	1024
	BYTE	UserKey[AES_USER_KEY_LEN], IV[AES_BLOCK_LEN];
	BYTE	PT[DATA_LEN+32], ET[DATA_LEN+32], DT[DATA_LEN+32];
	DWORD	i, tt, Iter, EncLen=0, DecLen;
	RET_VAL	ret;
	AES_ALG_INFO	EncAlgInfo, DecAlgInfo;

	//
	for( tt=0; tt<AES_USER_KEY_LEN; tt++)	UserKey[tt] = 0;
	for( tt=0; tt<AES_BLOCK_LEN; tt++)		IV[tt] = 0;
	AES_SetAlgInfo(AI_CBC, AI_NO_PADDING, IV, &EncAlgInfo);
	AES_SetAlgInfo(AI_CBC, AI_NO_PADDING, IV, &DecAlgInfo);

	//
	ret = AES_EncKeySchedule(UserKey, AES_USER_KEY_LEN, &EncAlgInfo);
	if( ret!=CTR_SUCCESS )	Error(ret, "AES_EncKeySchedule() returns.");
	ret = AES_DecKeySchedule(UserKey, AES_USER_KEY_LEN, &DecAlgInfo);
	if( ret!=CTR_SUCCESS )	Error(ret, "AES_DecKeySchedule() returns.");

	for( i=0; i<3; i++) {
		fprintf(stdout, "\n==== test %d\n", i);
		Iter = 2 * 18000;

		//
		for( tt=0; tt<DATA_LEN; tt++)	PT[tt] = 0;

		//
		SPEED_TEST("Enc:", " / ", Iter, DATA_LEN,
			{	EncLen = tt = 0;
				ret = AES_EncInit(&EncAlgInfo);
				ret = AES_EncUpdate(&EncAlgInfo, PT, DATA_LEN,
									ET, &EncLen);
				ret = AES_EncFinal(&EncAlgInfo, ET+EncLen, &tt);
				EncLen += tt;									}	);
		//
		SPEED_TEST("Dec:", " // ", Iter, DATA_LEN,
			{	DecLen = tt = 0;
				ret = AES_DecInit(&DecAlgInfo);
				ret = AES_DecUpdate(&DecAlgInfo, ET, EncLen,
									DT, &DecLen);
				ret = AES_DecFinal(&DecAlgInfo, DT+DecLen, &tt);
				DecLen += tt;									}	);

		//
		for( tt=0; tt<DATA_LEN; tt++)
			if( DT[tt]!=0 )	break;
		if( tt==DATA_LEN )	printf("OK");
		else				printf("FAIL");
	}
#undef DATA_LEN
}

/**************************************************************************
*
*/
void	GetKeyIV(
		BYTE	Key[AES_USER_KEY_LEN],
		DWORD	*KeyLen,
		BYTE	IV[AES_BLOCK_LEN],
		DWORD	*IVLen)
{
	DWORD	ch, i, j;
	FILE	*pfile;

	if( (pfile=fopen("key.dat", "r"))==NULL ) {
		printf( "The file 'key.dat' was not opened\n");
		Error(0, "File(key.dat) Open Error");
	}

	fscanf(pfile, "%d", &j);
	*KeyLen = j;
	for( i=0; i<j; i++) {
		fscanf(pfile, "%X", &ch);
		Key[i] = (BYTE) ch;
	}

	fscanf(pfile, "%d", &j);
	if( j!=AES_BLOCK_LEN ) {
		*IVLen = 0;
		for( i=0; i<AES_BLOCK_LEN; i++)
			IV[i] = (BYTE) 0;
	}
	else {
		*IVLen = AES_BLOCK_LEN;
		for( i=0; i<AES_BLOCK_LEN; i++) {
			fscanf(pfile, "%X", &ch);
			IV[i] = (BYTE) ch;
		}
	}

	fclose(pfile);
}

/**************************************************************************
*
*/
void	GeneralTest(
		DWORD	EncType,
		DWORD	ModeType,
		DWORD	PadType,
		char	*infile,
		char	*outfile)
{
	FILE	*pIn, *pOut;
	BYTE	UserKey[AES_USER_KEY_LEN];
	BYTE	IV[AES_BLOCK_LEN];
	BYTE	SrcData[1024+32], DstData[1024+32];
	DWORD	UKLen, IVLen, SrcLen, DstLen;
	RET_VAL	ret;
	AES_ALG_INFO	AlgInfo;

	//
	GetKeyIV(UserKey, &UKLen, IV, &IVLen);

	//
	if( (pIn=fopen(infile, "rb"))==NULL ) {
		printf( "The file '%s' was not opened\n", infile);
		Error(0, "File(infile) Open Error");
	}
	if( (pOut=fopen(outfile, "wb"))==NULL ) {
		printf( "The file '%s' was not opened\n", outfile);
		Error(0, "File(outfile) Open Error");
	}
	//
	AES_SetAlgInfo(ModeType, PadType, IV, &AlgInfo);

	if( EncType==0 ) {		//	Encryption
		ret = AES_EncKeySchedule(UserKey, UKLen, &AlgInfo);
		if( ret!=CTR_SUCCESS )	Error(ret, "AES_EncKeySchedule() returns.");

		ret = AES_EncInit(&AlgInfo);
		if( ret!=CTR_SUCCESS )	Error(ret, "AES_EncInit() returns.");

		for(  ;  ;  ) {
			SrcLen = fread(SrcData, sizeof(BYTE), 1024, pIn);
			if( SrcLen==0 )	break;

			DstLen = 1024;
			ret = AES_EncUpdate(&AlgInfo, SrcData, SrcLen, DstData, &DstLen);
			if( ret!=CTR_SUCCESS )	Error(ret, "AES_EncUpdate() returns.");

			fwrite(DstData, sizeof(BYTE), DstLen, pOut);
		}

		DstLen = 1024;
		ret = AES_EncFinal(&AlgInfo, DstData, &DstLen);
		if( ret!=CTR_SUCCESS )	Error(ret, "AES_EncFinal() returns.");
		fwrite(DstData, sizeof(BYTE), DstLen, pOut);
	}
	else {					//	Decryption
		if( ModeType==AI_ECB || ModeType==AI_CBC )
			ret = AES_DecKeySchedule(UserKey, UKLen, &AlgInfo);
		else if( ModeType==AI_OFB || ModeType==AI_CFB )
			ret = AES_EncKeySchedule(UserKey, UKLen, &AlgInfo);
		if( ret!=CTR_SUCCESS )	Error(ret, "AES_DecKeySchedule() returns.");

		ret = AES_DecInit(&AlgInfo);
		if( ret!=CTR_SUCCESS )	Error(ret, "AES_DecInit() returns.");

		for(  ;  ;  ) {
			SrcLen = fread(SrcData, sizeof(BYTE), 1024, pIn);
			if( SrcLen==0 )	break;

			DstLen = 1024;
			ret = AES_DecUpdate(&AlgInfo, SrcData, SrcLen, DstData, &DstLen);
			if( ret!=CTR_SUCCESS )	Error(ret, "AES_DecUpdate() returns.");

			fwrite(DstData, sizeof(BYTE), DstLen, pOut);
		}

		DstLen = 1024;
		ret = AES_DecFinal(&AlgInfo, DstData, &DstLen);
		if( ret!=CTR_SUCCESS )	Error(ret, "AES_DecFinal() returns.");
		fwrite(DstData, sizeof(BYTE), DstLen, pOut);
	}

	fclose(pIn);
	fclose(pOut);
}

/**************************************************************************
*
*/
void	ChangeToCapital(char *String)
{
	DWORD	i;

	if( String[0]=='-' ) {
		for( i=1;  ; i++) {
			if( String[i]=='\0' )	break;
			if( (String[i]>='a') && (String[i]<='z') )
				String[i] += 'A' - 'a';
		}
	}
}

/**************************************************************************
*
*/
void	main(int argc, char **argv)
{
	DWORD	i;

	//
	for( i=1; i<(DWORD)argc; i++)
		ChangeToCapital(argv[i]);

	//
	if( argc==2 ) {
		if( strcmp(argv[1], "-T")==0 )		ValidityTest();
		else if( strcmp(argv[1], "-S")==0 )	SpeedTest();
		else	Error(CTR_USAGE_ERROR, "Invalid Use of Argument");
	}
	else if( argc==5 ) {
		DWORD	EncType=0, ModeType=0, PadType=0;

		//
		if( strcmp(argv[1], "-E")==0 )		EncType = 0;
		else if( strcmp(argv[1], "-D")==0 )	EncType = 1;
		else	Error(CTR_USAGE_ERROR, "Invalid Use of Argument");

		//
		if( strcmp(argv[2], "-ECB")==0 ) {
			ModeType = AI_ECB;
			PadType = AI_NO_PADDING;
		}
		else if( strcmp(argv[2], "-CBC")==0 ) {
			ModeType = AI_CBC;
			PadType = AI_NO_PADDING;
		}
		else if( strcmp(argv[2], "-OFB")==0 ) {
			ModeType = AI_OFB;
			PadType = AI_NO_PADDING;
		}
		else if( strcmp(argv[2], "-CFB")==0 ) {
			ModeType = AI_CFB;
			PadType = AI_NO_PADDING;
		}
		else if( strcmp(argv[2], "-ECBPAD")==0 ) {
			ModeType = AI_ECB;
			PadType = AI_PKCS_PADDING;
		}
		else if( strcmp(argv[2], "-CBCPAD")==0 ) {
			ModeType = AI_CBC;
			PadType = AI_PKCS_PADDING;
		}
		else if( strcmp(argv[2], "-OFBPAD")==0 ) {
			ModeType = AI_OFB;
			PadType = AI_PKCS_PADDING;
		}
		else if( strcmp(argv[2], "-CFBPAD")==0 ) {
			ModeType = AI_CFB;
			PadType = AI_PKCS_PADDING;
		}
		else	Error(CTR_USAGE_ERROR, "Invalid Use of Argument");

		GeneralTest(EncType, ModeType, PadType, argv[3], argv[4]);
	}
	else
		Error(CTR_USAGE_ERROR, "Invalid Number of Argument");
}

/*************** END OF FILE **********************************************/