#include<stdio.h>
#include<math.h>
#include<string.h>
#include<malloc.h>
///////////////////////////////////////////
typedef 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 *BitK2);
void GeneratesY(BYTE *BitB,BYTE *X0,BYTE *BitY);
void GeneratesZ(BYTE *BitY,BYTE *BitZ);
void GeneratesZstar(BYTE *BitY,BYTE *BitZstar);
////////////////////////////////////////

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

	//用temp填補(bǔ)右移后的空位
	bit_key[0]=temp;
	}	
}
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];
}
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);
}
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];	
}
void iterate(BYTE *QuenceB,BYTE *Z,BYTE *BitK2)
{
	BYTE *BitY,K20,X0;
	BYTE *BitZ,*BitZstar;
	int i=0;

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

	BitZ=(BYTE *)malloc(8);
	memset(BitZ,0,8);
	BitZstar=(BYTE *)malloc(8);
	memset(BitZstar,0,8);
	
	BitToByte(&K20,BitK2+40,8);
	
	for(i=0;i<512;i++)
	{
		if(i==0)
			X0=K20;
		else
			BitToByte(&X0,BitZstar,8);
		///////////////////////////////////
//		for(int k=0;k<1024;k++)
//			printf("%d",QuenceB[k]);
		////////////////////////////////////
		GeneratesY(QuenceB+i*8,&X0,BitY);
		//////////////////////////////
//		for(int k=8;k<16;k++)
//			printf("%d",BitY[k]);
//		printf("\n");
		//////////////////////////////
		GeneratesZ(BitY,BitZ);
		////////////////////////////////
//		for(int k=0;k<16;k++)
//		{
//			if(k==15|k==13|k==12|k==9|k==7|k==4|k==3|k==2)
//			printf("%d",BitY[k]);
//		}
//		printf("\n");
//		for(int k=0;k<8;k++)
//			printf("%d",BitZ[k]);
//		printf("\n");
		//////////////////////////////////
		GeneratesZstar(BitY,BitZstar);
		BitToByte(Z+i,BitZ,8);
	}
}
void GeneratesY(BYTE *BitB,BYTE *X0,BYTE *BitY)
{
	BYTE B;
	int Y=0;


	BitToByte(&B,BitB,8);
//	printf("%d\t",*X0);
//	for(int k=0;k<8;k++)
//		printf("%d",BitB[k]);
//	printf("\n");
	Y=((int)(pow((int)(B^(*X0)),2.0)+1))%(int)(pow(2,16));
/*	Y=(BYTE)(((B^(*X0))*(B^(*X0))+1)%65536);*/
//	for(int k=0;k<2;k++)
//		printf("%x",Y);
	ByteToBit(BitY,(BYTE *)&Y,16);
//	for(int k=0;k<16;k++)
//		printf("%d",BitY[k]);
//	printf("\n");
}
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];
}
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 main()
{
	BYTE Key[11]="Ceressiaww";	
	BYTE *BitKey;
	BYTE *BitK1,*BitK2;
	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;
	
	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*512);
	memset(QuenceB,0,8*512);
	
	Z=(BYTE *)malloc(512);
	memset(Z,0,512);

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

	ByteToBit(BitKey,Key,80);
	///////////////////////////////
//	for(int j=0;j<80;j++)
//		printf("%d",BitKey[j]);
	/////////////////////////////////
	StartKey(BitKey,BitK1,BitK2);
	InitLFSR(BitK1,BitK2,vector1,vector2);
	/////////////////////////////////////
/*	printf("\nBitK1,BitK2\n");
	for(int j=0;j<32;j++)
	{
		if(j%8==0&&j!=0)
			printf("\n");
		printf("%d",BitK1[j]);
	}
	for(j=0;j<48;j++)
	{
		if(j%8==0)
			printf("\n");
		printf("%d",BitK2[j]);
	}*/
	///////////////////////////////////////

	for(i=0;i<512;i++)
	{
		RightRotate(BitK1,32,vector1,1);
		RightRotate(BitK2,48,vector2,1);
		GeneratesB(BitK1,BitK2,QuenceB+i*8);	
	}
	//////////////////////////////
/*	printf("\nQuenceB\n");
	for(i=0;i<512*8;i++)
	{
		if(i%8==0&&i!=0)
			printf("\n");
		printf("%d",QuenceB[i]);
	}*/
	//////////////////////////////
 	iterate(QuenceB,Z,BitK2);

	for(int j=0;j<512;j++)
		printf("%x\t",Z[j]);


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

	for(int k=0;k<1024*4;k++)
	{
		rewind(fpr);
	while(!feof(fpr))
	{
		memset(buf,0,512);
		readbyte=fread(buf,1,512,fpr);
		for(int n=0;n<512;n++)
			buf[n]=buf[n]^Z[n%512];
		fwrite(buf,1,readbyte,fpw);
	}
	}
	fclose(fpr);
	fclose(fpw);


	fpr=fopen("h:\\txt\\C1024.txt","rb");
	fpw=fopen("h:\\txt\\PC1024.txt","wb");

	while(!feof(fpr))
	{
		memset(buf,0,512);
		readbyte=fread(buf,1,512,fpr);
		for(int n=0;n<512;n++)
			buf[n]=buf[n]^Z[n%512];
		fwrite(buf,1,readbyte,fpw);
	}
	fclose(fpr);
	fclose(fpw);
}