#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);// 字節(jié)組轉(zhuǎn)換成位組
//static void BitToByte(BYTE *Out,BYTE *In, int bits);// 位組轉(zhuǎn)換成字節(jié)組
static void BitToByte(BYTE Out,BYTE *In, int bits);// 位組轉(zhuǎn)換成字節(jié)
static void RightRotate(BYTE *bit_key,int n,int *vector);//LFSR運(yùn)轉(zhuǎn)
void StartRR(BYTE *K,int *vector);
void InitKey(BYTE *Key,BYTE *K1,BYTE *K2);
void BaseQ(BYTE *BitS,BYTE *BitT,BYTE *BitB);
void GeneratesY(BYTE B,BYTE *BitK2,BYTE Y);
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|=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存放當(dāng)前狀態(tài)經(jīng)過反饋函數(shù)得到的值

	for(int i=0;i<n;i++)
	{
		//等號(hào)右邊為反饋函數(shù)
		temp = bit_key[vector[0]] ^ bit_key[vector[1]] ^ bit_key[vector[2]] ^ bit_key[vector[3]] ^ bit_key[4]^1;

		//整個(gè)64bit右移一位
		for(int j=63;j>0;j--)
			bit_key[j]=bit_key[j-1];

		//用temp填補(bǔ)右移后的空位
		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 B,BYTE *BitK2,BYTE *Y)
{
	BYTE *X;
	
	BitToByte(X,BitK2,8);
	
	*Y=(pow((*B)^(*X),2.0)+1)mod(pow(2,16));
}

void GeneratesZ(BYTE Y,BYTE Z,BYTE Z1)
{
	BYTE *BitY,*BitZ,*BitZ1;

	BitY=(BYTE *)malloc(16);
	BitZ=(BYTE *)malloc(8);
	BitZ1=(BYTE *)malloc(8);
	
	ByteToBit(BitY,Y,16);
	
	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];

	BitToByte(Z,BitZ,8);
	BitToByte(Z1,BitZ1,8);
}


void main()
{
	BYTE *Key={'C','e','r','e','s','s','i','a','m','a'};
	BYTE *B,*Y,*Z,*Z1;
	
	BYTE *BitK1,*BitK2;
	BYTE *BitKey;
	BYTE *BitB;

	int* vector[2];

	*vector[1]={31,6,5,1,0};
	*vector[2]={47,8,6,3,0};

	BitK1=(BYTE *)malloc(32);
	BitK2=(BYTE *)malloc(48);
	
	BitB=(BYTE *)malloc(8);
	
	BitKey=(BYTE *)malloc(80);

	ByteToBit(BitKey,Key,80);
	InitKey(BitKey,BitK1,BitK2);

	StartRR(BitK1,vector[1]);
	StartRR(BitK2,vector[2]);

	BaseQ(BitK1,BitK2,BitB);

	BitToByte(B,BitB,8);
	GeneratesY(B,BitK2,Y);

	GeneratesZ(Y,Z,Z1)

}