Если вбить в яндекс 'aes 128 ecb mode', найдутся хорошие статьи ребят на "хабре": раз и два — толковые и одновременно слишком подробные.
Рассказ об алгоритме в картинках находится здесь (который также можно найти по ссылкам в одной из статей ребят выше).
Кратко об алгоритме: 1) создаем объект с 16-байтным state и массивом 16-байтных ключей; 2) пишем примитивы для объекта (они же трансформации); 3) запускаем n раз (где n — кол-во раундов). Все трансформации делаем симметричными — для зашифровки и расшифровки одновременно. Расшифровка в терминах алгоритма — это зашифровка наоборот.
Структура:
using byte_t = unsigned char;
struct aes128 {
aes128(const std::string& text, const std::string& cipher, bool decrypt = false)
: state({begin(text), end(text)}), keys({{begin(cipher), end(cipher)}}), decrypt(decrypt) {}
aes128() = default;
aes128(const aes128&) = default;
std::vector<byte_t> state;
std::vector<std::vector<byte_t>> keys;
bool decrypt;
}Первым делом после создания генерируем ключи (инфа о sbox и RCON будет ниже):
void key_expansion() {
for (int j = 1; j != 11; j++) { // for 11 rounds
std::vector<byte_t> key = keys[j-1];
std::vector<byte_t> column = {key[13], key[14], key[15], key[12]}; // rotation
for (auto& x: column) x = sbox(x);
column[0] ^= RCON[j];
std::transform(begin(column), end(column), begin(key), begin(key), std::bit_xor<byte_t>());
std::transform(begin(key)+4, end(key), begin(key), begin(key)+4, std::bit_xor<byte_t>());
keys.emplace_back(std::move(key));
}
}Пишем примитивы (они же трансформации). Трансформация добавляет сложность в state, чтоб было секьюрно.
void add_round_key(int r) {
std::transform(begin(keys[r]), end(keys[r]), begin(state), begin(state), std::bit_xor<byte_t>());
}
void substitute_bytes() {
std::transform(begin(state), end(state), begin(state), [&](byte_t x) { return sbox(x, decrypt); });
}
void shift_rows() {
int k = decrypt ? 3 : 1; // coef for rotation point
for (int i = 1; i != 4; ++i)
shift_row({state[i], state[4+i], state[8+i], state[12+i]}, (k*i) % 4, i);
}
void shift_row(std::array<byte_t, 4>&& row, int k, int j) {
std::rotate(begin(row), begin(row)+k, end(row));
for (int i = 0; i != 4; ++i) { state[i*4+j] = row[i]; }
}Плюс еще одна трансформация (инфу о байтах 0xe, 0x2… берем из статьей ребят выше):
void mix_columns() {
for (int i = 0; i != 4; i++) {
const std::array<byte_t, 4> column = {state[i*4], state[i*4+1], state[i*4+2], state[i*4+3]};
if (!decrypt) {
state[i*4] = vector_mult(column, { 0x2, 0x3, 0x1, 0x1 });
state[i*4+1] = vector_mult(column, { 0x1, 0x2, 0x3, 0x1 });
state[i*4+2] = vector_mult(column, { 0x1, 0x1, 0x2, 0x3 });
state[i*4+3] = vector_mult(column, { 0x3, 0x1, 0x1, 0x2 });
} else {
state[i*4] = vector_mult(column, { 0xe, 0xb, 0xd, 0x9 });
state[i*4+1] = vector_mult(column, { 0x9, 0xe, 0xb, 0xd });
state[i*4+2] = vector_mult(column, { 0xd, 0x9, 0xe, 0xb });
state[i*4+3] = vector_mult(column, { 0xb, 0xd, 0x9, 0xe });
}
}
}Собственно, алгоритмы:
aes128 encrypt(const std::string& text, const std::string& cipher) {
aes128 aes(text, cipher);
aes.key_expansion();
aes.add_round_key(0);
for (int i = 1; i != 10; i++) {
aes.substitute_bytes();
aes.shift_rows();
aes.mix_columns();
aes.add_round_key(i);
}
aes.substitute_bytes();
aes.shift_rows();
aes.add_round_key(10);
return aes;
}
template <typename I>
aes128 decrypt(I first, I last, const std::string& cipher) {
aes128 aes({first, last}, cipher, true);
aes.key_expansion();
aes.add_round_key(10);
aes.shift_rows();
aes.substitute_bytes();
for (int i = 9; i != 0; --i) {
aes.add_round_key(i);
aes.mix_columns();
aes.shift_rows();
aes.substitute_bytes();
}
aes.add_round_key(0);
return aes;
}Утилиты:
byte_t hex(char ch) { return (ch - '0') % 39; }
byte_t sbox(byte_t x, bool decrypt = false) {
std::string s = (decrypt ? INV_SBOX : SBOX)[x >> 4][x & 15];
return hex(s[0]) << 4 | hex(s[1]);
}
byte_t mult_by_2(byte_t x) { return (x < 128) ? x << 1 : (x << 1 & 0xff) ^ 0x1b; }
byte_t mult_by_8(byte_t x) { return mult_by_2(mult_by_2(mult_by_2(x))); }
const std::unordered_map<byte_t, std::function<byte_t(byte_t)>> mapper = {
{0x1, [](byte_t x) { return x; }},
{0x2, mult_by_2},
{0x3, [](byte_t x) { return mult_by_2(x) ^ x; }},
{0x9, [](byte_t x) { return mult_by_8(x) ^ x; }},
{0xb, [](byte_t x) { return mult_by_8(x) ^ mult_by_2(x) ^ x; }},
{0xd, [](byte_t x) { return mult_by_8(x) ^ mult_by_2(mult_by_2(x)) ^ x; }},
{0xe, [](byte_t x) { return mult_by_8(x) ^ mult_by_2(mult_by_2(x)) ^ mult_by_2(x); }},
};
byte_t vector_mult(const std::array<byte_t, 4>& v1, std::array<byte_t, 4>&& v2) {
std::transform(begin(v1), end(v1), begin(v2), begin(v2),
[](byte_t x, byte_t y) { return mapper.at(y)(x); });
return std::accumulate(begin(v2), end(v2), byte_t(0), std::bit_xor<byte_t>());
}Константы:
const std::vector<std::vector<std::string>> SBOX = {
{ "63", "7c", "77", "7b", "f2", "6b", "6f", "c5", "30", "01", "67", "2b", "fe", "d7", "ab", "76" },
{ "ca", "82", "c9", "7d", "fa", "59", "47", "f0", "ad", "d4", "a2", "af", "9c", "a4", "72", "c0" },
{ "b7", "fd", "93", "26", "36", "3f", "f7", "cc", "34", "a5", "e5", "f1", "71", "d8", "31", "15" },
{ "04", "c7", "23", "c3", "18", "96", "05", "9a", "07", "12", "80", "e2", "eb", "27", "b2", "75" },
{ "09", "83", "2c", "1a", "1b", "6e", "5a", "a0", "52", "3b", "d6", "b3", "29", "e3", "2f", "84" },
{ "53", "d1", "00", "ed", "20", "fc", "b1", "5b", "6a", "cb", "be", "39", "4a", "4c", "58", "cf" },
{ "d0", "ef", "aa", "fb", "43", "4d", "33", "85", "45", "f9", "02", "7f", "50", "3c", "9f", "a8" },
{ "51", "a3", "40", "8f", "92", "9d", "38", "f5", "bc", "b6", "da", "21", "10", "ff", "f3", "d2" },
{ "cd", "0c", "13", "ec", "5f", "97", "44", "17", "c4", "a7", "7e", "3d", "64", "5d", "19", "73" },
{ "60", "81", "4f", "dc", "22", "2a", "90", "88", "46", "ee", "b8", "14", "de", "5e", "0b", "db" },
{ "e0", "32", "3a", "0a", "49", "06", "24", "5c", "c2", "d3", "ac", "62", "91", "95", "e4", "79" },
{ "e7", "c8", "37", "6d", "8d", "d5", "4e", "a9", "6c", "56", "f4", "ea", "65", "7a", "ae", "08" },
{ "ba", "78", "25", "2e", "1c", "a6", "b4", "c6", "e8", "dd", "74", "1f", "4b", "bd", "8b", "8a" },
{ "70", "3e", "b5", "66", "48", "03", "f6", "0e", "61", "35", "57", "b9", "86", "c1", "1d", "9e" },
{ "e1", "f8", "98", "11", "69", "d9", "8e", "94", "9b", "1e", "87", "e9", "ce", "55", "28", "df" },
{ "8c", "a1", "89", "0d", "bf", "e6", "42", "68", "41", "99", "2d", "0f", "b0", "54", "bb", "16" }};
const std::vector<int> RCON = { 0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54 }; // ten rounds
const std::vector<std::vector<std::string>> INV_SBOX = {
{ "52", "09", "6a", "d5", "30", "36", "a5", "38", "bf", "40", "a3", "9e", "81", "f3", "d7", "fb" },
{ "7c", "e3", "39", "82", "9b", "2f", "ff", "87", "34", "8e", "43", "44", "c4", "de", "e9", "cb" },
{ "54", "7b", "94", "32", "a6", "c2", "23", "3d", "ee", "4c", "95", "0b", "42", "fa", "c3", "4e" },
{ "08", "2e", "a1", "66", "28", "d9", "24", "b2", "76", "5b", "a2", "49", "6d", "8b", "d1", "25" },
{ "72", "f8", "f6", "64", "86", "68", "98", "16", "d4", "a4", "5c", "cc", "5d", "65", "b6", "92" },
{ "6c", "70", "48", "50", "fd", "ed", "b9", "da", "5e", "15", "46", "57", "a7", "8d", "9d", "84" },
{ "90", "d8", "ab", "00", "8c", "bc", "d3", "0a", "f7", "e4", "58", "05", "b8", "b3", "45", "06" },
{ "d0", "2c", "1e", "8f", "ca", "3f", "0f", "02", "c1", "af", "bd", "03", "01", "13", "8a", "6b" },
{ "3a", "91", "11", "41", "4f", "67", "dc", "ea", "97", "f2", "cf", "ce", "f0", "b4", "e6", "73" },
{ "96", "ac", "74", "22", "e7", "ad", "35", "85", "e2", "f9", "37", "e8", "1c", "75", "df", "6e" },
{ "47", "f1", "1a", "71", "1d", "29", "c5", "89", "6f", "b7", "62", "0e", "aa", "18", "be", "1b" },
{ "fc", "56", "3e", "4b", "c6", "d2", "79", "20", "9a", "db", "c0", "fe", "78", "cd", "5a", "f4" },
{ "1f", "dd", "a8", "33", "88", "07", "c7", "31", "b1", "12", "10", "59", "27", "80", "ec", "5f" },
{ "60", "51", "7f", "a9", "19", "b5", "4a", "0d", "2d", "e5", "7a", "9f", "93", "c9", "9c", "ef" },
{ "a0", "e0", "3b", "4d", "ae", "2a", "f5", "b0", "c8", "eb", "bb", "3c", "83", "53", "99", "61" },
{ "17", "2b", "04", "7e", "ba", "77", "d6", "26", "e1", "69", "14", "63", "55", "21", "0c", "7d" }};
Ссылки:
