draft_sq-ci-al.cpp

序列加密算法

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.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 BitToInt(int 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);
	
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 BitToInt(int Out,BYTE *In,int bits)
{
	Out=0;
	int i;
	for(i=0;i<bits;i++)
		Out+=In[i]*pow(2,i);
}
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 /*B,X,*/Y;

	int i;

	BitX=(BYTE *)malloc(8);

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

	BitToByte(&B,BitB,8);
	BitToByte(&X,BitX,8);


	printf("\nX%d\t%dOR\n",B,X);

	printf("\nX%dOR\n",(B^X));

	Y=(int)(pow((int)(B^X),2)+1)%(int)(pow(2,16));
	printf("\n%d\n",Y);
	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 main()
{
	//BYTE *Key={'C','e','r','e','s','s','i','a','m','a'};
	BYTE Key[11]="miaomiaomm";

	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);
	///////////////////////////
	printf("\n\n");
	for(i=0;i<80;i++)
	{
		if(i%8==0&&i!=0)
			printf("\n");
		printf("%d",BitKey[i]);
	}
	printf("\n");
	///////////////////////////
	InitKey(BitKey,BitK1,BitK2);
	/////////////////////////////
/*	printf("BitK\n");
	for(i=0;i<32;i++)
	{
		if(i%8==0&&i!=0)
			printf("\n");
		printf("%d",BitK1[i]);
	}
	printf("\n");
	for(i=0;i<48;i++)
	{
		if(i%8==0&&i!=0)
			printf("\n");
		printf("%d",BitK2[i]);
	}
	printf("\n");*/
	//////////////////////////////

	StartRR(BitK1,vector1);
	StartRR(BitK2,vector2);
	//////////////////////////////////
/*	printf("BitKAfter\n");
	for(i=0;i<32;i++)
	{
		if(i%8==0&&i!=0)
			printf("\n");
		printf("%d",BitK1[i]);
	}
	printf("\n");
	for(i=0;i<48;i++)
	{
		if(i%8==0&&i!=0)
			printf("\n");
		printf("%d",BitK2[i]);
	}
	printf("\n");*/
	//////////////////////////////////

	BaseQ(BitK1,BitK2,BitB);
	//////////////////////////////////
/*	for(i=0;i<8;i++)
		printf("%d",BitB[i]);
	printf("\n");*/
	////////////////////////////////////

	GeneratesY(BitB,BitK2,BitY);
	///////////////////////////////////////
	for(i=0;i<16;i++)
		printf("%d",BitY[i]);
	printf("\n");
	///////////////////////////////////////
	GeneratesZ(BitY,BitZ,BitZ1);

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

}