des.cpp

该文本对DES设计做了详细介绍

#include "stdafx.h"
#include <iostream.h>
#include "DES.h"

/*
 *DES的构造函数
 *参数:dataParam[]原文, keyParam[]密钥,dataLengthParam原文长度, keyLengthParam密钥长度
 */
DES::DES(char dataParam[], char keyParam[], int dataLengthParam,int keyLengthParam)
{
	int i,j;
   int dataLength = dataLengthParam;
   int keyLength = keyLengthParam;
	for(i=0; i<dataLength; i++)
	{
	   data[i] = dataParam[i];
	}
	for(i; i<64; i++)   //长度不足64位的部分用0补足, 48就是ASC||码中0的数值
	{
		 data[i] = 48;
	}
	for( j=0; j<keyLength; j++)
	{
		key[j] =keyParam[j];
	}
	for(j; j<64; j++)  //长度不足64位的部分用0补足, 48就是ASC||码中0的数值
	{
		 key[j] = 48;
	}
	InitialTables();
	DESInitialPermutation();

}
//初始化算法中用到的转换的表格
void DES::InitialTables()
 {
	 int LEvenTableTemp[] = { 58,50,42,34,26,18,10,2,
		            60,52,44,36,28,20,12,4,
				    62,54,46,38,30,22,14,6,
				    64,56,48,40,32,24,16,8 };
	 for(int i=0; i<32; i++)
	 { LEvenTable [i] = LEvenTableTemp[i];}

	int ROddTableTemp[] =  { 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};
	for( i=0; i<32; i++)
	{ ROddTable[i] = ROddTableTemp[i];}


	int ETableTemp[] ={32,  1,  2,  3,  4,  5,
		                4,  5,  6,  7,  8,  9,
					    8,  9, 10, 11, 12, 13,
					   12, 13, 14, 15, 16, 17,
					   16, 17, 18, 19, 20, 21,
					   20, 21, 22, 23, 24, 25,
					   24, 25, 26, 27, 28, 29,
					   28, 29, 30, 31, 32, 1 };
	for(int k=0; k<48; k++)
	{ ETable[k] = ETableTemp[k];}

	  int SBox1Temp[] = {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 };
	  for(int s1=0; s1<64; s1++)
      {  SBox1[s1] = SBox1Temp[s1];}
	  

	 int SBox2Temp[]  = {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 }; 
		 for(int s2=0; s2<64; s2++)
      {  SBox2[s2] = SBox2Temp[s2];}

	  int SBox3Temp[] =  {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 };
		for(int s3=0; s3<64; s3++)
      {  SBox3[s3] = SBox3Temp[s3];}

	  int SBox4Temp[] =  {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} ;
	  for(int s4=0; s4<64; s4++)
      {  SBox4[s4] = SBox4Temp[s4];}

	  int SBox5Temp[] =  {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 }; 
					  for(int s5=0; s5<64; s5++)
      {  SBox5[s5] = SBox5Temp[s5];}

	  int SBox6Temp[]  = {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};
					   for(int s6=0; s6<64; s6++)
      {  SBox6[s6] = SBox6Temp[s6];}

	  int SBox7Temp[]  = {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};
					   for(int s7=0; s7<64; s7++)
      {  SBox7[s7] = SBox7Temp[s7];}

	  int SBox8Temp[]  = {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};
					   for(int s8=0; s8<64; s8++)
      {  SBox8[s8] = SBox8Temp[s8];}

	   

	  int PTableTemp[] = {16,7,20,21,29,12,28,17,
		               1,15,23,26,5,18,31,10,
					   2,8,24,14,32,27,3,9,
					   19,13,30,6,22,11,4,25 };
	  for(int p=0; p <32; p++)
	  { PTable[p] = PTableTemp[p]; }

	  int PC2TableTemp[] = {14,17,11,24,1,5,3,28,
		                 15,6,21,10,23,19,12,4,
						 26,8,16,7,27,20,13,2,
						 41,52,31,37,47,55,30,40,
						 51,45,33,48,44,49,39,56,
						 34,53,46,42,50,36,29,32 };
	  for(int t=0; t<48; t++)
	  { PC2Table[t] = PC2TableTemp[t];}

	  int KeyTableTemp[] = { 57, 49, 41, 33, 25, 17,  9,
							 1, 58, 50, 42, 34, 26, 18,
							 10,  2, 59, 51, 43, 35, 27, 
							 19, 11,  3, 60, 52, 44, 36, 
						     63, 55, 47, 39, 31, 23, 15, 
							 7, 62, 54, 46, 38, 30, 22,
							 14,  6, 61, 53, 45, 37, 29,
							 21, 13,  5, 28, 20, 12,  4};

	  for(int key=0; key<28; key++)
	  {
		  KeyTableC[key] =KeyTableTemp[key];
	     KeyTableD[key] =KeyTableTemp[key+28];
	  }

	  int finalTableTemp[] = {40,8,48,16,56,24,64,32,
		  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};
	  for(int f=0; f<64; f++)
	  {FinalTable[f] = finalTableTemp[f];}
	   
 }
/*
 *功能：DES初始变换
 */
void DES::DESInitialPermutation()
{
    Permutation( data,LEvenTable,32,leftData);
    Permutation( data, ROddTable, 32,rightData);
}

void DES::ExpansionPermulation(char *rightData, char * result)
{
   Permutation(rightData, ETable,48, result);
}

/*
 *功能：对位实现异或操作，并将结果保存在xorResult中
 *参数：a，b将要对其进行异或操作的两个数组
 */
void DES::XOR(char *a, char *b,int time, char* xorResult)
{
	for(int i=0; i<time; i++)
	{
		xorResult[i] =((a[i] &1 )^ (b[i]&1 ))+48;
	}
}

/*
*功能：Substitution根据SBox的值，将48位数变成32位数
*/
void DES::Substitution(char *rightData, char * result)
{
	int p1,p2,p3,p4,p5,p6,row,colum,sboxResult;
    for(int i=0; i<8; i++)
	{
	   p1 = (int) rightData[i*6 +0]-48 ;
	   p2 = (int) rightData[i*6 +1]-48;
	   p3 = (int) rightData[i*6 +2]-48 ;
	   p4 = (int) rightData[i*6 +3]-48;
	   p5 = (int) rightData[i*6 +4]-48;
	   p6 = (int) rightData[i*6 +5]-48;
	   if(p1 > 0) p1 =1; else p1 =0;
	   if(p2 > 0) p2 =1;else p2 =0;
	   if(p3 > 0) p3 =1;else p3 =0;
	   if(p4 > 0) p4 =1;else p4 =0;
	   if(p5 > 0) p5 =1;else p5 =0;
	   if(p6 > 0) p6 =1;else p6 =0;
	   row = p1*2 + p6;
	   colum = p2*8 + p3*4 + p4*2 + p5;

	 sboxResult = SearchSBox(i+1, row,colum);
     DecimalToChar(result, i*4, sboxResult);	
	}
}
/*
*功能：查找SBox，取出保存在其中的值
*参数：tableNo所要查找的SBox编号，row行号，colum列号
*/
int DES::SearchSBox(int tableNo, int row, int colum)
{
	int result;
	int index = row*16 + colum;
	if(tableNo == 1)
		result = SBox1[index];
	else if(tableNo == 2)
		result = SBox2[index];
	else if(tableNo == 3)
		result = SBox3[index];
	else if(tableNo == 4)
		result = SBox4[index];
	else if(tableNo == 5)
		result = SBox5[index];
	else if(tableNo ==6)
		result = SBox6[index];
	else if(tableNo == 7)
		result = SBox7[index];
	else 
		result = SBox8[index];
	
	return result;
}
/*
 *功能：根据查SBox所得的结果，将十进制数转换成二进制
 *参数：chang保存结果的数组， indexFrom保存在数组中的起始下标，number查SBox的结果
*/
void DES::DecimalToChar(char *change, int indexFrom, int number)
{
	int modTemp, leftTemp;
	int numTemp = number;
	for(int i=0; i <4; i++)
	{
		modTemp = numTemp % 2;
		leftTemp = numTemp /2;
		numTemp = leftTemp;
		change[indexFrom+3-i] = modTemp+48;
	}		
}

/*
 *功能：实现P置换，将32bit的数组置换
 */
void DES::PermutationFuntion(char *input, char *result)
{
	Permutation(input, PTable,32, result);
}
/*
 *功能：辅助函数，实现数组的置换
 *参数：perm数组函数交换所用的表格，initial数组将要被置换的数组
 *返回值：返回交换后的数组
 */
void DES::Permutation(char *initial, int *perm,int length, char* result)
  {
    for(int i=0; i<length; i++)
    {
      result[i]=initial[perm[i]-1];
    }
    return ;
  }

/*
 *对外提供的DES加解密的函数
 *参数: round循环的次数,主要是为了产生中间结果,当round=16时,就一次性完成加解密.
 * result保存加解密后的结果, flag="E"时执行加密, 否则执行解密
 */
void DES::Encry( int round,char *result, char flag)
{
	char temp32Sec[32];
	

	for(int r =1; r <=round; r++)
    {
		

	ExpansionPermulation((char *)rightData,(char *) temp48);
	//产生第r循环的key
	if(flag=='e' || flag=='E')   //执行加密
	GenerateKey((char *) tempKey48, r);
	else
	GenerateKey((char *) tempKey48,  17-r);

	XOR((char *)temp48, (char *) tempKey48, 48, (char *)temp48);
	Substitution((char *)temp48, (char *)temp32);
    PermutationFuntion((char *)temp32,(char *) temp32Sec);
    XOR((char *)leftData, (char *)temp32Sec, 32, (char *)temp32);

	 for(int i=0; i<32; i++)
	  {leftData[i] = rightData[i];}
	for(int j=0; j<32; j++)
	{ rightData[j] = temp32[j]; }
	 

	}
	//最后一轮循环不需要左右交换
	if(round == 16)
	{
    for(int t=0; t<32; t++)
	{ 
		rightData[t] = leftData[t]; 
		leftData[t] = temp32[t];
	
	}
	}


	//最后的处理，先将左，右的32位的数组合并成一个64位的
	for(int l=0; l<32; l++)
	{
		temp64[l] = leftData[l];
	}
	for(int k=32; k<64; k++)
	{
		temp64[k] = rightData[k-32];
	}

	//将合并后的结果最后做一次置换
	Permutation((char *)temp64, FinalTable,64,  result);

}

 

 /*
  *功能：根据ScheduleTable判断key要左移的位数
  *返回：返回左移的次数
  */
 int DES::ShiftTimes(int round)
 {
	 if(round==1 || round==2 || round==9 || round==16)
		 return 1;
	 else
		 return 2;
 }

 /*
  *功能：将64位的初时key转换成两个28位的半keyC和D
  *参数：key，64位的输入key。outputKeyC，outputKeyD 28位的输出key
  */
 void DES::InitialKey(char *key, char *outputKeyC, char *outputKeyD)
 {
    Permutation(key, KeyTableC,28,  outputKeyC);
	Permutation(key, KeyTableD,28,  outputKeyD);
 }

 /*
  *功能：根据ShiftTimes的返回值，将两个输入分别左移相应的位数
  *参数：inputC，inputD两个28位的将要被左移的key， round次数
  */
 void DES:: Shift(char *inputC, char *inputD,int round)
 {
	 int shiftPosition = ShiftTimes(round);
	 char tempC = inputC[0];
	 char tempD = inputD[0];
	 if(shiftPosition == 1)
	 {
		 
	   for(int i=0; i<27; i++)
	   {
		 inputC[i] = inputC[i+1];
	     inputD[i] = inputD[i+1];
	   }
	   inputC[27] = tempC;
	   inputD[27] = tempD;
	 }
	 else
	 {
		 char tempC1 = inputC[1];
		 char tempD1 = inputD[1];
	   for(int j=0; j<26; j++)
	   {
		 inputC[j] = inputC[j+2];
	     inputD[j] = inputD[j+2];
	   }
	   inputC[26] = tempC;
	   inputC[27] = tempC1;
	   inputD[26] = tempD;
	   inputD[27] = tempD1;
	 }
 
 }

 /*
  *功能：将2个28位的输入key合并成56位，并根据PC2Table表格，转换成48位的key输出
  *参数：inputC，inputD输入的左右两个28位的左移后的key. result转换后的48位的输出key
  */
 void DES::PermuChoiceTwo(char *inputC, char *inputD, char *result)
 {
	 char temp[56];
	 for(int i=0; i<28; i++)
	 {temp[i] = inputC[i];}
	 for(i; i<56; i++)
	 {temp[i] = inputD[i];}
     Permutation((char *)temp, PC2Table,48,  result);

 }

 /*
  *功能：输出第round循环后得到的key
  *参数  result返回的结果即第round轮的key，round循环的次数
  */

 void DES::GenerateKey( char *result, int round)
 {
	 char inputC[28];
	 char inputD[28];
	 InitialKey(key, (char *)inputC, (char *)inputD);
	 for(int i=1; i<=round; i++)
	 {
      Shift((char *)inputC, (char *)inputD, i);
	  PermuChoiceTwo((char *)inputC, (char *)inputD, result);
	 }
 }