hillcipher.cpp

自己编写的加密算法 hill加密算法。包括

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

//using namespace std;

const int maxArrayDimension=20;

class HillArray
{

	//the maximum dimension of hill array that user defined
	int size;
	//value of the hill array
	int detHArray;
//*************************************************************************************
	//fill the array menbers with random number
	void fillArray();
	//
	void showArray(int array[][maxArrayDimension],int arraydim);
	//a hill array must be a inverse matrix and gcd(det A,26)=1
	bool isHillArray();
	//if a array is hill array we must caculate it inverse matrix
	//this function is for caculating detHA with recursion
	int detArray(int dimR,int dimL,int remArray[][maxArrayDimension]);
	//this function is prepare for caculate the inverse matrix
	int memberV(int row,int line);
	//fill the inverse matrix
	void fillInversHArray();


public:
	//this matrix holds hill array
	int HArray[maxArrayDimension][maxArrayDimension];
	int inverseHArray[maxArrayDimension][maxArrayDimension];

	//constract a hill array of a specific length
	HillArray(int userDimension)
	{
		//dimension of the array must be less than max and positive
		if(userDimension>maxArrayDimension)
			userDimension=maxArrayDimension;
		else if(userDimension<=0)
			userDimension=1;

		size=userDimension;
	}

	//caculate the det of hill array
	int detHillArray();

	void showOriginalArray();

	void showInverseArray();

	void initalFunc();

};

int HillArray::detArray(int dimR,int dimL,int remArray[][maxArrayDimension])
{
	int temp[maxArrayDimension][maxArrayDimension];
	int tempf;
	int flag;
	int i,j,k;
	int det=0;

	if(dimR==2)
	{
		return remArray[0][0];
	}

	for(i=0;i<dimR-1;i++)
	{
		flag=0;
		for(j=0,tempf=0;j<dimR;j++,tempf++)
		{
			if(j==(dimL-1))
			{
				flag=1;
				continue;
			}
			temp[i][tempf-flag]=remArray[i][j];
		}
	}

	if(dimR==3)
	{
		return temp[0][0]*temp[1][1]-temp[0][1]*temp[1][0];
	}

	for(k=0;k<dimR-1;k++)
	{
		det+=((int)pow(-1,(dimR+k)))*temp[dimR-2][k]*detArray(dimR-1,k+1,temp);
	}

	return det;
}

int HillArray::memberV(int row,int line)
{
	//for storage HillArray(row,line)
	int temp[maxArrayDimension][maxArrayDimension];

	int flagR,flagL;
	int inR,inL;
	int i,j;
	int member;

	flagR=0;
	for(i=0,inR=0;i<size;i++,inR++)
	{
		flagL=0;
		if(i==row)
		{
			flagR=1;
			continue;
		}
		for(j=0,inL=0;j<size;j++,inL++)
		{
			if(j==line)
			{
				flagL=1;
				continue;
			}
			temp[inR-flagR][inL-flagL]=HArray[i][j];
		}
	}

	//showArray(temp,size-1);

	member=((int)pow(-1,row+line+2))*detArray(size,size,temp);

	return (member%26+26)%26;
}

void HillArray::fillArray()
{
	//circulate number
	int i,j;

	//seed the rand number generator with current time
	srand((unsigned)time(NULL));

	//use double cycle to fill the array full
	for(i=0;i<size;i++)
	{
		for(j=0;j<size;j++)
		{
			//the menbers of this array must range from 0 to 25
			HArray[i][j]=rand()%26;
		}
	}
}

void HillArray::showArray(int array[][maxArrayDimension],int arraydim)
{
	//circulate number
	int i,j;

	for(i=0;i<arraydim;i++)
	{
		for(j=0;j<arraydim;j++)
		{
			printf("%2d ",array[i][j]);
		}
		printf("\n");
	}
	printf("\n");
}

int HillArray::detHillArray()
{
	detHArray=detArray(size+1,size+1,HArray);
	return detHArray;
}

bool HillArray::isHillArray()
{
	int det;

	det=(detHillArray()%26+26)%26;

	if(det&&(det%2)&&(det%13))
		return true;

	return false;
}

void HillArray::fillInversHArray()
{
	int i,j;
	int invDet;

	for(i=1;i<26;i++)
	{
		if((((detHArray%26+26)%26)*i)%26==1)
		{
			invDet=i;
		//	printf("%d\n",i);
			break;
		}
	}

	for(i=0;i<size;i++)
		for(j=0;j<size;j++)
		{
			inverseHArray[i][j]=(invDet*memberV(j,i))%26;
		}
}

void HillArray::showOriginalArray()
{
	showArray(HArray,size);
}

void HillArray::showInverseArray()
{
	showArray(inverseHArray,size);
}

void HillArray::initalFunc()
{
	do
	{
		fillArray();
	}while(!isHillArray());
	fillInversHArray();
}

int main()
{
	HillArray one(4);
	char plaintext[5],t[5];
	char ciphertext[5];
	int temp=0;

	int i,j;
	long l;

	l=clock();
	one.initalFunc();
	l=clock()-l;

	printf("%ld\n",l);
	one.showOriginalArray();

	one.showInverseArray();

	printf("input your plaintext:");
	gets(plaintext);

	for(i=0;i<4;i++)
	{
		temp=0;
		for(j=0;j<4;j++)
		{
			temp+=(plaintext[j]-97)*one.HArray[i][j];
		}
		ciphertext[i]=(char)(temp%26+97);
	}

	for(i=0;i<4;i++)
	{
		temp=0;
		for(j=0;j<4;j++)
		{
			temp+=(ciphertext[j]-97)*one.inverseHArray[i][j];
		}
		t[i]=(char)(temp%26+97);
	}

	t[4]=NULL;
	ciphertext[4]=NULL;	
	puts(ciphertext);
	printf("\n");
	puts(t);	
//	for(i=0;i<3;i++)
//		printf("%c",ciphertext[i]);

	//printf("%d",one.detHillArray());
	printf("\n");

	return 0;

}