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 实现的密码学套件。目标是提供一个简单易用的密码学库。
372 lines (371 loc) • 16.4 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 U8.from(x);
// 计算字节和位移
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)
U8.from(x);
// 计算字节和位移
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 = K.subarray(0, 16);
const KR = 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,
});
}