Криптон

const int N = 4;
const int M = 3;
int Q[8] = { 40, 134 ,20 , 97 , 148 , 65 , 41 , 130 };
int B[16] = { 0x63, 0x7c, 0x77, 0x7b , 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76 };
int KEY[32] = { 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
              0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2 };
int P0(int x)
{
	switch (x)
	{
	case 0x0: return 0xf; break;
	case 0x1: return 0xe; break;
	case 0x2: return 0xa; break;
	case 0x3: return 0x1; break;
	case 0x4: return 0xb; break;
	case 0x5: return 0x5; break;
	case 0x6: return 0x8; break;
	case 0x7: return 0xd; break;
	case 0x8: return 0x9; break;
	case 0x9: return 0x3; break;
	case 0xa: return 0x2; break;
	case 0xb: return 0x7; break;
	case 0xc: return 0x0; break;
	case 0xd: return 0x6; break;
	case 0xe: return 0x4; break;
	case 0xf: return 0xc; break;
	}
}

int P1(int x)
{
	switch (x)
	{
	case 0x0: return 0xb; break;
	case 0x1: return 0xa; break;
	case 0x2: return 0xd; break;
	case 0x3: return 0x7; break;
	case 0x4: return 0x8; break;
	case 0x5: return 0xe; break;
	case 0x6: return 0x0; break;
	case 0x7: return 0x5; break;
	case 0x8: return 0xf; break;
	case 0x9: return 0x6; break;
	case 0xa: return 0x3; break;
	case 0xb: return 0x4; break;
	case 0xc: return 0x1; break;
	case 0xd: return 0x9; break;
	case 0xe: return 0x2; break;
	case 0xf: return 0xc; break;
	}
}

int P0_1(int x)
{
	switch (x)
	{
	case 0x0: return 0xc; break;
	case 0x1: return 0x3; break;
	case 0x2: return 0xa; break;
	case 0x3: return 0x9; break;
	case 0x4: return 0xe; break;
	case 0x5: return 0x5; break;
	case 0x6: return 0xd; break;
	case 0x7: return 0xb; break;
	case 0x8: return 0x6; break;
	case 0x9: return 0x8; break;
	case 0xa: return 0x2; break;
	case 0xb: return 0x4; break;
	case 0xc: return 0xf; break;
	case 0xd: return 0x7; break;
	case 0xe: return 0x1; break;
	case 0xf: return 0x0; break;
	}
}

int P1_1(int x)
{
	switch (x)
	{
	case 0x0: return 0x6; break;
	case 0x1: return 0xc; break;
	case 0x2: return 0xe; break;
	case 0x3: return 0xa; break;
	case 0x4: return 0xb; break;
	case 0x5: return 0x7; break;
	case 0x6: return 0x9; break;
	case 0x7: return 0x3; break;
	case 0x8: return 0x4; break;
	case 0x9: return 0xd; break;
	case 0xa: return 0x1; break;
	case 0xb: return 0x0; break;
	case 0xc: return 0xf; break;
	case 0xd: return 0x2; break;
	case 0xe: return 0x5; break;
	case 0xf: return 0x8; break;
	}
}

int rol_m(int Y, int m)
{
	return ((Y << m) & 255 | ((Y << m) / 256));
}

int one_zero(int h)///количество единиц четно или нет в двоичной записи числа
{
	int k=0, power = 128;
	for (int i = 0; i < 8&&(h!=0); i++)
	{
		if (h - power >= 0)
		{
			h -=power;
			k++;
		}
		power /= 2;
	}
	if (k % 2 == 0)
		return 0;
	else return 1;
}

int S(int x)
{
	int z = P1(x/16)*16 +P0(x%16);
	int w = 0, power = 128;
	for (int i = 0; i < 2 * N; i++)
	{
		w += (one_zero((z& Q[i])))*power;
		power /= 2;
	}
	int y = P1_1(w / 16) * 16 + P0_1(w % 16);
	return y;
}

int** Y(int n, int** a)//один элемент а="f0"
{
		int** b = new int*[N];
	for (int i = 0; i < N; i++)
		b[i] = new int[N];

	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
		{
			switch ((i + j + 2 * n) % 4)
			{
			case 0: b[i][j] = rol_m(S(a[i][j]), 1);break;
			case 1: b[i][j] = rol_m(S(a[i][j]), 3);break;
			case 2: b[i][j] = S(rol_m(a[i][j], 7));break;
			case 3: b[i][j] = S(rol_m(a[i][j], 5));break;
			}
		}
	return b;
}

int** Pi(int**a, int n)
{
	int m[4]= { 0xfc,0xf3,0xcf,0x3f };

	int** b = new int*[N];
	for (int i = 0; i < N; i++)
		b[i] = new int[N];

	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
			b[i][j] = 0;

	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
			for (int k = 0; k < N; k++)
					b[i][j] ^= (m[(i - j + 3 + k + 2 * n) % 4] &a[k][j]);
	return b;
}

void T(int** A)//транспoнируем
{
	int x;
	for (int i = 0; i < N; i++)
		for (int j = 0; j < i; j++)
		{
			x = A[i][j];
			A[i][j] = A[j][i];
			A[j][i] = x;
		}
}

int rol_n(unsigned int  X, int n)
{
	return ((X << n) & 4294967295 | ((X << n) / 4294967296));
}

int rolb_n(unsigned int X, int n)
{
	int Y = 0; int power = 16777216;
	for (int i = 0; i < N; i++)
	{
		Y += rol_m(X/power, n)*power;
		X %= power;
		power /= 256;

	}

	return Y;
}

int*** key(int* K)
{
	int** H = new int*[N];
	for (int i = 0; i < N; i++)
		H[i] = new int[N];

	unsigned int* U = new unsigned int[N];

	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
				H[i][j] = K[i*N + j];
	H = Pi(Y(0, H), 0);
	T(H);
	for (int i = 0; i < N; i++)
		U[i] = 0;
	unsigned int power = 16777216;//16^6
	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
	{
		U[i] += (H[i][j])*power;
		power /= 256;
	}

	unsigned int * V = new unsigned int[N];
	int l = 1;
	for (int i = 0; i < N; i++)
		for (int j = N - 1; j >= 0; j--)
		{
			H[i][j] = K[l];
			l += 2;
		}
	H = Pi(Y(1, H), 1);
	T(H);
	for (int i = 0; i < N; i++)
		V[i] = 0;
	power = 16777216;//16^6
	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
		{
			V[i] += (H[i][j])*power;
			power /= 256;
		}

	unsigned int * e = new unsigned int[8];

	for (int i = 0; i < N; i++)
		{
			e[i]= U[i]^V[0]^V[1]^V[2]^V[3];
			e[i + 4]= V[i]^U[0]^U[1]^U[2]^U[3];
		}

	unsigned int * c = new unsigned int[13];
	c[0] = 0xa54ff53a;
	for (int i = 1; i < 13; i++)
		c[i] = (c[i - 1] + 0x3c6ef372) % 4294967296;

	unsigned int * mc = new unsigned int[N];
	mc[0] = 0xacacacac;

	for (int i = 1; i < N; i++)
		mc[i] = rolb_n(mc[i - 1], 1);

	int ***ke = new int**[13];
	for (int i = 0; i < 13; i++)
	{
		ke[i] = new int*[N];
		for (int j = 0; j < N; j++)
			ke[i][j] = new int[N];
	}

	unsigned int o0,o1, p0,p1 , t;
	for (int i = 0; i < N; i++)
	{
		power = 16777216;
		p0 = e[i];
		p1 = e[i + 4];
		t = mc[i];
		o0 = c[0];
		o1 = c[1];
		for (int j = 0; j < N; j++)
		{
			ke[0][i][j] = (p0 / power) ^ (o0 / power) ^ (t / power);
			ke[1][i][j] = (p1 / power) ^ (o1 / power) ^ (t / power);
			p0%=power;
			p1%=power;
			t %=power;
			o0%=power;
			o1%=power;
			power /= 256;
		}
	}

	for (int r = 2; r < 13; r++)
	{
		if (r % 2 == 1)
		{
			e[4] = rolb_n(e[7], 2);
			e[5] = rolb_n(e[4], 2);
			e[6] = rol_n(e[5], 8);
			e[7] = rol_n(e[6], 16);
			for (int i = 0; i < N; i++)
			{
				power = 16777216;
				p0 = e[i + 4];
				t = mc[i];
				o0 = c[r];
				for (int j = 0; j < N; j++)
				{
					ke[r][i][j] = (p0 / power) ^ (o0 / power) ^ (t / power);
					p0 %= power;
					t %= power;
					o0 %= power;
					power /= 256;
				}
			}
		}
		else
		{
			e[0] = rol_n(e[1], 24);
			e[1] = rol_n(e[2], 16);
			e[2] = rolb_n(e[3], 6);
			e[3] = rolb_n(e[0], 6);
			for (int i = 0; i < N; i++)
			{
				power = 16777216;
				p0 = e[i];
				t = mc[i];
				o0 = c[r];
				for (int j = 0; j < N; j++)
				{
					ke[r][i][j] = (p0 / power) ^ (o0 / power) ^ (t / power);
					p0 %= power;
					t %= power;
					o0 %= power;
					power /= 256;
				}
			}
		}
	}
	return ke;
}

void out(int**X, ofstream&f)
{
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < N; j++)
		{
			f << hex << X[i][j] << ' ';
		}

		f << '\n';
	}
	f << endl;
}

int** encryption(int**P, int***Key)
{
	int** C = new int*[N];
	for (int i = 0; i < N; i++)
		C[i] = new int[N];

	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
				C[i][j] = P[i][j];
	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
				C[i][j] ^= Key[0][i][j];

	int n, r;
	for (r = 1; r <=12; r++)//
	{
		n = (r - 1) % 2;
		C = Y(n, C);
		C = Pi(C, n);
		T(C);
		for (int i = 0; i < N; i++)
			for (int j = 0; j < N; j++)
				C[i][j] ^= Key[r][i][j];

	}
	T(C);
	C = Pi(C, 1);
	T(C);
	return C;
}

int** decryption(int**C, int***Key)
{
	int** P = new int*[N];
	for (int i = 0; i < N; i++)
		P[i] = new int[N];

	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
			P[i][j] = C[i][j];
	T(P);
	P = Pi(P, 1);
	T(P);
	int ny, npi;
	for (int r = 12; r >= 1; r--)
	{
		for (int i = 0; i < N; i++)
			for (int j = 0; j < N; j++)
					P[i][j]^= Key[r][i][j];///
		T(P);
		ny = r % 2;
		npi = (r + 1) % 2;
		P = Pi(P, npi);
		P = Y(ny,P);
	}
	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
				P[i][j]^= Key[0][i][j];
	return P;
}

void Crypton(ofstream&f2, ofstream&f3)
{
	int** C = new int*[N];
	for (int i = 0; i < N; i++)
		C[i] = new int[N];

	int** P = new int*[N];
	for (int i = 0; i < N; i++)
		P[i] = new int[N];

	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
			P[i][j] = B[i*N + j];
	out(P, f2);
	int ***ke = new int**[13];
	for (int i = 0; i < 13; i++)
	{
		ke[i] = new int*[N];
		for (int j = 0; j < N; j++)
			ke[i][j] = new int[N];
	}

	ke=key(KEY);
	C = encryption(P, ke);
	f2 << "Begin of decrypt" << endl;
	P = decryption(C, ke);
}