tstupdatelasted-ok-sq-ci-al-20050824.cpp

序列加密算法

#include<stdio.h>
#include<math.h>
#include<string.h>
#include<malloc.h>
#include<time.h>
///////////////////////////////////////////
typedef unsigned char BYTE;
////////////////////////////////////////
void ByteToBit(BYTE *Out, BYTE *In, int bits);
void BitToByte(BYTE *Out, BYTE *In, int bits);
void RightRotate(BYTE *bit_key,int length,int *vector,int n);
void StartKey(BYTE *BitKey,BYTE *BitK1,BYTE *BitK2);
void InitLFSR(BYTE *BitK1,BYTE *BitK2,int *vector1,int *vector2);
void GeneratesB(BYTE *BitK1,BYTE *BitK2,BYTE *BitB);
void iterate(BYTE *QuenceB,BYTE *Z,BYTE *BitZstar);
void GeneratesY(BYTE *BitB,BYTE *X0,BYTE *BitY);
void GeneratesZ(BYTE *BitY,BYTE *BitZ);
void GeneratesZstar(BYTE *BitY,BYTE *BitZstar);
void Run(BYTE *BitK1,BYTE *BitK2,BYTE *QuenceB,int *vector1,int *vector2,BYTE *Z,BYTE *BitZstar);
////////////////////////////////////////
/*ByteToBit
return None;
Out:Out
In:Input
*/
void ByteToBit(BYTE *Out, BYTE *In, int bits)
{
    	for(int i=0; i<bits; ++i)
        	Out[i] = (In[i>>3]>>(7-(i&7))) & 1;
}
/*BitToByte*/
void BitToByte(BYTE *Out, BYTE *In, int bits)//?
{
    memset(Out, 0, bits>>3);
    for(int i=0; i<bits; ++i)
    {
		Out[i>>3]|=In[i]<<(7-i&7);
    }
}
/*LFSR运转函数
BitKey：运转前状态
length：LFSR的长度
vector：LFSR的特征值
n:运转次数*/
void RightRotate(BYTE *bit_key,int length,int *vector,int n)
{
	BYTE temp=0;	//temp存放当前状态经过反馈函数得到的值

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

	//整个64bit右移一位
	for(int j=length;j>0;j--)
		bit_key[j]=bit_key[j-1];

	//用temp填补右移后的空位
	bit_key[0]=temp;
	}	
}
/*
分离出K1和K2
BitKey：原始80bit密钥
BitK1：32bit子密钥
BitK2：48bit子密钥
*/
void StartKey(BYTE *BitKey,BYTE *BitK1,BYTE *BitK2)
{
	int i=0;
	for(i=0;i<32;i++)
		BitK1[i]=BitKey[i];
	for(i=0;i<48;i++)
		BitK2[i]=BitKey[i+32];
}
/*
初始化LFSR（两个）
BitK1：子密钥1
BitK2：子密钥2
vector1：LFSR1的特征值
vector2：LFSR2的特征值
*/
void InitLFSR(BYTE *BitK1,BYTE *BitK2,int *vector1,int *vector2)
{
	BYTE K10,K20;
	BitToByte(&K10,BitK1+24,8);
	BitToByte(&K20,BitK2+40,8);

	RightRotate(BitK1,32,vector1,(int)K10);
	RightRotate(BitK2,48,vector2,(int)K20);
}
/*
生成第一步的8bit输出
BitK1，BitK2：运转后的LFSR值
BitB：存放输出的8bit*/
void GeneratesB(BYTE *BitK1,BYTE *BitK2,BYTE *BitB)
{
	BitB[0]=BitK1[23];
	BitB[1]=BitK2[43];
	BitB[2]=BitK2[19];
	BitB[3]=BitK2[0];
	BitB[4]=BitK1[7];
	BitB[5]=BitK2[32];
	BitB[6]=BitK1[0];
	BitB[7]=BitK2[13];	
}
/*迭代步骤
 QuenceB：存放了一系列的B值输出（byte）
 Z：最后生成的用于加密的8bit字节
 BitK2：用以确定X初值*/
void iterate(BYTE *QuenceB,BYTE *Z,BYTE *BitZstar)
{
	BYTE *BitY,*X0;
	BYTE *BitZ;
	int i=0;

	BitY=(BYTE *)malloc(16);
	memset(BitY,0,16);

	X0=(BYTE *)malloc(1);
	memset(X0,0,1);

	BitZ=(BYTE *)malloc(8);
	memset(BitZ,0,8);
//	BitZstar=(BYTE *)malloc(8);
//	memset(BitZstar,0,8);
	
//	BitToByte(&X0,BitK2+40,8);
	
	
	for(i=0;i<10;i++)
	{
//		if(i==0)
//			X0=K20;//?????????????????
//		else
			BitToByte(X0,BitZstar,8);

		GeneratesY(QuenceB+i*8,X0,BitY);

		GeneratesZ(BitY,BitZ);

		GeneratesZstar(BitY,BitZstar);
		BitToByte(Z+i,BitZ,8);
	}
}
/*迭代过程的Y生成过程
BitB:8bit
X0：运算所用值(初始为K20，以后为Zstar)
BitY：存放生成的16bitY*/
void GeneratesY(BYTE *BitB,BYTE *X0,BYTE *BitY)
{
	BYTE B;
	int Y=0;


	BitToByte(&B,BitB,8);

	Y=((int)(pow((int)(B^(*X0)),2.0)+1))%(int)(pow(2,16));

	ByteToBit(BitY,(BYTE *)&Y,16);

}
/*由Y根据要求生成输出Z
*BitY:Y串
*BitZ:Z串
*/
void GeneratesZ(BYTE *BitY,BYTE *BitZ)
{
	BitZ[0]=BitY[15];
	BitZ[1]=BitY[13];
	BitZ[2]=BitY[12];
	BitZ[3]=BitY[9];
	BitZ[4]=BitY[7];
	BitZ[5]=BitY[4];
	BitZ[6]=BitY[3];
	BitZ[7]=BitY[2];
}
/*由Y生成，用于确定下一个X0
BitY：Y串
BitZstar：用于X0的串*/
void GeneratesZstar(BYTE *BitY,BYTE *BitZstar)
{
	BitZstar[0]=BitY[14];
	BitZstar[1]=BitY[11];
	BitZstar[2]=BitY[10];
	BitZstar[3]=BitY[8];
	BitZstar[4]=BitY[6];
	BitZstar[5]=BitY[5];
	BitZstar[6]=BitY[1];
	BitZstar[7]=BitY[0];
}
/*初始化后开始运行*/
void Run(BYTE *BitK1,BYTE *BitK2,BYTE *QuenceB,int *vector1,int *vector2,BYTE *Z,BYTE *BitZstar)
{
	int i;
//	BYTE X0;
	for(i=0;i<10;i++)
	{
		RightRotate(BitK1,32,vector1,1);
		RightRotate(BitK2,48,vector2,1);
		GeneratesB(BitK1,BitK2,QuenceB+i*8);	
	}
 	iterate(QuenceB,Z,BitZstar);
	for(i=0;i<10;i++)
	{
		printf("%x\t",Z[i]);
	}
	printf("\n");
}
/*加解密
Out：处理后的结果（byte）
In：原始文件（byte）
Z:加密用*/
void Crypt(BYTE *Out,BYTE *In,int readbyte,BYTE *Z)
{
	int i=0;
	for(i=0;i<readbyte;i++)
		Out[i]=In[i]^Z[i];
}

void main()
{
	BYTE Key[11]="Ceressiaww";	
	BYTE *BitKey;
	BYTE *BitK1,*BitK2,*BitZstar;
	BYTE *QuenceB;
	BYTE *Z;
	BYTE *buf;
	int vector1[5]={31,6,5,1,0},vector2[5]={47,8,6,3,0};
	int i,readbyte=0;
	FILE *fpr,*fpw;
	clock_t start,end;
	double elasped;
	
	BitKey=(BYTE *)malloc(80);
	memset(BitKey,0,80);

	BitK1=(BYTE *)malloc(32);
	memset(BitK1,0,32);
	BitK2=(BYTE *)malloc(48);
	memset(BitKey,0,48);

	QuenceB=(BYTE *)malloc(8*10);
	memset(QuenceB,0,8*10);
	
	Z=(BYTE *)malloc(10);
	memset(Z,0,10);

	buf=(BYTE *)malloc(10);
	memset(buf,0,10);

	BitZstar=(BYTE *)malloc(8);
	memset(BitZstar,0,8);

	ByteToBit(BitKey,Key,80);

	StartKey(BitKey,BitK1,BitK2);
	InitLFSR(BitK1,BitK2,vector1,vector2);
	memcpy(BitZstar,BitK2+40,8);

/*	for(i=0;i<32;i++)
	{
		if(i%8==0)
			printf("\n");
		printf("%d",BitK1[i]);
	}

	for(i=0;i<48;i++)
	{
		if(i%8==0)
			printf("\n");
		printf("%d",BitK2[i]);
	}*/

start=clock();
for(i=0;i<6;i++)
{
	Run(BitK1,BitK2,QuenceB,vector1,vector2,Z,BitZstar);
}
end=clock();
//	for(i=0;i<10;i++)
//	{
//		printf("%x",Z[i]);
//		printf("\n");
//	}
	elasped=((double)(end-start))/CLOCKS_PER_SEC;
	printf("\nGeneratesZ is %f\n",elasped);

/*
	fpr=fopen("h:\\txt\\tst-1024.txt","rb");
	fpw=fopen("h:\\txt\\C1024.txt","wb");

	start=clock();
	for(int k=0;k<1024*4;k++)
	{
		rewind(fpr);
//	start=clock();
	while(!feof(fpr))
	{
		memset(buf,0,1024);
		memset(Z,0,1024);
		memset(QuenceB,0,1024*8);
		memset(Z,0,1024);
		readbyte=fread(buf,1,1024,fpr);
		
		Run(BitK1,BitK2,QuenceB,vector1,vector2,Z,BitZstar);
		Crypt(buf,buf,readbyte,Z);

		fwrite(buf,1,readbyte,fpw);
	}
//	end=clock();
//	elasped=((double)(end-start))/CLOCKS_PER_SEC;
//	printf("\nEncrypt-Elasped is %f\n",elasped);
	}
	end=clock();
	elasped=((double)(end-start))/CLOCKS_PER_SEC;
	printf("\nEncrypt-Elasped is %f\n",elasped);
	fclose(fpr);
	fclose(fpw);
*/
/*
	fpr=fopen("h:\\txt\\C1024.txt","rb");
	fpw=fopen("h:\\txt\\PC1024.txt","wb");

	start=clock();
	while(!feof(fpr))
	{
		memset(buf,0,1024);
		memset(Z,0,1024);
		memset(QuenceB,0,1024*8);
		memset(Z,0,1024);
		readbyte=fread(buf,1,1024,fpr);

		Run(BitK1,BitK2,QuenceB,vector1,vector2,Z,BitZstar);
		Crypt(buf,buf,readbyte,Z);

		fwrite(buf,1,readbyte,fpw);
	}
	end=clock();
	elasped=((double)(end-start))/CLOCKS_PER_SEC;
	printf("\nDecrypt-Elasped is %f\n",elasped);
	
	fclose(fpr);
	fclose(fpw);

	printf("\n");
	for(i=0;i<10;i++)
	{
		printf("%x",Z[i]);
		printf("\n");
	}*/
}