desdlg.cpp

DES的算法实现

		return 1;
	else
        return 0;

}


void CDESDlg::InitialPermuteData(CString s,char* Return_value,bool bType)
{
	//if bType==true is encrypt
	//else is decrypt
	if(bType)
	{
		char sz_64data[64] = {0};
		int iTmpBit[64] = {0};
		for(int i=0;i<64;i++)
		{
			iTmpBit[i] = (s[i>>3]>>(i&7)) & 1;
			//a = 0x61 = 0110,0001
			//after this , a is 1000,0110
			
		}
		//let me convert it to right
		for(int j=0;j<8;j++)
			for(int k=0;k<8;k++)
				sz_64data[8*j+k] = SingleBinaryToChar(iTmpBit[8*(j+1)-(k+1)]);
			//IP
			char sz_IPData[64] = {0};
			for(int k=0;k<64;k++)
			{
				sz_IPData[k] = sz_64data[IP_Table[k]-1];
			}
			memcpy(Return_value,sz_IPData,64);
	}
	else
	{
		CString sz_64data;
		for(unsigned int ui=0;ui < s.GetLength();ui++)
		{
			char ch = s.GetAt(ui);			
			
			sz_64data += HexCharToBinary(tolower(ch));
		}
		char sz_IPData[64] = {0};
		for(int i=0;i<64;i++)
		{
			sz_IPData[i] = sz_64data[IP_Table[i]-1];
		}
		memcpy(Return_value,sz_IPData,64);
	}


}


CString CDESDlg::HexCharToBinary(char ch)
{
	switch(ch)
	{
	case '0':
		return "0000";
	case '1':
		return "0001";
	case '2':
		return "0010";
	case '3':
		return "0011";
	case '4':
		return "0100";
	case '5':
		return "0101";
	case '6':
		return "0110";
	case '7':
		return "0111";
	case '8':
		return "1000";
	case '9':
		return "1001";
	case 'a':
		return "1010";
	case 'b':
		return "1011";
	case 'c':
		return "1100";
	case 'd':
		return "1101";
	case 'e':
		return "1110";
	case 'f':
		return "1111";
	default:
		return "";
	}
}

CString CDESDlg::HexIntToBinary(int i)
{
	switch(i)
	{
	case 0:
		return "0000";
	case 1:
		return "0001";
	case 2:
		return "0010";
	case 3:
		return "0011";
	case 4:
		return "0100";
	case 5:
		return "0101";
	case 6:
		return "0110";
	case 7:
		return "0111";
	case 8:
		return "1000";
	case 9:
		return "1001";
	case 10:
		return "1010";
	case 11:
		return "1011";
	case 12:
		return "1100";
	case 13:
		return "1101";
	case 14:
		return "1110";
	case 15:
		return "1111";
	default:
		return "";
	}
}


void CDESDlg::EncryptData(CString s)
{
	char sz_IP[64] = {0};
	char sz_Li[32] = {0};
	char sz_Ri[32] = {0};
	char sz_Final64[64] = {0};
	char szCiphertextBinary[64] = {0};
	//IP
	CDESDlg::InitialPermuteData(s,sz_IP,true);
	memcpy(sz_Li,sz_IP,32);
	memcpy(sz_Ri,sz_IP + 32,32);
	
	for(int i=0;i<16;i++)
	{
		FunctionF(sz_Li,sz_Ri,i);
	}
	//so D=LR
	
	memcpy(sz_Final64,sz_Ri,32);//原版为memcpy(sz_Final64,sz_Li,32)
	memcpy(sz_Final64 + 32,sz_Li,32);//原版为memcpy(sz_Final64 + 32,sz_Ri,32)
	
	//~IP
	for(int j=0;j<64;j++)
	{
		szCiphertextBinary[j] = sz_Final64[IPR_Table[j]-1];
	}
	memcpy(ciptext,(char *)(LPCTSTR)BinaryToString(szCiphertextBinary,64,true),16);
	memset(ciptext+16 ,0,1);
}



void CDESDlg::FunctionF(char* sz_Li,char* sz_Ri,int iKey)
{
	char sz_48R[48] = {0};
	char sz_xor48[48] = {0};
	char sz_P32[32] = {0};
	char sz_Rii[32] = {0};
	char sz_Key[48] = {0};
	memcpy(sz_Key,SubKeys[iKey],48);
	ExpansionR(sz_Ri,sz_48R);
	XOR(sz_48R,sz_Key,48,sz_xor48);
	CString s_Compress32 = CompressFuncS(sz_xor48);
	PermutationP(s_Compress32,sz_P32);
	XOR(sz_P32,sz_Li,32,sz_Rii);
	memcpy(sz_Li,sz_Ri,32);
	memcpy(sz_Ri,sz_Rii,32);
}

void CDESDlg::ExpansionR(char* sz,char* Return_value)
{
	char sz_48ER[48] = {0};
	for(int i=0;i<48;i++)
	{
		sz_48ER[i] = sz[E_Table[i]-1];
	}
	memcpy(Return_value,sz_48ER,48);
}



void CDESDlg::XOR(char* sz_P1,char* sz_P2,int len,char* Return_value)
{
	char sz_Buffer[256] = {0};
	for(int i=0;i<len;i++)
	{
		sz_Buffer[i] = SingleBinaryToChar(SingleCharToBinary(sz_P1[i]) ^ SingleCharToBinary(sz_P2[i]));
	}
	memcpy(Return_value,sz_Buffer,len);
}


CString CDESDlg::CompressFuncS(char* sz_48)
{
	char sTmp[8][6] = {0};
    CString sz_32 = "";
	for(int i=0;i<8;i++)
	{
		memcpy(sTmp[i],sz_48 + 6 * i,6);
		int iX = SingleCharToBinary(sTmp[i][0]) * 2 + SingleCharToBinary(sTmp[i][5]);
		int iY = 0;
		for(int j=1;j<5;j++)
		{
			iY += SingleCharToBinary(sTmp[i][j]) * pow(2.0,4-j);
		}
		sz_32 += HexIntToBinary(S_Box[i][iX][iY]);
	}
	return sz_32;
}

void CDESDlg::PermutationP(CString s,char* Return_value)
{
	char sz_32bits[32] = {0};
	for(int i=0;i<32;i++)
	{
		sz_32bits[i] = s.GetAt(P_Table[i]-1);   
		
	}
	memcpy(Return_value,sz_32bits,32);
}

CString CDESDlg::BinaryToString(char* szSource,int len,bool bType)
{
	//bType == true is Binary to Hex
	//else is Binary to Char
	int ilen;
	if(len % 8 != 0)
		return "";
	else
		ilen = len / 8;
	
	CString s_return = "";
	for(int i=0;i<ilen;i++)
	{
		char szTmp8[8] = {0};
		int iCh = 0;
		memcpy(szTmp8,szSource+8*i,8);
		for(int j=0;j<8;j++)
		{
			iCh+=SingleCharToBinary(szTmp8[j]) * pow(2.0,7-j);
		}
		if(bType)
		{
			char buffer[16] = {0};
			itoa(iCh,buffer,16);
			//if the integer less than 16,insert a zero to buffer
			if(iCh < 16)
			{
				char cTmp = buffer[0];
				buffer[0] = '0';
				buffer[1] = cTmp;
			}
			s_return += buffer[0];
			s_return += buffer[1];
			buffer[0] = '\0';
			buffer[1] = '\0';
		}
		else
		{
			char ch = (char)iCh;
			s_return += ch;
		}
	}
	
	return s_return;
}


void CDESDlg::DecryptData(CString s)
{
	char sz_IP[64] = {0};
	char sz_Li[32] = {0};
	char sz_Ri[32] = {0};
	char sz_Final64[64] = {0};
	char szPlaintextBinary[64] = {0};
	//IP --- return is sz_IP
	InitialPermuteData(s,sz_IP,false);
	//divide the 64 bits data to two parts
	memcpy(sz_Ri,sz_IP,32); //exchange L to R
	memcpy(sz_Li,sz_IP + 32,32);  //exchange R to L
	
	//16 rounds F and xor and exchange
	for(int i=0;i<16;i++)
	{
		FunctionF(sz_Ri,sz_Li,15-i);
	}
	//the round 16 will not exchange L and R
	memcpy(sz_Final64,sz_Li,32);
	memcpy(sz_Final64 + 32,sz_Ri,32);
	
	// ~IP
	for(int j=0;j<64;j++)
	{
		szPlaintextBinary[j] = sz_Final64[IPR_Table[j]-1];
	}
	memcpy(cleartext,(char *)(LPCTSTR)BinaryToString(szPlaintextBinary,64,false),8);
	memset(cleartext + 8,0,1);
}