mirror of
https://github.com/MercuryWorkshop/scramjet.git
synced 2025-05-14 06:50:01 -04:00
805 lines
No EOL
21 KiB
TypeScript
805 lines
No EOL
21 KiB
TypeScript
/* eslint-disable */
|
|
|
|
var Nr = 14;
|
|
var Nk = 8;
|
|
var Decrypt = false;
|
|
function enc_utf8(s) {
|
|
try {
|
|
return unescape(encodeURIComponent(s));
|
|
} catch (e) {
|
|
throw "Error on UTF-8 encode";
|
|
}
|
|
};
|
|
function dec_utf8(s) {
|
|
try {
|
|
return decodeURIComponent(escape(s));
|
|
} catch (e) {
|
|
throw "Bad Key";
|
|
}
|
|
};
|
|
function padBlock(byteArr) {
|
|
var array = [],
|
|
cpad,
|
|
i;
|
|
if (byteArr.length < 16) {
|
|
cpad = 16 - byteArr.length;
|
|
array = [
|
|
cpad,
|
|
cpad,
|
|
cpad,
|
|
cpad,
|
|
cpad,
|
|
cpad,
|
|
cpad,
|
|
cpad,
|
|
cpad,
|
|
cpad,
|
|
cpad,
|
|
cpad,
|
|
cpad,
|
|
cpad,
|
|
cpad,
|
|
cpad,
|
|
];
|
|
}
|
|
for (i = 0; i < byteArr.length; i++) {
|
|
array[i] = byteArr[i];
|
|
}
|
|
return array;
|
|
};
|
|
function block2s(block, lastBlock) {
|
|
var string = "",
|
|
padding,
|
|
i;
|
|
if (lastBlock) {
|
|
padding = block[15];
|
|
if (padding > 16) {
|
|
throw "Decryption error: Maybe bad key";
|
|
}
|
|
if (padding === 16) {
|
|
return "";
|
|
}
|
|
for (i = 0; i < 16 - padding; i++) {
|
|
string += String.fromCharCode(block[i]);
|
|
}
|
|
} else {
|
|
for (i = 0; i < 16; i++) {
|
|
string += String.fromCharCode(block[i]);
|
|
}
|
|
}
|
|
return string;
|
|
};
|
|
function a2h(numArr) {
|
|
var string = "",
|
|
i;
|
|
for (i = 0; i < numArr.length; i++) {
|
|
string += (numArr[i] < 16 ? "0" : "") + numArr[i].toString(16);
|
|
}
|
|
return string;
|
|
};
|
|
function h2a(s) {
|
|
var ret = [];
|
|
s.replace(/(..)/g, function (s) {
|
|
ret.push(parseInt(s, 16));
|
|
});
|
|
return ret;
|
|
};
|
|
function s2a(string, binary) {
|
|
var array = [],
|
|
i;
|
|
|
|
if (!binary) {
|
|
string = enc_utf8(string);
|
|
}
|
|
|
|
for (i = 0; i < string.length; i++) {
|
|
array[i] = string.charCodeAt(i);
|
|
}
|
|
|
|
return array;
|
|
};
|
|
function size(newsize) {
|
|
switch (newsize) {
|
|
case 128:
|
|
Nr = 10;
|
|
Nk = 4;
|
|
break;
|
|
case 192:
|
|
Nr = 12;
|
|
Nk = 6;
|
|
break;
|
|
case 256:
|
|
Nr = 14;
|
|
Nk = 8;
|
|
break;
|
|
default:
|
|
throw "Invalid Key Size Specified:" + newsize;
|
|
}
|
|
};
|
|
function randArr(num) {
|
|
var result = [],
|
|
i;
|
|
for (i = 0; i < num; i++) {
|
|
result = result.concat(Math.floor(Math.random() * 256));
|
|
}
|
|
return result;
|
|
};
|
|
function openSSLKey(passwordArr, saltArr) {
|
|
var rounds = Nr >= 12 ? 3 : 2,
|
|
key = [],
|
|
iv = [],
|
|
md5_hash = [],
|
|
result = [],
|
|
data00 = passwordArr.concat(saltArr),
|
|
i;
|
|
md5_hash[0] = MD5(data00);
|
|
result = md5_hash[0];
|
|
for (i = 1; i < rounds; i++) {
|
|
md5_hash[i] = MD5(md5_hash[i - 1].concat(data00));
|
|
result = result.concat(md5_hash[i]);
|
|
}
|
|
key = result.slice(0, 4 * Nk);
|
|
iv = result.slice(4 * Nk, 4 * Nk + 16);
|
|
return {
|
|
key: key,
|
|
iv: iv,
|
|
};
|
|
};
|
|
function rawEncrypt(plaintext, key, iv) {
|
|
key = expandKey(key);
|
|
var numBlocks = Math.ceil(plaintext.length / 16),
|
|
blocks = [],
|
|
i,
|
|
cipherBlocks = [];
|
|
for (i = 0; i < numBlocks; i++) {
|
|
blocks[i] = padBlock(plaintext.slice(i * 16, i * 16 + 16));
|
|
}
|
|
if (plaintext.length % 16 === 0) {
|
|
blocks.push([
|
|
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
|
|
]);
|
|
numBlocks++;
|
|
}
|
|
for (i = 0; i < blocks.length; i++) {
|
|
blocks[i] =
|
|
i === 0
|
|
? xorBlocks(blocks[i], iv)
|
|
: xorBlocks(blocks[i], cipherBlocks[i - 1]);
|
|
cipherBlocks[i] = encryptBlock(blocks[i], key);
|
|
}
|
|
return cipherBlocks;
|
|
};
|
|
function rawDecrypt(cryptArr, key, iv, binary) {
|
|
key = expandKey(key);
|
|
var numBlocks = cryptArr.length / 16,
|
|
cipherBlocks = [],
|
|
i,
|
|
plainBlocks = [],
|
|
string = "";
|
|
for (i = 0; i < numBlocks; i++) {
|
|
cipherBlocks.push(cryptArr.slice(i * 16, (i + 1) * 16));
|
|
}
|
|
for (i = cipherBlocks.length - 1; i >= 0; i--) {
|
|
plainBlocks[i] = decryptBlock(cipherBlocks[i], key);
|
|
plainBlocks[i] =
|
|
i === 0
|
|
? xorBlocks(plainBlocks[i], iv)
|
|
: xorBlocks(plainBlocks[i], cipherBlocks[i - 1]);
|
|
}
|
|
for (i = 0; i < numBlocks - 1; i++) {
|
|
string += block2s(plainBlocks[i], false);
|
|
}
|
|
string += block2s(plainBlocks[i], true);
|
|
return binary ? string : dec_utf8(string);
|
|
};
|
|
function encryptBlock(block, words) {
|
|
Decrypt = false;
|
|
var state = addRoundKey(block, words, 0),
|
|
round;
|
|
for (round = 1; round < Nr + 1; round++) {
|
|
state = subBytes(state);
|
|
state = shiftRows(state);
|
|
if (round < Nr) {
|
|
state = mixColumns(state);
|
|
}
|
|
state = addRoundKey(state, words, round);
|
|
}
|
|
|
|
return state;
|
|
};
|
|
function decryptBlock(block, words) {
|
|
Decrypt = true;
|
|
var state = addRoundKey(block, words, Nr),
|
|
round;
|
|
for (round = Nr - 1; round > -1; round--) {
|
|
state = shiftRows(state);
|
|
state = subBytes(state);
|
|
state = addRoundKey(state, words, round);
|
|
if (round > 0) {
|
|
state = mixColumns(state);
|
|
}
|
|
}
|
|
|
|
return state;
|
|
};
|
|
function subBytes(state) {
|
|
var S = Decrypt ? SBoxInv : SBox,
|
|
temp = [],
|
|
i;
|
|
for (i = 0; i < 16; i++) {
|
|
temp[i] = S[state[i]];
|
|
}
|
|
return temp;
|
|
};
|
|
function shiftRows(state) {
|
|
var temp = [],
|
|
shiftBy = Decrypt
|
|
? [0, 13, 10, 7, 4, 1, 14, 11, 8, 5, 2, 15, 12, 9, 6, 3]
|
|
: [0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, 1, 6, 11],
|
|
i;
|
|
for (i = 0; i < 16; i++) {
|
|
temp[i] = state[shiftBy[i]];
|
|
}
|
|
return temp;
|
|
};
|
|
function mixColumns(state) {
|
|
var t = [],
|
|
c;
|
|
if (!Decrypt) {
|
|
for (c = 0; c < 4; c++) {
|
|
t[c * 4] =
|
|
G2X[state[c * 4]] ^
|
|
G3X[state[1 + c * 4]] ^
|
|
state[2 + c * 4] ^
|
|
state[3 + c * 4];
|
|
t[1 + c * 4] =
|
|
state[c * 4] ^
|
|
G2X[state[1 + c * 4]] ^
|
|
G3X[state[2 + c * 4]] ^
|
|
state[3 + c * 4];
|
|
t[2 + c * 4] =
|
|
state[c * 4] ^
|
|
state[1 + c * 4] ^
|
|
G2X[state[2 + c * 4]] ^
|
|
G3X[state[3 + c * 4]];
|
|
t[3 + c * 4] =
|
|
G3X[state[c * 4]] ^
|
|
state[1 + c * 4] ^
|
|
state[2 + c * 4] ^
|
|
G2X[state[3 + c * 4]];
|
|
}
|
|
} else {
|
|
for (c = 0; c < 4; c++) {
|
|
t[c * 4] =
|
|
GEX[state[c * 4]] ^
|
|
GBX[state[1 + c * 4]] ^
|
|
GDX[state[2 + c * 4]] ^
|
|
G9X[state[3 + c * 4]];
|
|
t[1 + c * 4] =
|
|
G9X[state[c * 4]] ^
|
|
GEX[state[1 + c * 4]] ^
|
|
GBX[state[2 + c * 4]] ^
|
|
GDX[state[3 + c * 4]];
|
|
t[2 + c * 4] =
|
|
GDX[state[c * 4]] ^
|
|
G9X[state[1 + c * 4]] ^
|
|
GEX[state[2 + c * 4]] ^
|
|
GBX[state[3 + c * 4]];
|
|
t[3 + c * 4] =
|
|
GBX[state[c * 4]] ^
|
|
GDX[state[1 + c * 4]] ^
|
|
G9X[state[2 + c * 4]] ^
|
|
GEX[state[3 + c * 4]];
|
|
}
|
|
}
|
|
|
|
return t;
|
|
};
|
|
function addRoundKey(state, words, round) {
|
|
var temp = [],
|
|
i;
|
|
for (i = 0; i < 16; i++) {
|
|
temp[i] = state[i] ^ words[round][i];
|
|
}
|
|
return temp;
|
|
};
|
|
function xorBlocks(block1, block2) {
|
|
var temp = [],
|
|
i;
|
|
for (i = 0; i < 16; i++) {
|
|
temp[i] = block1[i] ^ block2[i];
|
|
}
|
|
return temp;
|
|
};
|
|
function expandKey(key) {
|
|
var w = [],
|
|
temp = [],
|
|
i,
|
|
r,
|
|
t,
|
|
flat = [],
|
|
j;
|
|
|
|
for (i = 0; i < Nk; i++) {
|
|
r = [key[4 * i], key[4 * i + 1], key[4 * i + 2], key[4 * i + 3]];
|
|
w[i] = r;
|
|
}
|
|
|
|
for (i = Nk; i < 4 * (Nr + 1); i++) {
|
|
w[i] = [];
|
|
for (t = 0; t < 4; t++) {
|
|
temp[t] = w[i - 1][t];
|
|
}
|
|
if (i % Nk === 0) {
|
|
temp = subWord(rotWord(temp));
|
|
temp[0] ^= Rcon[i / Nk - 1];
|
|
} else if (Nk > 6 && i % Nk === 4) {
|
|
temp = subWord(temp);
|
|
}
|
|
for (t = 0; t < 4; t++) {
|
|
w[i][t] = w[i - Nk][t] ^ temp[t];
|
|
}
|
|
}
|
|
for (i = 0; i < Nr + 1; i++) {
|
|
flat[i] = [];
|
|
for (j = 0; j < 4; j++) {
|
|
flat[i].push(
|
|
w[i * 4 + j][0],
|
|
w[i * 4 + j][1],
|
|
w[i * 4 + j][2],
|
|
w[i * 4 + j][3]
|
|
);
|
|
}
|
|
}
|
|
return flat;
|
|
};
|
|
function subWord(w) {
|
|
for (var i = 0; i < 4; i++) {
|
|
w[i] = SBox[w[i]];
|
|
}
|
|
return w;
|
|
};
|
|
function rotWord(w) {
|
|
var tmp = w[0],
|
|
i;
|
|
for (i = 0; i < 3; i++) {
|
|
w[i] = w[i + 1];
|
|
}
|
|
w[3] = tmp;
|
|
return w;
|
|
};
|
|
function strhex(str, size) {
|
|
var i,
|
|
ret = [];
|
|
for (i = 0; i < str.length; i += size) {
|
|
ret[i / size] = parseInt(str.substr(i, size), 16);
|
|
}
|
|
return ret;
|
|
};
|
|
function invertArr(arr) {
|
|
var i,
|
|
ret = [];
|
|
for (i = 0; i < arr.length; i++) {
|
|
ret[arr[i]] = i;
|
|
}
|
|
return ret;
|
|
};
|
|
function Gxx(a, b) {
|
|
var i, ret;
|
|
|
|
ret = 0;
|
|
for (i = 0; i < 8; i++) {
|
|
ret = (b & 1) === 1 ? ret ^ a : ret;
|
|
a = a > 0x7f ? 0x11b ^ (a << 1) : a << 1;
|
|
b >>>= 1;
|
|
}
|
|
|
|
return ret;
|
|
};
|
|
function Gx(x) {
|
|
var i,
|
|
r = [];
|
|
for (i = 0; i < 256; i++) {
|
|
r[i] = Gxx(x, i);
|
|
}
|
|
return r;
|
|
};
|
|
var SBox = strhex(
|
|
"637c777bf26b6fc53001672bfed7ab76ca82c97dfa5947f0add4a2af9ca472c0b7fd9326363ff7cc34a5e5f171d8311504c723c31896059a071280e2eb27b27509832c1a1b6e5aa0523bd6b329e32f8453d100ed20fcb15b6acbbe394a4c58cfd0efaafb434d338545f9027f503c9fa851a3408f929d38f5bcb6da2110fff3d2cd0c13ec5f974417c4a77e3d645d197360814fdc222a908846eeb814de5e0bdbe0323a0a4906245cc2d3ac629195e479e7c8376d8dd54ea96c56f4ea657aae08ba78252e1ca6b4c6e8dd741f4bbd8b8a703eb5664803f60e613557b986c11d9ee1f8981169d98e949b1e87e9ce5528df8ca1890dbfe6426841992d0fb054bb16",
|
|
2
|
|
);
|
|
var SBoxInv = invertArr(SBox);
|
|
var Rcon = strhex(
|
|
"01020408102040801b366cd8ab4d9a2f5ebc63c697356ad4b37dfaefc591",
|
|
2
|
|
);
|
|
var G2X = Gx(2);
|
|
var G3X = Gx(3);
|
|
var G9X = Gx(9);
|
|
var GBX = Gx(0xb);
|
|
var GDX = Gx(0xd);
|
|
var GEX = Gx(0xe);
|
|
function enc(string, pass, binary) {
|
|
var salt = randArr(8),
|
|
pbe = openSSLKey(s2a(pass, binary), salt),
|
|
key = pbe.key,
|
|
iv = pbe.iv,
|
|
cipherBlocks,
|
|
saltBlock = [[83, 97, 108, 116, 101, 100, 95, 95].concat(salt)];
|
|
string = s2a(string, binary);
|
|
cipherBlocks = rawEncrypt(string, key, iv);
|
|
|
|
cipherBlocks = saltBlock.concat(cipherBlocks);
|
|
return Base64.encode(cipherBlocks);
|
|
};
|
|
function dec(string, pass, binary) {
|
|
var cryptArr = Base64.decode(string),
|
|
salt = cryptArr.slice(8, 16),
|
|
pbe = openSSLKey(s2a(pass, binary), salt),
|
|
key = pbe.key,
|
|
iv = pbe.iv;
|
|
cryptArr = cryptArr.slice(16, cryptArr.length);
|
|
|
|
string = rawDecrypt(cryptArr, key, iv, binary);
|
|
return string;
|
|
};
|
|
function MD5(numArr) {
|
|
function rotateLeft(lValue, iShiftBits) {
|
|
return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));
|
|
}
|
|
|
|
function addUnsigned(lX, lY) {
|
|
var lX4, lY4, lX8, lY8, lResult;
|
|
lX8 = lX & 0x80000000;
|
|
lY8 = lY & 0x80000000;
|
|
lX4 = lX & 0x40000000;
|
|
lY4 = lY & 0x40000000;
|
|
lResult = (lX & 0x3fffffff) + (lY & 0x3fffffff);
|
|
if (lX4 & lY4) {
|
|
return lResult ^ 0x80000000 ^ lX8 ^ lY8;
|
|
}
|
|
if (lX4 | lY4) {
|
|
if (lResult & 0x40000000) {
|
|
return lResult ^ 0xc0000000 ^ lX8 ^ lY8;
|
|
} else {
|
|
return lResult ^ 0x40000000 ^ lX8 ^ lY8;
|
|
}
|
|
} else {
|
|
return lResult ^ lX8 ^ lY8;
|
|
}
|
|
}
|
|
|
|
function f(x, y, z) {
|
|
return (x & y) | (~x & z);
|
|
}
|
|
function g(x, y, z) {
|
|
return (x & z) | (y & ~z);
|
|
}
|
|
function h(x, y, z) {
|
|
return x ^ y ^ z;
|
|
}
|
|
function funcI(x, y, z) {
|
|
return y ^ (x | ~z);
|
|
}
|
|
|
|
function ff(a, b, c, d, x, s, ac) {
|
|
a = addUnsigned(a, addUnsigned(addUnsigned(f(b, c, d), x), ac));
|
|
return addUnsigned(rotateLeft(a, s), b);
|
|
}
|
|
|
|
function gg(a, b, c, d, x, s, ac) {
|
|
a = addUnsigned(a, addUnsigned(addUnsigned(g(b, c, d), x), ac));
|
|
return addUnsigned(rotateLeft(a, s), b);
|
|
}
|
|
|
|
function hh(a, b, c, d, x, s, ac) {
|
|
a = addUnsigned(a, addUnsigned(addUnsigned(h(b, c, d), x), ac));
|
|
return addUnsigned(rotateLeft(a, s), b);
|
|
}
|
|
|
|
function ii(a, b, c, d, x, s, ac) {
|
|
a = addUnsigned(a, addUnsigned(addUnsigned(funcI(b, c, d), x), ac));
|
|
return addUnsigned(rotateLeft(a, s), b);
|
|
}
|
|
|
|
function convertToWordArray(numArr) {
|
|
var lWordCount,
|
|
lMessageLength = numArr.length,
|
|
lNumberOfWords_temp1 = lMessageLength + 8,
|
|
lNumberOfWords_temp2 =
|
|
(lNumberOfWords_temp1 - (lNumberOfWords_temp1 % 64)) / 64,
|
|
lNumberOfWords = (lNumberOfWords_temp2 + 1) * 16,
|
|
lWordArray = [],
|
|
lBytePosition = 0,
|
|
lByteCount = 0;
|
|
while (lByteCount < lMessageLength) {
|
|
lWordCount = (lByteCount - (lByteCount % 4)) / 4;
|
|
lBytePosition = (lByteCount % 4) * 8;
|
|
lWordArray[lWordCount] =
|
|
lWordArray[lWordCount] | (numArr[lByteCount] << lBytePosition);
|
|
lByteCount++;
|
|
}
|
|
lWordCount = (lByteCount - (lByteCount % 4)) / 4;
|
|
lBytePosition = (lByteCount % 4) * 8;
|
|
lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
|
|
lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
|
|
lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
|
|
return lWordArray;
|
|
}
|
|
|
|
function wordToHex(lValue) {
|
|
var lByte,
|
|
lCount,
|
|
wordToHexArr = [];
|
|
for (lCount = 0; lCount <= 3; lCount++) {
|
|
lByte = (lValue >>> (lCount * 8)) & 255;
|
|
wordToHexArr = wordToHexArr.concat(lByte);
|
|
}
|
|
return wordToHexArr;
|
|
}
|
|
|
|
var x = [],
|
|
k,
|
|
AA,
|
|
BB,
|
|
CC,
|
|
DD,
|
|
a,
|
|
b,
|
|
c,
|
|
d,
|
|
rnd = strhex(
|
|
"67452301efcdab8998badcfe10325476d76aa478e8c7b756242070dbc1bdceeef57c0faf4787c62aa8304613fd469501698098d88b44f7afffff5bb1895cd7be6b901122fd987193a679438e49b40821f61e2562c040b340265e5a51e9b6c7aad62f105d02441453d8a1e681e7d3fbc821e1cde6c33707d6f4d50d87455a14eda9e3e905fcefa3f8676f02d98d2a4c8afffa39428771f6816d9d6122fde5380ca4beea444bdecfa9f6bb4b60bebfbc70289b7ec6eaa127fad4ef308504881d05d9d4d039e6db99e51fa27cf8c4ac5665f4292244432aff97ab9423a7fc93a039655b59c38f0ccc92ffeff47d85845dd16fa87e4ffe2ce6e0a30143144e0811a1f7537e82bd3af2352ad7d2bbeb86d391",
|
|
8
|
|
);
|
|
|
|
x = convertToWordArray(numArr);
|
|
|
|
a = rnd[0];
|
|
b = rnd[1];
|
|
c = rnd[2];
|
|
d = rnd[3];
|
|
|
|
for (k = 0; k < x.length; k += 16) {
|
|
AA = a;
|
|
BB = b;
|
|
CC = c;
|
|
DD = d;
|
|
a = ff(a, b, c, d, x[k + 0], 7, rnd[4]);
|
|
d = ff(d, a, b, c, x[k + 1], 12, rnd[5]);
|
|
c = ff(c, d, a, b, x[k + 2], 17, rnd[6]);
|
|
b = ff(b, c, d, a, x[k + 3], 22, rnd[7]);
|
|
a = ff(a, b, c, d, x[k + 4], 7, rnd[8]);
|
|
d = ff(d, a, b, c, x[k + 5], 12, rnd[9]);
|
|
c = ff(c, d, a, b, x[k + 6], 17, rnd[10]);
|
|
b = ff(b, c, d, a, x[k + 7], 22, rnd[11]);
|
|
a = ff(a, b, c, d, x[k + 8], 7, rnd[12]);
|
|
d = ff(d, a, b, c, x[k + 9], 12, rnd[13]);
|
|
c = ff(c, d, a, b, x[k + 10], 17, rnd[14]);
|
|
b = ff(b, c, d, a, x[k + 11], 22, rnd[15]);
|
|
a = ff(a, b, c, d, x[k + 12], 7, rnd[16]);
|
|
d = ff(d, a, b, c, x[k + 13], 12, rnd[17]);
|
|
c = ff(c, d, a, b, x[k + 14], 17, rnd[18]);
|
|
b = ff(b, c, d, a, x[k + 15], 22, rnd[19]);
|
|
a = gg(a, b, c, d, x[k + 1], 5, rnd[20]);
|
|
d = gg(d, a, b, c, x[k + 6], 9, rnd[21]);
|
|
c = gg(c, d, a, b, x[k + 11], 14, rnd[22]);
|
|
b = gg(b, c, d, a, x[k + 0], 20, rnd[23]);
|
|
a = gg(a, b, c, d, x[k + 5], 5, rnd[24]);
|
|
d = gg(d, a, b, c, x[k + 10], 9, rnd[25]);
|
|
c = gg(c, d, a, b, x[k + 15], 14, rnd[26]);
|
|
b = gg(b, c, d, a, x[k + 4], 20, rnd[27]);
|
|
a = gg(a, b, c, d, x[k + 9], 5, rnd[28]);
|
|
d = gg(d, a, b, c, x[k + 14], 9, rnd[29]);
|
|
c = gg(c, d, a, b, x[k + 3], 14, rnd[30]);
|
|
b = gg(b, c, d, a, x[k + 8], 20, rnd[31]);
|
|
a = gg(a, b, c, d, x[k + 13], 5, rnd[32]);
|
|
d = gg(d, a, b, c, x[k + 2], 9, rnd[33]);
|
|
c = gg(c, d, a, b, x[k + 7], 14, rnd[34]);
|
|
b = gg(b, c, d, a, x[k + 12], 20, rnd[35]);
|
|
a = hh(a, b, c, d, x[k + 5], 4, rnd[36]);
|
|
d = hh(d, a, b, c, x[k + 8], 11, rnd[37]);
|
|
c = hh(c, d, a, b, x[k + 11], 16, rnd[38]);
|
|
b = hh(b, c, d, a, x[k + 14], 23, rnd[39]);
|
|
a = hh(a, b, c, d, x[k + 1], 4, rnd[40]);
|
|
d = hh(d, a, b, c, x[k + 4], 11, rnd[41]);
|
|
c = hh(c, d, a, b, x[k + 7], 16, rnd[42]);
|
|
b = hh(b, c, d, a, x[k + 10], 23, rnd[43]);
|
|
a = hh(a, b, c, d, x[k + 13], 4, rnd[44]);
|
|
d = hh(d, a, b, c, x[k + 0], 11, rnd[45]);
|
|
c = hh(c, d, a, b, x[k + 3], 16, rnd[46]);
|
|
b = hh(b, c, d, a, x[k + 6], 23, rnd[47]);
|
|
a = hh(a, b, c, d, x[k + 9], 4, rnd[48]);
|
|
d = hh(d, a, b, c, x[k + 12], 11, rnd[49]);
|
|
c = hh(c, d, a, b, x[k + 15], 16, rnd[50]);
|
|
b = hh(b, c, d, a, x[k + 2], 23, rnd[51]);
|
|
a = ii(a, b, c, d, x[k + 0], 6, rnd[52]);
|
|
d = ii(d, a, b, c, x[k + 7], 10, rnd[53]);
|
|
c = ii(c, d, a, b, x[k + 14], 15, rnd[54]);
|
|
b = ii(b, c, d, a, x[k + 5], 21, rnd[55]);
|
|
a = ii(a, b, c, d, x[k + 12], 6, rnd[56]);
|
|
d = ii(d, a, b, c, x[k + 3], 10, rnd[57]);
|
|
c = ii(c, d, a, b, x[k + 10], 15, rnd[58]);
|
|
b = ii(b, c, d, a, x[k + 1], 21, rnd[59]);
|
|
a = ii(a, b, c, d, x[k + 8], 6, rnd[60]);
|
|
d = ii(d, a, b, c, x[k + 15], 10, rnd[61]);
|
|
c = ii(c, d, a, b, x[k + 6], 15, rnd[62]);
|
|
b = ii(b, c, d, a, x[k + 13], 21, rnd[63]);
|
|
a = ii(a, b, c, d, x[k + 4], 6, rnd[64]);
|
|
d = ii(d, a, b, c, x[k + 11], 10, rnd[65]);
|
|
c = ii(c, d, a, b, x[k + 2], 15, rnd[66]);
|
|
b = ii(b, c, d, a, x[k + 9], 21, rnd[67]);
|
|
a = addUnsigned(a, AA);
|
|
b = addUnsigned(b, BB);
|
|
c = addUnsigned(c, CC);
|
|
d = addUnsigned(d, DD);
|
|
}
|
|
|
|
return wordToHex(a).concat(wordToHex(b), wordToHex(c), wordToHex(d));
|
|
};
|
|
// function encString (plaintext, key, iv) {
|
|
// var i;
|
|
// plaintext = s2a(plaintext, false);
|
|
|
|
// key = s2a(key, false);
|
|
// for (i = key.length; i < 32; i++) {
|
|
// key[i] = 0;
|
|
// }
|
|
|
|
// if (iv === undefined) {
|
|
// } else {
|
|
// iv = s2a(iv, false);
|
|
// for (i = iv.length; i < 16; i++) {
|
|
// iv[i] = 0;
|
|
// }
|
|
// }
|
|
|
|
// var ct = rawEncrypt(plaintext, key, iv);
|
|
// var ret = [iv];
|
|
// for (i = 0; i < ct.length; i++) {
|
|
// ret[ret.length] = ct[i];
|
|
// }
|
|
// return Base64.encode(ret);
|
|
// };
|
|
// function decString (ciphertext, key) {
|
|
// // var tmp = Base64.decode(ciphertext);
|
|
// var tmp = atob(ciphertext);
|
|
// var iv = tmp.slice(0, 16);
|
|
// var ct = tmp.slice(16, tmp.length);
|
|
// var i;
|
|
|
|
// key = s2a(key, false);
|
|
// for (i = key.length; i < 32; i++) {
|
|
// key[i] = 0;
|
|
// }
|
|
|
|
// var pt = rawDecrypt(ct, key, iv, false);
|
|
// return pt;
|
|
// };
|
|
// function Base64() {
|
|
// var _chars =
|
|
// "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
|
|
// chars = _chars.split(""),
|
|
// encode = function (b, withBreaks) {
|
|
// var flatArr = [],
|
|
// b64 = "",
|
|
// i,
|
|
// broken_b64,
|
|
// totalChunks = Math.floor((b.length * 16) / 3);
|
|
// for (i = 0; i < b.length * 16; i++) {
|
|
// flatArr.push(b[Math.floor(i / 16)][i % 16]);
|
|
// }
|
|
// for (i = 0; i < flatArr.length; i = i + 3) {
|
|
// b64 += chars[flatArr[i] >> 2];
|
|
// b64 += chars[((flatArr[i] & 3) << 4) | (flatArr[i + 1] >> 4)];
|
|
// if (flatArr[i + 1] !== undefined) {
|
|
// b64 += chars[((flatArr[i + 1] & 15) << 2) | (flatArr[i + 2] >> 6)];
|
|
// } else {
|
|
// b64 += "=";
|
|
// }
|
|
// if (flatArr[i + 2] !== undefined) {
|
|
// b64 += chars[flatArr[i + 2] & 63];
|
|
// } else {
|
|
// b64 += "=";
|
|
// }
|
|
// }
|
|
// broken_b64 = b64.slice(0, 64) + "\n";
|
|
// for (i = 1; i < Math.ceil(b64.length / 64); i++) {
|
|
// broken_b64 +=
|
|
// b64.slice(i * 64, i * 64 + 64) +
|
|
// (Math.ceil(b64.length / 64) === i + 1 ? "" : "\n");
|
|
// }
|
|
// return broken_b64;
|
|
// },
|
|
// decode = function (string) {
|
|
// string = string.replace(/\n/g, "");
|
|
// var flatArr = [],
|
|
// c = [],
|
|
// b = [],
|
|
// i;
|
|
// for (i = 0; i < string.length; i = i + 4) {
|
|
// c[0] = _chars.indexOf(string.charAt(i));
|
|
// c[1] = _chars.indexOf(string.charAt(i + 1));
|
|
// c[2] = _chars.indexOf(string.charAt(i + 2));
|
|
// c[3] = _chars.indexOf(string.charAt(i + 3));
|
|
|
|
// b[0] = (c[0] << 2) | (c[1] >> 4);
|
|
// b[1] = ((c[1] & 15) << 4) | (c[2] >> 2);
|
|
// b[2] = ((c[2] & 3) << 6) | c[3];
|
|
// flatArr.push(b[0], b[1], b[2]);
|
|
// }
|
|
// flatArr = flatArr.slice(0, flatArr.length - (flatArr.length % 16));
|
|
// return flatArr;
|
|
// };
|
|
|
|
// if (typeof Array.indexOf === "function") {
|
|
// _chars = chars;
|
|
// }
|
|
|
|
// return {
|
|
// encode: encode,
|
|
// decode: decode,
|
|
// };
|
|
// }
|
|
|
|
const Base64 = {
|
|
encode: function (b) {
|
|
var _chars =
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
|
|
chars = _chars.split(""),
|
|
flatArr = [],
|
|
b64 = "",
|
|
i,
|
|
broken_b64,
|
|
totalChunks = Math.floor((b.length * 16) / 3);
|
|
for (i = 0; i < b.length * 16; i++) {
|
|
flatArr.push(b[Math.floor(i / 16)][i % 16]);
|
|
}
|
|
for (i = 0; i < flatArr.length; i = i + 3) {
|
|
b64 += chars[flatArr[i] >> 2];
|
|
b64 += chars[((flatArr[i] & 3) << 4) | (flatArr[i + 1] >> 4)];
|
|
if (flatArr[i + 1] !== undefined) {
|
|
b64 += chars[((flatArr[i + 1] & 15) << 2) | (flatArr[i + 2] >> 6)];
|
|
} else {
|
|
b64 += "=";
|
|
}
|
|
if (flatArr[i + 2] !== undefined) {
|
|
b64 += chars[flatArr[i + 2] & 63];
|
|
} else {
|
|
b64 += "=";
|
|
}
|
|
}
|
|
broken_b64 = b64.slice(0, 64) + "\n";
|
|
for (i = 1; i < Math.ceil(b64.length / 64); i++) {
|
|
broken_b64 +=
|
|
b64.slice(i * 64, i * 64 + 64) +
|
|
(Math.ceil(b64.length / 64) === i + 1 ? "" : "\n");
|
|
}
|
|
return broken_b64;
|
|
},
|
|
decode: function (string) {
|
|
string = string.replace(/\n/g, "");
|
|
var _chars =
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
|
|
chars = _chars.split(""),
|
|
flatArr = [],
|
|
c = [],
|
|
b = [],
|
|
i;
|
|
for (i = 0; i < string.length; i = i + 4) {
|
|
c[0] = _chars.indexOf(string.charAt(i));
|
|
c[1] = _chars.indexOf(string.charAt(i + 1));
|
|
c[2] = _chars.indexOf(string.charAt(i + 2));
|
|
c[3] = _chars.indexOf(string.charAt(i + 3));
|
|
|
|
b[0] = (c[0] << 2) | (c[1] >> 4);
|
|
b[1] = ((c[1] & 15) << 4) | (c[2] >> 2);
|
|
b[2] = ((c[2] & 3) << 6) | c[3];
|
|
flatArr.push(b[0], b[1], b[2]);
|
|
}
|
|
flatArr = flatArr.slice(0, flatArr.length - (flatArr.length % 16));
|
|
return flatArr;
|
|
}
|
|
}
|
|
|
|
export { enc, dec }; |