Richard
745 lines
44 KiB
JavaScript
745 lines
44 KiB
JavaScript
(function() {
|
|
"use strict";
|
|
function bufferStartsWith(buffer, prefix) {
|
|
if (prefix.length > buffer.length) {
|
|
return false;
|
|
}
|
|
for (let i = 0; i < prefix.length; i++) {
|
|
if (buffer[i] !== prefix[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function bufferToHex(buffer) {
|
|
return Array.from(new Uint8Array(buffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
|
|
}
|
|
function concatBuffers(a, b) {
|
|
const out = new Uint8Array(a.length + b.length);
|
|
out.set(a, 0);
|
|
out.set(b, a.length);
|
|
return out;
|
|
}
|
|
function hexToBuffer(hex) {
|
|
if (hex.length % 2 !== 0) {
|
|
throw new Error(`Hex string must have an even length. Got: ${hex}`);
|
|
}
|
|
const buffer = new ArrayBuffer(hex.length / 2);
|
|
const view = new DataView(buffer);
|
|
for (let i = 0; i < hex.length; i += 2) {
|
|
const byteString = hex.substring(i, i + 2);
|
|
const byteValue = parseInt(byteString, 16);
|
|
view.setUint8(i / 2, byteValue);
|
|
}
|
|
return new Uint8Array(buffer);
|
|
}
|
|
async function delay(ms) {
|
|
await new Promise((resolve) => setTimeout(resolve, ms));
|
|
}
|
|
function timeDuration(start) {
|
|
return Math.floor((performance.now() - start) * 10) / 10;
|
|
}
|
|
class PasswordBuffer {
|
|
constructor(nonce, mode = "uint32") {
|
|
this.nonce = nonce;
|
|
this.mode = mode;
|
|
this.buffer = new Uint8Array(this.nonce.length + this.COUNTER_BYTES);
|
|
this.buffer.set(this.nonce, 0);
|
|
this.dataView = new DataView(this.buffer.buffer);
|
|
}
|
|
nonce;
|
|
mode;
|
|
COUNTER_BYTES = 4;
|
|
buffer;
|
|
dataView;
|
|
encoder = new TextEncoder();
|
|
/**
|
|
* Appends the counter to the nonce buffer.
|
|
* In 'string' mode, encodes the counter as a UTF-8 string.
|
|
* In 'uint32' mode, writes the counter as a big-endian 32-bit integer.
|
|
*/
|
|
setCounter(n) {
|
|
if (this.mode === "string") {
|
|
return concatBuffers(this.nonce, this.encoder.encode(n.toString()));
|
|
}
|
|
this.dataView.setUint32(this.nonce.length, n, false);
|
|
return this.buffer;
|
|
}
|
|
}
|
|
async function solveChallenge(options) {
|
|
const {
|
|
challenge,
|
|
controller,
|
|
counterMode = "uint32",
|
|
counterStart = 0,
|
|
counterStep = 1,
|
|
deriveKey: deriveKey2,
|
|
timeout = 9e4
|
|
} = options;
|
|
const { nonce, keyPrefix, salt } = challenge.parameters;
|
|
const nonceBuf = hexToBuffer(nonce);
|
|
const saltBuf = hexToBuffer(salt);
|
|
const keyPrefixBuf = keyPrefix.length % 2 === 0 ? hexToBuffer(keyPrefix) : null;
|
|
const password = new PasswordBuffer(nonceBuf, counterMode);
|
|
const start = performance.now();
|
|
let counter = counterStart;
|
|
let iterations = 0;
|
|
let derivedKeyHex = "";
|
|
let lastYield = start;
|
|
while (true) {
|
|
if (controller?.signal.aborted || timeout && iterations % 10 === 0 && performance.now() - start > timeout) {
|
|
return null;
|
|
}
|
|
const { derivedKey } = await deriveKey2(
|
|
challenge.parameters,
|
|
saltBuf,
|
|
password.setCounter(counter)
|
|
);
|
|
if (iterations % 10 === 0 && performance.now() - lastYield > 200) {
|
|
await delay(0);
|
|
lastYield = performance.now();
|
|
}
|
|
if (keyPrefixBuf ? bufferStartsWith(derivedKey, keyPrefixBuf) : bufferToHex(derivedKey).startsWith(keyPrefix)) {
|
|
derivedKeyHex = bufferToHex(derivedKey);
|
|
break;
|
|
}
|
|
counter = counter + counterStep;
|
|
iterations = iterations + 1;
|
|
}
|
|
return {
|
|
counter,
|
|
derivedKey: derivedKeyHex,
|
|
time: timeDuration(start)
|
|
};
|
|
}
|
|
function handler(options) {
|
|
const { deriveKey: deriveKey2 } = options;
|
|
let controller = void 0;
|
|
self.onmessage = async (message) => {
|
|
const { challenge, counterMode, counterStart, counterStep, timeout, type } = message.data;
|
|
if (type === "abort") {
|
|
controller?.abort();
|
|
} else if (type === "work") {
|
|
controller = new AbortController();
|
|
let solution;
|
|
try {
|
|
solution = await solveChallenge({
|
|
challenge,
|
|
controller,
|
|
counterStart,
|
|
counterStep,
|
|
deriveKey: deriveKey2,
|
|
counterMode,
|
|
timeout
|
|
});
|
|
} catch (err) {
|
|
return self.postMessage({ error: err });
|
|
}
|
|
self.postMessage(solution);
|
|
}
|
|
};
|
|
}
|
|
function __awaiter(thisArg, _arguments, P, generator) {
|
|
function adopt(value) {
|
|
return value instanceof P ? value : new P(function(resolve) {
|
|
resolve(value);
|
|
});
|
|
}
|
|
return new (P || (P = Promise))(function(resolve, reject) {
|
|
function fulfilled(value) {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
}
|
|
function rejected(value) {
|
|
try {
|
|
step(generator["throw"](value));
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
}
|
|
function step(result) {
|
|
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
|
|
}
|
|
step((generator = generator.apply(thisArg, [])).next());
|
|
});
|
|
}
|
|
typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
|
|
var e = new Error(message);
|
|
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
|
|
};
|
|
class Mutex {
|
|
constructor() {
|
|
this.mutex = Promise.resolve();
|
|
}
|
|
lock() {
|
|
let begin = () => {
|
|
};
|
|
this.mutex = this.mutex.then(() => new Promise(begin));
|
|
return new Promise((res) => {
|
|
begin = res;
|
|
});
|
|
}
|
|
dispatch(fn) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const unlock = yield this.lock();
|
|
try {
|
|
return yield Promise.resolve(fn());
|
|
} finally {
|
|
unlock();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
var _a;
|
|
function getGlobal() {
|
|
if (typeof globalThis !== "undefined")
|
|
return globalThis;
|
|
if (typeof self !== "undefined")
|
|
return self;
|
|
if (typeof window !== "undefined")
|
|
return window;
|
|
return global;
|
|
}
|
|
const globalObject = getGlobal();
|
|
const nodeBuffer = (_a = globalObject.Buffer) !== null && _a !== void 0 ? _a : null;
|
|
const textEncoder = globalObject.TextEncoder ? new globalObject.TextEncoder() : null;
|
|
function hexCharCodesToInt(a, b) {
|
|
return (a & 15) + (a >> 6 | a >> 3 & 8) << 4 | (b & 15) + (b >> 6 | b >> 3 & 8);
|
|
}
|
|
function writeHexToUInt8(buf, str) {
|
|
const size = str.length >> 1;
|
|
for (let i = 0; i < size; i++) {
|
|
const index = i << 1;
|
|
buf[i] = hexCharCodesToInt(str.charCodeAt(index), str.charCodeAt(index + 1));
|
|
}
|
|
}
|
|
function hexStringEqualsUInt8(str, buf) {
|
|
if (str.length !== buf.length * 2) {
|
|
return false;
|
|
}
|
|
for (let i = 0; i < buf.length; i++) {
|
|
const strIndex = i << 1;
|
|
if (buf[i] !== hexCharCodesToInt(str.charCodeAt(strIndex), str.charCodeAt(strIndex + 1))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
const alpha = "a".charCodeAt(0) - 10;
|
|
const digit = "0".charCodeAt(0);
|
|
function getDigestHex(tmpBuffer, input, hashLength) {
|
|
let p = 0;
|
|
for (let i = 0; i < hashLength; i++) {
|
|
let nibble = input[i] >>> 4;
|
|
tmpBuffer[p++] = nibble > 9 ? nibble + alpha : nibble + digit;
|
|
nibble = input[i] & 15;
|
|
tmpBuffer[p++] = nibble > 9 ? nibble + alpha : nibble + digit;
|
|
}
|
|
return String.fromCharCode.apply(null, tmpBuffer);
|
|
}
|
|
const getUInt8Buffer = nodeBuffer !== null ? (data) => {
|
|
if (typeof data === "string") {
|
|
const buf = nodeBuffer.from(data, "utf8");
|
|
return new Uint8Array(buf.buffer, buf.byteOffset, buf.length);
|
|
}
|
|
if (nodeBuffer.isBuffer(data)) {
|
|
return new Uint8Array(data.buffer, data.byteOffset, data.length);
|
|
}
|
|
if (ArrayBuffer.isView(data)) {
|
|
return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
|
|
}
|
|
throw new Error("Invalid data type!");
|
|
} : (data) => {
|
|
if (typeof data === "string") {
|
|
return textEncoder.encode(data);
|
|
}
|
|
if (ArrayBuffer.isView(data)) {
|
|
return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
|
|
}
|
|
throw new Error("Invalid data type!");
|
|
};
|
|
const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
const base64Lookup = new Uint8Array(256);
|
|
for (let i = 0; i < base64Chars.length; i++) {
|
|
base64Lookup[base64Chars.charCodeAt(i)] = i;
|
|
}
|
|
function getDecodeBase64Length(data) {
|
|
let bufferLength = Math.floor(data.length * 0.75);
|
|
const len = data.length;
|
|
if (data[len - 1] === "=") {
|
|
bufferLength -= 1;
|
|
if (data[len - 2] === "=") {
|
|
bufferLength -= 1;
|
|
}
|
|
}
|
|
return bufferLength;
|
|
}
|
|
function decodeBase64(data) {
|
|
const bufferLength = getDecodeBase64Length(data);
|
|
const len = data.length;
|
|
const bytes = new Uint8Array(bufferLength);
|
|
let p = 0;
|
|
for (let i = 0; i < len; i += 4) {
|
|
const encoded1 = base64Lookup[data.charCodeAt(i)];
|
|
const encoded2 = base64Lookup[data.charCodeAt(i + 1)];
|
|
const encoded3 = base64Lookup[data.charCodeAt(i + 2)];
|
|
const encoded4 = base64Lookup[data.charCodeAt(i + 3)];
|
|
bytes[p] = encoded1 << 2 | encoded2 >> 4;
|
|
p += 1;
|
|
bytes[p] = (encoded2 & 15) << 4 | encoded3 >> 2;
|
|
p += 1;
|
|
bytes[p] = (encoded3 & 3) << 6 | encoded4 & 63;
|
|
p += 1;
|
|
}
|
|
return bytes;
|
|
}
|
|
const MAX_HEAP = 16 * 1024;
|
|
const WASM_FUNC_HASH_LENGTH = 4;
|
|
const wasmMutex = new Mutex();
|
|
const wasmModuleCache = /* @__PURE__ */ new Map();
|
|
function WASMInterface(binary, hashLength) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let wasmInstance = null;
|
|
let memoryView = null;
|
|
let initialized = false;
|
|
if (typeof WebAssembly === "undefined") {
|
|
throw new Error("WebAssembly is not supported in this environment!");
|
|
}
|
|
const writeMemory = (data, offset = 0) => {
|
|
memoryView.set(data, offset);
|
|
};
|
|
const getMemory = () => memoryView;
|
|
const getExports = () => wasmInstance.exports;
|
|
const setMemorySize = (totalSize) => {
|
|
wasmInstance.exports.Hash_SetMemorySize(totalSize);
|
|
const arrayOffset = wasmInstance.exports.Hash_GetBuffer();
|
|
const memoryBuffer = wasmInstance.exports.memory.buffer;
|
|
memoryView = new Uint8Array(memoryBuffer, arrayOffset, totalSize);
|
|
};
|
|
const getStateSize = () => {
|
|
const view = new DataView(wasmInstance.exports.memory.buffer);
|
|
const stateSize = view.getUint32(wasmInstance.exports.STATE_SIZE, true);
|
|
return stateSize;
|
|
};
|
|
const loadWASMPromise = wasmMutex.dispatch(() => __awaiter(this, void 0, void 0, function* () {
|
|
if (!wasmModuleCache.has(binary.name)) {
|
|
const asm = decodeBase64(binary.data);
|
|
const promise = WebAssembly.compile(asm);
|
|
wasmModuleCache.set(binary.name, promise);
|
|
}
|
|
const module = yield wasmModuleCache.get(binary.name);
|
|
wasmInstance = yield WebAssembly.instantiate(module, {
|
|
// env: {
|
|
// emscripten_memcpy_big: (dest, src, num) => {
|
|
// const memoryBuffer = wasmInstance.exports.memory.buffer;
|
|
// const memView = new Uint8Array(memoryBuffer, 0);
|
|
// memView.set(memView.subarray(src, src + num), dest);
|
|
// },
|
|
// print_memory: (offset, len) => {
|
|
// const memoryBuffer = wasmInstance.exports.memory.buffer;
|
|
// const memView = new Uint8Array(memoryBuffer, 0);
|
|
// console.log('print_int32', memView.subarray(offset, offset + len));
|
|
// },
|
|
// },
|
|
});
|
|
}));
|
|
const setupInterface = () => __awaiter(this, void 0, void 0, function* () {
|
|
if (!wasmInstance) {
|
|
yield loadWASMPromise;
|
|
}
|
|
const arrayOffset = wasmInstance.exports.Hash_GetBuffer();
|
|
const memoryBuffer = wasmInstance.exports.memory.buffer;
|
|
memoryView = new Uint8Array(memoryBuffer, arrayOffset, MAX_HEAP);
|
|
});
|
|
const init = (bits = null) => {
|
|
initialized = true;
|
|
wasmInstance.exports.Hash_Init(bits);
|
|
};
|
|
const updateUInt8Array = (data) => {
|
|
let read = 0;
|
|
while (read < data.length) {
|
|
const chunk = data.subarray(read, read + MAX_HEAP);
|
|
read += chunk.length;
|
|
memoryView.set(chunk);
|
|
wasmInstance.exports.Hash_Update(chunk.length);
|
|
}
|
|
};
|
|
const update = (data) => {
|
|
if (!initialized) {
|
|
throw new Error("update() called before init()");
|
|
}
|
|
const Uint8Buffer = getUInt8Buffer(data);
|
|
updateUInt8Array(Uint8Buffer);
|
|
};
|
|
const digestChars = new Uint8Array(hashLength * 2);
|
|
const digest = (outputType, padding = null) => {
|
|
if (!initialized) {
|
|
throw new Error("digest() called before init()");
|
|
}
|
|
initialized = false;
|
|
wasmInstance.exports.Hash_Final(padding);
|
|
if (outputType === "binary") {
|
|
return memoryView.slice(0, hashLength);
|
|
}
|
|
return getDigestHex(digestChars, memoryView, hashLength);
|
|
};
|
|
const save = () => {
|
|
if (!initialized) {
|
|
throw new Error("save() can only be called after init() and before digest()");
|
|
}
|
|
const stateOffset = wasmInstance.exports.Hash_GetState();
|
|
const stateLength = getStateSize();
|
|
const memoryBuffer = wasmInstance.exports.memory.buffer;
|
|
const internalState = new Uint8Array(memoryBuffer, stateOffset, stateLength);
|
|
const prefixedState = new Uint8Array(WASM_FUNC_HASH_LENGTH + stateLength);
|
|
writeHexToUInt8(prefixedState, binary.hash);
|
|
prefixedState.set(internalState, WASM_FUNC_HASH_LENGTH);
|
|
return prefixedState;
|
|
};
|
|
const load = (state) => {
|
|
if (!(state instanceof Uint8Array)) {
|
|
throw new Error("load() expects an Uint8Array generated by save()");
|
|
}
|
|
const stateOffset = wasmInstance.exports.Hash_GetState();
|
|
const stateLength = getStateSize();
|
|
const overallLength = WASM_FUNC_HASH_LENGTH + stateLength;
|
|
const memoryBuffer = wasmInstance.exports.memory.buffer;
|
|
if (state.length !== overallLength) {
|
|
throw new Error(`Bad state length (expected ${overallLength} bytes, got ${state.length})`);
|
|
}
|
|
if (!hexStringEqualsUInt8(binary.hash, state.subarray(0, WASM_FUNC_HASH_LENGTH))) {
|
|
throw new Error("This state was written by an incompatible hash implementation");
|
|
}
|
|
const internalState = state.subarray(WASM_FUNC_HASH_LENGTH);
|
|
new Uint8Array(memoryBuffer, stateOffset, stateLength).set(internalState);
|
|
initialized = true;
|
|
};
|
|
const isDataShort = (data) => {
|
|
if (typeof data === "string") {
|
|
return data.length < MAX_HEAP / 4;
|
|
}
|
|
return data.byteLength < MAX_HEAP;
|
|
};
|
|
let canSimplify = isDataShort;
|
|
switch (binary.name) {
|
|
case "argon2":
|
|
case "scrypt":
|
|
canSimplify = () => true;
|
|
break;
|
|
case "blake2b":
|
|
case "blake2s":
|
|
canSimplify = (data, initParam) => initParam <= 512 && isDataShort(data);
|
|
break;
|
|
case "blake3":
|
|
canSimplify = (data, initParam) => initParam === 0 && isDataShort(data);
|
|
break;
|
|
case "xxhash64":
|
|
// cannot simplify
|
|
case "xxhash3":
|
|
case "xxhash128":
|
|
case "crc64":
|
|
canSimplify = () => false;
|
|
break;
|
|
}
|
|
const calculate = (data, initParam = null, digestParam = null) => {
|
|
if (!canSimplify(data, initParam)) {
|
|
init(initParam);
|
|
update(data);
|
|
return digest("hex", digestParam);
|
|
}
|
|
const buffer = getUInt8Buffer(data);
|
|
memoryView.set(buffer);
|
|
wasmInstance.exports.Hash_Calculate(buffer.length, initParam, digestParam);
|
|
return getDigestHex(digestChars, memoryView, hashLength);
|
|
};
|
|
yield setupInterface();
|
|
return {
|
|
getMemory,
|
|
writeMemory,
|
|
getExports,
|
|
setMemorySize,
|
|
init,
|
|
update,
|
|
digest,
|
|
save,
|
|
load,
|
|
calculate,
|
|
hashLength
|
|
};
|
|
});
|
|
}
|
|
new Mutex();
|
|
new Mutex();
|
|
new Mutex();
|
|
new Mutex();
|
|
new Mutex();
|
|
new Mutex();
|
|
new Mutex();
|
|
new Mutex();
|
|
new Mutex();
|
|
new Mutex();
|
|
new Mutex();
|
|
var name$a = "sha256";
|
|
var data$a = "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";
|
|
var hash$a = "8c18dd94";
|
|
var wasmJson$a = {
|
|
name: name$a,
|
|
data: data$a,
|
|
hash: hash$a
|
|
};
|
|
new Mutex();
|
|
new Mutex();
|
|
function createSHA256() {
|
|
return WASMInterface(wasmJson$a, 32).then((wasm) => {
|
|
wasm.init(256);
|
|
const obj = {
|
|
init: () => {
|
|
wasm.init(256);
|
|
return obj;
|
|
},
|
|
update: (data) => {
|
|
wasm.update(data);
|
|
return obj;
|
|
},
|
|
// biome-ignore lint/suspicious/noExplicitAny: Conflict with IHasher type
|
|
digest: (outputType) => wasm.digest(outputType),
|
|
save: () => wasm.save(),
|
|
load: (data) => {
|
|
wasm.load(data);
|
|
return obj;
|
|
},
|
|
blockSize: 64,
|
|
digestSize: 32
|
|
};
|
|
return obj;
|
|
});
|
|
}
|
|
new Mutex();
|
|
new Mutex();
|
|
new Mutex();
|
|
new Mutex();
|
|
new Mutex();
|
|
new Mutex();
|
|
new Mutex();
|
|
function calculateKeyBuffer(hasher, key) {
|
|
const { blockSize } = hasher;
|
|
const buf = getUInt8Buffer(key);
|
|
if (buf.length > blockSize) {
|
|
hasher.update(buf);
|
|
const uintArr = hasher.digest("binary");
|
|
hasher.init();
|
|
return uintArr;
|
|
}
|
|
return new Uint8Array(buf.buffer, buf.byteOffset, buf.length);
|
|
}
|
|
function calculateHmac(hasher, key) {
|
|
hasher.init();
|
|
const { blockSize } = hasher;
|
|
const keyBuf = calculateKeyBuffer(hasher, key);
|
|
const keyBuffer = new Uint8Array(blockSize);
|
|
keyBuffer.set(keyBuf);
|
|
const opad = new Uint8Array(blockSize);
|
|
for (let i = 0; i < blockSize; i++) {
|
|
const v = keyBuffer[i];
|
|
opad[i] = v ^ 92;
|
|
keyBuffer[i] = v ^ 54;
|
|
}
|
|
hasher.update(keyBuffer);
|
|
const obj = {
|
|
init: () => {
|
|
hasher.init();
|
|
hasher.update(keyBuffer);
|
|
return obj;
|
|
},
|
|
update: (data) => {
|
|
hasher.update(data);
|
|
return obj;
|
|
},
|
|
digest: ((outputType) => {
|
|
const uintArr = hasher.digest("binary");
|
|
hasher.init();
|
|
hasher.update(opad);
|
|
hasher.update(uintArr);
|
|
return hasher.digest(outputType);
|
|
}),
|
|
save: () => {
|
|
throw new Error("save() not supported");
|
|
},
|
|
load: () => {
|
|
throw new Error("load() not supported");
|
|
},
|
|
blockSize: hasher.blockSize,
|
|
digestSize: hasher.digestSize
|
|
};
|
|
return obj;
|
|
}
|
|
function createHMAC(hash, key) {
|
|
if (!hash || !hash.then) {
|
|
throw new Error('Invalid hash function is provided! Usage: createHMAC(createMD5(), "key").');
|
|
}
|
|
return hash.then((hasher) => calculateHmac(hasher, key));
|
|
}
|
|
function calculatePBKDF2(digest, salt, iterations, hashLength, outputType) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const DK = new Uint8Array(hashLength);
|
|
const block1 = new Uint8Array(salt.length + 4);
|
|
const block1View = new DataView(block1.buffer);
|
|
const saltBuffer = getUInt8Buffer(salt);
|
|
const saltUIntBuffer = new Uint8Array(saltBuffer.buffer, saltBuffer.byteOffset, saltBuffer.length);
|
|
block1.set(saltUIntBuffer);
|
|
let destPos = 0;
|
|
const hLen = digest.digestSize;
|
|
const l = Math.ceil(hashLength / hLen);
|
|
let T = null;
|
|
let U = null;
|
|
for (let i = 1; i <= l; i++) {
|
|
block1View.setUint32(salt.length, i);
|
|
digest.init();
|
|
digest.update(block1);
|
|
T = digest.digest("binary");
|
|
U = T.slice();
|
|
for (let j = 1; j < iterations; j++) {
|
|
digest.init();
|
|
digest.update(U);
|
|
U = digest.digest("binary");
|
|
for (let k = 0; k < hLen; k++) {
|
|
T[k] ^= U[k];
|
|
}
|
|
}
|
|
DK.set(T.subarray(0, hashLength - destPos), destPos);
|
|
destPos += hLen;
|
|
}
|
|
if (outputType === "binary") {
|
|
return DK;
|
|
}
|
|
const digestChars = new Uint8Array(hashLength * 2);
|
|
return getDigestHex(digestChars, DK, hashLength);
|
|
});
|
|
}
|
|
const validateOptions$2 = (options) => {
|
|
if (!options || typeof options !== "object") {
|
|
throw new Error("Invalid options parameter. It requires an object.");
|
|
}
|
|
if (!options.hashFunction || !options.hashFunction.then) {
|
|
throw new Error('Invalid hash function is provided! Usage: pbkdf2("password", "salt", 1000, 32, createSHA1()).');
|
|
}
|
|
if (!Number.isInteger(options.iterations) || options.iterations < 1) {
|
|
throw new Error("Iterations should be a positive number");
|
|
}
|
|
if (!Number.isInteger(options.hashLength) || options.hashLength < 1) {
|
|
throw new Error("Hash length should be a positive number");
|
|
}
|
|
if (options.outputType === void 0) {
|
|
options.outputType = "hex";
|
|
}
|
|
if (!["hex", "binary"].includes(options.outputType)) {
|
|
throw new Error(`Insupported output type ${options.outputType}. Valid values: ['hex', 'binary']`);
|
|
}
|
|
};
|
|
function pbkdf2(options) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
validateOptions$2(options);
|
|
const hmac = yield createHMAC(options.hashFunction, options.password);
|
|
return calculatePBKDF2(hmac, options.salt, options.iterations, options.hashLength, options.outputType);
|
|
});
|
|
}
|
|
var name$3 = "scrypt";
|
|
var data$3 = "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";
|
|
var hash$3 = "b32721f8";
|
|
var wasmJson$3 = {
|
|
name: name$3,
|
|
data: data$3,
|
|
hash: hash$3
|
|
};
|
|
function scryptInternal(options) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const { costFactor, blockSize, parallelism, hashLength } = options;
|
|
const SHA256Hasher = createSHA256();
|
|
const blockData = yield pbkdf2({
|
|
password: options.password,
|
|
salt: options.salt,
|
|
iterations: 1,
|
|
hashLength: 128 * blockSize * parallelism,
|
|
hashFunction: SHA256Hasher,
|
|
outputType: "binary"
|
|
});
|
|
const scryptInterface = yield WASMInterface(wasmJson$3, 0);
|
|
const VSize = 128 * blockSize * costFactor;
|
|
const XYSize = 256 * blockSize;
|
|
scryptInterface.setMemorySize(blockData.length + VSize + XYSize);
|
|
scryptInterface.writeMemory(blockData, 0);
|
|
scryptInterface.getExports().scrypt(blockSize, costFactor, parallelism);
|
|
const expensiveSalt = scryptInterface.getMemory().subarray(0, 128 * blockSize * parallelism);
|
|
const outputData = yield pbkdf2({
|
|
password: options.password,
|
|
salt: expensiveSalt,
|
|
iterations: 1,
|
|
hashLength,
|
|
hashFunction: SHA256Hasher,
|
|
outputType: "binary"
|
|
});
|
|
if (options.outputType === "hex") {
|
|
const digestChars = new Uint8Array(hashLength * 2);
|
|
return getDigestHex(digestChars, outputData, hashLength);
|
|
}
|
|
return outputData;
|
|
});
|
|
}
|
|
const isPowerOfTwo = (v) => v && !(v & v - 1);
|
|
const validateOptions$1 = (options) => {
|
|
if (!options || typeof options !== "object") {
|
|
throw new Error("Invalid options parameter. It requires an object.");
|
|
}
|
|
if (!Number.isInteger(options.blockSize) || options.blockSize < 1) {
|
|
throw new Error("Block size should be a positive number");
|
|
}
|
|
if (!Number.isInteger(options.costFactor) || options.costFactor < 2 || !isPowerOfTwo(options.costFactor)) {
|
|
throw new Error("Cost factor should be a power of 2, greater than 1");
|
|
}
|
|
if (!Number.isInteger(options.parallelism) || options.parallelism < 1) {
|
|
throw new Error("Parallelism should be a positive number");
|
|
}
|
|
if (!Number.isInteger(options.hashLength) || options.hashLength < 1) {
|
|
throw new Error("Hash length should be a positive number.");
|
|
}
|
|
if (options.outputType === void 0) {
|
|
options.outputType = "hex";
|
|
}
|
|
if (!["hex", "binary"].includes(options.outputType)) {
|
|
throw new Error(`Insupported output type ${options.outputType}. Valid values: ['hex', 'binary']`);
|
|
}
|
|
};
|
|
function scrypt(options) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
validateOptions$1(options);
|
|
return scryptInternal(options);
|
|
});
|
|
}
|
|
new Mutex();
|
|
new Mutex();
|
|
async function deriveKey(parameters, salt, password) {
|
|
const { cost, keyLength = 32, memoryCost = 8, parallelism = 1 } = parameters;
|
|
return {
|
|
parameters: {
|
|
memoryCost,
|
|
parallelism
|
|
},
|
|
derivedKey: await scrypt({
|
|
password,
|
|
salt,
|
|
blockSize: memoryCost,
|
|
costFactor: cost,
|
|
hashLength: keyLength,
|
|
parallelism,
|
|
outputType: "binary"
|
|
})
|
|
};
|
|
}
|
|
handler({
|
|
deriveKey
|
|
});
|
|
})();
|