quantum.cpp

用c语言做的用二分法进行量子加密

}
	
	

	

byte condition(int p1,int p2,byte i)//状态条件
{
	int qubit;
	if((p1==1)&&(p2==0)&&(i==0))return 1;
	if((p1==0)&&(p2==1)&&(i==0))return 0;
	if(((p1==2)&&(p2==2)&&(i==0))||((p1==2)&&(p2==-2)&&(i==0))||((p1==1)&&(p2==0)&&(i==1))||((p1==0)&&(p2==1)&&(i==1)))
	{
		 qubit=prob()-1;
		 if(qubit<0)return qubit+2;
		 else return qubit;
	}
	if((p1==2)&&(p2==2)&&(i==1))return 1;
	if((p1==2)&&(p2==-2)&&(i==1))return 0;
	return -1;
}
void Bob_receieve()
{

	Bob_quantum=quantum;
	Bob_measure();
	return;
}
void Qsetup()
{
	Alice_quantum->use=1;/*Alice_quantum的初值*/
	Alice_quantum->full=0;
	return;
}
void Bob_measure()
{   
	byte qubit;
	
	if((Bob_quantum->use==1)&&(Bob_quantum->full==0))
	{
		Bob_ack();
		return;
	}
	if((Bob_quantum->use==1)&&(Bob_quantum->full==1))
	{
		qubit=measure(Bob_quantum,Bob_per);
		Bob_per->bitseq[counter]=qubit;
		return;
	}
}
void Bob_ack()
{
	printf("Bob:I know channel is setup!\n");
	Bob_pool->dest=Alice;
	Bob_pool->source=Bob;
	Bob_pool->buffer[0]=ack;
	Bob_pool->full=1;
	BobToAlice();
	return;
}
void init()
{
	Alice_per=Get_per_buffer();
	Eve_per=Get_per_buffer();
	Bob_per=Get_per_buffer();
	Bob_pool=Get_Pchannel();
	quantum=Get_Qchannel();
	Alice_quantum=Get_Qchannel();
	Eve_quantum=Get_Qchannel();
	Bob_quantum=Get_Qchannel();
	old_channel=Get_Pchannel();
	Alice_pool=Get_Pchannel();
	initrandom();
	Qsetup();
	free(Alice_pool);
	free(old_channel);
	quantumtras();
	/*Bob_measure();*/
	Alice_pool->buffer[0]=ack;/*后加的确认函数*/
	Alice_measure();
	return;
}
void AliceToBob()
{
	old_channel=Alice_pool;
	Bob_get();
	return;
}
void Bob_get()
{

	printf("Bob_get:enter\n");
	if((old_channel->dest==Bob)&&(old_channel->full==1))
	{
		Bob_pool=old_channel;
		return;
	}
	printf("ERROR:not Bob's frame!\n");
	exit(0);
};
void BobToAlice()
{
	old_channel=Bob_pool;
Alice_get();
	return;
}
void Alice_get()
{

	printf("Alice:get message from old channel\n");
	if((old_channel->dest==Alice)&&(old_channel->full==1))
	{
		Alice_pool=old_channel;
	
		return;
	}
	printf("ERROR:not Alice's frame!\n");
	exit(0);
}
void Alice_measure()
{
	if(Alice_pool->buffer[0]==ack)
	{
		printf("\nAlice:I know setup is complete!\n");
		return;
	}
}
void convert(byte qubit)/*prob()是探测的意思*/
{
	byte alp;
	alp=prob();/*alp是探测来的*/
	Alice_per->alphabet[counter]=alp;/*alphabet是表的意思*/
	Alice_per->state[counter]=0;
	alphabet(qubit,alp,Alice_quantum);/*Alice_quantum是Qchannel的对象*/
	return;
}
void Alice_send_quantum()/*typedef struct{
	byte bitseq[buffersize];
	byte alphabet[buffersize];
	byte state[buffersize];
}Per_buffer;
Per_buffer Alice_per;*/
{
	byte qubit;
	qubit=Alice_per->bitseq[counter];/*bitseq中存储的是随机数！外面文件中的！*/
	convert(qubit);
	Alice_quantum->use=1;
	Alice_quantum->full=1;
	quantumtras();
	printf(".");
	return;
}
void Bob_send_alphabet()
{
	int loopcount;
	int index=0;
	/*do
	{*/
		for(loopcount=0;loopcount</*size*/buffersize;loopcount++)/*size是定义的全局变量为64*/
		{
			Bob_pool->buffer[loopcount]=Bob_per->alphabet[index];
			index++;
			/*if(index==counter)
			{
				Bob_pool->buffer[loopcount]=end;
				break;
			}*/
		}
		Bob_pool->buffer[loopcount]=end;
		Bob_pool->dest=Alice;/*Alice全局变量为121*/
		Bob_pool->source=Bob;/*Bob为234*/
		Bob_pool->full=1;
		BobToAlice();/*old_channel为Alice_channle*/
		Alice_compare(index);
	/*}while(index<buffersize);*/
	return;
}
void Alice_compare(int index)/*比较Alice的基于Bob的基*/
{
	int loopcount;
	int index1=0;
	int n=index;
	int i;
	for(loopcount=0;loopcount<n;loopcount++)
	{
		
		if(Alice_per->alphabet[index1]==Alice_pool->buffer[loopcount])
			/*ALice的基在alphabet中，Bob传来的放到 Alice_pool中*/
		
			Alice_per->state[index1]=1;
	
		else
		
			Alice_per->state[index1]=0;
		
		index1++;
	}
	printf("\n");
	printf("\nAlice's state:\n");
	for(i=0;i<n;i++)
	printf("%d",Alice_per->state[i]);
	printf("\n");
	return;
}
void Alice_send_raw()
{
	int loopcount;
	int index=0;
	/*do
	{*/
		for(loopcount=0;loopcount<buffersize;loopcount++)
		{
			Alice_pool->buffer[loopcount]=Alice_per->state[index];
			index++;
			/*if(index==buffersize)
			{
				Alice_pool->buffer[++loopcount]=end;
				break;
			}*/
		}
		Alice_pool->buffer[++loopcount]=end;
		Alice_pool->dest=Bob;
		Alice_pool->source=Alice;
		Alice_pool->full=1;
		AliceToBob();
		Bob_ext_raw(index);

	/*}while(index<buffersize);*/
	return;
}
void Bob_ext_raw(int index)
{
	int loopcount;
	int index1=0;
	int n=index;
	int i;
	for(loopcount=0;loopcount<n;loopcount++)
	{
		if(Bob_pool->buffer[loopcount]==end)break;
		Bob_per->state[index1]=Bob_pool->buffer[loopcount];
		index1++;
	}
	printf("\n");
printf("\nBob's state:\n");
for(i=0;i<n;i++)
printf("%d",Bob_per->state[i]);
printf("\n");
	return;
}
int calculate()
{
	int loopcount;
	int bits=0;
	for(loopcount=0;loopcount<buffersize;loopcount++)
	{
		if(Bob_per->state[loopcount]==1)
		{
			bits++;
		}
	}
	printf("\n**the length of key :%d***\n",bits);
	return bits;
}
int Bob_send_neg(int neg_len)
{
	int loopcount;
	int index=0;
	int result;
	
/*	do
	{*/
		for(loopcount=0;loopcount<buffersize;loopcount++)
		
			if((prob()==1)&&(Bob_per->state[loopcount]==1))
			{	Bob_pool->buffer[index]=loopcount;
				Bob_pool->buffer[++index]=Bob_per->bitseq[loopcount];
				Bob_per->state[loopcount]=0;
				index++;
				negition++;
			}
			/*if(index==size)
			{*/
				
			
		
	/*}while(negition<neg_len);*/
			
	Bob_pool->dest=Alice;
	Bob_pool->source=Bob;
	Bob_pool->full=1;
	BobToAlice();
	result=Alice_detect(index);
	printf("\n the number of test key: %f\n",negition);
	printf("the number of error bits: %d\n",result);

	if(result==0)return 0;
	else return result;
	
}
int Alice_detect(int index)
{
	int loopcount;
	int index1;
	int n=0;
	for(loopcount=0;loopcount<index;loopcount++)
	{
		/*if(Alice_pool->buffer[loopcount]!=end)*/
	
			index1=Alice_pool->buffer[loopcount];
			if(Alice_per->bitseq[index1]!=Alice_pool->buffer[++loopcount])
			{printf("$$\\");
			n++;
			
			}
			else Alice_per->state[index1]=0;

	printf("&&\\");	
		
	}
	if(n==0)
	return 0;
	else return n;
}
void recycle()
{
	free(quantum);
	free(Alice_quantum);
	free(Eve_quantum);
	free(Bob_quantum);
	Alice_pool=Get_Pchannel();/*Get_Pchannel()是分配Pchannel的空间！*/
	Bob_pool=Get_Pchannel();
	old_channel=Get_Pchannel();
	return;
}
void Get_key()
{
	int loopcount;
	int index1=0;
	int index2=0;
    Bob_final_key=(int*)malloc(buffersize*sizeof(int));
	Alice_final_key=(int*)malloc(buffersize*sizeof(int));
	for(loopcount=0;loopcount<buffersize;loopcount++)
	{
		if(Bob_per->state[loopcount]==1)
		{
			Bob_final_key[index1]=Bob_per->bitseq[loopcount];
			index1++;
		}
		if(Alice_per->state[loopcount]==1)
		{
			Alice_final_key[index2]=Alice_per->bitseq[loopcount];
			index2++;
		}
	}
	Bob_final_key[index1]=end;
	Alice_final_key[index2]=end;
	int i=0,j=0;
	printf("\nAlice final key:\n");
	while(Alice_final_key[i]!=end)
	{printf("%d",Alice_final_key[i]);
	i++;
	}
	printf("\nBob final key:\n");
	while(Bob_final_key[j]!=end)
	{printf("%d",Bob_final_key[j]);
	j++;
	}
	printf("\n");
	return;
}
void clear()
{
	free(Alice_pool);
	free(Bob_pool);
	free(old_channel);
	free(Alice_per);
	free(Bob_per);
	free(Eve_per);
	return;
}

void logo()
{
	int i;
	for(i=0;i<10;i++)printf(" ");
	for(i=10;i<70;i++)printf("*");
	for(i=70;i<80;i++)printf(" ");
	printf("\n");
	for(i=0;i<10;i++)printf(" ");
	printf("*");
	printf("Welcome to demostation of quantum transmission!");
	printf("*\n");
	printf("\n");
	for(i=0;i<10;i++)printf(" ");
	for(i=10;i<70;i++)printf("*");
	for(i=70;i<80;i++)printf(" ");
}