decrypt_4.cpp

一种非线性流式加密算法,对称加密

//////////////////////////////////////////////////////////////////////////
#include <time.h>
#include <stdio.h>
#include <string.h>
#include <memory.h>
#include <math.h>
//////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////
typedef unsigned char BYTE;

//TOD为当前机器时间的低64bit
static BYTE TOD[8]={4,5,6,7,8,9,10,11};

static BYTE Qstream[84];
//////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////

// 随机数表
const static char f[128]={
	87,79,71,1,107,3,121,6,111,10,113,15,59,21,24,89,
		70,36,40,45,67,55,9,66,109,78,84,91,98,105,112,120,
		0,119,16,25,115,43,17,62,72,90,92,103,114,125,127,97,
		30,44,56,69,74,95,108,122,110,22,65,51,58,82,96,13,
		31,86,54,49,42,83,100,118,8,26,41,63,81,101,5,12,
		14,52,85,93,19,7,28,27,61,94,116,11,34,57,80,104,
		39,126,48,73,75,123,20,46,53,35,124,23,50,77,29,4,
		32,60,88,117,18,47,76,106,102,38,68,99,2,33,64,37
};

//P1置换表
const static char P1[128]={
	0,16,32,48,64,80,96,112,8,24,40,56,72,88,104,120,
		1,17,33,49,65,81,97,113,9,25,41,57,73,89,105,121,
		2,18,34,50,66,82,98,114,10,26,42,58,74,90,106,122,
		3,19,35,51,67,83,99,115,11,27,43,59,75,91,107,123,
		4,20,36,52,68,84,100,116,12,28,44,60,76,92,108,124,
		5,21,37,53,69,85,101,117,13,29,45,61,77,93,109,125,
		6,22,38,54,70,86,102,118,14,30,46,62,78,94,110,126,
		7,23,39,55,71,87,103,119,15,31,47,63,79,95,111,127
};

//P2置换表
const static char P2[128]={
	0,64,1,65,2,66,3,67,4,68,5,69,6,70,7,71,
		8,72,9,73,10,74,11,75,12,76,13,77,14,78,15,79,
		16,80,17,81,18,82,19,83,20,84,21,85,22,86,23,87,
		24,88,25,89,26,90,27,91,28,92,29,93,30,94,31,95,
		32,96,33,97,34,98,35,99,36,100,37,101,38,102,39,103,
		40,104,41,105,42,106,43,107,44,108,45,109,46,110,47,111,
		48,112,49,113,50,114,51,115,52,116,53,117,54,118,55,119,
		56,120,57,121,58,122,59,123,60,124,61,125,62,126,63,127
};

//////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////
void GetKey(BYTE *password,BYTE *key);					//由TOD和原始密钥通过异或运算得到新的密钥key

void BytetoBit(BYTE *key,BYTE *bit_key,int readbyte);	//将byte变为bit

void BittoByte(BYTE *key,BYTE *bit_key,int readbyte);	//将bit变为byte

int GetN(BYTE *bit_key,int *vector);					//得到随即运转的次数N

void RightRotate(BYTE *bit_key,int n,int *vector);		//反馈移位

void LFSR1(BYTE *key,BYTE *&lfsr1);						//寄存器1的输出控制函数

void LFSR2(BYTE *key,BYTE *&lfsr2);						//寄存器2的输出控制函数

void LFSR(BYTE *key,BYTE *&lfsr);						//寄存器3的输出控制函数

void CalculateN(BYTE *N,BYTE *lfsr);					//由寄存器1的输出生成N0到N6

void CalculateM(BYTE *M,BYTE *lfsr);					//由寄存器2的输出生成N0到N6

void FunctionF(BYTE *N,BYTE *FI);								//F函数：计算F[N0](N2)

void FunctionG(BYTE *N,BYTE *FI,BYTE *Fout,BYTE *F);					//G函数：生成8bit的跳频字

void FrequencyH(BYTE *lfsr,BYTE *fh,BYTE *Fn);			//生成高8bit的跳频换频字

void FrequencyL(BYTE *lfsr,BYTE *fl,BYTE *Fm);			//生成低8bit的勤务跳换频字

void Q(BYTE *lfsr,BYTE *fh,BYTE *fl,BYTE *Fn,BYTE *Fm,BYTE *buf,int readbyte);	//生成84bit串序随即序列

void RHG(BYTE *buf,BYTE *key,int readbyte);				//加密明文

void Decrypt(BYTE *buf,BYTE *password,int readbyte);	//加密函数

///////////////////////////THE END///////////////////////////////////

///////////////////////////CODES START////////////////////////////////


void BytetoBit(BYTE *key,BYTE *bit_key,int readbyte)
{
	//逐位获得二进制码，每字节的二进制高bit位存储在数组高位中
	for( int i=0; i<readbyte*8; i++ )
		bit_key[i] = ( key[i>>3] >> ( i & 7 ) ) & 1;
}

void BittoByte(BYTE *key,BYTE *bit_key,int readbyte)
{
	//从bit数组中取每8位转化为byte
	for( int i=0; i<readbyte*8; i += 8 )
	{
		key[i>>3] = bit_key[i]
				  + bit_key[i + 1]*2
				  + bit_key[i + 2]*4
				  + bit_key[i + 3]*8 
				  + bit_key[i + 4]*16
			      + bit_key[i + 5]*32
				  + bit_key[i + 6]*64
				  + bit_key[i + 7]*128;
	}
}

void RightRotate(BYTE *bit_key,int n,int *vector)
{
	BYTE temp = 0;	//temp存放当前状态经过反馈函数得到的值
	BYTE head = 63;

	for( int i=0; i<n; i++ )
	{
		//等号右边为反馈函数
		temp = ( bit_key[ ( head + vector[0] ) % 64 ]
				^ bit_key[ ( head + vector[1] ) % 64 ]
				^ bit_key[ ( head + vector[2] ) % 64 ]
				^ bit_key[ ( head + vector[3] ) % 64 ]
				^ 1 ) & 1;

		//用temp填补右移后的空位
		bit_key[head] = temp;


		//整个64bit右移一位
		head--;
		head %= 64;
	}
}

int GetN(BYTE *bit_key,int *vector)
{
	//把寄存器的初值运转128次
	RightRotate(bit_key,128,vector);

	int temp = 0;
	//取此时寄存器输出的高7bit
	for( int i=0; i<7; i++ )
		temp += ( bit_key[63-i] << (7-i) );

	//把高7bit作为随机数表的输入，得到一个7bit的数
	return( f[temp] );
}

void GetKey(BYTE *password,BYTE *key)
{
	int temp = 0;
	BYTE *pHead;
	int i;

	//将TOD和原始密钥做异或，并判断结果是否为全零，是则重新对TOD赋值（避免寄存器进入全零死态）
	pHead = Qstream;

	do
	{
		BittoByte(TOD, pHead, 8);
		for( i=0; i<8; i++ )
		{
			key[i] = password[i] ^ TOD[i];
			temp += key[i];
		}
		pHead++;
	}while( temp == 0 );
}

void LFSR1(BYTE *key,BYTE *&lfsr1)
{
	lfsr1 = new BYTE[64];
	int vector[4] = {0,-60,-61,-63};	//寄存器1的本原多项式

	//将寄存器1的输入转化为64bit存放在bit_key中
	BytetoBit(key,lfsr1,8);
	//得到寄存器1的输出
	RightRotate(lfsr1,GetN(lfsr1,vector),vector);	
}
void LFSR2(BYTE *key,BYTE *&lfsr2)
{
	lfsr2 = new BYTE[64];
  	int vector[4] = {0,-1,-3,-4};	//寄存器2的本原多项式

	//将寄存器2的输入转化为64bit存放在bit_key中
	BytetoBit(key,lfsr2,8);

	//得到寄存器2的输出
	RightRotate(lfsr2,GetN(lfsr2,vector),vector);	
}
void LFSR(BYTE *key,BYTE *&lfsr)
{
	BYTE *lfsr1;
	BYTE *lfsr2;
	int vector[4] = {0,-1,-3,-4};	//寄存器3的本原多项式
	lfsr = new BYTE[64];

	//得到寄存器1的输出lfsr1
	LFSR1(key,lfsr1);

	//得到寄存器2的输出lfsr2
	LFSR2(key,lfsr2);

	//把lfsr1和lfsr2进行异或运算后把结果给lfsr
	for( int i=0; i<8; i++ )
		for( int j=0; j<8; j++ )
			lfsr[ i * 8 + j ] = ( ( lfsr1[ i * 8 + j ]
								^ lfsr2[ ( 8 - i ) * 8 - ( 8 - j ) ] ) )
								& 1;

	//得到寄存器3的输出即非线性函数1和2的输入
	delete []lfsr1;
	delete []lfsr2;
	RightRotate(lfsr,GetN(lfsr,vector),vector);	
}

void CalculateN(BYTE *N,BYTE *lfsr)
{
	BYTE *BL;
	BL = lfsr;

	//从寄存器输出的64bit中确定线性函数1的7个数N[0]到N[6]
	N[0] = ( BL[8]<<1 ) + BL[7];
	N[1] = ( BL[6]<<6 ) + ( BL[5]<<5 ) + ( BL[4]<<4 ) + ( BL[3]<<3 ) + ( BL[2]<<2 ) + ( BL[1]<<1 ) + BL[0];
	N[2] = ( BL[16]<<7 ) + ( BL[15]<<6 ) + ( BL[14]<<5 ) + ( BL[13]<<4 ) + ( BL[12]<<3 ) + ( BL[11]<<2 ) + ( BL[10]<<1 ) + BL[9];
	N[3] = ( BL[63]<<6 ) + ( BL[62]<<5 ) + ( BL[61]<<4 ) + ( BL[60]<<3 ) + ( BL[59]<<2 ) + ( BL[58]<<1 ) + BL[57];
	N[4] = ( BL[38]<<4 ) + ( BL[37]<<3 ) + ( BL[36]<<2 ) + ( BL[35]<<1 )+ BL[34];
	N[5] = ( BL[47]<<3 ) + ( BL[46]<<2 ) + ( BL[45]<<1 ) + BL[44];
	N[6] = ( BL[12]<<4 ) + ( BL[10]<<3 ) + ( BL[8]<<2 ) + ( BL[6]<<1 ) + BL[4];
}

void CalculateM(BYTE *M,BYTE *lfsr)
{
	BYTE *BL;
	BL = lfsr;

	//从寄存器输出的64bit中确定线性函数2的7个数M[0]到M[6]
	M[0] = ( BL[25]<<1 ) + BL[24];
	M[1] = ( BL[23]<<6 ) + ( BL[22]<<5 ) + ( BL[21]<<4 ) + ( BL[20]<<3 ) + ( BL[19]<<2 ) + ( BL[18]<<1 ) + BL[17];
	M[2] = ( BL[33]<<7 ) + ( BL[32]<<6 ) + ( BL[31]<<5 ) + ( BL[30]<<4 ) + ( BL[29]<<3 ) + ( BL[28]<<2 ) + ( BL[27]<<1 ) + BL[26];
	M[3] = ( BL[56]<<6 ) + ( BL[55]<<5 ) + ( BL[54]<<4 ) + ( BL[53]<<3 ) + ( BL[52]<<2 ) + ( BL[51]<<1 ) + BL[50];
	M[4] = ( BL[43]<<4 ) + ( BL[42]<<3 ) + ( BL[41]<<2 ) + ( BL[40]<<1 ) + BL[39];
	M[5] = ( BL[02]<<3 ) + ( BL[01]<<2 ) + ( BL[49]<<1 ) + BL[48];
	M[6] = ( BL[22]<<4 ) + ( BL[20]<<3 ) + ( BL[18]<<2 ) + ( BL[16]<<1 ) + BL[14];
}

void FunctionF(BYTE *N,BYTE *FI)
{
	//根据N[0]的值选择一个非线性函数，作用在N[2]上，输出8bit的BYTE_FI
	BYTE BYTE_FI;
	switch(N[0])
	{
	case 0:	
		BYTE_FI = ( N[2] & 0x80 ) || ( ( N[2] + N[1] ) & 0x7F );
		break;
	case 1:
		BYTE_FI = ( N[2] & 0x80 ) || ( ( ( N[2] + N[3] ) ^ N[3] ) & 0x7F );
		break;
	case 2:
		BYTE_FI = ( N[2] & 0x80 ) || ( ( P2[N[2] & 0x7F] ^ N[3] ) & 0x7F );
		break;
	case 3:
		BYTE_FI = ( N[2] & 0x80 ) || ( ( P1[N[2] & 0x7F] ^ N[3] ) & 0x7F );
		break;	
	default: 
		break;
	}

	BytetoBit(&BYTE_FI,FI,1); 
}

void FunctionG(BYTE *N,BYTE *FI,BYTE *Fout,BYTE *F)
{
	BYTE FI1[8],FI2[8];
	BYTE BYTE_FI2;
	int i = 0;
	
	//计算FI1
	for( i=0; i<8; i++ )
		FI1[i] = FI[i];

	if( N[4] > 7 ) 
		N[4] = 0;
	if( N[5] > 7 )
		N[5] = 0;

	FI1[7] = ( FI1[7] ^ FI1[ N[4] ] ) & 1;

	for( i=0; i<8; i++ )
		F[i] = FI1[i];

	//计算FI2
	for( i=0; i<8; i++ )
		FI2[i] = FI1[i];

	FI2[7] = ( FI2[7] ^ FI2[ N[5]+1 ] ) & 1;
	FI2[6] = ( FI2[6] ^ FI2[ N[5] ] ) & 1;

	BittoByte(&BYTE_FI2,FI2,1);

	//计算函数G(FI2)，得到BYTE_FI2，并转换为8bit的跳频字
	BYTE_FI2 = ( BYTE_FI2 & 0xf0 ) || ( ( ( BYTE_FI2 + N[6] ) ^ ( BYTE_FI2 / 0x10 ) ) & 0x0f );
	
	BytetoBit(&BYTE_FI2,FI2,1);
}


void FrequencyH(BYTE *lfsr,BYTE *fh,BYTE *Fn)
{
	//生成高8bit的跳频换频字
	BYTE N[7];
	BYTE fn[8];

	CalculateN(N,lfsr);
	FunctionF(N,fn);
	FunctionG(N,fn,fh,Fn);
}

void FrequencyL(BYTE *lfsr,BYTE *fl,BYTE *Fm)
{
	//生成低8bit的勤务跳换频字
	BYTE M[7];
	BYTE fm[8];

	CalculateN(M,lfsr);
	FunctionF(M,fm);
	FunctionG(M,fm,fl,Fm);
}

void Q(BYTE *lfsr,BYTE *fh,BYTE *fl,BYTE *Fn,BYTE *Fm,BYTE *buf,int readbyte)
{
	BYTE Byte_Qstream[168];
	BYTE Bit_Qstream[168];
	BYTE *BL;
	BYTE Bfh,Bfl,Bf[8];
	BYTE head = 0;
	int i,j,k;

	BL = lfsr;
	
	//用寄存器3输出的64bit，非线性函数1输出的8bit，非线性函数2输出的8bit，
	//以及两个8bit跳频字做运算得到的4bit合起来构成一个84bit的串序随机序列
	for( i=0; i<64; i++ )
		Qstream[i] = BL[i];

	for( i=64; i<72; i++ )
		Qstream[i] = Fm[i-64];
	
	for( i=72; i<80; i++ ) 
		Qstream[i] = Fn[i-72];
	
	BittoByte(&Bfh,fh,1);
	BittoByte(&Bfl,fl,1);
	Bfh = ( Bfh ^ Bfl ) & 0x0f ;
	BytetoBit(&Bfh,Bf,1);

	for( i=80; i<84; i++ )
		Qstream[i] = Bf[i-80];
	
	//用串序随机序列与明文异或生成密文
	for( i=0,j=0,k=1; i<84; i+=2,j+=2,k+=2 )
	{
		Bit_Qstream[ i + 84 ] = Bit_Qstream[ k ];
		Bit_Qstream[ i + 85 ] = Bit_Qstream[ j ];
	}
	for( i=0; i<168; i++ )
	{
		Byte_Qstream[i] = Qstream[ head ] *128
				    + Qstream[ ( head + 1 ) % 168 ] * 64
					+ Qstream[ ( head + 2 ) % 168 ] * 32
					+ Qstream[ ( head + 3 ) % 168 ] * 16 
					+ Qstream[ ( head + 4 ) % 168 ] * 8
					+ Qstream[ ( head + 5 ) % 168 ] * 4
					+ Qstream[ ( head + 6 ) % 168 ] * 2
					+ Qstream[ ( head + 7 ) % 168 ] ;
		head++;
	}

	for( i=0; i<readbyte; i++ )
		buf[i] ^= Byte_Qstream[i];

	delete []lfsr;
}

void RHG(BYTE *buf,BYTE *key,int readbyte)
{
	//非线性函数
	BYTE *lfsr = NULL;
	BYTE tempLfsr1[64];
	BYTE tempLfsr2[64];
	BYTE fh[8];
	BYTE fl[8];
	BYTE Fn[8];
	BYTE Fm[8];

	LFSR(key,lfsr);
	
	for( int i=0; i<64; i++ )
	{
		tempLfsr1[i] = lfsr[i];
		tempLfsr2[i] = lfsr[i];
	}
	FrequencyH(tempLfsr1,fh,Fn);
	FrequencyL(tempLfsr2,fl,Fm);
	Q(lfsr,fh,fl,Fn,Fm,buf,readbyte);
}

void Decrypt(BYTE *buf,BYTE *password,int readbyte)
{
	BYTE key[8];
	GetKey(password,key);
	RHG(buf,key,readbyte);
}

void main (void)
{
	int readbyte=0;
	unsigned char password[8]={1,2,3,4,5,6,7,8};	//原始密钥
	unsigned char buf[168*1024];
	BYTE *buf1;

	FILE *fd1,*fd2;
	fd1=fopen(".\\5.wma","rb");
	fd2=fopen(".\\5m.wma","wb");

	BytetoBit(Qstream,TOD,8);

	while(!feof(fd1))
	{
		memset(buf,0,sizeof(buf));
		readbyte=fread(buf,sizeof(char),168*1024,fd1);
		//加密
		for(int i=0;i<readbyte/168;i++)
		{
			buf1 = & buf[i * 168];
			Decrypt(buf1,password,168);
		}
		buf1 = & buf[i * 168];
		Decrypt(buf1,password,readbyte%168);
		fwrite(buf,sizeof(char),readbyte,fd2);			
	}
	fclose(fd2);
	fclose(fd1);
}

///////////////////////////CODES END////////////////////////////////