des.cpp

用C++开发的一个简单的DES加密解密程序

// DES.cpp: implementation of the CDES class.
//
//////////////////////////////////////////////////////////////////////
#include "iostream"
#include "string"
#include "stdlib.h"
using namespace std;

#include "DES.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CDES::CDES(char* data, char* key)
{
	strcpy(this->data,data);
	this->data[strlen(this->data)] = '\0';
	strcpy(this->Compkey,key);
	this->Compkey[strlen(this->Compkey)] = '\0';

	cout << endl << "DATA:";
	print(this->data,DATA_LENGTH);
	cout << endl << "KEY:";
	print(this->Compkey,KEY_TOTAL_LENGTH);

	FillAllS();
//	SampleKeys();
}

CDES::~CDES()
{

}

char* CDES::Encrypt()
{
	// Calculate Keys
	GenKeys();

	// Begin Encryption
#ifdef SDES
	char *ip = DataIP(); // Initial Permutation on Input bits
#else
	char *ip = DataIP_DES();
#endif

	cout << endl << "Initial Permutation";
	print(ip,DATA_LENGTH);

	char *loopData = ip;
	char *FKr;

	for (int i = 1 ; i <= NO_OF_KEYS ; i++)
	{
		FKr = FKFunction(loopData,i);

		cout << endl << "FK" << i << " Result";
		print(FKr,DATA_LENGTH);

		if (i != NO_OF_KEYS)
		{
			loopData = Switch(FKr);
			
			cout << endl << "Switch Result";
			print(loopData,DATA_LENGTH);
		}
		else
		{
			loopData = FKr;
		}
	}

	char *IPinv = IPInverse(loopData);

	cout << endl << "IP Inverse";
	print(IPinv,DATA_LENGTH);

	return IPinv;
}

char* CDES::keyIPermutation()
{
#ifdef SDES
	char *keyP = new char[KEY_TOTAL_LENGTH];

	keyP[0] = Compkey[3-1];
	keyP[1] = Compkey[5-1];
	keyP[2] = Compkey[2-1];
	keyP[3] = Compkey[7-1];
	keyP[4] = Compkey[4-1];
	keyP[5] = Compkey[10-1];
	keyP[6] = Compkey[1-1];
	keyP[7] = Compkey[9-1];
	keyP[8] = Compkey[8-1];
	keyP[9] = Compkey[6-1];
#else
	char *keyP = new char[KEY_USED_BITS];

	keyP[0] = Compkey[57-1];
	keyP[1] = Compkey[49-1];
	keyP[2] = Compkey[41-1];
	keyP[3] = Compkey[33-1];
	keyP[4] = Compkey[25-1];
	keyP[5] = Compkey[17-1];
	keyP[6] = Compkey[9-1];
	keyP[7] = Compkey[1-1];
	keyP[8] = Compkey[58-1];
	keyP[9] = Compkey[50-1];
	keyP[10] = Compkey[42-1];
	keyP[11] = Compkey[34-1];
	keyP[12] = Compkey[26-1];
	keyP[13] = Compkey[18-1];
	keyP[14] = Compkey[10-1];
	keyP[15] = Compkey[2-1];
	keyP[16] = Compkey[59-1];
	keyP[17] = Compkey[51-1];
	keyP[18] = Compkey[43-1];
	keyP[19] = Compkey[35-1];
	keyP[20] = Compkey[27-1];
	keyP[21] = Compkey[19-1];
	keyP[22] = Compkey[11-1];
	keyP[23] = Compkey[3-1];
	keyP[24] = Compkey[60-1];
	keyP[25] = Compkey[52-1];
	keyP[26] = Compkey[44-1];
	keyP[27] = Compkey[63-1];
	keyP[28] = Compkey[63-1];
	keyP[29] = Compkey[55-1];
	keyP[30] = Compkey[47-1];
	keyP[31] = Compkey[39-1];
	keyP[32] = Compkey[31-1];
	keyP[33] = Compkey[23-1];
	keyP[34] = Compkey[15-1];
	keyP[35] = Compkey[7-1];
	keyP[36] = Compkey[62-1];
	keyP[37] = Compkey[54-1];
	keyP[38] = Compkey[46-1];
	keyP[39] = Compkey[38-1];
	keyP[40] = Compkey[30-1];
	keyP[41] = Compkey[22-1];
	keyP[42] = Compkey[14-1];
	keyP[43] = Compkey[6-1];
	keyP[44] = Compkey[61-1];
	keyP[45] = Compkey[53-1];
	keyP[46] = Compkey[45-1];
	keyP[47] = Compkey[37-1];
	keyP[48] = Compkey[29-1];
	keyP[49] = Compkey[21-1];
	keyP[50] = Compkey[13-1];
	keyP[51] = Compkey[5-1];
	keyP[52] = Compkey[28-1];
	keyP[53] = Compkey[20-1];
	keyP[54] = Compkey[12-1];
	keyP[55] = Compkey[4-1];
#endif

	return keyP;
}

char* CDES::LeftShift(char *keyPF, char LorR, int bits)
{
	char *sbits = new char[KEY_USED_BITS/2];
	int i,k;

	if (LorR == 'L')		// shift left bits
	{
		for (i = 0,k = 0 ; i < (KEY_USED_BITS/2) ; i++,k++)
		{
			sbits[i] = keyPF[k];
		}
	}
	else if (LorR == 'R')	// shift right bits
	{
		for (i = 0,k = (KEY_USED_BITS/2) ; i < (KEY_USED_BITS/2) ; i++,k++)
		{
			sbits[i] = keyPF[k];
		}
	}

	char temb;

	// Shift the Bits
	for (i = 1 ; i <= bits ; i++)
	{
		temb = sbits[(KEY_USED_BITS/2)-1];
		for (int k = 0 ; k < (KEY_USED_BITS/2) ; k++)
		{
			if ((KEY_USED_BITS/2)-1 == k)
				sbits[(k+((KEY_USED_BITS/2)-1)) % (KEY_USED_BITS/2)] = temb;
			else
				sbits[(k+((KEY_USED_BITS/2)-1)) % (KEY_USED_BITS/2)] = sbits[k];
		}
	}

	return sbits;
}

char* CDES::JoinShifted(char *Lbits, char *Rbits)
{
	char *key1 = new char[KEY_USED_BITS];

	int i,j;

	for (i = 0 ; i < (KEY_USED_BITS/2) ; i++)
	{
		key1[i] = Lbits[i];
	}

	for (i = (KEY_USED_BITS/2),j = 0 ; j < (KEY_USED_BITS/2) ; i++,j++)
	{
		key1[i] = Rbits[j];
	}

	return key1;
}

void CDES::keyPermutationA(char *keyJoined,int k)
{
#ifdef SDES
	key[k-1][0] = keyJoined[6-1];
	key[k-1][1] = keyJoined[3-1];
	key[k-1][2] = keyJoined[7-1];
	key[k-1][3] = keyJoined[4-1];
	key[k-1][4] = keyJoined[8-1];
	key[k-1][5] = keyJoined[5-1];
	key[k-1][6] = keyJoined[10-1];
	key[k-1][7] = keyJoined[9-1];
#else
	key[k-1][0] = keyJoined[14-1];
	key[k-1][1] = keyJoined[17-1];
	key[k-1][2] = keyJoined[11-1];
	key[k-1][3] = keyJoined[24-1];
	key[k-1][4] = keyJoined[1-1];
	key[k-1][5] = keyJoined[5-1];
	key[k-1][6] = keyJoined[3-1];
	key[k-1][7] = keyJoined[28-1];
	key[k-1][8] = keyJoined[15-1];
	key[k-1][9] = keyJoined[6-1];
	key[k-1][10] = keyJoined[21-1];
	key[k-1][11] = keyJoined[10-1];
	key[k-1][12] = keyJoined[23-1];
	key[k-1][13] = keyJoined[19-1];
	key[k-1][14] = keyJoined[12-1];
	key[k-1][15] = keyJoined[4-1];
	key[k-1][16] = keyJoined[26-1];
	key[k-1][17] = keyJoined[8-1];
	key[k-1][18] = keyJoined[16-1];
	key[k-1][19] = keyJoined[7-1];
	key[k-1][20] = keyJoined[27-1];
	key[k-1][21] = keyJoined[20-1];
	key[k-1][22] = keyJoined[13-1];
	key[k-1][23] = keyJoined[2-1];
	key[k-1][24] = keyJoined[41-1];
	key[k-1][25] = keyJoined[52-1];
	key[k-1][26] = keyJoined[31-1];
	key[k-1][27] = keyJoined[37-1];
	key[k-1][28] = keyJoined[47-1];
	key[k-1][29] = keyJoined[55-1];
	key[k-1][30] = keyJoined[30-1];
	key[k-1][31] = keyJoined[40-1];
	key[k-1][32] = keyJoined[51-1];
	key[k-1][33] = keyJoined[45-1];
	key[k-1][34] = keyJoined[33-1];
	key[k-1][35] = keyJoined[48-1];
	key[k-1][36] = keyJoined[44-1];
	key[k-1][37] = keyJoined[49-1];
	key[k-1][38] = keyJoined[39-1];
	key[k-1][39] = keyJoined[56-1];
	key[k-1][40] = keyJoined[34-1];
	key[k-1][41] = keyJoined[53-1];
	key[k-1][42] = keyJoined[46-1];
	key[k-1][43] = keyJoined[42-1];
	key[k-1][44] = keyJoined[50-1];
	key[k-1][45] = keyJoined[36-1];
	key[k-1][46] = keyJoined[29-1];
	key[k-1][47] = keyJoined[32-1];
#endif
}

char* CDES::DataIP()
{
	char *dataIP = new char[DATA_LENGTH];

	dataIP[0] = data[2-1];
	dataIP[1] = data[6-1];
	dataIP[2] = data[3-1];
	dataIP[3] = data[1-1];
	dataIP[4] = data[4-1];
	dataIP[5] = data[8-1];
	dataIP[6] = data[5-1];
	dataIP[7] = data[7-1];

	return dataIP;
}

char* CDES::DataIP_DES()
{
	char *dataIP = new char[DATA_LENGTH];

	dataIP[0] = data[58-1];
	dataIP[1] = data[50-1];
	dataIP[2] = data[42-1];
	dataIP[3] = data[34-1];
	dataIP[4] = data[26-1];
	dataIP[5] = data[18-1];
	dataIP[6] = data[10-1];
	dataIP[7] = data[2-1];
	dataIP[8] = data[60-1];
	dataIP[9] = data[52-1];
	dataIP[10] = data[44-1];
	dataIP[11] = data[36-1];
	dataIP[12] = data[28-1];
	dataIP[13] = data[20-1];
	dataIP[14] = data[12-1];
	dataIP[15] = data[4-1];
	dataIP[16] = data[62-1];
	dataIP[17] = data[54-1];
	dataIP[18] = data[46-1];
	dataIP[19] = data[38-1];
	dataIP[20] = data[30-1];
	dataIP[21] = data[22-1];
	dataIP[22] = data[14-1];
	dataIP[23] = data[6-1];
	dataIP[24] = data[64-1];
	dataIP[25] = data[56-1];
	dataIP[26] = data[48-1];
	dataIP[27] = data[40-1];
	dataIP[28] = data[32-1];
	dataIP[29] = data[24-1];
	dataIP[30] = data[16-1];
	dataIP[31] = data[8-1];
	dataIP[32] = data[57-1];
	dataIP[33] = data[49-1];
	dataIP[34] = data[41-1];
	dataIP[35] = data[33-1];
	dataIP[36] = data[25-1];
	dataIP[37] = data[17-1];
	dataIP[38] = data[9-1];
	dataIP[39] = data[1-1];
	dataIP[40] = data[59-1];
	dataIP[41] = data[51-1];
	dataIP[42] = data[43-1];
	dataIP[43] = data[35-1];
	dataIP[44] = data[27-1];
	dataIP[45] = data[19-1];
	dataIP[46] = data[11-1];
	dataIP[47] = data[3-1];
	dataIP[48] = data[61-1];
	dataIP[49] = data[53-1];
	dataIP[50] = data[45-1];
	dataIP[51] = data[37-1];
	dataIP[52] = data[29-1];
	dataIP[53] = data[21-1];
	dataIP[54] = data[13-1];
	dataIP[55] = data[5-1];
	dataIP[56] = data[63-1];
	dataIP[57] = data[55-1];
	dataIP[58] = data[47-1];
	dataIP[59] = data[39-1];
	dataIP[60] = data[31-1];
	dataIP[61] = data[23-1];
	dataIP[62] = data[15-1];
	dataIP[63] = data[7-1];

	return dataIP;
}

char* CDES::ExtendedPermutation(char *right)
{
	char* ep = new char[KEY_P_LENGTH];
	int i = DATA_LENGTH/2;

#ifdef SDES
	ep[0] = right[i+4-1];
	ep[1] = right[i+1-1];
	ep[2] = right[i+2-1];
	ep[3] = right[i+3-1];
	ep[4] = right[i+2-1];
	ep[5] = right[i+3-1];
	ep[6] = right[i+4-1];
	ep[7] = right[i+1-1];
#else

	ep[0] = right[i+32-1];
	ep[1] = right[i+1-1];
	ep[2] = right[i+2-1];
	ep[3] = right[i+3-1];
	ep[4] = right[i+4-1];
	ep[5] = right[i+5-1];
	ep[6] = right[i+4-1];
	ep[7] = right[i+5-1];
	ep[8] = right[i+6-1];
	ep[9] = right[i+7-1];
	ep[10] = right[i+8-1];
	ep[11] = right[i+9-1];
	ep[12] = right[i+8-1];
	ep[13] = right[i+9-1];
	ep[14] = right[i+10-1];
	ep[15] = right[i+11-1];
	ep[16] = right[i+12-1];
	ep[17] = right[i+13-1];
	ep[18] = right[i+12-1];
	ep[19] = right[i+13-1];
	ep[20] = right[i+14-1];
	ep[21] = right[i+15-1];
	ep[22] = right[i+16-1];
	ep[23] = right[i+17-1];
	ep[24] = right[i+16-1];
	ep[25] = right[i+17-1];
	ep[26] = right[i+18-1];
	ep[27] = right[i+19-1];
	ep[28] = right[i+20-1];
	ep[29] = right[i+21-1];
	ep[30] = right[i+20-1];
	ep[31] = right[i+21-1];
	ep[32] = right[i+22-1];
	ep[33] = right[i+23-1];
	ep[34] = right[i+24-1];
	ep[35] = right[i+25-1];
	ep[36] = right[i+24-1];
	ep[37] = right[i+25-1];
	ep[38] = right[i+26-1];
	ep[39] = right[i+27-1];
	ep[40] = right[i+28-1];
	ep[41] = right[i+29-1];
	ep[42] = right[i+28-1];
	ep[43] = right[i+29-1];
	ep[44] = right[i+30-1];
	ep[45] = right[i+31-1];
	ep[46] = right[i+32-1];
	ep[47] = right[i+1-1];

#endif

	return ep;
}

char* CDES::XORwithKey(char *b, int k)
{
	char *result = new char[DATA_LENGTH];
	int i;

	for (i = 0 ; i < DATA_LENGTH ; i++)
	{
		result[i] = XOR(b[i],key[k-1][i]);
	}

	return result;
}

char CDES::XOR(char a, char b)
{
	if (a == b)
		return '0';
	else
		return '1';
}

void CDES::FillS0_SDES()
{
	S[0][0][0] = 1;
	S[0][0][1] = 0;
	S[0][0][2] = 3;
	S[0][0][3] = 2;

	S[0][1][0] = 3;
	S[0][1][1] = 2;
	S[0][1][2] = 1;
	S[0][1][3] = 0;

	S[0][2][0] = 0;
	S[0][2][1] = 2;
	S[0][2][2] = 1;