encryption-for-node
Version:
Portable Crypto libraries for Node and Browsers
838 lines • 51.7 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.TWOFISH = void 0;
function BYTE(x) {
return x & 0xFF;
}
function BYTE1(x) {
return (x >> 8) & 0xFF;
}
function BYTE2(x) {
return (x >> 16) & 0xFF;
}
function HIBYTE(x) {
return (x >> 24) & 0xFF;
}
function readUInt32LE(array, index) {
return (((array[index + 3] & 0xFF) << 24) |
((array[index + 2] & 0xFF) << 16) |
((array[index + 1] & 0xFF) << 8) |
(array[index] & 0xFF)) >>> 0;
}
function writeUInt32LE(array, value, index) {
array[index] = value & 0xFF;
array[index + 1] = (value >> 8) & 0xFF;
array[index + 2] = (value >> 16) & 0xFF;
array[index + 3] = (value >> 24) & 0xFF;
}
function rotl(value, shift) {
shift &= 31; // make sure shift is between 0 and 31
if (shift === 0) {
return value;
}
const return_value = ((value << shift) | (value >>> (32 - shift))) >>> 0;
return return_value;
}
function rotr(value, shift) {
shift &= 31; // make sure shift is between 0 and 31
if (shift === 0) {
return value;
}
const return_value = ((value >>> shift) | (value << (32 - shift))) >>> 0;
return return_value;
}
function __PAIR64__(high, low, x) {
var t = (BigInt(high) << 32n) | BigInt(low);
if (x) {
t = t >> BigInt(x);
}
var final = Number(t & BigInt('0xffffffff'));
return final;
}
function isBufferOrUint8Array(obj) {
return obj instanceof Uint8Array || (typeof Buffer !== 'undefined' && obj instanceof Buffer);
}
function isBuffer(obj) {
return (typeof Buffer !== 'undefined' && obj instanceof Buffer);
}
function extendUint8Array(array, newLength, padValue) {
const newArray = new Uint8Array(newLength);
newArray.set(array);
for (let i = array.length; i < newLength; i++) {
newArray[i] = padValue;
}
return newArray;
}
function concatenateUint8Arrays(arrays) {
const totalLength = arrays.reduce((length, array) => length + array.length, 0);
const concatenatedArray = new Uint8Array(totalLength);
let offset = 0;
for (let i = 0; i < arrays.length; i++) {
concatenatedArray.set(arrays[i], offset);
offset += arrays[i].length;
}
return concatenatedArray;
}
function xor(buf1, buf2) {
let number = -1;
const bufResult = buf1.map((b) => {
if (number != buf2.length - 1) {
number = number + 1;
}
else {
number = 0;
}
return b ^ buf2[number];
});
return bufResult;
}
function align(a, n) {
var a = a % n;
if (a) {
return (n - a);
}
else {
return 0;
}
}
function removePKCSPadding(buffer, number, PKCS = false) {
const lastByte = buffer[buffer.length - 1];
if (PKCS == true) {
return buffer.subarray(0, buffer.length - lastByte);
}
else if (lastByte != number) {
return buffer;
}
else {
var len = buffer.length;
for (let i = buffer.length - 1; i > 0; i--) {
if (buffer[i] == number) {
len--;
}
}
return buffer.subarray(0, len);
}
}
/**
* TWOFISH encryption.
*
* 16 byte key, 16 byte IV
*
* Example:
* ```
* const cipher = new TWOFISH();
* // Key for browser
* const encoder_key = new TextEncoder();
* const key = encoder_key.encode("0123456789ABCDEF");
* cipher.set_key(key)
* // Key for node
* const key = Buffer.from("0123456789ABCDEF");
* cipher.set_key(key)
* // set IV for browser
* const encoder_IV = new TextEncoder();
* const IV = encoder_IV.encode("0123456789ABCDEF");
* cipher.set_iv(IV)
* // set IV for node
* const IV = Buffer.from("0123456789ABCDEF");
* cipher.set_iv(IV)
* // Encrypt for browser
* const encoder_text = new TextEncoder();
* const text = encoder_text.encode("test text");
* const text_length = text.length
* const ciphertext = cipher.encrypt(text)
* // Encrypt for node
* const text = Buffer.from("test text");
* const text_length = text.length
* const ciphertext = cipher.encrypt(text)
* // Decrypt for browser
* cipher.set_key(key)
* cipher.set_iv(IV)
* const ciphertext = new Uint8Array(data.length)
* ciphertext.set(data)
* const decrypt_text = cipher.decrypt(ciphertext)
* const decoded_text = new TextDecoder();
* const string_data = decoded_text.decode(decrypt_text.subarray(0,text_length));
* // Decrypt for Node
* cipher.set_key(key)
* cipher.set_iv(IV)
* const ciphertext = Buffer.from(data);
* const decrypt_text = cipher.decrypt(ciphertext)
* const final_text = ciphertext.subarray(0,message_len)
* const string_data = final_text.toString()
* ```
*/
class TWOFISH {
constructor() {
this.key_set = false;
this.iv_set = false;
this.MDS_table = [];
this.MDS_1 = new Uint8Array([
0x75, 0x32, 0xBC, 0xBC, 0xF3, 0x21, 0xEC, 0xEC, 0xC6, 0x43, 0x20, 0x20, 0xF4, 0xC9, 0xB3, 0xB3,
0xDB, 0x03, 0xDA, 0xDA, 0x7B, 0x8B, 0x02, 0x02, 0xFB, 0x2B, 0xE2, 0xE2, 0xC8, 0xFA, 0x9E, 0x9E,
0x4A, 0xEC, 0xC9, 0xC9, 0xD3, 0x09, 0xD4, 0xD4, 0xE6, 0x6B, 0x18, 0x18, 0x6B, 0x9F, 0x1E, 0x1E,
0x45, 0x0E, 0x98, 0x98, 0x7D, 0x38, 0xB2, 0xB2, 0xE8, 0xD2, 0xA6, 0xA6, 0x4B, 0xB7, 0x26, 0x26,
0xD6, 0x57, 0x3C, 0x3C, 0x32, 0x8A, 0x93, 0x93, 0xD8, 0xEE, 0x82, 0x82, 0xFD, 0x98, 0x52, 0x52,
0x37, 0xD4, 0x7B, 0x7B, 0x71, 0x37, 0xBB, 0xBB, 0xF1, 0x97, 0x5B, 0x5B, 0xE1, 0x83, 0x47, 0x47,
0x30, 0x3C, 0x24, 0x24, 0x0F, 0xE2, 0x51, 0x51, 0xF8, 0xC6, 0xBA, 0xBA, 0x1B, 0xF3, 0x4A, 0x4A,
0x87, 0x48, 0xBF, 0xBF, 0xFA, 0x70, 0x0D, 0x0D, 0x06, 0xB3, 0xB0, 0xB0, 0x3F, 0xDE, 0x75, 0x75,
0x5E, 0xFD, 0xD2, 0xD2, 0xBA, 0x20, 0x7D, 0x7D, 0xAE, 0x31, 0x66, 0x66, 0x5B, 0xA3, 0x3A, 0x3A,
0x8A, 0x1C, 0x59, 0x59, 0x00, 0x00, 0x00, 0x00, 0xBC, 0x93, 0xCD, 0xCD, 0x9D, 0xE0, 0x1A, 0x1A,
0x6D, 0x2C, 0xAE, 0xAE, 0xC1, 0xAB, 0x7F, 0x7F, 0xB1, 0xC7, 0x2B, 0x2B, 0x0E, 0xB9, 0xBE, 0xBE,
0x80, 0xA0, 0xE0, 0xE0, 0x5D, 0x10, 0x8A, 0x8A, 0xD2, 0x52, 0x3B, 0x3B, 0xD5, 0xBA, 0x64, 0x64,
0xA0, 0x88, 0xD8, 0xD8, 0x84, 0xA5, 0xE7, 0xE7, 0x07, 0xE8, 0x5F, 0x5F, 0x14, 0x11, 0x1B, 0x1B,
0xB5, 0xC2, 0x2C, 0x2C, 0x90, 0xB4, 0xFC, 0xFC, 0x2C, 0x27, 0x31, 0x31, 0xA3, 0x65, 0x80, 0x80,
0xB2, 0x2A, 0x73, 0x73, 0x73, 0x81, 0x0C, 0x0C, 0x4C, 0x5F, 0x79, 0x79, 0x54, 0x41, 0x6B, 0x6B,
0x92, 0x02, 0x4B, 0x4B, 0x74, 0x69, 0x53, 0x53, 0x36, 0x8F, 0x94, 0x94, 0x51, 0x1F, 0x83, 0x83,
0x38, 0x36, 0x2A, 0x2A, 0xB0, 0x9C, 0xC4, 0xC4, 0xBD, 0xC8, 0x22, 0x22, 0x5A, 0xF8, 0xD5, 0xD5,
0xFC, 0xC3, 0xBD, 0xBD, 0x60, 0x78, 0x48, 0x48, 0x62, 0xCE, 0xFF, 0xFF, 0x96, 0x07, 0x4C, 0x4C,
0x6C, 0x77, 0x41, 0x41, 0x42, 0xE6, 0xC7, 0xC7, 0xF7, 0x24, 0xEB, 0xEB, 0x10, 0x14, 0x1C, 0x1C,
0x7C, 0x63, 0x5D, 0x5D, 0x28, 0x22, 0x36, 0x36, 0x27, 0xC0, 0x67, 0x67, 0x8C, 0xAF, 0xE9, 0xE9,
0x13, 0xF9, 0x44, 0x44, 0x95, 0xEA, 0x14, 0x14, 0x9C, 0xBB, 0xF5, 0xF5, 0xC7, 0x18, 0xCF, 0xCF,
0x24, 0x2D, 0x3F, 0x3F, 0x46, 0xE3, 0xC0, 0xC0, 0x3B, 0xDB, 0x72, 0x72, 0x70, 0x6C, 0x54, 0x54,
0xCA, 0x4C, 0x29, 0x29, 0xE3, 0x35, 0xF0, 0xF0, 0x85, 0xFE, 0x08, 0x08, 0xCB, 0x17, 0xC6, 0xC6,
0x11, 0x4F, 0xF3, 0xF3, 0xD0, 0xE4, 0x8C, 0x8C, 0x93, 0x59, 0xA4, 0xA4, 0xB8, 0x96, 0xCA, 0xCA,
0xA6, 0x3B, 0x68, 0x68, 0x83, 0x4D, 0xB8, 0xB8, 0x20, 0x28, 0x38, 0x38, 0xFF, 0x2E, 0xE5, 0xE5,
0x9F, 0x56, 0xAD, 0xAD, 0x77, 0x84, 0x0B, 0x0B, 0xC3, 0x1D, 0xC8, 0xC8, 0xCC, 0xFF, 0x99, 0x99,
0x03, 0xED, 0x58, 0x58, 0x6F, 0x9A, 0x19, 0x19, 0x08, 0x0A, 0x0E, 0x0E, 0xBF, 0x7E, 0x95, 0x95,
0x40, 0x50, 0x70, 0x70, 0xE7, 0x30, 0xF7, 0xF7, 0x2B, 0xCF, 0x6E, 0x6E, 0xE2, 0x6E, 0x1F, 0x1F,
0x79, 0x3D, 0xB5, 0xB5, 0x0C, 0x0F, 0x09, 0x09, 0xAA, 0x34, 0x61, 0x61, 0x82, 0x16, 0x57, 0x57,
0x41, 0x0B, 0x9F, 0x9F, 0x3A, 0x80, 0x9D, 0x9D, 0xEA, 0x64, 0x11, 0x11, 0xB9, 0xCD, 0x25, 0x25,
0xE4, 0xDD, 0xAF, 0xAF, 0x9A, 0x08, 0x45, 0x45, 0xA4, 0x8D, 0xDF, 0xDF, 0x97, 0x5C, 0xA3, 0xA3,
0x7E, 0xD5, 0xEA, 0xEA, 0xDA, 0x58, 0x35, 0x35, 0x7A, 0xD0, 0xED, 0xED, 0x17, 0xFC, 0x43, 0x43,
0x66, 0xCB, 0xF8, 0xF8, 0x94, 0xB1, 0xFB, 0xFB, 0xA1, 0xD3, 0x37, 0x37, 0x1D, 0x40, 0xFA, 0xFA,
0x3D, 0x68, 0xC2, 0xC2, 0xF0, 0xCC, 0xB4, 0xB4, 0xDE, 0x5D, 0x32, 0x32, 0xB3, 0x71, 0x9C, 0x9C,
0x0B, 0xE7, 0x56, 0x56, 0x72, 0xDA, 0xE3, 0xE3, 0xA7, 0x60, 0x87, 0x87, 0x1C, 0x1B, 0x15, 0x15,
0xEF, 0x3A, 0xF9, 0xF9, 0xD1, 0xBF, 0x63, 0x63, 0x53, 0xA9, 0x34, 0x34, 0x3E, 0x85, 0x9A, 0x9A,
0x8F, 0x42, 0xB1, 0xB1, 0x33, 0xD1, 0x7C, 0x7C, 0x26, 0x9B, 0x88, 0x88, 0x5F, 0xA6, 0x3D, 0x3D,
0xEC, 0xD7, 0xA1, 0xA1, 0x76, 0xDF, 0xE4, 0xE4, 0x2A, 0x94, 0x81, 0x81, 0x49, 0x01, 0x91, 0x91,
0x81, 0xFB, 0x0F, 0x0F, 0x88, 0xAA, 0xEE, 0xEE, 0xEE, 0x61, 0x16, 0x16, 0x21, 0x73, 0xD7, 0xD7,
0xC4, 0xF5, 0x97, 0x97, 0x1A, 0xA8, 0xA5, 0xA5, 0xEB, 0x3F, 0xFE, 0xFE, 0xD9, 0xB5, 0x6D, 0x6D,
0xC5, 0xAE, 0x78, 0x78, 0x39, 0x6D, 0xC5, 0xC5, 0x99, 0xE5, 0x1D, 0x1D, 0xCD, 0xA4, 0x76, 0x76,
0xAD, 0xDC, 0x3E, 0x3E, 0x31, 0x67, 0xCB, 0xCB, 0x8B, 0x47, 0xB6, 0xB6, 0x01, 0x5B, 0xEF, 0xEF,
0x18, 0x1E, 0x12, 0x12, 0x23, 0xC5, 0x60, 0x60, 0xDD, 0xB0, 0x6A, 0x6A, 0x1F, 0xF6, 0x4D, 0x4D,
0x4E, 0xE9, 0xCE, 0xCE, 0x2D, 0x7C, 0xDE, 0xDE, 0xF9, 0x9D, 0x55, 0x55, 0x48, 0x5A, 0x7E, 0x7E,
0x4F, 0xB2, 0x21, 0x21, 0xF2, 0x7A, 0x03, 0x03, 0x65, 0x26, 0xA0, 0xA0, 0x8E, 0x19, 0x5E, 0x5E,
0x78, 0x66, 0x5A, 0x5A, 0x5C, 0x4B, 0x65, 0x65, 0x58, 0x4E, 0x62, 0x62, 0x19, 0x45, 0xFD, 0xFD,
0x8D, 0xF4, 0x06, 0x06, 0xE5, 0x86, 0x40, 0x40, 0x98, 0xBE, 0xF2, 0xF2, 0x57, 0xAC, 0x33, 0x33,
0x67, 0x90, 0x17, 0x17, 0x7F, 0x8E, 0x05, 0x05, 0x05, 0x5E, 0xE8, 0xE8, 0x64, 0x7D, 0x4F, 0x4F,
0xAF, 0x6A, 0x89, 0x89, 0x63, 0x95, 0x10, 0x10, 0xB6, 0x2F, 0x74, 0x74, 0xFE, 0x75, 0x0A, 0x0A,
0xF5, 0x92, 0x5C, 0x5C, 0xB7, 0x74, 0x9B, 0x9B, 0x3C, 0x33, 0x2D, 0x2D, 0xA5, 0xD6, 0x30, 0x30,
0xCE, 0x49, 0x2E, 0x2E, 0xE9, 0x89, 0x49, 0x49, 0x68, 0x72, 0x46, 0x46, 0x44, 0x55, 0x77, 0x77,
0xE0, 0xD8, 0xA8, 0xA8, 0x4D, 0x04, 0x96, 0x96, 0x43, 0xBD, 0x28, 0x28, 0x69, 0x29, 0xA9, 0xA9,
0x29, 0x79, 0xD9, 0xD9, 0x2E, 0x91, 0x86, 0x86, 0xAC, 0x87, 0xD1, 0xD1, 0x15, 0x4A, 0xF4, 0xF4,
0x59, 0x15, 0x8D, 0x8D, 0xA8, 0x82, 0xD6, 0xD6, 0x0A, 0xBC, 0xB9, 0xB9, 0x9E, 0x0D, 0x42, 0x42,
0x6E, 0xC1, 0xF6, 0xF6, 0x47, 0xB8, 0x2F, 0x2F, 0xDF, 0x06, 0xDD, 0xDD, 0x34, 0x39, 0x23, 0x23,
0x35, 0x62, 0xCC, 0xCC, 0x6A, 0xC4, 0xF1, 0xF1, 0xCF, 0x12, 0xC1, 0xC1, 0xDC, 0xEB, 0x85, 0x85,
0x22, 0x9E, 0x8F, 0x8F, 0xC9, 0xA1, 0x71, 0x71, 0xC0, 0xF0, 0x90, 0x90, 0x9B, 0x53, 0xAA, 0xAA,
0x89, 0xF1, 0x01, 0x01, 0xD4, 0xE1, 0x8B, 0x8B, 0xED, 0x8C, 0x4E, 0x4E, 0xAB, 0x6F, 0x8E, 0x8E,
0x12, 0xA2, 0xAB, 0xAB, 0xA2, 0x3E, 0x6F, 0x6F, 0x0D, 0x54, 0xE6, 0xE6, 0x52, 0xF2, 0xDB, 0xDB,
0xBB, 0x7B, 0x92, 0x92, 0x02, 0xB6, 0xB7, 0xB7, 0x2F, 0xCA, 0x69, 0x69, 0xA9, 0xD9, 0x39, 0x39,
0xD7, 0x0C, 0xD3, 0xD3, 0x61, 0x23, 0xA7, 0xA7, 0x1E, 0xAD, 0xA2, 0xA2, 0xB4, 0x99, 0xC3, 0xC3,
0x50, 0x44, 0x6C, 0x6C, 0x04, 0x05, 0x07, 0x07, 0xF6, 0x7F, 0x04, 0x04, 0xC2, 0x46, 0x27, 0x27,
0x16, 0xA7, 0xAC, 0xAC, 0x25, 0x76, 0xD0, 0xD0, 0x86, 0x13, 0x50, 0x50, 0x56, 0xF7, 0xDC, 0xDC,
0x55, 0x1A, 0x84, 0x84, 0x09, 0x51, 0xE1, 0xE1, 0xBE, 0x25, 0x7A, 0x7A, 0x91, 0xEF, 0x13, 0x13,
]);
this.MDS_2 = new Uint8Array([
0x39, 0x39, 0xD9, 0xA9, 0x17, 0x17, 0x90, 0x67, 0x9C, 0x9C, 0x71, 0xB3, 0xA6, 0xA6, 0xD2, 0xE8,
0x07, 0x07, 0x05, 0x04, 0x52, 0x52, 0x98, 0xFD, 0x80, 0x80, 0x65, 0xA3, 0xE4, 0xE4, 0xDF, 0x76,
0x45, 0x45, 0x08, 0x9A, 0x4B, 0x4B, 0x02, 0x92, 0xE0, 0xE0, 0xA0, 0x80, 0x5A, 0x5A, 0x66, 0x78,
0xAF, 0xAF, 0xDD, 0xE4, 0x6A, 0x6A, 0xB0, 0xDD, 0x63, 0x63, 0xBF, 0xD1, 0x2A, 0x2A, 0x36, 0x38,
0xE6, 0xE6, 0x54, 0x0D, 0x20, 0x20, 0x43, 0xC6, 0xCC, 0xCC, 0x62, 0x35, 0xF2, 0xF2, 0xBE, 0x98,
0x12, 0x12, 0x1E, 0x18, 0xEB, 0xEB, 0x24, 0xF7, 0xA1, 0xA1, 0xD7, 0xEC, 0x41, 0x41, 0x77, 0x6C,
0x28, 0x28, 0xBD, 0x43, 0xBC, 0xBC, 0x32, 0x75, 0x7B, 0x7B, 0xD4, 0x37, 0x88, 0x88, 0x9B, 0x26,
0x0D, 0x0D, 0x70, 0xFA, 0x44, 0x44, 0xF9, 0x13, 0xFB, 0xFB, 0xB1, 0x94, 0x7E, 0x7E, 0x5A, 0x48,
0x03, 0x03, 0x7A, 0xF2, 0x8C, 0x8C, 0xE4, 0xD0, 0xB6, 0xB6, 0x47, 0x8B, 0x24, 0x24, 0x3C, 0x30,
0xE7, 0xE7, 0xA5, 0x84, 0x6B, 0x6B, 0x41, 0x54, 0xDD, 0xDD, 0x06, 0xDF, 0x60, 0x60, 0xC5, 0x23,
0xFD, 0xFD, 0x45, 0x19, 0x3A, 0x3A, 0xA3, 0x5B, 0xC2, 0xC2, 0x68, 0x3D, 0x8D, 0x8D, 0x15, 0x59,
0xEC, 0xEC, 0x21, 0xF3, 0x66, 0x66, 0x31, 0xAE, 0x6F, 0x6F, 0x3E, 0xA2, 0x57, 0x57, 0x16, 0x82,
0x10, 0x10, 0x95, 0x63, 0xEF, 0xEF, 0x5B, 0x01, 0xB8, 0xB8, 0x4D, 0x83, 0x86, 0x86, 0x91, 0x2E,
0x6D, 0x6D, 0xB5, 0xD9, 0x83, 0x83, 0x1F, 0x51, 0xAA, 0xAA, 0x53, 0x9B, 0x5D, 0x5D, 0x63, 0x7C,
0x68, 0x68, 0x3B, 0xA6, 0xFE, 0xFE, 0x3F, 0xEB, 0x30, 0x30, 0xD6, 0xA5, 0x7A, 0x7A, 0x25, 0xBE,
0xAC, 0xAC, 0xA7, 0x16, 0x09, 0x09, 0x0F, 0x0C, 0xF0, 0xF0, 0x35, 0xE3, 0xA7, 0xA7, 0x23, 0x61,
0x90, 0x90, 0xF0, 0xC0, 0xE9, 0xE9, 0xAF, 0x8C, 0x9D, 0x9D, 0x80, 0x3A, 0x5C, 0x5C, 0x92, 0xF5,
0x0C, 0x0C, 0x81, 0x73, 0x31, 0x31, 0x27, 0x2C, 0xD0, 0xD0, 0x76, 0x25, 0x56, 0x56, 0xE7, 0x0B,
0x92, 0x92, 0x7B, 0xBB, 0xCE, 0xCE, 0xE9, 0x4E, 0x01, 0x01, 0xF1, 0x89, 0x1E, 0x1E, 0x9F, 0x6B,
0x34, 0x34, 0xA9, 0x53, 0xF1, 0xF1, 0xC4, 0x6A, 0xC3, 0xC3, 0x99, 0xB4, 0x5B, 0x5B, 0x97, 0xF1,
0x47, 0x47, 0x83, 0xE1, 0x18, 0x18, 0x6B, 0xE6, 0x22, 0x22, 0xC8, 0xBD, 0x98, 0x98, 0x0E, 0x45,
0x1F, 0x1F, 0x6E, 0xE2, 0xB3, 0xB3, 0xC9, 0xF4, 0x74, 0x74, 0x2F, 0xB6, 0xF8, 0xF8, 0xCB, 0x66,
0x99, 0x99, 0xFF, 0xCC, 0x14, 0x14, 0xEA, 0x95, 0x58, 0x58, 0xED, 0x03, 0xDC, 0xDC, 0xF7, 0x56,
0x8B, 0x8B, 0xE1, 0xD4, 0x15, 0x15, 0x1B, 0x1C, 0xA2, 0xA2, 0xAD, 0x1E, 0xD3, 0xD3, 0x0C, 0xD7,
0xE2, 0xE2, 0x2B, 0xFB, 0xC8, 0xC8, 0x1D, 0xC3, 0x5E, 0x5E, 0x19, 0x8E, 0x2C, 0x2C, 0xC2, 0xB5,
0x49, 0x49, 0x89, 0xE9, 0xC1, 0xC1, 0x12, 0xCF, 0x95, 0x95, 0x7E, 0xBF, 0x7D, 0x7D, 0x20, 0xBA,
0x11, 0x11, 0x64, 0xEA, 0x0B, 0x0B, 0x84, 0x77, 0xC5, 0xC5, 0x6D, 0x39, 0x89, 0x89, 0x6A, 0xAF,
0x7C, 0x7C, 0xD1, 0x33, 0x71, 0x71, 0xA1, 0xC9, 0xFF, 0xFF, 0xCE, 0x62, 0xBB, 0xBB, 0x37, 0x71,
0x0F, 0x0F, 0xFB, 0x81, 0xB5, 0xB5, 0x3D, 0x79, 0xE1, 0xE1, 0x51, 0x09, 0x3E, 0x3E, 0xDC, 0xAD,
0x3F, 0x3F, 0x2D, 0x24, 0x76, 0x76, 0xA4, 0xCD, 0x55, 0x55, 0x9D, 0xF9, 0x82, 0x82, 0xEE, 0xD8,
0x40, 0x40, 0x86, 0xE5, 0x78, 0x78, 0xAE, 0xC5, 0x25, 0x25, 0xCD, 0xB9, 0x96, 0x96, 0x04, 0x4D,
0x77, 0x77, 0x55, 0x44, 0x0E, 0x0E, 0x0A, 0x08, 0x50, 0x50, 0x13, 0x86, 0xF7, 0xF7, 0x30, 0xE7,
0x37, 0x37, 0xD3, 0xA1, 0xFA, 0xFA, 0x40, 0x1D, 0x61, 0x61, 0x34, 0xAA, 0x4E, 0x4E, 0x8C, 0xED,
0xB0, 0xB0, 0xB3, 0x06, 0x54, 0x54, 0x6C, 0x70, 0x73, 0x73, 0x2A, 0xB2, 0x3B, 0x3B, 0x52, 0xD2,
0x9F, 0x9F, 0x0B, 0x41, 0x02, 0x02, 0x8B, 0x7B, 0xD8, 0xD8, 0x88, 0xA0, 0xF3, 0xF3, 0x4F, 0x11,
0xCB, 0xCB, 0x67, 0x31, 0x27, 0x27, 0x46, 0xC2, 0x67, 0x67, 0xC0, 0x27, 0xFC, 0xFC, 0xB4, 0x90,
0x38, 0x38, 0x28, 0x20, 0x04, 0x04, 0x7F, 0xF6, 0x48, 0x48, 0x78, 0x60, 0xE5, 0xE5, 0x2E, 0xFF,
0x4C, 0x4C, 0x07, 0x96, 0x65, 0x65, 0x4B, 0x5C, 0x2B, 0x2B, 0xC7, 0xB1, 0x8E, 0x8E, 0x6F, 0xAB,
0x42, 0x42, 0x0D, 0x9E, 0xF5, 0xF5, 0xBB, 0x9C, 0xDB, 0xDB, 0xF2, 0x52, 0x4A, 0x4A, 0xF3, 0x1B,
0x3D, 0x3D, 0xA6, 0x5F, 0xA4, 0xA4, 0x59, 0x93, 0xB9, 0xB9, 0xBC, 0x0A, 0xF9, 0xF9, 0x3A, 0xEF,
0x13, 0x13, 0xEF, 0x91, 0x08, 0x08, 0xFE, 0x85, 0x91, 0x91, 0x01, 0x49, 0x16, 0x16, 0x61, 0xEE,
0xDE, 0xDE, 0x7C, 0x2D, 0x21, 0x21, 0xB2, 0x4F, 0xB1, 0xB1, 0x42, 0x8F, 0x72, 0x72, 0xDB, 0x3B,
0x2F, 0x2F, 0xB8, 0x47, 0xBF, 0xBF, 0x48, 0x87, 0xAE, 0xAE, 0x2C, 0x6D, 0xC0, 0xC0, 0xE3, 0x46,
0x3C, 0x3C, 0x57, 0xD6, 0x9A, 0x9A, 0x85, 0x3E, 0xA9, 0xA9, 0x29, 0x69, 0x4F, 0x4F, 0x7D, 0x64,
0x81, 0x81, 0x94, 0x2A, 0x2E, 0x2E, 0x49, 0xCE, 0xC6, 0xC6, 0x17, 0xCB, 0x69, 0x69, 0xCA, 0x2F,
0xBD, 0xBD, 0xC3, 0xFC, 0xA3, 0xA3, 0x5C, 0x97, 0xE8, 0xE8, 0x5E, 0x05, 0xED, 0xED, 0xD0, 0x7A,
0xD1, 0xD1, 0x87, 0xAC, 0x05, 0x05, 0x8E, 0x7F, 0x64, 0x64, 0xBA, 0xD5, 0xA5, 0xA5, 0xA8, 0x1A,
0x26, 0x26, 0xB7, 0x4B, 0xBE, 0xBE, 0xB9, 0x0E, 0x87, 0x87, 0x60, 0xA7, 0xD5, 0xD5, 0xF8, 0x5A,
0x36, 0x36, 0x22, 0x28, 0x1B, 0x1B, 0x11, 0x14, 0x75, 0x75, 0xDE, 0x3F, 0xD9, 0xD9, 0x79, 0x29,
0xEE, 0xEE, 0xAA, 0x88, 0x2D, 0x2D, 0x33, 0x3C, 0x79, 0x79, 0x5F, 0x4C, 0xB7, 0xB7, 0xB6, 0x02,
0xCA, 0xCA, 0x96, 0xB8, 0x35, 0x35, 0x58, 0xDA, 0xC4, 0xC4, 0x9C, 0xB0, 0x43, 0x43, 0xFC, 0x17,
0x84, 0x84, 0x1A, 0x55, 0x4D, 0x4D, 0xF6, 0x1F, 0x59, 0x59, 0x1C, 0x8A, 0xB2, 0xB2, 0x38, 0x7D,
0x33, 0x33, 0xAC, 0x57, 0xCF, 0xCF, 0x18, 0xC7, 0x06, 0x06, 0xF4, 0x8D, 0x53, 0x53, 0x69, 0x74,
0x9B, 0x9B, 0x74, 0xB7, 0x97, 0x97, 0xF5, 0xC4, 0xAD, 0xAD, 0x56, 0x9F, 0xE3, 0xE3, 0xDA, 0x72,
0xEA, 0xEA, 0xD5, 0x7E, 0xF4, 0xF4, 0x4A, 0x15, 0x8F, 0x8F, 0x9E, 0x22, 0xAB, 0xAB, 0xA2, 0x12,
0x62, 0x62, 0x4E, 0x58, 0x5F, 0x5F, 0xE8, 0x07, 0x1D, 0x1D, 0xE5, 0x99, 0x23, 0x23, 0x39, 0x34,
0xF6, 0xF6, 0xC1, 0x6E, 0x6C, 0x6C, 0x44, 0x50, 0x32, 0x32, 0x5D, 0xDE, 0x46, 0x46, 0x72, 0x68,
0xA0, 0xA0, 0x26, 0x65, 0xCD, 0xCD, 0x93, 0xBC, 0xDA, 0xDA, 0x03, 0xDB, 0xBA, 0xBA, 0xC6, 0xF8,
0x9E, 0x9E, 0xFA, 0xC8, 0xD6, 0xD6, 0x82, 0xA8, 0x6E, 0x6E, 0xCF, 0x2B, 0x70, 0x70, 0x50, 0x40,
0x85, 0x85, 0xEB, 0xDC, 0x0A, 0x0A, 0x75, 0xFE, 0x93, 0x93, 0x8A, 0x32, 0xDF, 0xDF, 0x8D, 0xA4,
0x29, 0x29, 0x4C, 0xCA, 0x1C, 0x1C, 0x14, 0x10, 0xD7, 0xD7, 0x73, 0x21, 0xB4, 0xB4, 0xCC, 0xF0,
0xD4, 0xD4, 0x09, 0xD3, 0x8A, 0x8A, 0x10, 0x5D, 0x51, 0x51, 0xE2, 0x0F, 0x00, 0x00, 0x00, 0x00,
0x19, 0x19, 0x9A, 0x6F, 0x1A, 0x1A, 0xE0, 0x9D, 0x94, 0x94, 0x8F, 0x36, 0xC7, 0xC7, 0xE6, 0x42,
0xC9, 0xC9, 0xEC, 0x4A, 0xD2, 0xD2, 0xFD, 0x5E, 0x7F, 0x7F, 0xAB, 0xC1, 0xA8, 0xA8, 0xD8, 0xE0,
]);
this.MDS_3 = new Uint8Array([
0xA7, 0xBC, 0x00, 0xBC, 0x14, 0xED, 0x00, 0xEC, 0x09, 0x21, 0x00, 0x20, 0xBD, 0xB4, 0x00, 0xB3,
0xDE, 0xDA, 0x00, 0xDA, 0x06, 0x03, 0x00, 0x02, 0x26, 0xE3, 0x00, 0xE2, 0xC2, 0x9F, 0x00, 0x9E,
0x36, 0xCA, 0x00, 0xC9, 0xDC, 0xD4, 0x00, 0xD4, 0x51, 0x19, 0x00, 0x18, 0x0A, 0x1F, 0x00, 0x1E,
0x53, 0x98, 0x00, 0x98, 0xB5, 0xB2, 0x00, 0xB2, 0xBA, 0xA7, 0x00, 0xA6, 0x02, 0x27, 0x00, 0x26,
0x2D, 0x3D, 0x00, 0x3C, 0xBC, 0x93, 0x00, 0x93, 0xC6, 0x83, 0x00, 0x82, 0x95, 0x53, 0x00, 0x52,
0x0B, 0x7C, 0x00, 0x7B, 0xA8, 0xBB, 0x00, 0xBB, 0x88, 0x5C, 0x00, 0x5B, 0x64, 0x48, 0x00, 0x47,
0x6C, 0x24, 0x00, 0x24, 0xF1, 0x51, 0x00, 0x51, 0xBE, 0xBB, 0x00, 0xBA, 0x0E, 0x4B, 0x00, 0x4A,
0xCF, 0xBF, 0x00, 0xBF, 0x6A, 0x0E, 0x00, 0x0D, 0xB9, 0xB0, 0x00, 0xB0, 0x1D, 0x76, 0x00, 0x75,
0x5B, 0xD3, 0x00, 0xD2, 0xDA, 0x7D, 0x00, 0x7D, 0xDF, 0x66, 0x00, 0x66, 0xFE, 0x3A, 0x00, 0x3A,
0xA6, 0x59, 0x00, 0x59, 0x00, 0x00, 0x00, 0x00, 0x4F, 0xCE, 0x00, 0xCD, 0x7D, 0x1B, 0x00, 0x1A,
0x99, 0xAE, 0x00, 0xAE, 0x6C, 0x80, 0x00, 0x7F, 0x78, 0x2C, 0x00, 0x2B, 0xC7, 0xBE, 0x00, 0xBE,
0x20, 0xE1, 0x00, 0xE0, 0x6D, 0x8A, 0x00, 0x8A, 0x24, 0x3C, 0x00, 0x3B, 0x8F, 0x65, 0x00, 0x64,
0x28, 0xD9, 0x00, 0xD8, 0x29, 0xE8, 0x00, 0xE7, 0xEF, 0x5F, 0x00, 0x5F, 0x25, 0x1B, 0x00, 0x1B,
0x77, 0x2D, 0x00, 0x2C, 0x44, 0xFD, 0x00, 0xFC, 0x53, 0x31, 0x00, 0x31, 0x08, 0x81, 0x00, 0x80,
0xDC, 0x73, 0x00, 0x73, 0xF4, 0x0C, 0x00, 0x0C, 0xAB, 0x79, 0x00, 0x79, 0x95, 0x6B, 0x00, 0x6B,
0x94, 0x4B, 0x00, 0x4B, 0xDD, 0x53, 0x00, 0x53, 0xC5, 0x94, 0x00, 0x94, 0x70, 0x83, 0x00, 0x83,
0x6E, 0x2A, 0x00, 0x2A, 0x4C, 0xC5, 0x00, 0xC4, 0x85, 0x23, 0x00, 0x22, 0x52, 0xD6, 0x00, 0xD5,
0xBF, 0xBE, 0x00, 0xBD, 0xD8, 0x48, 0x00, 0x48, 0x30, 0x00, 0x01, 0xFF, 0x9D, 0x4C, 0x00, 0x4C,
0xE3, 0x41, 0x00, 0x41, 0x28, 0xC8, 0x00, 0xC7, 0x1B, 0xEC, 0x00, 0xEB, 0x24, 0x1C, 0x00, 0x1C,
0xDF, 0x5D, 0x00, 0x5D, 0x4A, 0x36, 0x00, 0x36, 0xE7, 0x67, 0x00, 0x67, 0x3B, 0xEA, 0x00, 0xE9,
0x0C, 0x45, 0x00, 0x44, 0x7F, 0x15, 0x00, 0x14, 0x57, 0xF6, 0x00, 0xF5, 0xDF, 0xCF, 0x00, 0xCF,
0x51, 0x3F, 0x00, 0x3F, 0x29, 0xC1, 0x00, 0xC0, 0x16, 0x73, 0x00, 0x72, 0xDC, 0x54, 0x00, 0x54,
0x16, 0x2A, 0x00, 0x29, 0x18, 0xF1, 0x00, 0xF0, 0x83, 0x09, 0x00, 0x08, 0xE2, 0xC6, 0x00, 0xC6,
0x60, 0xF3, 0x00, 0xF3, 0xB4, 0x8D, 0x00, 0x8C, 0xEC, 0xA4, 0x00, 0xA4, 0x4E, 0xCB, 0x00, 0xCA,
0xE1, 0x68, 0x00, 0x68, 0xD0, 0xB8, 0x00, 0xB8, 0x48, 0x38, 0x00, 0x38, 0x2D, 0xE6, 0x00, 0xE5,
0xF5, 0xAD, 0x00, 0xAD, 0xFB, 0x0B, 0x00, 0x0B, 0xE0, 0xC8, 0x00, 0xC8, 0xCB, 0x9A, 0x00, 0x99,
0xF0, 0x58, 0x00, 0x58, 0x09, 0x1A, 0x00, 0x19, 0x12, 0x0E, 0x00, 0x0E, 0x3D, 0x96, 0x00, 0x95,
0x90, 0x70, 0x00, 0x70, 0x17, 0xF8, 0x00, 0xF7, 0xFA, 0x6E, 0x00, 0x6E, 0x50, 0x20, 0x00, 0x1F,
0xB6, 0xB5, 0x00, 0xB5, 0x1B, 0x09, 0x00, 0x09, 0xDE, 0x61, 0x00, 0x61, 0x98, 0x57, 0x00, 0x57,
0x4C, 0x9F, 0x00, 0x9F, 0xBA, 0x9D, 0x00, 0x9D, 0x4E, 0x12, 0x00, 0x11, 0x86, 0x26, 0x00, 0x25,
0xC1, 0xB0, 0x00, 0xAF, 0xA2, 0x45, 0x00, 0x45, 0x31, 0xE0, 0x00, 0xDF, 0xF3, 0xA3, 0x00, 0xA3,
0x53, 0xEB, 0x00, 0xEA, 0x32, 0x36, 0x00, 0x35, 0x4A, 0xEE, 0x00, 0xED, 0x13, 0x44, 0x00, 0x43,
0x31, 0xF9, 0x00, 0xF8, 0x45, 0xFC, 0x00, 0xFB, 0x74, 0x38, 0x00, 0x37, 0x5D, 0xFA, 0x00, 0xFA,
0xA5, 0xC2, 0x00, 0xC2, 0xBC, 0xB5, 0x00, 0xB4, 0x3B, 0x33, 0x00, 0x32, 0x24, 0x9D, 0x00, 0x9C,
0xF2, 0x56, 0x00, 0x56, 0x4C, 0xE4, 0x00, 0xE3, 0x07, 0x88, 0x00, 0x87, 0x37, 0x15, 0x00, 0x15,
0x29, 0xFA, 0x00, 0xF9, 0x90, 0x64, 0x00, 0x63, 0xFC, 0x34, 0x00, 0x34, 0xC3, 0x9A, 0x00, 0x9A,
0xD1, 0xB1, 0x00, 0xB1, 0x04, 0x7D, 0x00, 0x7C, 0xC1, 0x88, 0x00, 0x88, 0x05, 0x3E, 0x00, 0x3D,
0xC3, 0xA2, 0x00, 0xA1, 0x55, 0xE5, 0x00, 0xE4, 0xBE, 0x81, 0x00, 0x81, 0x4A, 0x91, 0x00, 0x91,
0x7C, 0x10, 0x00, 0x0F, 0x32, 0xEF, 0x00, 0xEE, 0x4F, 0x17, 0x00, 0x16, 0x94, 0xD7, 0x00, 0xD7,
0xB9, 0x98, 0x00, 0x97, 0xC2, 0xA5, 0x00, 0xA5, 0x2A, 0xFF, 0x00, 0xFE, 0x8E, 0x6E, 0x00, 0x6D,
0x73, 0x79, 0x00, 0x78, 0xA6, 0xC5, 0x00, 0xC5, 0x7E, 0x1E, 0x00, 0x1D, 0x71, 0x77, 0x00, 0x76,
0x89, 0x3F, 0x00, 0x3E, 0x98, 0xCB, 0x00, 0xCB, 0xD2, 0xB6, 0x00, 0xB6, 0x5C, 0xEF, 0x00, 0xEF,
0x36, 0x12, 0x00, 0x12, 0xE8, 0x60, 0x00, 0x60, 0x8D, 0x6B, 0x00, 0x6A, 0x15, 0x4E, 0x00, 0x4D,
0x37, 0xCF, 0x00, 0xCE, 0xA9, 0xDE, 0x00, 0xDE, 0x96, 0x56, 0x00, 0x55, 0xA2, 0x7E, 0x00, 0x7E,
0x01, 0x22, 0x00, 0x21, 0x6C, 0x04, 0x00, 0x03, 0x8B, 0xA0, 0x00, 0xA0, 0xA7, 0x5E, 0x00, 0x5E,
0xDE, 0x5A, 0x00, 0x5A, 0xA7, 0x65, 0x00, 0x65, 0xA6, 0x62, 0x00, 0x62, 0x5E, 0xFD, 0x00, 0xFD,
0x81, 0x07, 0x00, 0x06, 0x6B, 0x41, 0x00, 0x40, 0x56, 0xF3, 0x00, 0xF2, 0x03, 0x34, 0x00, 0x33,
0xF7, 0x17, 0x00, 0x17, 0x0D, 0x06, 0x00, 0x05, 0x63, 0xE8, 0x00, 0xE8, 0xE1, 0x4F, 0x00, 0x4F,
0x19, 0x8A, 0x00, 0x89, 0xF8, 0x10, 0x00, 0x10, 0xE5, 0x74, 0x00, 0x74, 0x73, 0x0B, 0x00, 0x0A,
0x87, 0x5D, 0x00, 0x5C, 0x2B, 0x9C, 0x00, 0x9B, 0x6F, 0x2D, 0x00, 0x2D, 0x7B, 0x31, 0x00, 0x30,
0x17, 0x2F, 0x00, 0x2E, 0x72, 0x4A, 0x00, 0x49, 0xDA, 0x46, 0x00, 0x46, 0x99, 0x77, 0x00, 0x77,
0xB8, 0xA9, 0x00, 0xA8, 0x51, 0x96, 0x00, 0x96, 0x00, 0x29, 0x00, 0x28, 0x92, 0xA9, 0x00, 0xA9,
0xA2, 0xD9, 0x00, 0xD9, 0xBF, 0x86, 0x00, 0x86, 0x33, 0xD2, 0x00, 0xD1, 0x5F, 0xF4, 0x00, 0xF4,
0x6E, 0x8D, 0x00, 0x8D, 0x2A, 0xD7, 0x00, 0xD6, 0xC6, 0xB9, 0x00, 0xB9, 0xAB, 0x42, 0x00, 0x42,
0x2F, 0xF7, 0x00, 0xF6, 0xFF, 0x2F, 0x00, 0x2F, 0xE5, 0xDD, 0x00, 0xDD, 0x6D, 0x23, 0x00, 0x23,
0x97, 0xCC, 0x00, 0xCC, 0x2E, 0xF2, 0x00, 0xF1, 0xE1, 0xC1, 0x00, 0xC1, 0xC7, 0x86, 0x00, 0x85,
0xC0, 0x8F, 0x00, 0x8F, 0x6A, 0x72, 0x00, 0x71, 0xB0, 0x91, 0x00, 0x90, 0xEE, 0xAA, 0x00, 0xAA,
0x7A, 0x02, 0x00, 0x01, 0xB5, 0x8C, 0x00, 0x8B, 0x79, 0x4F, 0x00, 0x4E, 0x1A, 0x8F, 0x00, 0x8E,
0xB4, 0xAB, 0x00, 0xAB, 0xE0, 0x6F, 0x00, 0x6F, 0x61, 0xE6, 0x00, 0xE6, 0x44, 0xDC, 0x00, 0xDB,
0x36, 0x93, 0x00, 0x92, 0xB8, 0xB7, 0x00, 0xB7, 0xF9, 0x69, 0x00, 0x69, 0x82, 0x3A, 0x00, 0x39,
0xE3, 0xD3, 0x00, 0xD3, 0x84, 0xA7, 0x00, 0xA7, 0xCB, 0xA2, 0x00, 0xA2, 0x4D, 0xC4, 0x00, 0xC3,
0x94, 0x6C, 0x00, 0x6C, 0x09, 0x07, 0x00, 0x07, 0x75, 0x05, 0x00, 0x04, 0x08, 0x28, 0x00, 0x27,
0xBD, 0xAC, 0x00, 0xAC, 0x9B, 0xD0, 0x00, 0xD0, 0x99, 0x50, 0x00, 0x50, 0x4D, 0xDD, 0x00, 0xDC,
0x6F, 0x84, 0x00, 0x84, 0x5A, 0xE1, 0x00, 0xE1, 0xE3, 0x7A, 0x00, 0x7A, 0x80, 0x14, 0x00, 0x13,
]);
this.MDS_4 = new Uint8Array([
0xD9, 0xA9, 0x39, 0xD9, 0x90, 0x67, 0x17, 0x90, 0x71, 0xB3, 0x9C, 0x71, 0xD2, 0xE8, 0xA6, 0xD2,
0x05, 0x04, 0x07, 0x05, 0x98, 0xFD, 0x52, 0x98, 0x65, 0xA3, 0x80, 0x65, 0xDF, 0x76, 0xE4, 0xDF,
0x08, 0x9A, 0x45, 0x08, 0x02, 0x92, 0x4B, 0x02, 0xA0, 0x80, 0xE0, 0xA0, 0x66, 0x78, 0x5A, 0x66,
0xDD, 0xE4, 0xAF, 0xDD, 0xB0, 0xDD, 0x6A, 0xB0, 0xBF, 0xD1, 0x63, 0xBF, 0x36, 0x38, 0x2A, 0x36,
0x54, 0x0D, 0xE6, 0x54, 0x43, 0xC6, 0x20, 0x43, 0x62, 0x35, 0xCC, 0x62, 0xBE, 0x98, 0xF2, 0xBE,
0x1E, 0x18, 0x12, 0x1E, 0x24, 0xF7, 0xEB, 0x24, 0xD7, 0xEC, 0xA1, 0xD7, 0x77, 0x6C, 0x41, 0x77,
0xBD, 0x43, 0x28, 0xBD, 0x32, 0x75, 0xBC, 0x32, 0xD4, 0x37, 0x7B, 0xD4, 0x9B, 0x26, 0x88, 0x9B,
0x70, 0xFA, 0x0D, 0x70, 0xF9, 0x13, 0x44, 0xF9, 0xB1, 0x94, 0xFB, 0xB1, 0x5A, 0x48, 0x7E, 0x5A,
0x7A, 0xF2, 0x03, 0x7A, 0xE4, 0xD0, 0x8C, 0xE4, 0x47, 0x8B, 0xB6, 0x47, 0x3C, 0x30, 0x24, 0x3C,
0xA5, 0x84, 0xE7, 0xA5, 0x41, 0x54, 0x6B, 0x41, 0x06, 0xDF, 0xDD, 0x06, 0xC5, 0x23, 0x60, 0xC5,
0x45, 0x19, 0xFD, 0x45, 0xA3, 0x5B, 0x3A, 0xA3, 0x68, 0x3D, 0xC2, 0x68, 0x15, 0x59, 0x8D, 0x15,
0x21, 0xF3, 0xEC, 0x21, 0x31, 0xAE, 0x66, 0x31, 0x3E, 0xA2, 0x6F, 0x3E, 0x16, 0x82, 0x57, 0x16,
0x95, 0x63, 0x10, 0x95, 0x5B, 0x01, 0xEF, 0x5B, 0x4D, 0x83, 0xB8, 0x4D, 0x91, 0x2E, 0x86, 0x91,
0xB5, 0xD9, 0x6D, 0xB5, 0x1F, 0x51, 0x83, 0x1F, 0x53, 0x9B, 0xAA, 0x53, 0x63, 0x7C, 0x5D, 0x63,
0x3B, 0xA6, 0x68, 0x3B, 0x3F, 0xEB, 0xFE, 0x3F, 0xD6, 0xA5, 0x30, 0xD6, 0x25, 0xBE, 0x7A, 0x25,
0xA7, 0x16, 0xAC, 0xA7, 0x0F, 0x0C, 0x09, 0x0F, 0x35, 0xE3, 0xF0, 0x35, 0x23, 0x61, 0xA7, 0x23,
0xF0, 0xC0, 0x90, 0xF0, 0xAF, 0x8C, 0xE9, 0xAF, 0x80, 0x3A, 0x9D, 0x80, 0x92, 0xF5, 0x5C, 0x92,
0x81, 0x73, 0x0C, 0x81, 0x27, 0x2C, 0x31, 0x27, 0x76, 0x25, 0xD0, 0x76, 0xE7, 0x0B, 0x56, 0xE7,
0x7B, 0xBB, 0x92, 0x7B, 0xE9, 0x4E, 0xCE, 0xE9, 0xF1, 0x89, 0x01, 0xF1, 0x9F, 0x6B, 0x1E, 0x9F,
0xA9, 0x53, 0x34, 0xA9, 0xC4, 0x6A, 0xF1, 0xC4, 0x99, 0xB4, 0xC3, 0x99, 0x97, 0xF1, 0x5B, 0x97,
0x83, 0xE1, 0x47, 0x83, 0x6B, 0xE6, 0x18, 0x6B, 0xC8, 0xBD, 0x22, 0xC8, 0x0E, 0x45, 0x98, 0x0E,
0x6E, 0xE2, 0x1F, 0x6E, 0xC9, 0xF4, 0xB3, 0xC9, 0x2F, 0xB6, 0x74, 0x2F, 0xCB, 0x66, 0xF8, 0xCB,
0xFF, 0xCC, 0x99, 0xFF, 0xEA, 0x95, 0x14, 0xEA, 0xED, 0x03, 0x58, 0xED, 0xF7, 0x56, 0xDC, 0xF7,
0xE1, 0xD4, 0x8B, 0xE1, 0x1B, 0x1C, 0x15, 0x1B, 0xAD, 0x1E, 0xA2, 0xAD, 0x0C, 0xD7, 0xD3, 0x0C,
0x2B, 0xFB, 0xE2, 0x2B, 0x1D, 0xC3, 0xC8, 0x1D, 0x19, 0x8E, 0x5E, 0x19, 0xC2, 0xB5, 0x2C, 0xC2,
0x89, 0xE9, 0x49, 0x89, 0x12, 0xCF, 0xC1, 0x12, 0x7E, 0xBF, 0x95, 0x7E, 0x20, 0xBA, 0x7D, 0x20,
0x64, 0xEA, 0x11, 0x64, 0x84, 0x77, 0x0B, 0x84, 0x6D, 0x39, 0xC5, 0x6D, 0x6A, 0xAF, 0x89, 0x6A,
0xD1, 0x33, 0x7C, 0xD1, 0xA1, 0xC9, 0x71, 0xA1, 0xCE, 0x62, 0xFF, 0xCE, 0x37, 0x71, 0xBB, 0x37,
0xFB, 0x81, 0x0F, 0xFB, 0x3D, 0x79, 0xB5, 0x3D, 0x51, 0x09, 0xE1, 0x51, 0xDC, 0xAD, 0x3E, 0xDC,
0x2D, 0x24, 0x3F, 0x2D, 0xA4, 0xCD, 0x76, 0xA4, 0x9D, 0xF9, 0x55, 0x9D, 0xEE, 0xD8, 0x82, 0xEE,
0x86, 0xE5, 0x40, 0x86, 0xAE, 0xC5, 0x78, 0xAE, 0xCD, 0xB9, 0x25, 0xCD, 0x04, 0x4D, 0x96, 0x04,
0x55, 0x44, 0x77, 0x55, 0x0A, 0x08, 0x0E, 0x0A, 0x13, 0x86, 0x50, 0x13, 0x30, 0xE7, 0xF7, 0x30,
0xD3, 0xA1, 0x37, 0xD3, 0x40, 0x1D, 0xFA, 0x40, 0x34, 0xAA, 0x61, 0x34, 0x8C, 0xED, 0x4E, 0x8C,
0xB3, 0x06, 0xB0, 0xB3, 0x6C, 0x70, 0x54, 0x6C, 0x2A, 0xB2, 0x73, 0x2A, 0x52, 0xD2, 0x3B, 0x52,
0x0B, 0x41, 0x9F, 0x0B, 0x8B, 0x7B, 0x02, 0x8B, 0x88, 0xA0, 0xD8, 0x88, 0x4F, 0x11, 0xF3, 0x4F,
0x67, 0x31, 0xCB, 0x67, 0x46, 0xC2, 0x27, 0x46, 0xC0, 0x27, 0x67, 0xC0, 0xB4, 0x90, 0xFC, 0xB4,
0x28, 0x20, 0x38, 0x28, 0x7F, 0xF6, 0x04, 0x7F, 0x78, 0x60, 0x48, 0x78, 0x2E, 0xFF, 0xE5, 0x2E,
0x07, 0x96, 0x4C, 0x07, 0x4B, 0x5C, 0x65, 0x4B, 0xC7, 0xB1, 0x2B, 0xC7, 0x6F, 0xAB, 0x8E, 0x6F,
0x0D, 0x9E, 0x42, 0x0D, 0xBB, 0x9C, 0xF5, 0xBB, 0xF2, 0x52, 0xDB, 0xF2, 0xF3, 0x1B, 0x4A, 0xF3,
0xA6, 0x5F, 0x3D, 0xA6, 0x59, 0x93, 0xA4, 0x59, 0xBC, 0x0A, 0xB9, 0xBC, 0x3A, 0xEF, 0xF9, 0x3A,
0xEF, 0x91, 0x13, 0xEF, 0xFE, 0x85, 0x08, 0xFE, 0x01, 0x49, 0x91, 0x01, 0x61, 0xEE, 0x16, 0x61,
0x7C, 0x2D, 0xDE, 0x7C, 0xB2, 0x4F, 0x21, 0xB2, 0x42, 0x8F, 0xB1, 0x42, 0xDB, 0x3B, 0x72, 0xDB,
0xB8, 0x47, 0x2F, 0xB8, 0x48, 0x87, 0xBF, 0x48, 0x2C, 0x6D, 0xAE, 0x2C, 0xE3, 0x46, 0xC0, 0xE3,
0x57, 0xD6, 0x3C, 0x57, 0x85, 0x3E, 0x9A, 0x85, 0x29, 0x69, 0xA9, 0x29, 0x7D, 0x64, 0x4F, 0x7D,
0x94, 0x2A, 0x81, 0x94, 0x49, 0xCE, 0x2E, 0x49, 0x17, 0xCB, 0xC6, 0x17, 0xCA, 0x2F, 0x69, 0xCA,
0xC3, 0xFC, 0xBD, 0xC3, 0x5C, 0x97, 0xA3, 0x5C, 0x5E, 0x05, 0xE8, 0x5E, 0xD0, 0x7A, 0xED, 0xD0,
0x87, 0xAC, 0xD1, 0x87, 0x8E, 0x7F, 0x05, 0x8E, 0xBA, 0xD5, 0x64, 0xBA, 0xA8, 0x1A, 0xA5, 0xA8,
0xB7, 0x4B, 0x26, 0xB7, 0xB9, 0x0E, 0xBE, 0xB9, 0x60, 0xA7, 0x87, 0x60, 0xF8, 0x5A, 0xD5, 0xF8,
0x22, 0x28, 0x36, 0x22, 0x11, 0x14, 0x1B, 0x11, 0xDE, 0x3F, 0x75, 0xDE, 0x79, 0x29, 0xD9, 0x79,
0xAA, 0x88, 0xEE, 0xAA, 0x33, 0x3C, 0x2D, 0x33, 0x5F, 0x4C, 0x79, 0x5F, 0xB6, 0x02, 0xB7, 0xB6,
0x96, 0xB8, 0xCA, 0x96, 0x58, 0xDA, 0x35, 0x58, 0x9C, 0xB0, 0xC4, 0x9C, 0xFC, 0x17, 0x43, 0xFC,
0x1A, 0x55, 0x84, 0x1A, 0xF6, 0x1F, 0x4D, 0xF6, 0x1C, 0x8A, 0x59, 0x1C, 0x38, 0x7D, 0xB2, 0x38,
0xAC, 0x57, 0x33, 0xAC, 0x18, 0xC7, 0xCF, 0x18, 0xF4, 0x8D, 0x06, 0xF4, 0x69, 0x74, 0x53, 0x69,
0x74, 0xB7, 0x9B, 0x74, 0xF5, 0xC4, 0x97, 0xF5, 0x56, 0x9F, 0xAD, 0x56, 0xDA, 0x72, 0xE3, 0xDA,
0xD5, 0x7E, 0xEA, 0xD5, 0x4A, 0x15, 0xF4, 0x4A, 0x9E, 0x22, 0x8F, 0x9E, 0xA2, 0x12, 0xAB, 0xA2,
0x4E, 0x58, 0x62, 0x4E, 0xE8, 0x07, 0x5F, 0xE8, 0xE5, 0x99, 0x1D, 0xE5, 0x39, 0x34, 0x23, 0x39,
0xC1, 0x6E, 0xF6, 0xC1, 0x44, 0x50, 0x6C, 0x44, 0x5D, 0xDE, 0x32, 0x5D, 0x72, 0x68, 0x46, 0x72,
0x26, 0x65, 0xA0, 0x26, 0x93, 0xBC, 0xCD, 0x93, 0x03, 0xDB, 0xDA, 0x03, 0xC6, 0xF8, 0xBA, 0xC6,
0xFA, 0xC8, 0x9E, 0xFA, 0x82, 0xA8, 0xD6, 0x82, 0xCF, 0x2B, 0x6E, 0xCF, 0x50, 0x40, 0x70, 0x50,
0xEB, 0xDC, 0x85, 0xEB, 0x75, 0xFE, 0x0A, 0x75, 0x8A, 0x32, 0x93, 0x8A, 0x8D, 0xA4, 0xDF, 0x8D,
0x4C, 0xCA, 0x29, 0x4C, 0x14, 0x10, 0x1C, 0x14, 0x73, 0x21, 0xD7, 0x73, 0xCC, 0xF0, 0xB4, 0xCC,
0x09, 0xD3, 0xD4, 0x09, 0x10, 0x5D, 0x8A, 0x10, 0xE2, 0x0F, 0x51, 0xE2, 0x00, 0x00, 0x00, 0x00,
0x9A, 0x6F, 0x19, 0x9A, 0xE0, 0x9D, 0x1A, 0xE0, 0x8F, 0x36, 0x94, 0x8F, 0xE6, 0x42, 0xC7, 0xE6,
0xEC, 0x4A, 0xC9, 0xEC, 0xFD, 0x5E, 0xD2, 0xFD, 0xAB, 0xC1, 0x7F, 0xAB, 0xD8, 0xE0, 0xA8, 0xD8,
]);
this.q_table = [
[
0xA9, 0x67, 0xB3, 0xE8, 0x04, 0xFD, 0xA3, 0x76, 0x9A, 0x92, 0x80, 0x78, 0xE4, 0xDD, 0xD1, 0x38,
0x0D, 0xC6, 0x35, 0x98, 0x18, 0xF7, 0xEC, 0x6C, 0x43, 0x75, 0x37, 0x26, 0xFA, 0x13, 0x94, 0x48,
0xF2, 0xD0, 0x8B, 0x30, 0x84, 0x54, 0xDF, 0x23, 0x19, 0x5B, 0x3D, 0x59, 0xF3, 0xAE, 0xA2, 0x82,
0x63, 0x01, 0x83, 0x2E, 0xD9, 0x51, 0x9B, 0x7C, 0xA6, 0xEB, 0xA5, 0xBE, 0x16, 0x0C, 0xE3, 0x61,
0xC0, 0x8C, 0x3A, 0xF5, 0x73, 0x2C, 0x25, 0x0B, 0xBB, 0x4E, 0x89, 0x6B, 0x53, 0x6A, 0xB4, 0xF1,
0xE1, 0xE6, 0xBD, 0x45, 0xE2, 0xF4, 0xB6, 0x66, 0xCC, 0x95, 0x03, 0x56, 0xD4, 0x1C, 0x1E, 0xD7,
0xFB, 0xC3, 0x8E, 0xB5, 0xE9, 0xCF, 0xBF, 0xBA, 0xEA, 0x77, 0x39, 0xAF, 0x33, 0xC9, 0x62, 0x71,
0x81, 0x79, 0x09, 0xAD, 0x24, 0xCD, 0xF9, 0xD8, 0xE5, 0xC5, 0xB9, 0x4D, 0x44, 0x08, 0x86, 0xE7,
0xA1, 0x1D, 0xAA, 0xED, 0x06, 0x70, 0xB2, 0xD2, 0x41, 0x7B, 0xA0, 0x11, 0x31, 0xC2, 0x27, 0x90,
0x20, 0xF6, 0x60, 0xFF, 0x96, 0x5C, 0xB1, 0xAB, 0x9E, 0x9C, 0x52, 0x1B, 0x5F, 0x93, 0x0A, 0xEF,
0x91, 0x85, 0x49, 0xEE, 0x2D, 0x4F, 0x8F, 0x3B, 0x47, 0x87, 0x6D, 0x46, 0xD6, 0x3E, 0x69, 0x64,
0x2A, 0xCE, 0xCB, 0x2F, 0xFC, 0x97, 0x05, 0x7A, 0xAC, 0x7F, 0xD5, 0x1A, 0x4B, 0x0E, 0xA7, 0x5A,
0x28, 0x14, 0x3F, 0x29, 0x88, 0x3C, 0x4C, 0x02, 0xB8, 0xDA, 0xB0, 0x17, 0x55, 0x1F, 0x8A, 0x7D,
0x57, 0xC7, 0x8D, 0x74, 0xB7, 0xC4, 0x9F, 0x72, 0x7E, 0x15, 0x22, 0x12, 0x58, 0x07, 0x99, 0x34,
0x6E, 0x50, 0xDE, 0x68, 0x65, 0xBC, 0xDB, 0xF8, 0xC8, 0xA8, 0x2B, 0x40, 0xDC, 0xFE, 0x32, 0xA4,
0xCA, 0x10, 0x21, 0xF0, 0xD3, 0x5D, 0x0F, 0x00, 0x6F, 0x9D, 0x36, 0x42, 0x4A, 0x5E, 0xC1, 0xE0,
],
[
0x75, 0xF3, 0xC6, 0xF4, 0xDB, 0x7B, 0xFB, 0xC8, 0x4A, 0xD3, 0xE6, 0x6B, 0x45, 0x7D, 0xE8, 0x4B,
0xD6, 0x32, 0xD8, 0xFD, 0x37, 0x71, 0xF1, 0xE1, 0x30, 0x0F, 0xF8, 0x1B, 0x87, 0xFA, 0x06, 0x3F,
0x5E, 0xBA, 0xAE, 0x5B, 0x8A, 0x00, 0xBC, 0x9D, 0x6D, 0xC1, 0xB1, 0x0E, 0x80, 0x5D, 0xD2, 0xD5,
0xA0, 0x84, 0x07, 0x14, 0xB5, 0x90, 0x2C, 0xA3, 0xB2, 0x73, 0x4C, 0x54, 0x92, 0x74, 0x36, 0x51,
0x38, 0xB0, 0xBD, 0x5A, 0xFC, 0x60, 0x62, 0x96, 0x6C, 0x42, 0xF7, 0x10, 0x7C, 0x28, 0x27, 0x8C,
0x13, 0x95, 0x9C, 0xC7, 0x24, 0x46, 0x3B, 0x70, 0xCA, 0xE3, 0x85, 0xCB, 0x11, 0xD0, 0x93, 0xB8,
0xA6, 0x83, 0x20, 0xFF, 0x9F, 0x77, 0xC3, 0xCC, 0x03, 0x6F, 0x08, 0xBF, 0x40, 0xE7, 0x2B, 0xE2,
0x79, 0x0C, 0xAA, 0x82, 0x41, 0x3A, 0xEA, 0xB9, 0xE4, 0x9A, 0xA4, 0x97, 0x7E, 0xDA, 0x7A, 0x17,
0x66, 0x94, 0xA1, 0x1D, 0x3D, 0xF0, 0xDE, 0xB3, 0x0B, 0x72, 0xA7, 0x1C, 0xEF, 0xD1, 0x53, 0x3E,
0x8F, 0x33, 0x26, 0x5F, 0xEC, 0x76, 0x2A, 0x49, 0x81, 0x88, 0xEE, 0x21, 0xC4, 0x1A, 0xEB, 0xD9,
0xC5, 0x39, 0x99, 0xCD, 0xAD, 0x31, 0x8B, 0x01, 0x18, 0x23, 0xDD, 0x1F, 0x4E, 0x2D, 0xF9, 0x48,
0x4F, 0xF2, 0x65, 0x8E, 0x78, 0x5C, 0x58, 0x19, 0x8D, 0xE5, 0x98, 0x57, 0x67, 0x7F, 0x05, 0x64,
0xAF, 0x63, 0xB6, 0xFE, 0xF5, 0xB7, 0x3C, 0xA5, 0xCE, 0xE9, 0x68, 0x44, 0xE0, 0x4D, 0x43, 0x69,
0x29, 0x2E, 0xAC, 0x15, 0x59, 0xA8, 0x0A, 0x9E, 0x6E, 0x47, 0xDF, 0x34, 0x35, 0x6A, 0xCF, 0xDC,
0x22, 0xC9, 0xC0, 0x9B, 0x89, 0xD4, 0xED, 0xAB, 0x12, 0xA2, 0x0D, 0x52, 0xBB, 0x02, 0x2F, 0xA9,
0xD7, 0x61, 0x1E, 0xB4, 0x50, 0x04, 0xF6, 0xC2, 0x16, 0x25, 0x86, 0x56, 0x55, 0x09, 0xBE, 0x91,
]
];
this.q0 = this.q_table[0];
this.q1 = this.q_table[1];
}
F() {
var x1 = this.key0;
var x2 = this.key1;
let x8 = 8;
var x11, x12, x13;
do {
x11 = HIBYTE(x2);
x12 = __PAIR64__(x2, x1, 24);
x1 = (x1 << 8) >>> 0;
x13 = (2 * HIBYTE(x2)) >>> 0;
if ((x2 & 0x80000000) != 0) {
x13 = (x13 ^ 0x14D) >>> 0;
}
x11 = (x11 & 0xFE00FFFF | ((x13 & 0x1FF) << 16));
x11 = (x11 ^ x12) >>> 0;
x12 = (x13 ^ (x2 >>> 25)) >>> 0;
if ((x2 & 0x1000000) != 0) {
x12 = (x12 ^ 0xA6) >>> 0;
}
x2 = (x11 ^ (((x12 << 24) | (x12 << 8)) >>> 0)) >>> 0;
--x8;
} while (x8);
return (x11 ^ (((x12 << 24) | (x12 << 8)) >>> 0)) >>> 0;
}
;
H02(y, L) {
const L1 = this.key[L + 8];
const L2 = this.key[L];
//MDS_table[0][q0[q0[y]^L[ 8]]^L[0]]
return this.MDS_table[0][this.q0[this.q0[y] ^ L1] ^ L2];
}
;
H12(y, L) {
const L1 = this.key[L + 9];
const L2 = this.key[L + 1];
//MDS_table[1][q0[q1[y]^L[ 9]]^L[1]]
return this.MDS_table[1][this.q0[this.q1[y] ^ L1] ^ L2];
}
;
H22(y, L) {
const L1 = this.key[L + 10];
const L2 = this.key[L + 2];
//MDS_table[2][q1[q0[y]^L[10]]^L[2]]
return this.MDS_table[2][this.q1[this.q0[y] ^ L1] ^ L2];
}
;
H32(y, L) {
const L1 = this.key[L + 11];
const L2 = this.key[L + 3];
//MDS_table[3][q1[q1[y]^L[11]]^L[3]]
return this.MDS_table[3][this.q1[this.q1[y] ^ L1] ^ L2];
}
;
h(k, L) {
return this.H02(k, L) ^ this.H12(k, L) ^ this.H22(k, L) ^ this.H32(k, L);
}
;
/**
* IV for CBC encryption.
*
* Must be 16 bytes!
*
* @param {Buffer|Uint8Array} iv - ```Buffer``` or ```Uint8Array```
*/
set_iv(iv) {
if (iv) {
if (!isBufferOrUint8Array(iv)) {
throw Error("IV must be a buffer or UInt8Array");
}
else {
if (iv.length != 16) {
throw Error("Enter a vaild 16 byte IV for CBC mode");
}
else {
this.iv = iv;
this.iv_set = true;
}
}
}
else {
throw Error("Enter a vaild 16 byte IV for CBC mode");
}
}
;
/**
* Key for encryption.
*
* Must be 16 bytes!
*
* @param {Buffer|Uint8Array} key - ```Buffer``` or ```Uint8Array```
*/
set_key(key) {
if (!isBufferOrUint8Array(key)) {
throw Error("key must be Buffer or Uint8Array");
}
var keyLen = key.length;
if (keyLen != 16) {
throw Error("Key must be 16 bytes");
}
const temp_MDS1 = new Uint32Array(256);
for (let i = 0; i < 256; i++) {
const element = readUInt32LE(this.MDS_1, i * 4);
temp_MDS1[i] = element;
}
this.MDS_table.push(temp_MDS1);
const temp_MDS2 = new Uint32Array(256);
for (let i = 0; i < 256; i++) {
const element = readUInt32LE(this.MDS_2, i * 4);
temp_MDS2[i] = element;
}
this.MDS_table.push(temp_MDS2);
const temp_MDS3 = new Uint32Array(256);
for (let i = 0; i < 256; i++) {
const element = readUInt32LE(this.MDS_3, i * 4);
temp_MDS3[i] = element;
}
this.MDS_table.push(temp_MDS3);
const temp_MDS4 = new Uint32Array(256);
for (let i = 0; i < 256; i++) {
const element = readUInt32LE(this.MDS_4, i * 4);
temp_MDS4[i] = element;
}
this.MDS_table.push(temp_MDS4);
this.buffer = new Uint8Array(160);
this.key = key;
const keys = new Uint32Array(4);
for (let i = 0; i < 4; i++) {
const element = readUInt32LE(key, i * 4);
keys[i] = element;
}
this.final_keys = new Uint8Array(16);
this.odd_keys = new Uint32Array(2);
this.even_keys = new Uint32Array(2);
let i_0 = 0;
let two = 2;
let one = 1;
let one_0 = 1;
do {
this.key0 = keys[one_0 - 1];
this.even_keys[i_0] = this.key0;
this.key1 = keys[one_0];
this.odd_keys[i_0] = this.key1;
let temp = this.F();
writeUInt32LE(this.final_keys, temp >>> 0, one * 4);
++i_0;
one_0 += 2;
--one;
} while (i_0 < two);
this.l_key = new Uint32Array(40);
var A, B, i;
for (i = 0; i < 40; i += 2) {
A = this.h(i, 0);
B = this.h(i + 1, 4);
B = rotl(B, 8);
A += B;
B += A;
writeUInt32LE(this.buffer, A >>> 0, i * 4);
writeUInt32LE(this.buffer, rotl(B, 9), (i * 4) + 4);
this.l_key[i] = A >>> 0;
this.l_key[i + 1] = rotl(B, 9);
}
this.xor_in = this.buffer.subarray(0, 16);
this.xor_out = this.buffer.subarray(16, 32);
A = 0;
B = 0;
this.block1 = new Uint32Array(256);
this.block2 = new Uint32Array(256);
this.block3 = new Uint32Array(256);
this.block4 = new Uint32Array(256);
this.key = this.final_keys;
for (i = 0; i < 256; i++) {
//xkey->s
this.block1[i] = this.MDS_table[0][(this.key[0] ^ this.q0[(this.key[4] ^ this.q0[i]) & 0xFF]) & 0xFF];
this.block2[i] = this.MDS_table[1][(this.key[1] ^ this.q0[(this.key[5] ^ this.q1[i]) & 0xFF]) & 0xFF];
this.block3[i] = this.MDS_table[2][(this.key[2] ^ this.q1[(this.key[6] ^ this.q0[i]) & 0xFF]) & 0xFF];
this.block4[i] = this.MDS_table[3][(this.key[3] ^ this.q1[(this.key[7] ^ this.q1[i]) & 0xFF]) & 0xFF];
}
this.key_set = true;
}
;
ENCRYPT_CYCLE(offset) {
var keys = this.keys;
let x8 = (((this.block2[BYTE1(keys[0])] ^ this.block1[BYTE(keys[0])]) >>> 0 ^ this.block3[BYTE2(keys[0])]) >>> 0 ^ this.block4[HIBYTE(keys[0])]) >>> 0;
let x9 = (((this.block2[BYTE(keys[1])] ^ this.block1[HIBYTE(keys[1])]) >>> 0 ^ this.block3[BYTE1(keys[1])]) >>> 0 ^ this.block4[BYTE2(keys[1])]) >>> 0;
let x26 = (x8 + 2 * x9 + this.l_key[4 * (offset) + 9]) >>> 0;
keys[2] = rotr((keys[2] ^ (x9 + x8 + this.l_key[4 * (offset) + 8]) >>> 0) >>> 0, 1);
let x0 = rotl(keys[3], 1);
keys[3] = (x0 ^ x26) >>> 0;
let x10 = (4 * offset) | 2;
let x9_1 = (((this.block2[BYTE1(keys[2])] ^ this.block1[BYTE(keys[2])]) >>> 0 ^ this.block3[BYTE2(keys[2])]) >>> 0 ^ this.block4[HIBYTE(keys[2])]) >>> 0;
let x8_1 = (((this.block2[BYTE(keys[3])] ^ this.block1[HIBYTE(keys[3])]) >>> 0 ^ this.block3[BYTE1(keys[3])]) >>> 0 ^ this.block4[BYTE2(keys[3])]) >>> 0;
let x20 = (x9_1 + 2 * x8_1 + this.l_key[x10 + 9]) >>> 0;
keys[0] = rotr(keys[0] ^ (x8_1 + x9_1 + this.l_key[x10 + 8]), 1);
keys[1] = rotl(keys[1], 1) ^ x20;
this.keys = keys;
}
;
DECRYPT_CYCLE(offset) {
var keys = this.keys;
let v6 = (4 * offset) | 2;
let v9 = (((this.block2[BYTE1(keys[0])] ^ this.block1[BYTE(keys[0])]) >>> 0 ^ this.block3[BYTE2(keys[0])]) >>> 0 ^ this.block4[HIBYTE(keys[0])]) >>> 0;
let v10 = 4 * offset;
let v11 = (((this.block2[BYTE(keys[1])] ^ this.block1[HIBYTE(keys[1])]) >>> 0 ^ this.block3[BYTE1(keys[1])]) >>> 0 ^ this.block4[BYTE2(keys[1])]) >>> 0;
let v13 = (v11 + v9 + this.l_key[v6 + 8]) >>> 0;
let v14 = (v9 + 2 * v11 + this.l_key[v6 + 9]) >>> 0;
keys[2] = rotl(keys[2], 1) ^ v13;
let v15 = rotr(keys[3] ^ v14, 1);
keys[3] = v15;
let v16 = (((this.block2[BYTE1(keys[2])] ^ this.block1[BYTE(keys[2])]) >>> 0 ^ this.block3[BYTE2(keys[2])]) >>> 0 ^ this.block4[HIBYTE(keys[2])]) >>> 0;
let v17 = (((this.block2[BYTE(v15)] ^ this.block1[HIBYTE(v15)]) >>> 0 ^ this.block3[BYTE1(v15)]) >>> 0 ^ this.block4[BYTE2(v15)]) >>> 0;
let v18 = (v17 + v16 + this.l_key[v10 + 8]) >>> 0;
let v19 = (v16 + 2 * v17 + this.l_key[v10 + 9]) >>> 0;
keys[0] = rotl(keys[0], 1) ^ v18;
keys[1] = rotr(keys[1] ^ v19, 1);
this.keys = keys;
}
;
encrypt_block(block) {
//check if IV is set, if so runs CBC
let start_chunk = block;
if (this.iv_set == true) {
start_chunk = xor(block, this.iv);
}
var make_keys = xor(start_chunk, this.xor_in);
this.keys = new Uint32Array(4);
for (let i = 0; i < 4; i++) {
const element = readUInt32LE(make_keys, i * 4);
this.keys[i] = element;
}
this.ENCRYPT_CYCLE(0);
this.ENCRYPT_CYCLE(1);
this.ENCRYPT_CYCLE(2);
this.ENCRYPT_CYCLE(3);
this.ENCRYPT_CYCLE(4);
this.ENCRYPT_CYCLE(5);
this.ENCRYPT_CYCLE(6);
this.ENCRYPT_CYCLE(7);
var out_blk;
if (isBuffer(block)) {
out_blk = Buffer.alloc(16);
}
else {
out_blk = new Uint8Array(16);
}
writeUInt32LE(out_blk, this.keys[2], 0);
writeUInt32LE(out_blk, this.keys[3], 4);
writeUInt32LE(out_blk, this.keys[0], 8);
writeUInt32LE(out_blk, this.keys[1], 12);
out_blk = xor(out_blk, this.xor_out);
if (this.iv_set == true) {
this.iv = out_blk;
}
return out_blk;
}
;
decrypt_block(block) {
let start_chunk = block;
if (this.iv_set == true) {
if (this.previous_block != undefined) {
this.iv = this.previous_block;
}
}
this.previous_block = start_chunk;
var make_keys = xor(start_chunk, this.xor_out);
this.keys = new Uint32Array(4);
for (let i = 0; i < 4; i++) {
const element = readUInt32LE(make_keys, i * 4);
this.keys[i] = element;
}
this.DECRYPT_CYCLE(7);
this.DECRYPT_CYCLE(6);
this.DECRYPT_CYCLE(5);
this.DECRYPT_CYCLE(4);
this.DECRYPT_CYCLE(3);
this.DECRYPT_CYCLE(2);
this.DECRYPT_CYCLE(1);
this.DECRYPT_CYCLE(0);
var out_blk;
if (isBuffer(block)) {
out_blk = Buffer.alloc(16);
}
else {
out_blk = new Uint8Array(16);
}
writeUInt32LE(out_blk, this.keys[2] >>> 0, 0);
writeUInt32LE(out_blk, this.keys[3] >>> 0, 4);
writeUInt32LE(out_blk, this.keys[0] >>> 0, 8);
writeUInt32LE(out_blk, this.keys[1] >>> 0, 12);
out_blk = xor(out_blk, this.xor_in);
var return_buffer = out_blk;
if (this.iv_set == true) {
return_buffer = xor(out_blk, this.iv);
}
return return_buffer;
}
;
/**
* If IV is not set, runs in ECB mode.
*
* If IV was set, runs in CBC mode.
*
* If remove_padding is ``number``, will check the last block and remove padded number.
*
* If remove_padding is ``true``, will remove PKCS padding on last block.
*
* @param {Buffer|Uint8Array} data_in - ```Buffer``` or ```Uint8Array```
* @param {number} padding - ```number``` defaults to 0 for PKCS or can use a value
* @returns ```Buffer``` or ```Uint8Array```
*/
encrypt(data_in, padding = 0) {
if (!isBufferOrUint8Array(data_in)) {
throw Error("Data must be Buffer or Uint8Array");
}
const block_size = 16;
if (this.key_set != true) {
throw Error("Please set key first");
}
var data = data_in;
var padd_value = padding;
const return_buff = [];
if (data.length % block_size != 0) {
var to_padd = block_size - (data.length % block_size);
if (padding == 0) {
padd_value = to_padd;
}
if (isBuffer(data_in)) {
var paddbuffer = Buffer.alloc(to_padd, padd_value & 0xFF);
data = Buffer.concat([data_in, paddbuffer]);
}
else {
data = extendUint8Array(data_in, data.length + to_padd, padd_value);
}
}
for (let index = 0; index < data.length / block_size; index++) {
const block = data.subarray((index * block_size), (index + 1) * block_size);
const return_block = this.encrypt_block(block);
return_buff.push(return_block);
}
var final_buffer;
if (isBuffer(data_in)) {
final_buffer = Buffer.concat(return_buff);
}
else {
final_buffer = concatenateUint8Arrays(return_buff);
}
this.iv_set = false;
return final_buffer;
}
;
/**
* If IV is not set, runs in ECB mode.
*
* If IV was set, runs in CBC mode.
*
* If remove_padding is ``number``, will check the last block and remove padded number.
*
* If remove_padding is ``true``, will remove PKCS padding on last block.
*
* @param {Buffer|Uint8Array} data_in - ```Buffer``` or ```Uint8Array```
* @param {boolean|number} remove_padding - Will check the last block and remove padded ``number``. Will remove PKCS if ``true``
* @returns ```Buffer``` or ```Uint8Array```
*/
decrypt(data_in, remove_padding = true) {
if (!isBufferOrUint8Array(data_in)) {
throw Error("Data mus