mirror of
https://github.com/MercuryWorkshop/scramjet.git
synced 2025-05-13 22:40:01 -04:00
chore: misc cleanup
This commit is contained in:
Percs
parent
ead9d160a9
commit
e7f05aecd3
5 changed files with 12 additions and 834 deletions
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "@mercuryworkshop/scramjet",
|
||||
"version": "1.0.2",
|
||||
"version": "1.0.2-dev",
|
||||
"description": "An experimental web proxy that aims to be the successor to Ultraviolet",
|
||||
"main": "./lib/index.cjs",
|
||||
"types": "./lib/index.d.js",
|
||||
|
|
@ -28,7 +28,7 @@
|
|||
"devDependencies": {
|
||||
"@fastify/static": "^8.0.1",
|
||||
"@mercuryworkshop/bare-as-module3": "^2.2.2",
|
||||
"@mercuryworkshop/epoxy-transport": "^2.1.12",
|
||||
"@mercuryworkshop/epoxy-transport": "^2.1.13",
|
||||
"@mercuryworkshop/libcurl-transport": "^1.3.10",
|
||||
"@rsdoctor/rspack-plugin": "^0.4.4",
|
||||
"@rspack/cli": "^1.0.5",
|
||||
|
|
|
|||
18
pnpm-lock.yaml
generated
18
pnpm-lock.yaml
generated
|
|
@ -46,8 +46,8 @@ importers:
|
|||
specifier: ^2.2.2
|
||||
version: 2.2.2
|
||||
'@mercuryworkshop/epoxy-transport':
|
||||
specifier: ^2.1.12
|
||||
version: 2.1.12
|
||||
specifier: ^2.1.13
|
||||
version: 2.1.13
|
||||
'@mercuryworkshop/libcurl-transport':
|
||||
specifier: ^1.3.10
|
||||
version: 1.3.10(typescript@5.6.2)
|
||||
|
|
@ -220,11 +220,11 @@ packages:
|
|||
'@mercuryworkshop/bare-mux@2.0.5':
|
||||
resolution: {integrity: sha512-Uu0JGqqh4K0MuOGnz5QI8DvnW3SGqmdeIP5HET1JKFjMy3HqPpRrIb3UAETZ7TPYjWgR/YJxNp2DmCsPluohCg==}
|
||||
|
||||
'@mercuryworkshop/epoxy-tls@2.1.5-1':
|
||||
resolution: {integrity: sha512-bheT8ua9FgfFR/GPDJmgTQVhdio/1IEmEPZAF3DZirA5DGF84tSIiv8e+ET3wxjatSdX56j6J7bx56igLmOk8w==}
|
||||
'@mercuryworkshop/epoxy-tls@2.1.6-1':
|
||||
resolution: {integrity: sha512-drnffDo9Ls73Fpmcup2Ys1z+BjzK+WLnzyfS4APFfWr9cJ0gu7567tx4M06XH5PUZMOS1J1Z3wqnRaBh/RX5bQ==}
|
||||
|
||||
'@mercuryworkshop/epoxy-transport@2.1.12':
|
||||
resolution: {integrity: sha512-hZeYZycSgLTaWDnwECB+dYYs7n3Af/ap3jGx7yX75I1zC6MT6tJQd6FZS7NhwuRj1OZ+oEEnucda5DGspYmxfQ==}
|
||||
'@mercuryworkshop/epoxy-transport@2.1.13':
|
||||
resolution: {integrity: sha512-2F3B+QCuuLSbi0449Xn31VdyrTzRcAlA6z4OLEVGNs9bi4HfTkFVKryarcts55euCZuVVGH7XtLqTXJUn0MX0g==}
|
||||
|
||||
'@mercuryworkshop/libcurl-transport@1.3.10':
|
||||
resolution: {integrity: sha512-XLSkk1n4uMu6M0sS5Rh5ZNT7dBGILHDneJYD9oOpWMU5yxzNDlwcmJggNaYqMfH7B8jjLmw5sK2gPU5hDFPAVg==}
|
||||
|
|
@ -3027,11 +3027,11 @@ snapshots:
|
|||
|
||||
'@mercuryworkshop/bare-mux@2.0.5': {}
|
||||
|
||||
'@mercuryworkshop/epoxy-tls@2.1.5-1': {}
|
||||
'@mercuryworkshop/epoxy-tls@2.1.6-1': {}
|
||||
|
||||
'@mercuryworkshop/epoxy-transport@2.1.12':
|
||||
'@mercuryworkshop/epoxy-transport@2.1.13':
|
||||
dependencies:
|
||||
'@mercuryworkshop/epoxy-tls': 2.1.5-1
|
||||
'@mercuryworkshop/epoxy-tls': 2.1.6-1
|
||||
|
||||
'@mercuryworkshop/libcurl-transport@1.3.10(typescript@5.6.2)':
|
||||
dependencies:
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ export default function (client: ScramjetClient, self: typeof window) {
|
|||
|
||||
client.Trap("document.documentURI", {
|
||||
get() {
|
||||
return decodeUrl(self.location.href);
|
||||
return client.url.href;
|
||||
},
|
||||
set() {
|
||||
return false;
|
||||
|
|
|
|||
|
|
@ -1,805 +0,0 @@
|
|||
/* 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 };
|
||||
|
|
@ -1,5 +1,3 @@
|
|||
import { enc, dec } from "./aes";
|
||||
|
||||
// for some reason eslint was parsing the type inside of the function params as a variable
|
||||
export interface Codec {
|
||||
// eslint-disable-next-line
|
||||
|
|
@ -65,21 +63,6 @@ const base64 = {
|
|||
},
|
||||
};
|
||||
|
||||
/*
|
||||
const aes = {
|
||||
encode: (str: string | undefined) => {
|
||||
if (!str) return str;
|
||||
|
||||
return encodeURIComponent(enc(str, "dynamic").substring(10));
|
||||
},
|
||||
decode: (str: string | undefined) => {
|
||||
if (!str) return str;
|
||||
|
||||
return dec("U2FsdGVkX1" + decodeURIComponent(str), "dynamic");
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
if (typeof self.$scramjet === "undefined") {
|
||||
//@ts-expect-error really dumb workaround
|
||||
self.$scramjet = {};
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue