hpc.cpp

同学的毕业设计。基于Hpc密码的选择重传协议的数据传输。希望能供大家参考。谢谢 ！

// HPC.cpp: implementation of the HPC class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
//#include "HpcBackN.h"
#include "HPC.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

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

#define	BYTE_SWAP

static char *alg_name[] = { "hpc", "hpc0.c" };

char **cipher_name()
{
	return alg_name;
}

#define	xor_eq(x,y)		(x)[0] ^= (y)[0]; (x)[1] ^= (y)[1]
#define	and_eq(x,y)		(x)[0] &= (y)[0]; (x)[1] &= (y)[1]
#define	 or_eq(x,y)		(x)[0] |= (y)[0]; (x)[1] |= (y)[1]
u8byte	l_key[286];

//u8byte	spice[8] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

u8byte	p119 = { 0xa23249d6, 0x2b992ddf };
u8byte	e19  = { 0xc0b36173, 0x25b946eb };
u8byte	r220 = { 0xe9e17158, 0xc442f56b };
#define add_eq(x,y)		(x)[1] += (y)[1] + (((x)[0] += (y)[0]) < (y)[0] ? 1 : 0)
#define sub_eq(x,y)		xs = (x)[0]; (x)[1] -= (y)[1] + (((x)[0] -= (y)[0]) > xs ? 1 : 0)   

void lsh_eq(u8byte x,int n)											
{if((n) > 31)											
	{	(x)[1] = (x)[0] << ((n) & 31); (x)[0] = 0;			
	}														
	else if((n) > 0)										
	{	(x)[1] = ((x)[1] << (n)) | ((x)[0] >> (-(n) & 31));	
		(x)[0] = (x)[0] << (n);								
	}
}
void	rsh_eq(u8byte x,int n)											
{if((n) > 31)											
	{	(x)[0] = (x)[1] >> ((n) & 31); (x)[1] = 0;			
	}														
	else if((n) > 0)										
	{	(x)[0] = ((x)[0] >> (n)) | ((x)[1] << (-(n) & 31));	
		(x)[1] = (x)[1] >> (n);								
	}
}
#define lo(x)	((x) & 0x0000ffff)
#define hi(x)	((x) >> 16)

//u4byte miyao[]={9,2,3,1,2,1,1,0};

HPC::HPC(u4byte miyao[],u4byte key_len, u8byte spice1[])
{
	set_key(miyao,key_len);
	int i=0,j=0;
	for(i=0;i<8;i++)
	{
		for(j =0;j<2;j++)
		{
		spice[i][j]=spice1[i][j];
		}
	}
}

HPC::~HPC()
{

}

void HPC::mult_64(u8byte r, const u8byte x, const u8byte y)
{
u4byte	x0, x1, x2, x3, y0, y1, y2, y3, t0, t1, t2, t3, c;

	x0 = lo(x[0]); x1 = hi(x[0]); x2 = lo(x[1]); x3 = hi(x[1]);
	y0 = lo(y[0]); y1 = hi(y[0]); y2 = lo(y[1]); y3 = hi(y[1]);

	t0 = x0 * y0; r[0] = lo(t0); c = hi(t0);

	t0 = x0 * y1; t1 = x1 * y0; c += lo(t0) + lo(t1);
	r[0] += (c << 16); c = hi(c) + hi(t0) + hi(t1);

	t0 = x0 * y2; t1 = x1 * y1; t2 = x2 * y0;
	c += lo(t0) + lo(t1) + lo(t2); r[1] = lo(c);
	c = hi(c) + hi(t0) + hi(t1) + hi(t2);

	t0 = x0 * y3; t1 = x1 * y2; t2 = x2 * y1; t3 = x3 * y0;
	c += lo(t0) + lo(t1) + lo(t2) + lo(t3); r[1] += (c << 16); 
/*
	c = hi(c) + hi(t0) + hi(t1) + hi(t2) + hi(t3);

	t0 = x1 * y3; t1 = x2 * y2; t2 = x3 * y1;
	c += lo(t0) + lo(t1) + lo(t2); r[1][0] = lo(c);
	c = hi(c) + hi(t0) + hi(t1) + hi(t2);

	t0 = x2 * y3; t1 = x3 * y2; c += lo(t0) + lo(t1);
	r[1][0] += (c << 16); c = hi(c) + hi(t0) + hi(t1);

	r[1][1] = c + x3 * y3;
*/
}

u4byte * HPC::set_key(const u4byte in_key[], const u4byte key_len )
{
u8byte	s[8], t;
	u4byte	i, j, xs;

	l_key[0][0] = p119[0] + 3; l_key[0][1] = p119[1];
	t[0] = key_len; t[1] = 0; mult_64(l_key[1], e19, t);
	l_key[2][0] = (r220[0] << 3) | (r220[1] >> 29); 
	l_key[2][1] = (r220[1] << 3) | (r220[0] >> 29); 

	for(i = 3; i < 256; ++i)
	{
		t[0] = l_key[i - 3][0]; t[1] = l_key[i - 3][1]; lsh_eq(t, 41);
		l_key[i][0] = l_key[i - 3][0]; l_key[i][1] = l_key[i - 3][1]; 
		rsh_eq(l_key[i], 23); 
		or_eq(l_key[i], t); 
		xor_eq(l_key[i], l_key[i - 2]); 
		add_eq(l_key[i], l_key[i - 1]);
	}
	
	l_key[0][1] ^= io_swap(in_key[0]); l_key[0][0] ^= io_swap(in_key[1]);
	l_key[1][1] ^= io_swap(in_key[2]); l_key[1][0] ^= io_swap(in_key[3]);

	if(key_len > 128)
	{
		l_key[2][1] ^= io_swap(in_key[4]); l_key[2][0] ^= io_swap(in_key[5]);
	}

	if(key_len > 192)
	{
		l_key[3][1] ^= io_swap(in_key[6]); l_key[3][0] ^= io_swap(in_key[7]);
	}

	for(i = 0; i < 8; ++i)
	{
		s[i][0] = l_key[248 + i][0]; s[i][1] = l_key[248 + i][1];
	}
			
	for(j = 0; j < 3; ++j)
		for(i = 0; i < 256; ++i)
		{
			t[0] = l_key[i][0]; t[1] = l_key[i][1]; xor_eq(t, l_key[(i + 83) & 255]); 
			add_eq(t, l_key[s[0][0] & 255]);
			xor_eq(s[0], t); add_eq(s[1], s[0]); xor_eq(s[3], s[2]); 
			sub_eq(s[5], s[4]); xor_eq(s[7], s[6]);
			t[0] = s[0][0]; t[1] = s[0][1]; rsh_eq(t, 13); add_eq(s[3], t);
			t[0] = s[1][0]; t[1] = s[1][1]; lsh_eq(t, 11); xor_eq(s[4], t);
			t[0] = s[3][0]; t[1] = s[3][1]; 
			lsh_eq(t, s[1][0] & 31); 
			xor_eq(s[5], t);
			t[0] = s[2][0]; t[1] = s[2][1]; rsh_eq(t, 17); add_eq(s[6], t);
			t[0] = s[3][0]; t[1] = s[3][1]; add_eq(t, s[4]); or_eq(s[7], t);
			sub_eq(s[2], s[5]);
			t[0] = s[6][0] ^ i; t[1] = s[6][1]; sub_eq(s[0], t);
			t[0] = s[5][0]; t[1] = s[5][1]; add_eq(t, p119); xor_eq(s[1], t);
			t[0] = s[7][0]; t[1] = s[7][1]; rsh_eq(t, j); add_eq(s[2], t);
			xor_eq(s[2], s[1]); sub_eq(s[4], s[3]); 
			xor_eq(s[6], s[5]); add_eq(s[0], s[7]);
			l_key[i][0] = s[2][0]; l_key[i][1] = s[2][1]; add_eq(l_key[i], s[6]);
		}

	for(i = 0; i < 30; ++i)
	{
		l_key[256 + i][0] = l_key[i][0]; l_key[256 + i][1] = l_key[i][1];
	}
		
	return (u4byte*)l_key;
}

void HPC::encrypt(const u4byte in_blk[], u4byte out_blk[])
{
u8byte	s0, s1, k, kk, t;
	u4byte	tt, xs;
	s4byte	i;

	s0[1] = io_swap(in_blk[0]); s0[0] = io_swap(in_blk[1]);
	s1[1] = io_swap(in_blk[2]); s1[0] = io_swap(in_blk[3]);

	add_eq(s0, l_key[128]); add_eq(s1, l_key[129]);

	for(i = 0; i < 8; ++i)
	{
		tt = s0[0] & 255; k[0] = l_key[tt][0]; k[1] = l_key[tt][1]; 
		add_eq(s1, k); 	lsh_eq(k, 8); xor_eq(s0, k); xor_eq(s1, s0);
		t[0] = s1[0]; t[1] = s1[1]; rsh_eq(t, 11); sub_eq(s0, t);
		t[0] = s1[0]; t[1] = s1[1]; lsh_eq(t, 2); xor_eq(s0, t);
		sub_eq(s0, spice[i ^ 4]);
		t[0] = s0[0]; t[1] = s0[1]; lsh_eq(t, 32);  
		kk[0] = p119[0] + 128; kk[1] = p119[1]; xor_eq(t, kk); add_eq(s0, t);
		t[0] = s0[0]; t[1] = s0[1]; rsh_eq(t, 17); xor_eq(s0, t);
		t[0] = s0[0]; t[1] = s0[1]; rsh_eq(t, 34); xor_eq(s0, t);		
		t[0] = spice[i][0]; t[1] = spice[i][1]; xor_eq(s0, t);
		lsh_eq(t, 5); add_eq(s0, t); 
		t[0] = spice[i][0]; t[1] = spice[i][1]; rsh_eq(t, 4);
		add_eq(s1, t); xor_eq(s0, t);
		t[0] = s0[0]; t[1] = s0[1]; lsh_eq(t, 22 + (s0[0] & 31)); add_eq(s0, t);
		t[0] = s0[0]; t[1] = s0[1]; rsh_eq(t, 23); xor_eq(s0, t);
		sub_eq(s0, spice[i ^ 7]);
		tt = s0[0] & 255; k[0] = l_key[tt][0]; k[1] = l_key[tt][1]; 
		tt += 3 * i + 1; kk[0] = l_key[tt][0]; kk[1] = l_key[tt][1]; 
		xor_eq(s1, k); t[0] = kk[0]; t[1] = kk[1]; lsh_eq(t, 8); 
		xor_eq(s0, t); xor_eq(kk, k); 
		t[0] = kk[0]; t[1] = kk[1]; rsh_eq(t, 5); add_eq(s1, t);
		t[0] = kk[0]; t[1] = kk[1]; lsh_eq(t, 12); sub_eq(s0, t);
		kk[0] &= ~255; xor_eq(s0, kk); 	add_eq(s1, s0);
		t[0] = s1[0]; t[1] = s1[1]; lsh_eq(t, 3); add_eq(s0, t);
		xor_eq(s0, spice[i ^ 2]); add_eq(s0, l_key[144 + i]);
		t[0] = s0[0]; t[1] = s0[1]; lsh_eq(t, 22); add_eq(s0, t);
		t[0] = s1[0]; t[1] = s1[1]; rsh_eq(t, 4); xor_eq(s0, t);
		add_eq(s0, spice[i ^ 1]);
		t[0] = s0[0]; t[1] = s0[1]; rsh_eq(t, 33 + i); xor_eq(s0, t);
	}

	add_eq(s0, l_key[136]); add_eq(s1, l_key[137]);

	out_blk[0] = io_swap(s0[1]); out_blk[1] = io_swap(s0[0]);
	out_blk[2] = io_swap(s1[1]); out_blk[3] = io_swap(s1[0]);
}

void HPC::decrypt(const u4byte in_blk[], u4byte out_blk[])
{
u8byte	s0, s1, k, kk, t;
	u4byte	tt, xs;
	s4byte	i;

	s0[1] = io_swap(in_blk[0]); s0[0] = io_swap(in_blk[1]);
	s1[1] = io_swap(in_blk[2]); s1[0] = io_swap(in_blk[3]);

	sub_eq(s0, l_key[136]); sub_eq(s1, l_key[137]);

	for(i = 7; i >= 0; --i)
	{
		t[0] = s0[0]; t[1] = s0[1]; rsh_eq(t, 33 + i); xor_eq(s0, t);
		sub_eq(s0, spice[i ^ 1]);
		t[0] = s1[0]; t[1] = s1[1]; rsh_eq(t, 4); xor_eq(s0, t);
		k[0] = s0[0]; k[1] = s0[1]; lsh_eq(k, 22);  
		t[0] = s0[0]; t[1] = s0[1]; sub_eq(t, k); 
		lsh_eq(t, 22); sub_eq(s0, t); sub_eq(s0, l_key[144 + i]);
		xor_eq(s0, spice[i ^ 2]); t[0] = s1[0]; t[1] = s1[1]; lsh_eq(t, 3); 
		sub_eq(s0, t); sub_eq(s1, s0); 
		tt = s0[0] & 255; k[0] = l_key[tt][0]; k[1] = l_key[tt][1];
		tt += 3 * i + 1; kk[0] = l_key[tt][0]; kk[1] = l_key[tt][1]; xor_eq(kk, k); 
		t[0] = kk[0] & ~255; t[1] = kk[1]; xor_eq(s0, t);
		t[0] = kk[0]; t[1] = kk[1]; lsh_eq(t, 12); add_eq(s0, t);
		t[0] = kk[0]; t[1] = kk[1]; rsh_eq(t, 5); sub_eq(s1, t);
		kk[0] = l_key[tt][0]; kk[1] = l_key[tt][1]; lsh_eq(kk, 8); 
		xor_eq(s0, kk); xor_eq(s1, k); add_eq(s0, spice[i ^ 7]); 
		t[0] = s0[0]; t[1] = s0[1]; rsh_eq(t, 23); xor_eq(s0, t);
		t[0] = s0[0]; t[1] = s0[1]; rsh_eq(t, 46); xor_eq(s0, t);
		tt = 22 + (s0[0] & 31); t[0] = s0[0]; t[1] = s0[1]; lsh_eq(t, tt);
		kk[0] = s0[0]; kk[1] = s0[1]; sub_eq(kk, t); lsh_eq(kk, tt); sub_eq(s0, kk);
		t[0] = kk[0] = spice[i][0]; t[1] = kk[1] = spice[i][1]; rsh_eq(kk, 4);
		xor_eq(s0, kk); sub_eq(s1, kk); k[0] = t[0]; k[1] = t[1]; lsh_eq(k, 5); 
		sub_eq(s0, k); xor_eq(s0, t); 
		t[0] = s0[0]; t[1] = s0[1]; rsh_eq(t, 17); xor_eq(s0, t);
		t[0] = p119[0] + 128; t[1] = p119[1]; k[0] = s0[0]; k[1] = s0[1];
		sub_eq(k, t); lsh_eq(k, 32); xor_eq(t, k); sub_eq(s0, t);
		add_eq(s0, spice[i ^ 4]); t[0] = s1[0]; t[1] = s1[1]; lsh_eq(t, 2); 
		xor_eq(s0, t); t[0] = s1[0]; t[1] = s1[1]; rsh_eq(t, 11); add_eq(s0, t);
		xor_eq(s1, s0); tt = s0[0] & 255; k[0] = l_key[tt][0]; k[1] = l_key[tt][1];
		t[0] = k[0]; t[1] = k[1]; lsh_eq(t, 8); xor_eq(s0, t); sub_eq(s1, k);
	}

	sub_eq(s0, l_key[128]); sub_eq(s1, l_key[129]);

	out_blk[0] = io_swap(s0[1]); out_blk[1] = io_swap(s0[0]);
	out_blk[2] = io_swap(s1[1]); out_blk[3] = io_swap(s1[0]);
}

void HPC::chtoul(char ch[], unsigned long ul[])
{
	int i,j;
	unsigned long a;
	ul[0]=0;ul[1]=0;ul[2]=0;ul[3]=0;
	for(j=0;j<4;j++)
	{
		for(i=0;i<4;i++)
		{	
		ul[j]=ul[j]<<8;
		a=ch[i+j*4];
		a=0x000000ff & a;
		ul[j]=a|ul[j];
		
		}
	}
}

void HPC::ultoch(unsigned long ul[], char ch[])
{
	unsigned long a;
	int i;
	for(i=0;i<4;i++)
	{
		a=ul[i];
		a &= 0xff000000;
		a=a>>24;
		ch[i*4+0] =a;
		
		a=ul[i];
		a &= 0x00ff0000;
		a=a>>16;
		ch[i*4+1] =a;
	
		a=ul[i];
		a &= 0x0000ff00;
		a=a>>8;
		ch[i*4+2] =a;
	
		a=ul[i];
		a &= 0x000000ff;

		ch[i*4+3] =a;
		
		
	}
}

void HPC::Jiami(CString strin, CString &strout)
{
	
	int Length,i,j,l,l1;
	char ch[2000],out[2000];
	char ch1[16],ch2[16];
	u4byte ul[4],ul1[4],temp[4];
	
	Length = l1 = strin.GetLength();
	l = Length%16;
	
	while((Length%16)!=0)
	{
		strin +='0';
		Length=strin.GetLength();
	}

	for(i=0;i<Length;i++)
	{
	ch[i]=strin.GetAt(i);
	}
	ch[i+1]='\0';

	i=0;
	for(i=0;i<(l1/16);i++)
	{
		
		for(j=0;j<16;j++)
		{
		ch1[j]=ch[i*16+j];
		}
		chtoul(ch1,ul);
		encrypt(ul,ul1);
		//temp[0]=ul1[0];temp[1]=ul1[1];temp[2]=ul1[2];temp[3]=ul1[3];
		//decrypt(temp,ul1);
		
		for(j=0;j<4;j++)
		{
			char str[9];
			//out[i*16+j] = ch2[j];
			//str +=ch2[j];
			sprintf(str,"%08x",ul1[j]);
		//	str[j]=ch2[j];
			str[8]='\0';
			strout +=str;
		}
		
		
	}
	
	u4byte a=0xffffffff;
	switch((l-1)/4)
	{
			u4byte b;
		//int n;
	case 0:

		for(j=0;j<16;j++)
		{
		ch1[j]=ch[i*16+j];
		}
		chtoul(ch1,ul);
		ul[3]=ul[2]=ul[1]=0;
		a=a<<(32-l*8);
		b=ul[0];
		b = b&a;
		ul[0]=b;
		encrypt(ul,ul1);
		for(j=0;j<4;j++)
		{
			char str[9];
			//out[i*16+j] = ch2[j];
			//str +=ch2[j];
			sprintf(str,"%08x",ul1[j]);
		//	str[j]=ch2[j];
			str[8]='\0';
			strout +=str;
		}
		break;
	case 1:
	
		for(j=0;j<16;j++)
		{
		ch1[j]=ch[i*16+j];
		}
		chtoul(ch1,ul);
		ul[3]=ul[2]=0;
		
		
		a=a<<(32-(l%4)*8);
		b=ul[1];
		b = b&a;
		ul[1]=b;
		encrypt(ul,ul1);
		for(j=0;j<4;j++)
		{
			char str[9];
			//out[i*16+j] = ch2[j];
			//str +=ch2[j];
			sprintf(str,"%08x",ul1[j]);
		//	str[j]=ch2[j];
			str[8]='\0';
			strout +=str;
		}
		break;
	case 2:
	
		for(j=0;j<16;j++)
		{
		ch1[j]=ch[i*16+j];
		}
		chtoul(ch1,ul);
		ul[3]=0;
		
		a=a<<(32-(l%4)*8);
		b=ul[2];
		b = b&a;
		ul[2]=b;
		encrypt(ul,ul1);
		for(j=0;j<4;j++)
		{
			char str[9];
			//out[i*16+j] = ch2[j];
			//str +=ch2[j];
			sprintf(str,"%08x",ul1[j]);
		//	str[j]=ch2[j];
			str[8]='\0';
			strout +=str;
		}
		break;
	case 3:

		for(j=0;j<16;j++)
		{
		ch1[j]=ch[i*16+j];
		}
		chtoul(ch1,ul);
		
		a=a<<(32-(l%4)*8);
		b=ul[3];
		b = b&a;
		ul[3]=b;
		encrypt(ul,ul1);
		for(j=0;j<4;j++)
		{
			char str[9];
			//out[i*16+j] = ch2[j];
			//str +=ch2[j];
			sprintf(str,"%08x",ul1[j]);
		//	str[j]=ch2[j];
			str[8]='\0';
			strout +=str;
		}
		break;
	}
}

void HPC::jiemi(CString strin, CString &strout)
{
	u4byte ul[4],ul1[4];
	char ch[16],ch1[17];
	while (!strin.IsEmpty())
	{
		ul[0] = strtoul(strin.Left(8),NULL,16);
		strin = strin.Mid(8);
		ul[1] = strtoul(strin.Left(8),NULL,16);
		strin = strin.Mid(8);
		ul[2] = strtoul(strin.Left(8),NULL,16);
		strin = strin.Mid(8);
		ul[3] = strtoul(strin.Left(8),NULL,16);
		strin = strin.Mid(8);

		decrypt(ul,ul1);

		ultoch(ul1,ch1);
		ch1[16]='\0';
		strout += ch1;
		//strout +=ul1;
		//strout +='\0';
	}
}