#include<bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::system_clock::now().time_since_epoch().count());
const int N = 4, T = 10, P = 283;
const int S[1 << 4][1 << 4] = {
{0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,},
{0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,},
{0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,},
{0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,},
{0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,},
{0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,},
{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,},
{0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,},
{0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,},
{0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,},
{0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,},
{0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,},
{0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,},
{0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,},
{0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16}
};
const int S_1[1 << 4][1 << 4] = {
{0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,},
{0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,},
{0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,},
{0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,},
{0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,},
{0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,},
{0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,},
{0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,},
{0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,},
{0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,},
{0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,},
{0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,},
{0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,},
{0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,},
{0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,},
{0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D}
};
const int G[N][N]{{0x02, 0x03, 0x01, 0x01},
{0x01, 0x02, 0x03, 0x01},
{0x01, 0x01, 0x02, 0x03},
{0x03, 0x01, 0x01, 0x02}};
const int G_1[N][N] = {{0x0E, 0x0B, 0x0D, 0x09},
{0x09, 0x0E, 0x0B, 0x0D},
{0x0D, 0x09, 0x0E, 0x0B},
{0x0B, 0x0D, 0x09, 0x0E}};
static const unsigned int Rcon[10] = {
0x01000000UL,
0x02000000UL,
0x04000000UL,
0x08000000UL,
0x10000000UL,
0x20000000UL,
0x40000000UL,
0x80000000UL,
0x1B000000UL,
0x36000000UL
};
int a[N][N], b[N][N], tmp[N];
unsigned int K[11][4];
inline int GMul(int x, int y) {
int res = 0;
for (int i = 0; i < 8; i++, x <<= 1)
if (y >> i & 1)res ^= x;
while (__lg(res) >= 8)res ^= P << (__lg(res) - 8);
return res;
}
inline void KeyExpansion() {
for (int i = 1; i <= 10; i++) {
unsigned int t = 0;
for (int j = 24, k = 1; k <= 4; j = (j + 8) % 32, k++)
t |= S[(K[i - 1][3] >> (j + 4)) & ((1 << 4) - 1)][(K[i - 1][3] >> j) & ((1 << 4) - 1)] << ((j + 8) % 32);
K[i][0] = K[i - 1][0] ^ Rcon[i - 1] ^ t;
for (int j = 1; j < 4; j++)K[i][j] = K[i - 1][j] ^ K[i][j - 1];
}
}
inline void SubByte() {
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
a[i][j] = S[a[i][j] >> 4][a[i][j] & ((1 << 4) - 1)];
}
inline void InvSubByte() {
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
a[i][j] = S_1[a[i][j] >> 4][a[i][j] & ((1 << 4) - 1)];
}
inline void ShiftRow() {
for (int i = 0; i < N; i++) {
memcpy(tmp, a[i], sizeof(tmp));
for (int j = 0; j < N; j++)
a[i][j] = tmp[(j + i) % N];
}
}
inline void InvShiftRow() {
for (int i = 0; i < N; i++) {
memcpy(tmp, a[i], sizeof(tmp));
for (int j = 0; j < N; j++)
a[i][j] = tmp[(j - i + N) % N];
}
}
inline void MixColumn() {
memset(b, 0, sizeof(b));
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++)
b[i][j] ^= GMul(a[k][j], G[i][k]);
memcpy(a, b, sizeof(a));
}
inline void InvMixColumn() {
memset(b, 0, sizeof(b));
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++)
b[i][j] ^= GMul(a[k][j], G_1[i][k]);
memcpy(a, b, sizeof(a));
}
inline void AddRoundKey(int u) {
for (int i = 0; i < N; i++)
for (int j = 0, k = 24; j < N; j++, k -= 8)
a[i][j] ^= (K[u][i] >> k) & ((1 << 8) - 1);
}
inline void Encryption() {
KeyExpansion();
AddRoundKey(0);
for (int i = 1; i < T; i++) {
SubByte();
ShiftRow();
MixColumn();
AddRoundKey(i);
}
SubByte();
ShiftRow();
AddRoundKey(T);
}
inline void Decryption() {
KeyExpansion();
AddRoundKey(T);
for (int i = T - 1; i >= 1; i--) {
InvShiftRow();
InvSubByte();
AddRoundKey(i);
InvMixColumn();
}
InvSubByte();
InvShiftRow();
AddRoundKey(0);
}
inline void out() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 7; k >= 0; k--)
printf("%d", a[i][j] >> k & 1);
putchar(' ');
}
puts("");
}
}
int main() {
for (int i = 0; i < N; i++)K[0][i] = rnd() % UINT32_MAX;
puts("密钥：");
for (int i = 0; i < N; i++) {
for (int j = 31; j >= 0; j -= 8) {
for (int k = 0; k < 8; k++)
printf("%d", K[0][i] >> (j - k) & 1);
putchar(' ');
}
puts("");
}
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
a[i][j] = rnd() % (1 << 8);
puts("原文："), out();
Encryption();
puts("密文："), out();
Decryption();
puts("原文："), out();
return 0;
}
运行结果：
密钥：
00101001 10110001 01100010 10110101
00000111 11111011 00110011 01110110
10010001 10110011 01110000 10111000
01011011 01010111 10000001 00011100
原文：
11111011 10001010 10111000 01000101
11011101 01110000 11110111 10101101
10101011 01011000 00100101 01001111
00000011 10101101 00001100 11101010
密文：
00110100 10111001 11010001 00011011
11101100 01101111 00111010 11000101
00101111 10010100 00010100 10111100
00001001 10011111 01101111 10011001
原文：
11111011 10001010 10111000 01000101
11011101 01110000 11110111 10101101
10101011 01011000 00100101 01001111
00000011 10101101 00001100 11101010