mima-kit
Version:
mima-kit is a cryptographic suite implemented in TypeScript. The goal is to provide an easy-to-use cryptographic library. mima-kit 是一个使用 TypeScript 实现的密码学套件。目标是提供一个简单易用的密码学库。
304 lines (303 loc) • 16.1 kB
JavaScript
import { createCipher } from '../../core/cipher';
import { KitError, U8 } from '../../core/utils';
// * Constants
const SBox1 = new Uint8Array([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 SBox2 = new Uint8Array([0xE2, 0x4E, 0x54, 0xFC, 0x94, 0xC2, 0x4A, 0xCC, 0x62, 0x0D, 0x6A, 0x46, 0x3C, 0x4D, 0x8B, 0xD1, 0x5E, 0xFA, 0x64, 0xCB, 0xB4, 0x97, 0xBE, 0x2B, 0xBC, 0x77, 0x2E, 0x03, 0xD3, 0x19, 0x59, 0xC1, 0x1D, 0x06, 0x41, 0x6B, 0x55, 0xF0, 0x99, 0x69, 0xEA, 0x9C, 0x18, 0xAE, 0x63, 0xDF, 0xE7, 0xBB, 0x00, 0x73, 0x66, 0xFB, 0x96, 0x4C, 0x85, 0xE4, 0x3A, 0x09, 0x45, 0xAA, 0x0F, 0xEE, 0x10, 0xEB, 0x2D, 0x7F, 0xF4, 0x29, 0xAC, 0xCF, 0xAD, 0x91, 0x8D, 0x78, 0xC8, 0x95, 0xF9, 0x2F, 0xCE, 0xCD, 0x08, 0x7A, 0x88, 0x38, 0x5C, 0x83, 0x2A, 0x28, 0x47, 0xDB, 0xB8, 0xC7, 0x93, 0xA4, 0x12, 0x53, 0xFF, 0x87, 0x0E, 0x31, 0x36, 0x21, 0x58, 0x48, 0x01, 0x8E, 0x37, 0x74, 0x32, 0xCA, 0xE9, 0xB1, 0xB7, 0xAB, 0x0C, 0xD7, 0xC4, 0x56, 0x42, 0x26, 0x07, 0x98, 0x60, 0xD9, 0xB6, 0xB9, 0x11, 0x40, 0xEC, 0x20, 0x8C, 0xBD, 0xA0, 0xC9, 0x84, 0x04, 0x49, 0x23, 0xF1, 0x4F, 0x50, 0x1F, 0x13, 0xDC, 0xD8, 0xC0, 0x9E, 0x57, 0xE3, 0xC3, 0x7B, 0x65, 0x3B, 0x02, 0x8F, 0x3E, 0xE8, 0x25, 0x92, 0xE5, 0x15, 0xDD, 0xFD, 0x17, 0xA9, 0xBF, 0xD4, 0x9A, 0x7E, 0xC5, 0x39, 0x67, 0xFE, 0x76, 0x9D, 0x43, 0xA7, 0xE1, 0xD0, 0xF5, 0x68, 0xF2, 0x1B, 0x34, 0x70, 0x05, 0xA3, 0x8A, 0xD5, 0x79, 0x86, 0xA8, 0x30, 0xC6, 0x51, 0x4B, 0x1E, 0xA6, 0x27, 0xF6, 0x35, 0xD2, 0x6E, 0x24, 0x16, 0x82, 0x5F, 0xDA, 0xE6, 0x75, 0xA2, 0xEF, 0x2C, 0xB2, 0x1C, 0x9F, 0x5D, 0x6F, 0x80, 0x0A, 0x72, 0x44, 0x9B, 0x6C, 0x90, 0x0B, 0x5B, 0x33, 0x7D, 0x5A, 0x52, 0xF3, 0x61, 0xA1, 0xF7, 0xB0, 0xD6, 0x3F, 0x7C, 0x6D, 0xED, 0x14, 0xE0, 0xA5, 0x3D, 0x22, 0xB3, 0xF8, 0x89, 0xDE, 0x71, 0x1A, 0xAF, 0xBA, 0xB5, 0x81]);
const SBox3 = new Uint8Array([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 SBox4 = new Uint8Array([0x30, 0x68, 0x99, 0x1B, 0x87, 0xB9, 0x21, 0x78, 0x50, 0x39, 0xDB, 0xE1, 0x72, 0x09, 0x62, 0x3C, 0x3E, 0x7E, 0x5E, 0x8E, 0xF1, 0xA0, 0xCC, 0xA3, 0x2A, 0x1D, 0xFB, 0xB6, 0xD6, 0x20, 0xC4, 0x8D, 0x81, 0x65, 0xF5, 0x89, 0xCB, 0x9D, 0x77, 0xC6, 0x57, 0x43, 0x56, 0x17, 0xD4, 0x40, 0x1A, 0x4D, 0xC0, 0x63, 0x6C, 0xE3, 0xB7, 0xC8, 0x64, 0x6A, 0x53, 0xAA, 0x38, 0x98, 0x0C, 0xF4, 0x9B, 0xED, 0x7F, 0x22, 0x76, 0xAF, 0xDD, 0x3A, 0x0B, 0x58, 0x67, 0x88, 0x06, 0xC3, 0x35, 0x0D, 0x01, 0x8B, 0x8C, 0xC2, 0xE6, 0x5F, 0x02, 0x24, 0x75, 0x93, 0x66, 0x1E, 0xE5, 0xE2, 0x54, 0xD8, 0x10, 0xCE, 0x7A, 0xE8, 0x08, 0x2C, 0x12, 0x97, 0x32, 0xAB, 0xB4, 0x27, 0x0A, 0x23, 0xDF, 0xEF, 0xCA, 0xD9, 0xB8, 0xFA, 0xDC, 0x31, 0x6B, 0xD1, 0xAD, 0x19, 0x49, 0xBD, 0x51, 0x96, 0xEE, 0xE4, 0xA8, 0x41, 0xDA, 0xFF, 0xCD, 0x55, 0x86, 0x36, 0xBE, 0x61, 0x52, 0xF8, 0xBB, 0x0E, 0x82, 0x48, 0x69, 0x9A, 0xE0, 0x47, 0x9E, 0x5C, 0x04, 0x4B, 0x34, 0x15, 0x79, 0x26, 0xA7, 0xDE, 0x29, 0xAE, 0x92, 0xD7, 0x84, 0xE9, 0xD2, 0xBA, 0x5D, 0xF3, 0xC5, 0xB0, 0xBF, 0xA4, 0x3B, 0x71, 0x44, 0x46, 0x2B, 0xFC, 0xEB, 0x6F, 0xD5, 0xF6, 0x14, 0xFE, 0x7C, 0x70, 0x5A, 0x7D, 0xFD, 0x2F, 0x18, 0x83, 0x16, 0xA5, 0x91, 0x1F, 0x05, 0x95, 0x74, 0xA9, 0xC1, 0x5B, 0x4A, 0x85, 0x6D, 0x13, 0x07, 0x4F, 0x4E, 0x45, 0xB2, 0x0F, 0xC9, 0x1C, 0xA6, 0xBC, 0xEC, 0x73, 0x90, 0x7B, 0xCF, 0x59, 0x8F, 0xA1, 0xF9, 0x2D, 0xF2, 0xB1, 0x00, 0x94, 0x37, 0x9F, 0xD0, 0x2E, 0x9C, 0x6E, 0x28, 0x3F, 0x80, 0xF0, 0x3D, 0xD3, 0x25, 0x8A, 0xB5, 0xE7, 0x42, 0xB3, 0xC7, 0xEA, 0xF7, 0x4C, 0x11, 0x33, 0x03, 0xA2, 0xAC, 0x60]);
const C1 = new Uint8Array([0x51, 0x7C, 0xC1, 0xB7, 0x27, 0x22, 0x0A, 0x94, 0xFE, 0x13, 0xAB, 0xE8, 0xFA, 0x9A, 0x6E, 0xE0]);
const C2 = new Uint8Array([0x6D, 0xB1, 0x4A, 0xCC, 0x9E, 0x21, 0xC8, 0x20, 0xFF, 0x28, 0xB1, 0xD5, 0xEF, 0x5D, 0xE2, 0xB0]);
const C3 = new Uint8Array([0xDB, 0x92, 0x37, 0x1D, 0x21, 0x26, 0xE9, 0x70, 0x03, 0x24, 0x97, 0x75, 0x04, 0xE8, 0xC9, 0x0E]);
// * Functions
function RL128(x, n) {
const x_byte = x.length;
const x_bit = x_byte << 3;
// 规范化移位数
const shift = n % x_bit;
if (shift === 0) {
return x.slice(0);
}
// 计算字节和位移
const byte_shift = shift >> 3;
const bit_shift = shift % 8;
const result = new U8(x.length);
for (let i = 0; i < x_byte; i++) {
const current = x[i];
const next = x[(i + 1) % x_byte];
result[i] = (current << bit_shift) | (next >> (8 - bit_shift));
}
// 处理字节移位
if (byte_shift > 0) {
const temp = new Uint8Array(result);
for (let i = 0; i < x_byte; i++) {
result[i] = temp[(i + byte_shift) % x_byte];
}
}
return result;
}
function RR128(x, n) {
const x_byte = x.length;
const x_bit = x_byte << 3;
// 规范化移位数
const shift = n % x_bit;
if (shift === 0) {
return x.slice(0);
}
// 计算字节和位移
const byte_shift = shift >> 3;
const bit_shift = shift % 8;
const result = new U8(x.length);
for (let i = 0; i < x_byte; i++) {
const current = x[i];
const next = x[(i - 1 + x_byte) % x_byte];
result[i] = (current >> bit_shift) | (next << (8 - bit_shift));
}
// 处理字节移位
if (byte_shift > 0) {
const temp = new Uint8Array(result);
for (let i = 0; i < x_byte; i++) {
result[i] = temp[(i - byte_shift + x_byte) % x_byte];
}
}
return result;
}
function XOR(x, y) {
return x.map((_, i) => x[i] ^ y[i]);
}
function FO(D, RK) {
return A(SL1(XOR(D, RK)));
}
function FE(D, RK) {
return A(SL2(XOR(D, RK)));
}
function SL1(x) {
const y = new Uint8Array(16);
// y0 = SB1(x0), y1 = SB2(x1), y2 = SB3(x2), y3 = SB4(x3),
// y4 = SB1(x4), y5 = SB2(x5), y6 = SB3(x6), y7 = SB4(x7),
// y8 = SB1(x8), y9 = SB2(x9), y10 = SB3(x10), y11 = SB4(x11),
// y12 = SB1(x12), y13 = SB2(x13), y14 = SB3(x14), y15 = SB4(x15).
y[0] = SBox1[x[0]];
y[1] = SBox2[x[1]];
y[2] = SBox3[x[2]];
y[3] = SBox4[x[3]];
y[4] = SBox1[x[4]];
y[5] = SBox2[x[5]];
y[6] = SBox3[x[6]];
y[7] = SBox4[x[7]];
y[8] = SBox1[x[8]];
y[9] = SBox2[x[9]];
y[10] = SBox3[x[10]];
y[11] = SBox4[x[11]];
y[12] = SBox1[x[12]];
y[13] = SBox2[x[13]];
y[14] = SBox3[x[14]];
y[15] = SBox4[x[15]];
return y;
}
function SL2(x) {
const y = new Uint8Array(16);
// y0 = SB3(x0), y1 = SB4(x1), y2 = SB1(x2), y3 = SB2(x3),
// y4 = SB3(x4), y5 = SB4(x5), y6 = SB1(x6), y7 = SB2(x7),
// y8 = SB3(x8), y9 = SB4(x9), y10 = SB1(x10), y11 = SB2(x11),
// y12 = SB3(x12), y13 = SB4(x13), y14 = SB1(x14), y15 = SB2(x15).
y[0] = SBox3[x[0]];
y[1] = SBox4[x[1]];
y[2] = SBox1[x[2]];
y[3] = SBox2[x[3]];
y[4] = SBox3[x[4]];
y[5] = SBox4[x[5]];
y[6] = SBox1[x[6]];
y[7] = SBox2[x[7]];
y[8] = SBox3[x[8]];
y[9] = SBox4[x[9]];
y[10] = SBox1[x[10]];
y[11] = SBox2[x[11]];
y[12] = SBox3[x[12]];
y[13] = SBox4[x[13]];
y[14] = SBox1[x[14]];
y[15] = SBox2[x[15]];
return y;
}
function A(x) {
const y = new Uint8Array(16);
// y0 = x3 ^ x4 ^ x6 ^ x8 ^ x9 ^ x13 ^ x14
// y1 = x2 ^ x5 ^ x7 ^ x8 ^ x9 ^ x12 ^ x15
// y2 = x1 ^ x4 ^ x6 ^ x10 ^ x11 ^ x12 ^ x15
// y3 = x0 ^ x5 ^ x7 ^ x10 ^ x11 ^ x13 ^ x14
// y4 = x0 ^ x2 ^ x5 ^ x8 ^ x11 ^ x14 ^ x15
// y5 = x1 ^ x3 ^ x4 ^ x9 ^ x10 ^ x14 ^ x15
// y6 = x0 ^ x2 ^ x7 ^ x9 ^ x10 ^ x12 ^ x13
// y7 = x1 ^ x3 ^ x6 ^ x8 ^ x11 ^ x12 ^ x13
// y8 = x0 ^ x1 ^ x4 ^ x7 ^ x10 ^ x13 ^ x15
// y9 = x0 ^ x1 ^ x5 ^ x6 ^ x11 ^ x12 ^ x14
// y10 = x2 ^ x3 ^ x5 ^ x6 ^ x8 ^ x13 ^ x15
// y11 = x2 ^ x3 ^ x4 ^ x7 ^ x9 ^ x12 ^ x14
// y12 = x1 ^ x2 ^ x6 ^ x7 ^ x9 ^ x11 ^ x12
// y13 = x0 ^ x3 ^ x6 ^ x7 ^ x8 ^ x10 ^ x13
// y14 = x0 ^ x3 ^ x4 ^ x5 ^ x9 ^ x11 ^ x14
// y15 = x1 ^ x2 ^ x4 ^ x5 ^ x8 ^ x10 ^ x15
y[0] = x[3] ^ x[4] ^ x[6] ^ x[8] ^ x[9] ^ x[13] ^ x[14];
y[1] = x[2] ^ x[5] ^ x[7] ^ x[8] ^ x[9] ^ x[12] ^ x[15];
y[2] = x[1] ^ x[4] ^ x[6] ^ x[10] ^ x[11] ^ x[12] ^ x[15];
y[3] = x[0] ^ x[5] ^ x[7] ^ x[10] ^ x[11] ^ x[13] ^ x[14];
y[4] = x[0] ^ x[2] ^ x[5] ^ x[8] ^ x[11] ^ x[14] ^ x[15];
y[5] = x[1] ^ x[3] ^ x[4] ^ x[9] ^ x[10] ^ x[14] ^ x[15];
y[6] = x[0] ^ x[2] ^ x[7] ^ x[9] ^ x[10] ^ x[12] ^ x[13];
y[7] = x[1] ^ x[3] ^ x[6] ^ x[8] ^ x[11] ^ x[12] ^ x[13];
y[8] = x[0] ^ x[1] ^ x[4] ^ x[7] ^ x[10] ^ x[13] ^ x[15];
y[9] = x[0] ^ x[1] ^ x[5] ^ x[6] ^ x[11] ^ x[12] ^ x[14];
y[10] = x[2] ^ x[3] ^ x[5] ^ x[6] ^ x[8] ^ x[13] ^ x[15];
y[11] = x[2] ^ x[3] ^ x[4] ^ x[7] ^ x[9] ^ x[12] ^ x[14];
y[12] = x[1] ^ x[2] ^ x[6] ^ x[7] ^ x[9] ^ x[11] ^ x[12];
y[13] = x[0] ^ x[3] ^ x[6] ^ x[7] ^ x[8] ^ x[10] ^ x[13];
y[14] = x[0] ^ x[3] ^ x[4] ^ x[5] ^ x[9] ^ x[11] ^ x[14];
y[15] = x[1] ^ x[2] ^ x[4] ^ x[5] ^ x[8] ^ x[10] ^ x[15];
return y;
}
function KeyScheduling(K, round) {
const _K = new Uint8Array(32);
_K.set(K);
K = _K;
const KL = new Uint8Array(16);
const KR = new Uint8Array(16);
KL.set(K.subarray(0, 16));
KR.set(K.subarray(16, 32));
let CK1, CK2, CK3;
switch (round) {
case 12:
CK1 = C1;
CK2 = C2;
CK3 = C3;
break;
case 14:
CK1 = C2;
CK2 = C3;
CK3 = C1;
break;
case 16:
CK1 = C3;
CK2 = C1;
CK3 = C2;
break;
}
const W0 = new Uint8Array(16);
const W1 = new Uint8Array(16);
const W2 = new Uint8Array(16);
const W3 = new Uint8Array(16);
W0.set(KL);
W1.set(FO(W0, CK1));
W1.forEach((_, i) => W1[i] ^= KR[i]);
W2.set(FE(W1, CK2));
W2.forEach((_, i) => W2[i] ^= W0[i]);
W3.set(FO(W2, CK3));
W3.forEach((_, i) => W3[i] ^= W1[i]);
const EK = computeEK([W0, W1, W2, W3], round);
const DK = computeDK(EK, round);
return { EK, DK };
}
function computeEK(W, round) {
const [W0, W1, W2, W3] = W;
// ek1 = W0 ^ (W1 >>> 19)
// ek2 = W1 ^ (W2 >>> 19)
// ek3 = W2 ^ (W3 >>> 19)
// ek4 = W3 ^ (W0 >>> 19)
// ek5 = W0 ^ (W1 >>> 31)
// ek6 = W1 ^ (W2 >>> 31)
// ek7 = W2 ^ (W3 >>> 31)
// ek8 = W3 ^ (W0 >>> 31)
// ek9 = W0 ^ (W1 <<< 61)
// ek10 = W1 ^ (W2 <<< 61)
// ek11 = W2 ^ (W3 <<< 61)
// ek12 = W3 ^ (W0 <<< 61)
// ek13 = W0 ^ (W1 <<< 31)
// ek14 = W1 ^ (W2 <<< 31)
// ek15 = W2 ^ (W3 <<< 31)
// ek16 = W3 ^ (W0 <<< 31)
// ek17 = W0 ^ (W1 <<< 19)
const ek01 = XOR(RR128(W1, 19), W0);
const ek02 = XOR(RR128(W2, 19), W1);
const ek03 = XOR(RR128(W3, 19), W2);
const ek04 = XOR(RR128(W0, 19), W3);
const ek05 = XOR(RR128(W1, 31), W0);
const ek06 = XOR(RR128(W2, 31), W1);
const ek07 = XOR(RR128(W3, 31), W2);
const ek08 = XOR(RR128(W0, 31), W3);
const ek09 = XOR(RL128(W1, 61), W0);
const ek10 = XOR(RL128(W2, 61), W1);
const ek11 = XOR(RL128(W3, 61), W2);
const ek12 = XOR(RL128(W0, 61), W3);
const ek13 = XOR(RL128(W1, 31), W0);
if (round === 12) {
return [ek01, ek02, ek03, ek04, ek05, ek06, ek07, ek08, ek09, ek10, ek11, ek12, ek13];
}
const ek14 = XOR(RL128(W2, 31), W1);
const ek15 = XOR(RL128(W3, 31), W2);
if (round === 14) {
return [ek01, ek02, ek03, ek04, ek05, ek06, ek07, ek08, ek09, ek10, ek11, ek12, ek13, ek14, ek15];
}
const ek16 = XOR(RL128(W0, 31), W3);
const ek17 = XOR(RL128(W1, 19), W0);
return [ek01, ek02, ek03, ek04, ek05, ek06, ek07, ek08, ek09, ek10, ek11, ek12, ek13, ek14, ek15, ek16, ek17];
}
function computeDK(EK, round) {
const DK = Array.from({ length: EK.length });
// dk1 = ek{ n + 1 },
// dk2 = A(ek{ n }),
// dk3 = A(ek{ n- 1}),
// ...,
// dk{ n }= A(ek2),
// dk{ n + 1 }= ek1.
DK[0] = EK[round];
let j = round - 1;
for (let i = 1; i < round; i++) {
DK[i] = A(EK[j--]);
}
DK[round] = EK[0];
return DK;
}
// * ARIA Algorithm
function _aria(K, b) {
if (K.byteLength !== b >> 3) {
throw new KitError(`Aria-${b} key must be ${b >> 3} byte`);
}
/**
* - 128-bit key: 12 rounds
* - 192-bit key: 14 rounds
* - 256-bit key: 16 rounds
*/
const round = b === 128 ? 12 : (b === 192 ? 14 : 16);
const { EK, DK } = KeyScheduling(K, round);
const cipher = (M, RK) => {
if (M.byteLength !== 16) {
throw new KitError('ARIA block must be 16 byte');
}
let P = M;
let i = 0;
while (i < round - 2) {
P = FO(P, RK[i++]);
P = FE(P, RK[i++]);
}
P = FO(P, RK[i++]);
P = SL2(XOR(P, RK[i++]));
P = XOR(P, RK[i++]);
return new U8(P);
};
return {
encrypt: (M) => cipher(M, EK),
decrypt: (C) => cipher(C, DK),
};
}
/**
* ARIA 分组密码算法 / block cipher algorithm
*
* @param {128 | 192 | 256} b - 密钥长度 / Key size (bit)
*/
export function aria(b) {
return createCipher((K) => _aria(K, b), {
ALGORITHM: `ARIA-${b}`,
BLOCK_SIZE: 16,
KEY_SIZE: b >> 3,
MIN_KEY_SIZE: 16,
MAX_KEY_SIZE: 32,
});
}