350 lines
13 KiB
JavaScript
350 lines
13 KiB
JavaScript
// Module ID: 8875
|
|
// Function ID: 69967
|
|
// Name: XorAndSalsa
|
|
// Dependencies: []
|
|
// Exports: scrypt, scryptAsync
|
|
|
|
// Module 8875 (XorAndSalsa)
|
|
function XorAndSalsa(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
let tmp81;
|
|
let tmp82;
|
|
let tmp83;
|
|
let tmp84;
|
|
let tmp85;
|
|
let tmp86;
|
|
let tmp87;
|
|
let tmp88;
|
|
let tmp89;
|
|
let tmp90;
|
|
let tmp91;
|
|
let tmp92;
|
|
let tmp93;
|
|
let tmp94;
|
|
let tmp95;
|
|
let tmp96;
|
|
let tmp = +arg1;
|
|
let tmp47 = tmp3;
|
|
let tmp48 = tmp6;
|
|
let tmp49 = tmp9;
|
|
let tmp50 = tmp12;
|
|
let tmp51 = tmp15;
|
|
let tmp52 = tmp18;
|
|
let tmp53 = tmp21;
|
|
let tmp54 = tmp24;
|
|
let tmp55 = tmp27;
|
|
let tmp56 = tmp30;
|
|
let tmp57 = tmp33;
|
|
let tmp58 = tmp36;
|
|
let tmp59 = tmp39;
|
|
let tmp60 = tmp42;
|
|
let tmp61 = tmp45;
|
|
let tmp62 = tmp46;
|
|
let num = 0;
|
|
do {
|
|
let tmp63 = closure_0;
|
|
let tmp64 = closure_1;
|
|
let tmp65 = tmp51 ^ closure_0(closure_1[1]).rotl(tmp47 + tmp59 | 0, 7);
|
|
let tmp66 = tmp55 ^ closure_0(closure_1[1]).rotl(tmp65 + tmp47 | 0, 9);
|
|
let tmp67 = tmp59 ^ closure_0(closure_1[1]).rotl(tmp66 + tmp65 | 0, 13);
|
|
let tmp68 = tmp47 ^ closure_0(closure_1[1]).rotl(tmp67 + tmp66 | 0, 18);
|
|
let tmp69 = tmp56 ^ closure_0(closure_1[1]).rotl(tmp52 + tmp48 | 0, 7);
|
|
let tmp70 = tmp60 ^ closure_0(closure_1[1]).rotl(tmp69 + tmp52 | 0, 9);
|
|
let tmp71 = tmp48 ^ closure_0(closure_1[1]).rotl(tmp70 + tmp69 | 0, 13);
|
|
let tmp72 = tmp52 ^ closure_0(closure_1[1]).rotl(tmp71 + tmp70 | 0, 18);
|
|
let tmp73 = tmp61 ^ closure_0(closure_1[1]).rotl(tmp57 + tmp53 | 0, 7);
|
|
let tmp74 = tmp49 ^ closure_0(closure_1[1]).rotl(tmp73 + tmp57 | 0, 9);
|
|
let tmp75 = tmp53 ^ closure_0(closure_1[1]).rotl(tmp74 + tmp73 | 0, 13);
|
|
let tmp76 = tmp57 ^ closure_0(closure_1[1]).rotl(tmp75 + tmp74 | 0, 18);
|
|
let tmp77 = tmp50 ^ closure_0(closure_1[1]).rotl(tmp62 + tmp58 | 0, 7);
|
|
let tmp78 = tmp54 ^ closure_0(closure_1[1]).rotl(tmp77 + tmp62 | 0, 9);
|
|
let tmp79 = tmp58 ^ closure_0(closure_1[1]).rotl(tmp78 + tmp77 | 0, 13);
|
|
let tmp80 = tmp62 ^ closure_0(closure_1[1]).rotl(tmp79 + tmp78 | 0, 18);
|
|
tmp81 = tmp71 ^ closure_0(closure_1[1]).rotl(tmp68 + tmp77 | 0, 7);
|
|
tmp82 = tmp74 ^ closure_0(closure_1[1]).rotl(tmp81 + tmp68 | 0, 9);
|
|
tmp83 = tmp77 ^ closure_0(closure_1[1]).rotl(tmp82 + tmp81 | 0, 13);
|
|
tmp84 = tmp68 ^ closure_0(closure_1[1]).rotl(tmp83 + tmp82 | 0, 18);
|
|
tmp85 = tmp75 ^ closure_0(closure_1[1]).rotl(tmp72 + tmp65 | 0, 7);
|
|
tmp86 = tmp78 ^ closure_0(closure_1[1]).rotl(tmp85 + tmp72 | 0, 9);
|
|
tmp87 = tmp65 ^ closure_0(closure_1[1]).rotl(tmp86 + tmp85 | 0, 13);
|
|
tmp88 = tmp72 ^ closure_0(closure_1[1]).rotl(tmp87 + tmp86 | 0, 18);
|
|
tmp89 = tmp79 ^ closure_0(closure_1[1]).rotl(tmp76 + tmp69 | 0, 7);
|
|
tmp90 = tmp66 ^ closure_0(closure_1[1]).rotl(tmp89 + tmp76 | 0, 9);
|
|
tmp91 = tmp69 ^ closure_0(closure_1[1]).rotl(tmp90 + tmp89 | 0, 13);
|
|
tmp92 = tmp76 ^ closure_0(closure_1[1]).rotl(tmp91 + tmp90 | 0, 18);
|
|
tmp93 = tmp67 ^ closure_0(closure_1[1]).rotl(tmp80 + tmp73 | 0, 7);
|
|
tmp94 = tmp70 ^ closure_0(closure_1[1]).rotl(tmp93 + tmp80 | 0, 9);
|
|
tmp95 = tmp73 ^ closure_0(closure_1[1]).rotl(tmp94 + tmp93 | 0, 13);
|
|
tmp96 = tmp80 ^ closure_0(closure_1[1]).rotl(tmp95 + tmp94 | 0, 18);
|
|
num = num + 2;
|
|
tmp47 = tmp84;
|
|
tmp48 = tmp81;
|
|
tmp49 = tmp82;
|
|
tmp50 = tmp83;
|
|
tmp51 = tmp87;
|
|
tmp52 = tmp88;
|
|
tmp53 = tmp85;
|
|
tmp54 = tmp86;
|
|
tmp55 = tmp90;
|
|
tmp56 = tmp91;
|
|
tmp57 = tmp92;
|
|
tmp58 = tmp89;
|
|
tmp59 = tmp93;
|
|
tmp60 = tmp94;
|
|
tmp61 = tmp95;
|
|
tmp62 = tmp96;
|
|
} while (num < 8);
|
|
arg4[+arg5] = (arg0[tmp] ^ arg2[+arg3]) + tmp84 | 0;
|
|
arg4[++arg5 + 1] = (arg0[+tmp + 1] ^ arg2[++arg3 + 1]) + tmp81 | 0;
|
|
arg4[+++arg5 + 1 + 1] = (arg0[++tmp + 1 + 1] ^ arg2[+++arg3 + 1 + 1]) + tmp82 | 0;
|
|
tmp = +tmp99 + 1;
|
|
arg4[tmp] = (arg0[+++tmp + 1 + 1 + 1] ^ arg2[++++arg3 + 1 + 1 + 1]) + tmp83 | 0;
|
|
tmp = +tmp + 1;
|
|
arg4[tmp] = (arg0[++++tmp + 1 + 1 + 1 + 1] ^ arg2[+++++arg3 + 1 + 1 + 1 + 1]) + tmp87 | 0;
|
|
tmp = +tmp + 1;
|
|
arg4[tmp] = (arg0[+++++tmp + 1 + 1 + 1 + 1 + 1] ^ arg2[++++++arg3 + 1 + 1 + 1 + 1 + 1]) + tmp88 | 0;
|
|
tmp = +tmp + 1;
|
|
arg4[tmp] = (arg0[++++++tmp + 1 + 1 + 1 + 1 + 1 + 1] ^ arg2[+++++++arg3 + 1 + 1 + 1 + 1 + 1 + 1]) + tmp85 | 0;
|
|
tmp = +tmp + 1;
|
|
arg4[tmp] = (arg0[+++++++tmp + 1 + 1 + 1 + 1 + 1 + 1 + 1] ^ arg2[++++++++arg3 + 1 + 1 + 1 + 1 + 1 + 1 + 1]) + tmp86 | 0;
|
|
tmp = +tmp + 1;
|
|
arg4[tmp] = (arg0[++++++++tmp + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1] ^ arg2[+++++++++arg3 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1]) + tmp90 | 0;
|
|
tmp = +tmp + 1;
|
|
arg4[tmp] = (arg0[+++++++++tmp + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1] ^ arg2[++++++++++arg3 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1]) + tmp91 | 0;
|
|
tmp = +tmp + 1;
|
|
arg4[tmp] = (arg0[++++++++++tmp + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1] ^ arg2[+++++++++++arg3 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1]) + tmp92 | 0;
|
|
tmp = +tmp + 1;
|
|
arg4[tmp] = (arg0[+++++++++++tmp + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1] ^ arg2[++++++++++++arg3 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1]) + tmp89 | 0;
|
|
tmp = +tmp + 1;
|
|
arg4[tmp] = (arg0[++++++++++++tmp + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1] ^ arg2[+++++++++++++arg3 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1]) + tmp93 | 0;
|
|
tmp = +tmp + 1;
|
|
arg4[tmp] = (arg0[+++++++++++++tmp + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1] ^ arg2[++++++++++++++arg3 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1]) + tmp94 | 0;
|
|
tmp = +tmp + 1;
|
|
arg4[tmp] = (arg0[++++++++++++++tmp + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1] ^ arg2[+++++++++++++++arg3 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1]) + tmp95 | 0;
|
|
arg4[+tmp + 1] = (arg0[+++++++++++++++tmp + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1] ^ arg2[++++++++++++++++arg3 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1]) + tmp96 | 0;
|
|
}
|
|
function BlockMix(V, arg1, B32, result, arg4) {
|
|
let sum4 = arg1;
|
|
let sum3 = result;
|
|
let sum = result + 16 * arg4;
|
|
let num = 0;
|
|
do {
|
|
B32[sum + num] = V[sum4 + 16 * (2 * arg4 - 1) + num];
|
|
num = num + 1;
|
|
} while (num < 16);
|
|
let num2 = 0;
|
|
if (0 < arg4) {
|
|
do {
|
|
let tmp4 = closure_3;
|
|
let tmp5 = B32;
|
|
let tmp6 = sum;
|
|
let tmp7 = V;
|
|
let tmp8 = sum4;
|
|
let tmp9 = B32;
|
|
let tmp10 = sum3;
|
|
let tmp11 = closure_3(B32, sum, V, sum4, B32, sum3);
|
|
let tmp12 = sum4;
|
|
let tmp14 = sum;
|
|
let sum1 = sum;
|
|
let tmp13 = sum3;
|
|
if (num2 > 0) {
|
|
sum1 = sum + 16;
|
|
}
|
|
let tmp16 = closure_3;
|
|
let sum2 = sum4 + 16;
|
|
let tmp18 = B32;
|
|
let tmp19 = sum3;
|
|
let tmp20 = V;
|
|
let tmp21 = sum2;
|
|
let tmp22 = B32;
|
|
let tmp23 = sum1;
|
|
let tmp24 = closure_3(B32, tmp13, V, sum2, B32, sum1);
|
|
num2 = num2 + 1;
|
|
sum3 = sum3 + 16;
|
|
sum4 = sum2 + 16;
|
|
sum = sum1;
|
|
} while (num2 < arg4);
|
|
}
|
|
}
|
|
function scryptInit(B, B, arg2) {
|
|
let N;
|
|
let asyncTick;
|
|
let dkLen;
|
|
let maxmem;
|
|
let onProgress;
|
|
let p;
|
|
let r;
|
|
({ N, r, p, dkLen, asyncTick, maxmem, onProgress } = require(dependencyMap[1]).checkOpts({}, arg2));
|
|
const require = onProgress;
|
|
require(dependencyMap[2]).number(N);
|
|
require(dependencyMap[2]).number(r);
|
|
require(dependencyMap[2]).number(p);
|
|
require(dependencyMap[2]).number(dkLen);
|
|
require(dependencyMap[2]).number(asyncTick);
|
|
require(dependencyMap[2]).number(maxmem);
|
|
if (undefined !== onProgress) {
|
|
if ("function" !== typeof onProgress) {
|
|
const _Error4 = Error;
|
|
const error = new Error("progressCb should be function");
|
|
throw error;
|
|
}
|
|
}
|
|
const result = 128 * r;
|
|
if (N > 1) {
|
|
if (!(N & N - 1)) {
|
|
if (N <= 4294967296) {
|
|
if (p >= 0) {
|
|
if (p <= 137438953440 / result) {
|
|
if (dkLen >= 0) {
|
|
if (dkLen <= 137438953440) {
|
|
const result1 = result * (N + p);
|
|
if (result1 > maxmem) {
|
|
const _Error = Error;
|
|
const _HermesInternal = HermesInternal;
|
|
const error1 = new Error("Scrypt: parameters too large, " + result1 + " (128 * r * (N + p)) > " + maxmem + " (maxmem)");
|
|
throw error1;
|
|
} else {
|
|
let obj = { c: 1, dkLen: result * p };
|
|
const pbkdf2Result = require(dependencyMap[3]).pbkdf2(require(dependencyMap[4]).sha256, B, B, obj);
|
|
const _Uint8Array = Uint8Array;
|
|
const uint8Array = new Uint8Array(result * N);
|
|
const u32Result = require(dependencyMap[1]).u32(pbkdf2Result);
|
|
const _Uint8Array2 = Uint8Array;
|
|
const uint8Array1 = new Uint8Array(result);
|
|
function blockMixCb() {
|
|
|
|
}
|
|
const u32Result1 = require(dependencyMap[1]).u32(uint8Array);
|
|
if (onProgress) {
|
|
const result2 = 2 * N * p;
|
|
const dependencyMap = result2;
|
|
const _Math = Math;
|
|
const _Math2 = Math;
|
|
let closure_2 = Math.max(Math.floor(result2 / 10000), 1);
|
|
let closure_3 = 0;
|
|
blockMixCb = function blockMixCb() {
|
|
closure_3 = closure_3 + 1;
|
|
let tmp = !onProgress;
|
|
if (!tmp) {
|
|
let result = closure_3 % closure_2;
|
|
if (result) {
|
|
result = closure_3 !== result2;
|
|
}
|
|
tmp = result;
|
|
}
|
|
if (!tmp) {
|
|
onProgress(closure_3 / result2);
|
|
}
|
|
};
|
|
}
|
|
obj = { N, r, p, dkLen, blockSize32: result / 4, V: u32Result1, B32: u32Result, B: pbkdf2Result, tmp: require(dependencyMap[1]).u32(uint8Array1), blockMixCb, asyncTick };
|
|
return obj;
|
|
}
|
|
}
|
|
}
|
|
const _Error2 = Error;
|
|
const error2 = new Error("Scrypt: dkLen should be positive integer less than or equal to (2^32 - 1) * 32");
|
|
throw error2;
|
|
}
|
|
}
|
|
const _Error3 = Error;
|
|
const error3 = new Error("Scrypt: p must be a positive integer less than or equal to ((2^32 - 1) * 32) / (128 * r)");
|
|
throw error3;
|
|
}
|
|
}
|
|
}
|
|
const error4 = new Error("Scrypt: N must be larger than 1, a power of 2, and less than 2^32");
|
|
throw error4;
|
|
}
|
|
function scryptOutput(B, dkLen, B, V, arr3) {
|
|
B.fill(0);
|
|
V.fill(0);
|
|
arr3.fill(0);
|
|
return require(dependencyMap[3]).pbkdf2(require(dependencyMap[4]).sha256, B, B, { c: 1, dkLen });
|
|
}
|
|
function _scryptAsync() {
|
|
// CreateGeneratorClosureLongIndex (0x67)
|
|
const obj = callback(tmp);
|
|
const _scryptAsync = obj;
|
|
return obj(...arguments);
|
|
}
|
|
let closure_2 = require(dependencyMap[0]);
|
|
|
|
export const scrypt = function scrypt(B, B) {
|
|
let B32;
|
|
let N;
|
|
let V;
|
|
let blockMixCb;
|
|
let blockSize32;
|
|
let dkLen;
|
|
let p;
|
|
let r;
|
|
let tmp2;
|
|
({ N, r, p, dkLen, blockSize32, V, B32, B, tmp: tmp2, blockMixCb } = scryptInit(B, B, arg2));
|
|
if (!require(dependencyMap[1]).isLE) {
|
|
require(dependencyMap[1]).byteSwap32(B32);
|
|
}
|
|
for (let num = 0; num < p; num = num + 1) {
|
|
let result = blockSize32 * num;
|
|
for (let num2 = 0; num2 < blockSize32; num2 = num2 + 1) {
|
|
V[num2] = B32[result + num2];
|
|
}
|
|
let num3 = 0;
|
|
let num4 = 0;
|
|
if (0 < N - 1) {
|
|
do {
|
|
let tmp7 = closure_4;
|
|
let sum = num4 + blockSize32;
|
|
let tmp9 = V;
|
|
let tmp10 = num4;
|
|
let tmp11 = V;
|
|
let tmp12 = sum;
|
|
let tmp13 = r;
|
|
let tmp14 = closure_4(V, num4, V, sum, r);
|
|
let blockMixCbResult = blockMixCb();
|
|
num3 = num3 + 1;
|
|
num4 = sum;
|
|
let diff = N - 1;
|
|
} while (num3 < diff);
|
|
}
|
|
let tmp17 = BlockMix;
|
|
let tmp18 = V;
|
|
let tmp19 = B32;
|
|
let tmp20 = result;
|
|
let tmp21 = r;
|
|
let tmp22 = BlockMix(V, (N - 1) * blockSize32, B32, result, r);
|
|
let blockMixCbResult1 = blockMixCb();
|
|
let num5 = 0;
|
|
if (0 < N) {
|
|
do {
|
|
let result1 = B32[result + blockSize32 - 16] % N;
|
|
let num6 = 0;
|
|
let num7 = 0;
|
|
if (0 < blockSize32) {
|
|
do {
|
|
tmp2[num6] = B32[result + num6] ^ V[result1 * blockSize32 + num6];
|
|
num6 = num6 + 1;
|
|
num7 = num6;
|
|
} while (num6 < blockSize32);
|
|
}
|
|
let tmp25 = closure_4;
|
|
let tmp26 = tmp2;
|
|
let num8 = 0;
|
|
let tmp27 = B32;
|
|
let tmp28 = result;
|
|
let tmp29 = r;
|
|
let tmp30 = closure_4(tmp2, 0, B32, result, r);
|
|
let blockMixCbResult2 = blockMixCb();
|
|
num5 = num5 + 1;
|
|
let tmp32 = num7;
|
|
let tmp33 = result1;
|
|
} while (num5 < N);
|
|
}
|
|
}
|
|
if (!require(dependencyMap[1]).isLE) {
|
|
require(dependencyMap[1]).byteSwap32(B32);
|
|
}
|
|
return scryptOutput(B, dkLen, B, V, tmp2);
|
|
};
|
|
export const scryptAsync = function scryptAsync(uint8Array, arg1, arg2) {
|
|
return _scryptAsync(...arguments);
|
|
};
|