cdes.cpp

该程序实现单层的DES加密算法

#include "stdio.h"
#include "stdlib.h"

void main()
{
	FILE *fpDES;
	FILE *fpText,*fpKey;
	if((fpDES=fopen("E:\\learn vc\\CDes_standard\\dataofDES.txt","w"))==NULL)
	{
		printf("Cannot open file dataofDES.\n");
		exit(0);
	}

	if((fpText=fopen("E:\\learn vc\\CDes_standard\\dataofText.txt","r"))==NULL)
	{
		printf("Cannot open file dataofText.\n");
		exit(0);
	}
	if((fpKey=fopen("E:\\learn vc\\CDes_standard\\dataofKey.txt","r"))==NULL)
	{
		printf("Cannot open file dataofKey.\n");
		exit(0);
	}

	int iPlainText[64];
	int iCipherText[64];
	int iKey[64];
	int iLeftText[32];
	int iRightText[32];
	int iCKey[28];
	int iDKey[28];
	//输入明文和密钥
	for(int i=0;i<64;i++)
	{
		fscanf(fpText,"%d\n",&iPlainText[i]);
		fscanf(fpKey,"%d\n",&iKey[i]);
	}
	fclose(fpText);
	fclose(fpKey);

	////////////////////////////////////////////////////////
	/*生成各轮的密钥*/
	////////////////////////////////////////////////////////
	int iKeyOfRound[16][48];

	//定义置换选择1(PC-1)
	int PC1trans[56]=
	{56,48,40,32,24,16,8,
	 0,57,49,41,33,25,17,
	 9,1,58,50,42,34,26,
	 18,10,2,59,51,43,35,
	 62,54,46,38,30,22,14,
	 6,61,53,45,37,29,21,
	 13,5,60,52,44,36,28,
	 20,12,4,27,19,11,3};
	//定义置换选择2(PCA-2)
	int PC2trans[48]=
	{13,16,10,23,0,4,2,27,
	 14,5,20,9,22,18,11,3,
	 25,7,15,6,26,19,12,1,
	 40,51,30,36,46,54,29,39,
	 50,44,32,47,43,48,38,55,
	 33,52,45,41,49,35,28,31};
	//定义各轮的左移次数
	int NumberOfShift[16]=
	{1,1,2,2,2,2,2,2,
	 1,2,2,2,2,2,2,1};

	//首先对初始密钥做PC1变换
	int iKeyAfterPC1[56];
	int IndexOfPC1;
	for(i=0;i<56;i++)
	{
		IndexOfPC1=PC1trans[i];
		iKeyAfterPC1[i]=iKey[IndexOfPC1];
	}
	fprintf(fpDES,"密钥经PC1变换后得到：\n");
	for(i=0;i<14;i++)
	{
		for(int j=0;j<4;j++)
			fprintf(fpDES,"%d",iKeyAfterPC1[i*4+j]);
		fprintf(fpDES," ");
	}
	fprintf(fpDES,"\n");

	//得到密钥的左半部分和右半部分
	for(i=0;i<28;i++)
	{
		iCKey[i]=iKeyAfterPC1[i];
		iDKey[i]=iKeyAfterPC1[i+28];
	}
	//开始密钥扩展的16轮循环
	for(int nRoundOfKey=0;nRoundOfKey<16;nRoundOfKey++)
	{
		//做移位运算，首先取出移位次数
		int nShiftNum;
		nShiftNum=NumberOfShift[nRoundOfKey];

		//定义数组暂存移位后的数据，把两部分合在一起
		int nTempOfShift[56];
		//移位
		if(nShiftNum==1)
		{
			for(i=0;i<27;i++)
				nTempOfShift[i]=iCKey[i+1];
			nTempOfShift[27]=iCKey[0];

			for(i=28;i<55;i++)
				nTempOfShift[i]=iDKey[i+1];
			nTempOfShift[55]=iDKey[0];
		}
		else
		{
			for(i=0;i<26;i++)
				nTempOfShift[i]=iCKey[i+2];
			nTempOfShift[26]=iCKey[0];
			nTempOfShift[27]=iCKey[1];

			for(i=28;i<54;i++)
				nTempOfShift[i]=iDKey[i+2];
			nTempOfShift[54]=iDKey[0];
			nTempOfShift[55]=iDKey[1];
		}
		fprintf(fpDES,"密钥经过第%d轮移位得到：\n",nRoundOfKey);
		for(i=0;i<14;i++)
		{
			for(int j=0;j<4;j++)
				fprintf(fpDES,"%d",nTempOfShift[i*4+j]);
			fprintf(fpDES," ");
		}
		fprintf(fpDES,"\n");

		//做置换选择2(PC-2)
		for(i=0;i<48;i++)
		{
			int IndexOfPC2;
			IndexOfPC2=PC2trans[i];
			iKeyOfRound[nRoundOfKey][i]=nTempOfShift[IndexOfPC2];
		}
		fprintf(fpDES,"密钥经过置换选择2得到第%d轮子密钥：\n",nRoundOfKey);
		for(i=0;i<12;i++)
		{
			for(int j=0;j<4;j++)
				fprintf(fpDES,"%d",iKeyOfRound[nRoundOfKey][i*4+j]);
			fprintf(fpDES," ");
		}
		fprintf(fpDES,"\n");

		//将暂存数组赋给下一轮的左半部分和右半部分
		for(i=0;i<28;i++)
		{
			iCKey[i]=nTempOfShift[i];
			iDKey[i]=nTempOfShift[i+28];
		}
	}

	//////////////////////////////////////////////////////////////
	/*密钥已经生成，下面开始DES加密*/
	//////////////////////////////////////////////////////////////

	//初始置换IP
	int iIPofPlain[64];
	int IPindex[64]={57,49,41,33,25,17,9,1,59,51,43,35,27,19,11,3,
		             61,53,45,37,29,21,13,5,63,55,47,39,31,23,15,7,
					 56,48,40,32,24,16,8,0,58,50,42,34,26,18,10,2,
					 60,52,44,36,28,20,12,4,62,54,46,38,30,22,14,6};
	int IndexOfIP;
	for(i=0;i<64;i++)
	{
		IndexOfIP=IPindex[i];
		iIPofPlain[i]=iPlainText[IndexOfIP];
	}
	fprintf(fpDES,"\n\n");
	fprintf(fpDES,"明文经过初始置换得到：\n");
	for(i=0;i<16;i++)
	{
		for(int j=0;j<4;j++)
			fprintf(fpDES,"%d",iIPofPlain[i*4+j]);
		fprintf(fpDES," ");
	}
	fprintf(fpDES,"\n");

	//得到L0和R0
	for(i=0;i<32;i++)
	{
		iLeftText[i]=iIPofPlain[i];
		iRightText[i]=iIPofPlain[i+32];
	}

	///////////////////////////////////////////////////////////////
	/*16轮循环*/
	///////////////////////////////////////////////////////////////

	//定义扩充/置换的脚标序列
	int IndexOfE[48]={31,0,1,2,3,4,3,4,5,6,7,8,
		              7,8,9,10,11,12,11,12,13,14,15,16,
					  15,16,17,18,19,20,19,20,21,22,23,24,
					  23,24,25,26,27,28,27,28,29,30,31,0};
	//定义S盒变换
	int S[8][4][16]=
	{{{14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7},
	{0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8},
	{4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0},
	{15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13}},
	{{15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10},
	{3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5},
	{0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15},
	{13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9}},
	{{10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8},
	{13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1},
	{13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7},
	{1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12}},
	{{7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15},
	{13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9},
	{10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4},
	{3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14}},
	{{2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9},
	{14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6},
	{4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14},
	{11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3}},
	{{12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11},
	{10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8},
	{9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6},
	{4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13}},
	{{4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1},
	{13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6},
	{1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2},
	{6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12}},
	{{13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7},
	{1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2},
	{7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8},
	{2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11}}};
	//定义S盒输出值对应的二进制
	int BinaryOfS[16][4]=
	{{0,0,0,0},{0,0,0,1},{0,0,1,0},{0,0,1,1},	
	{0,1,0,0},{0,1,0,1},{0,1,1,0},{0,1,1,1},
	{1,0,0,0},{1,0,0,1},{1,0,1,0},{1,0,1,1},
	{1,1,0,0},{1,1,0,1},{1,1,1,0},{1,1,1,1}};
	//定义P置换函数
	int Ptrans[32]=
	{15,6,19,20,28,11,27,16,
	 0,14,22,25,4,17,30,9,
	 1,7,23,13,31,26,2,8,
	 18,12,29,5,21,10,3,24};

	//////////////////////////////////////////////////////////////
	/*16轮DES加密*/
	//////////////////////////////////////////////////////////////

	for(int nRound=0;nRound<16;nRound++)
	{
		int iEofRight[48];     //扩充/置换后的数据
		//暂存一轮变换后的右半部分
		int iTempOfRight[32];

		//扩充/置换变换
		for(i=0;i<48;i++)
		{
			int IndexOfEtrans;
			IndexOfEtrans=IndexOfE[i];
			iEofRight[i]=iRightText[IndexOfEtrans];
		}
		fprintf(fpDES,"第%d轮DES置换变换后的数据：\n",nRound);
		for(i=0;i<12;i++)
		{
			for(int j=0;j<4;j++)
				fprintf(fpDES,"%d",iEofRight[i*4+j]);
			fprintf(fpDES," ");
		}
		fprintf(fpDES,"\n");

		//与该轮密钥做异或
		for(i=0;i<48;i++)
			iEofRight[i]=iEofRight[i]^iKeyOfRound[nRound][i];
		fprintf(fpDES,"第%d轮DES经与子密钥异或后的数据：\n",nRound);
		for(i=0;i<12;i++)
		{
			for(int j=0;j<4;j++)
				fprintf(fpDES,"%d",iEofRight[i*4+j]);
			fprintf(fpDES," ");
		}
		fprintf(fpDES,"\n");

		//S盒变换
		int nTempOfS[32];
		for(i=0;i<8;i++)
		{
			//确定S盒的行和列
			int nRow;
			int nColumn;
			nRow=iEofRight[i*6]*2;
			nRow+=iEofRight[i*6+5];
			nColumn=iEofRight[i*6+1]*8+iEofRight[i*6+2]*4+iEofRight[i*6+3]*2+iEofRight[i*6+4];
			//取出S盒的数据
			int nDataOfS;
			nDataOfS=S[i][nRow][nColumn];
			//得到对应的二进制，赋给暂存数组
			for(int j=0;j<4;j++)
				nTempOfS[i*4+j]=BinaryOfS[nDataOfS][j];
		}
		fprintf(fpDES,"第%d轮DES经S盒变换以后的数据：\n",nRound);
		for(i=0;i<8;i++)
		{
			for(int j=0;j<4;j++)
				fprintf(fpDES,"%d",nTempOfS[i*4+j]);
			fprintf(fpDES," ");
		}
		fprintf(fpDES,"\n");

		//对经过S盒变换的数据做置换P
		int nTempOfP[32];
		for(i=0;i<32;i++)
		{
			int IndexOfP;
			IndexOfP=Ptrans[i];
			nTempOfP[i]=nTempOfS[IndexOfP];
		}
		fprintf(fpDES,"第%d轮DES经置换P之后的数据：\n",nRound);
		for(i=0;i<8;i++)
		{
			for(int j=0;j<4;j++)
				fprintf(fpDES,"%d",nTempOfP[i*4+j]);
			fprintf(fpDES," ");
		}
		fprintf(fpDES,"\n");

		//与左半部分的数据做异或得到右半部分，存在暂存数组中
		for(i=0;i<32;i++)
			iTempOfRight[i]=nTempOfP[i]^iLeftText[i];
		//赋予新的左半部分和右半部分
		for(i=0;i<32;i++)
		{
			iLeftText[i]=iRightText[i];
			iRightText[i]=iTempOfRight[i];
		}
		fprintf(fpDES,"经第%d轮DES加密得到的数据：\n",nRound);
		for(i=0;i<8;i++)
		{
			for(int j=0;j<4;j++)
				fprintf(fpDES,"%d",iLeftText[i*4+j]);
			fprintf(fpDES," ");
		}
		for(i=0;i<8;i++)
		{
			for(int j=0;j<4;j++)
				fprintf(fpDES,"%d",iRightText[i*4+j]);
			fprintf(fpDES," ");
		}
		fprintf(fpDES,"\n");
	}

	/////////////////////////////////////////////////////////
	/*16轮变换已经完成，下面交换两部分，再做逆初始置换从而得到密文*/
	/////////////////////////////////////////////////////////

	//两部分交换
	int nTempOfCipher[64];
	for(i=0;i<32;i++)
	{
		nTempOfCipher[i]=iRightText[i];
		nTempOfCipher[i+32]=iLeftText[i];
	}
	//逆初始置换
	int InvOfIP[64]=
	{39,7,47,15,55,23,63,31,
	 38,6,46,14,54,22,62,30,
	 37,5,45,13,53,21,61,29,
	 36,4,44,12,52,20,60,28,
	 35,3,43,11,51,19,59,27,
	 34,2,42,10,50,18,58,26,
	 33,1,41,9,49,17,57,25,
	 32,0,40,8,48,16,56,24};
	for(i=0;i<64;i++)
	{
		int IndexOfInv;
		IndexOfInv=InvOfIP[i];
		iCipherText[i]=nTempOfCipher[IndexOfInv];
	}
	fprintf(fpDES,"最后得到的密文为：\n");
	for(i=0;i<16;i++)
	{
		for(int j=0;j<4;j++)
			fprintf(fpDES,"%d",iCipherText[i*4+j]);
		fprintf(fpDES," ");
	}
	fprintf(fpDES,"\n");
	fclose(fpDES);	
}