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 RightRotate(BYTE *bit_key,int n,int *vector);//LFSR
static void StartRR(BYTE *K,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 CipherRun();
static int CycleCLK();
	
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 RightRotate(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=63;j>0;j--)
			bit_key[j]=bit_key[j-1];

		//用temp填补右移后的空位
		bit_key[0]=temp;
	}
}
void StartRR(BYTE *BitK,int *vector)
{
	int n;
	n=BitK[7]*128+BitK[6]*64+BitK[5]*32+BitK[4]*16+BitK[3]*8+BitK[2]*4+BitK[1]*2+BitK[0]*1;
	RightRotate(BitK,n,vector);
}

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 CipherRun()
{
	BYTE Key[11]="hehehehehe";

	BYTE *BitK1,*BitK2,*BitY,*BitZ,*BitZ1;
	BYTE *BitKey;
	BYTE *BitB;

	int vector1[5]={31,6,5,1,0},vector2[5]={47,8,6,3,0};
	int i;

	BitK1=(BYTE *)malloc(32);
	BitK2=(BYTE *)malloc(48);

	BitY=(BYTE *)malloc(16);
	
	BitB=(BYTE *)malloc(8);
	BitZ=(BYTE *)malloc(8);
	BitZ1=(BYTE *)malloc(8);
	
	BitKey=(BYTE *)malloc(80);

	ByteToBit(BitKey,Key,80);

	InitKey(BitKey,BitK1,BitK2);

	StartRR(BitK1,vector1);
	StartRR(BitK2,vector2);
	BaseQ(BitK1,BitK2,BitB);

	GeneratesY(BitB,BitK2,BitY);
	GeneratesZ(BitY,BitZ,BitZ1);

	for(i=0;i<8;i++)
		printf("%d",BitZ[i]);
	printf("\n");

}

int CycleCLK()
{
	clock_t start,end;
	int i,time=0;
	double elapsed;

	start=clock();
	sleep(1);
	end=clock();

	elapsed = ((double)(end-start))/CLOCKS_PER_SEC;

	printf("%f\n",elapsed);

	return time;	
}

void main()
{
	FILE *fpr,*fpw;
	BYTE ch;

	fpr=fopen("H:\\txt\\opera.txt","rb");
	
	while(!feof(fpr))
	{
		ch=fgetc(fpr);
	}

}