buf-ch-sq-ci-al.cpp

序列加密算法

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#include<dos.h>

typedef unsigned char BYTE;

static void ByteToBit(BYTE *Out, BYTE *In, int bits);// 字节组转换成位组
static void BitToByte(BYTE *Out,BYTE *In, int bits);// 位组转换成字节组
static void RightRotate1(BYTE *bit_key,int n,int *vector);//LFSR
static void RightRotate2(BYTE *bit_key,int n,int *vector);
static void StartRR1(BYTE *K,int *vector);
static void StartRR2(BYTE *BitK,int *vector);
static void InitKey(BYTE *Key,BYTE *K1,BYTE *K2);
static void BaseQ(BYTE *BitS,BYTE *BitT,BYTE *BitB);
static void GeneratesY(BYTE *B,BYTE *BitK2,BYTE *Y);
static void GeneratesZ(BYTE *Y,BYTE *Z,BYTE *Z1);
static void RunRR(BYTE *BitK1,BYTE *BitK2,BYTE *BitZ,BYTE *BitZ1,BYTE *BitB,int *vector1,int *vector2);
void InitLFSR(BYTE *Key,BYTE *BitK1,BYTE *BitK2,int *vector1,int *vector2);
	
void ByteToBit(BYTE *Out, BYTE *In, int bits)
{
    	for(int i=0; i<bits; ++i)
        	Out[i] = (In[i>>3]>>(7-(i&7))) & 1;
}
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);
    }
}
void InitKey(BYTE *BitKey,BYTE *K1,BYTE *K2)
{
	int i=0;

	for(i=0;i<32;i++)
		K1[i]=BitKey[i];
	for(i=0;i<48;i++)
		K2[i]=BitKey[i+32];
}

void RightRotate1(BYTE *bit_key,int n,int *vector)
{
	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=32;j>0;j--)
			bit_key[j]=bit_key[j-1];

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

void RightRotate2(BYTE *bit_key,int n,int *vector)
{
	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=48;j>0;j--)
			bit_key[j]=bit_key[j-1];

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

void StartRR1(BYTE *BitK,int *vector)
{
	int n;
	n=BitK[7]<<7+BitK[6]<<6+BitK[5]<<5+BitK[4]<<4+BitK[3]<<3+BitK[2]<<2+BitK[1]<<1+BitK[0];
	RightRotate1(BitK,n,vector);
}

void StartRR2(BYTE *BitK,int *vector)
{
	int n;
	n=BitK[7]<<7+BitK[6]<<6+BitK[5]<<5+BitK[4]<<4+BitK[3]<<3+BitK[2]<<2+BitK[1]<<1+BitK[0];
	RightRotate2(BitK,n,vector);
}

void RunRR(BYTE *BitK1,BYTE *BitK2,BYTE *BitZ,BYTE *BitZ1,BYTE *BitB,int *vector1,int *vector2)
{
	BYTE *BitY;

	BitY=(BYTE *)malloc(16);

	RightRotate1(BitK1,1,vector1);
	RightRotate2(BitK2,1,vector2);

	BaseQ(BitK1,BitK2,BitB);
	GeneratesY(BitB,BitK2,BitY);
	GeneratesZ(BitY,BitZ,BitZ1);
}

void BaseQ(BYTE *BitS,BYTE *BitT,BYTE *BitB)
{
	BitB[0]=BitS[23];
	BitB[1]=BitT[43];
	BitB[2]=BitT[19];
	BitB[3]=BitT[0];
	BitB[4]=BitS[7];
	BitB[5]=BitT[32];
	BitB[6]=BitS[0];
	BitB[7]=BitT[13];	
}

void GeneratesY(BYTE *BitB,BYTE *BitK2,BYTE *BitY)
{
	BYTE *BitX,B,X;
	int Y;

	int i;

	BitX=(BYTE *)malloc(8);

	for(i=0;i<8;i++)
		BitX[i]=BitK2[40+i];
	
	BitToByte(&B,BitB,8);
	BitToByte(&X,BitX,8);

	Y=(int)(pow((int)(B^X),2)+1)%(int)(pow(2,16));
	ByteToBit(BitY,(BYTE *)&Y,16);
}

void GeneratesZ(BYTE *BitY,BYTE *BitZ,BYTE *BitZ1)
{	
	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];


	BitZ1[0]=BitY[14];
	BitZ1[1]=BitY[11];
	BitZ1[2]=BitY[10];
	BitZ1[3]=BitY[8];
	BitZ1[4]=BitY[6];
	BitZ1[5]=BitY[5];
	BitZ1[6]=BitY[1];
	BitZ1[7]=BitY[0];
}

void InitLFSR(BYTE *Key,BYTE *BitK1,BYTE *BitK2,int *vector1,int *vector2)
{
	BYTE *BitKey;

	BitKey=(BYTE *)malloc(80);
	memset(BitKey,0,80);

	ByteToBit(BitKey,Key,80);
	InitKey(BitKey,BitK1,BitK2);
	StartRR1(BitK1,vector1);
	StartRR2(BitK2,vector2);
}

void main()
{
	FILE *fpr,*fpw;
	BYTE ch,B;
	int vector1[5]={31,6,5,1,0},vector2[5]={47,8,6,3,0};
	BYTE* BitK1,BitK2,BitZ[32],*BitZ1[32],*BitB[32];
	BYTE Key[11]="hehehehehe";
	clock_t start,end;
	double elasped=0;

	BitK1=(BYTE *)malloc(32*32);
	BitK2=(BYTE *)malloc(48);
	BitZ=(BYTE *)malloc(256);
	BitZ1=(BYTE *)malloc(256);
	BitB=(BYTE *)malloc(256);

	memset(BitK1,0,256);
	memset(BitK2,0,256);
	
	InitLFSR(Key,BitK1,BitK2,vector1,vector2);

	fpr=fopen("H:\\txt\\tst-1024.txt","rb");
	fpw=fopen("h:\\txt\\Ctst.txt","wb");
	
	start=clock();
	for(int i=0;i<1024*4;i++)
	{
	rewind(fpr);
	while(!feof(fpr))
	{
		ch=fgetc(fpr);
		RunRR(BitK1,BitK2,BitZ,BitZ1,BitB,vector1,vector2);
		BitToByte(&B,BitZ,8);
		fputc(ch^B,fpw);

		readbyte=fread(buf,1,256,fpr);
		for(int j=0;j<32;j++)
		{
			
		}
	}
	}
	end=clock();

	elasped=((double)(end-start))/CLOCKS_PER_SEC;
	printf("Encrypt%f\n",elasped);
	fclose(fpr);
	fclose(fpw);


	InitLFSR(Key,BitK1,BitK2,vector1,vector2);

	fpr=fopen("H:\\txt\\Ctst.txt","rb");
	fpw=fopen("h:\\txt\\CPtst.txt","wb");
	
	start=clock();
	while(!feof(fpr))
	{
		ch=fgetc(fpr);
		RunRR(BitK1,BitK2,BitZ,BitZ1,BitB,vector1,vector2);
		BitToByte(&B,BitZ,8);
		fputc(ch^B,fpw);
	}
	end=clock();
	elasped=((double)(end-start))/CLOCKS_PER_SEC;
	printf("Decrypt%f\n",elasped);


	fclose(fpr);
	fclose(fpw);

}