mirror of
https://github.com/TecharoHQ/anubis.git
synced 2025-08-03 09:48:08 -04:00
5e8ebaeb5d
Possible fix for #877 In some cases, the parallel solution finder in Anubis could cause all of the worker promises to leak due to the fact the promises were being improperly terminated. A recursion bomb happens in the following scenario: 1. A worker sends a message indicating it found a solution to the proof of work challenge. 2. The `onmessage` handler for that worker calls `terminate()` 3. Inside `terminate()`, the parent process loops through all other workers and calls `w.terminate()` on them. 4. It's possible that terminating a worker could lead to the `onerror` event handler. 5. This would create a recursive loop of `onmessage` -> `terminate` -> `onerror` -> `terminate` -> `onerror` and so on. This infinite recursion quickly consumes all available stack space, but this has never been noticed in development because all of my computers have at least 64Gi of ram provisioned to them under the axiom paying for more ram is cheaper than paying in my time spent having to work around not having enough ram. Additionally, ia32 has a smaller base stack size, which means that they will run into this issue much sooner than users on other CPU architectures will. The fix adds a boolean `settled` flag to prevent termination from running more than once. Signed-off-by: Xe Iaso <me@xeiaso.net>
100 lines
2.2 KiB
JavaScript
100 lines
2.2 KiB
JavaScript
// https://dev.to/ratmd/simple-proof-of-work-in-javascript-3kgm
|
|
|
|
export default function process(
|
|
data,
|
|
difficulty = 5,
|
|
signal = null,
|
|
progressCallback = null,
|
|
_threads = 1,
|
|
) {
|
|
console.debug("slow algo");
|
|
return new Promise((resolve, reject) => {
|
|
let webWorkerURL = URL.createObjectURL(
|
|
new Blob(["(", processTask(), ")()"], { type: "application/javascript" }),
|
|
);
|
|
|
|
let worker = new Worker(webWorkerURL);
|
|
let settled = false;
|
|
|
|
const cleanup = () => {
|
|
if (settled) return;
|
|
settled = true;
|
|
worker.terminate();
|
|
if (signal != null) {
|
|
signal.removeEventListener("abort", onAbort);
|
|
}
|
|
URL.revokeObjectURL(webWorkerURL);
|
|
};
|
|
|
|
const onAbort = () => {
|
|
console.log("PoW aborted");
|
|
cleanup();
|
|
reject(new DOMException("Aborted", "AbortError"));
|
|
};
|
|
|
|
if (signal != null) {
|
|
if (signal.aborted) {
|
|
return onAbort();
|
|
}
|
|
signal.addEventListener("abort", onAbort, { once: true });
|
|
}
|
|
|
|
worker.onmessage = (event) => {
|
|
if (typeof event.data === "number") {
|
|
progressCallback?.(event.data);
|
|
} else {
|
|
cleanup();
|
|
resolve(event.data);
|
|
}
|
|
};
|
|
|
|
worker.onerror = (event) => {
|
|
cleanup();
|
|
reject(event);
|
|
};
|
|
|
|
worker.postMessage({
|
|
data,
|
|
difficulty,
|
|
});
|
|
});
|
|
}
|
|
|
|
function processTask() {
|
|
return function () {
|
|
const sha256 = (text) => {
|
|
const encoded = new TextEncoder().encode(text);
|
|
return crypto.subtle.digest("SHA-256", encoded.buffer).then((result) =>
|
|
Array.from(new Uint8Array(result))
|
|
.map((c) => c.toString(16).padStart(2, "0"))
|
|
.join(""),
|
|
);
|
|
};
|
|
|
|
addEventListener("message", async (event) => {
|
|
let data = event.data.data;
|
|
let difficulty = event.data.difficulty;
|
|
|
|
let hash;
|
|
let nonce = 0;
|
|
do {
|
|
if ((nonce & 1023) === 0) {
|
|
postMessage(nonce);
|
|
}
|
|
hash = await sha256(data + nonce++);
|
|
} while (
|
|
hash.substring(0, difficulty) !== Array(difficulty + 1).join("0")
|
|
);
|
|
|
|
nonce -= 1; // last nonce was post-incremented
|
|
|
|
postMessage({
|
|
hash,
|
|
data,
|
|
difficulty,
|
|
nonce,
|
|
});
|
|
});
|
|
}.toString();
|
|
}
|