Esempio n. 1
0
int main()
{
	srand(time(0));

	printf("#Alg\tN\tcost\titerations\n");

	for(int i = 20; i<1000; i+=2)
	{

		// the matrix that contains the compatatibilies
		int * D = (int*) malloc( sizeof(int)*i*i );
		// the array that contains a solution
		int * a = (int*) malloc( sizeof(int)*i );
		initArray(a, -1, i);

		//initialize the matrix
		genMatrix(D, i);

		// generate a solution
		genSolution(a, i);
		
		// calculate its cost
		//printf("Initial cost: %d\n", cost(D, a, i ) );
		
		// run the algorithms
		alg1(i, D, a);
		alg2(i, D, a);

		// free() the malloc()
		free(D);
		free(a);
	}

	return 0;
}
Esempio n. 2
0
int main()
{
	srand (time(NULL));

	//------------------------------------------------
	vector<int>  my_s, my_p;
	//------------------------------------------------
	int my_sub[16]			= {2, 11, 13, 0, 9, 7, 4, 14, 1, 12, 8, 15, 6, 10, 3, 5};
	//------------------------------------------------
	my_s = vector<int>(my_sub, my_sub+16);
	my_p = vector<int>(32); 
	for (int i = 0; i < 32; i++) my_p[i] = (i*5 + 11)%32;
	//------------------------------------------------
	Cipher ciph(my_s,my_p);

	//for (int i = 0; i < 16; i++) cout << ciph.sub->subs_inv[i] << ", "; cout << endl;
	//cout << ciph.PrintPermutation();
	cout << "Working.." << endl;

	double dKK[32];
	double dK[32];
	double dKs[ROUND_PER_KEY][32];

	double dX[32];
	double dY[32];

	double dHx, dHmax;
	int j = 0;
	probability P[32];
	probability Q[32];

	unsigned char ucX[5] = "\x22\x6f\x3e\x65";//"0000";
	unsigned char ucY[5];
	unsigned char ucK[5] = "\x73\x56\xa3\x64";


	for (int i = 0; i < 32; i++)
	{
		P[i].p00 = 0;
		P[i].p01 = 0;
		P[i].p10 = 0;
		P[i].p11 = 0;
	}

	for (int j = 0; j < ROUND_PER_KEY; j++)
		for (int i = 0; i < 32; i++)
		{
			switch (rand()%5)
			{
			case 0: dKs[j][i] = 0.0;
				break;
			case 1: dKs[j][i] = 1.0;
				break;
			default: dKs[j][i] = 0.5;
				break;
			}
		}
	/**/
	for (int i = 0; i < NUMBER_OF_KEY; i++)
	{
		for (int i = 0; i < 4; i++)
		{
			ucK[i] = rand()%0x100;
			//ucX[i] = rand()%0x100;
		}

		for(int i = 0; i < 4; i++)
			ucY[i] = ucX[i];
	
		ciph.CryptBlock(ucY,ucK);

		//uctod(ucK, dK);
		uctod(ucK, dKK);
		uctod(ucX, dX);
		uctod(ucY, dY);
		/*
		cout << "-----------------K orig--------------" << endl;
		for (int i = 0; i < 32; i++)
		{	
			cout << dKK[i] << "\t";
			if(!((i+1)%8)) cout << endl;
		}
		cout << endl << endl;

		/**/
		//---------------------------------------------------------------------------------------

		for (int t = 0; t < ROUND_PER_KEY; t++)
		{
		
			for (int i = 0; i < 32; i++)
			{
				dK[i] = dKs[t][i];
				/*
				switch (rand()%50)
				{
				case 0: dK[i] = 0.0;
					break;
				case 1: dK[i] = 1.0;
					break;
				default: dK[i] = 0.5;
					break;
				}
				/**/
			}
			/*
			cout << "-----------------K-------------------" << endl;
			for (int i = 0; i < 32; i++)
			{	
				cout << dK[i] << "\t";
				if(!((i+1)%8)) cout << endl;
			}	
			cout << endl << endl;
			/**/
			//---------------------------------------------------------------------------------------

			dHx = alg1(dK, dX, dY, &ciph);

			for (int i = 0; i < 32; i++)
			{
				if((dK[i] == 0.0)&&(dKK[i] == 0.0)) P[i].p00++;
				if((dK[i] == 1.0)&&(dKK[i] == 0.0)) P[i].p10++;
				if((dK[i] == 0.0)&&(dKK[i] == 1.0)) P[i].p01++;
				if((dK[i] == 1.0)&&(dKK[i] == 1.0)) P[i].p11++;
				/*if(dK[i] != 0.5)
				{
					if (dK[i] == dKK[i]) P[i].p00++;
					if (dK[i] != dKK[i]) P[i].p10++;
				}*/

			}
		}
		/**/
		//---------------------------------------------------------------------------------------
	}
	
	cout << "\tN00\tN10\tN01\tN11" << endl ;
	cout << fixed ;
	cout << setprecision(2);
	for (int i = 0; i < 32; i++)
	{
		cout << i << "\t";
		cout << P[i].p00 << "\t";
		cout << P[i].p10 << "\t";
		cout << P[i].p01 << "\t";
		cout << P[i].p11 << endl;
	}

	double temp;
	for (int i = 0; i < 32; i++)
	{
		temp = P[i].p00 + P[i].p01;
		Q[i].p00 = P[i].p00/temp;
		Q[i].p10 = P[i].p01/temp;

		temp = P[i].p10 + P[i].p11;
		Q[i].p01 = P[i].p10/temp;
		Q[i].p11 = P[i].p11/temp;

		temp = P[i].p00 + P[i].p10;
		P[i].p00 = P[i].p00/temp;
		P[i].p10 = P[i].p10/temp;

		temp = P[i].p01 + P[i].p11;
		P[i].p01 = P[i].p01/temp;
		P[i].p11 = P[i].p11/temp;
	}
	/**/
	cout << endl << endl;
	cout << "\tp00\tp10\tp01\tp11" << endl ;
	for (int i = 0; i < 32; i++)
	{
		cout << i << "\t";
		cout << P[i].p00 << "\t";
		cout << P[i].p10 << "\t";
		cout << P[i].p01 << "\t";
		cout << P[i].p11 << endl;
	}
	cout << endl << endl;
	cout << "\tq00\tq10\tq01\tq11" << endl ;
	for (int i = 0; i < 32; i++)
	{
		cout << i << "\t";
		cout << Q[i].p00 << "\t";
		cout << Q[i].p10 << "\t";
		cout << Q[i].p01 << "\t";
		cout << Q[i].p11 << endl;
	}
	cout << endl << endl;
	cout.unsetf ( ios_base::fixed );  

	/*
	cout << "-----------------K-------------------" << endl;
	for (int i = 0; i < 32; i++)
	{	
		cout << dK[i] << "\t";
		if(!((i+1)%8)) cout << endl;
	}	
	cout << endl << endl;
	/**/
	//cout << "H* = " << dHx << endl;
	/*
	double s[] = {1, 1, 1, 1};
	SubInv(s);
	cout << s[0] << s[1] << s[2] << s[3] << endl << endl;
	
	for (int i = 0; i < 16; i++)
	{
		int temp = ciph.sub->subs_inv[i];
		cout << temp/2/2/2%2 << temp/2/2%2 << temp/2%2 << temp%2 << endl;
	}
	/**/

	_getch();
	return 0;
}