diff --git a/Dockerfile b/Dockerfile index d5ad1cd..1ee0f7a 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,5 +1,5 @@ -FROM golang:1.16-alpine as build +FROM golang:1.22-alpine as build ARG GOARCH= ARG GO_BUILD_ARGS= diff --git a/README.md b/README.md index 24b43e5..7c8f9de 100644 --- a/README.md +++ b/README.md @@ -187,13 +187,20 @@ Revokes an existing API token. In order to set up 💥PoW! Bot Deterrent on your page, you just need to load/include `pow-bot-deterrent.js` and one or more html elements with all 3 of the following properties: -#### `data-pow-bot-deterrent-url` +#### `data-pow-bot-deterrent-static-assets-cross-origin-url` -This is the base url from which `pow-bot-deterrent.js` will attempt to load additional resources `pow-bot-deterrent.css` and `proofOfWorker.js`. +*OPTIONAL* This is the base url from which `pow-bot-deterrent.js` will attempt to load additional resources `pow-bot-deterrent.css` and `proofOfWorker_CrossOrigin.js`. -> 💬 *INFO* In our examples, we passed the Bot Deterrent server URL down to the HTML page and used it as the value for this property. -However, that's not required. The HTML page doesn't need to talk to the Bot Deterrent server at all, it just needs to know where it can -download the `pow-bot-deterrent.css` and `proofOfWorker.js` files. There is nothing stopping you from simply hosting those files on your own server or CDN and placing the corresponding URL into the `data-pow-bot-deterrent-url` property. +Example value: `https://bot-deterrent.example.com/static/` + +> 💬 *INFO* The HTML page doesn't need to talk to the Bot Deterrent server at all, it just needs to know where it can +download the `pow-bot-deterrent.css` and `proofOfWorker_CrossOrigin.js` files. Doing this cross-origin is simpler and easier, but it can cause issues with website's [Content Security Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/CSP). So if you care about that, try using `data-pow-bot-deterrent-static-assets-path` instead. + +#### `data-pow-bot-deterrent-static-assets-path` + +A path (on the same origin as your site) where the `pow-bot-deterrent.css`, `proofOfWorker.js`, and `scrypt.wasm` files can be found. + +*OPTIONAL*, default value is `/pow-bot-deterrent-static/` #### `data-pow-bot-deterrent-challenge` @@ -470,7 +477,7 @@ There are two main important parts, the form and the javascript at the bottom:
@@ -484,7 +491,7 @@ There are two main important parts, the form and the javascript at the bottom: document.querySelector("form input[type='submit']").disabled = false; }; - + ``` ⚠️ **NOTE** that the element with the `pow-bot-deterrent` data properties is placed **inside a form element**. This is required because the bot deterrent needs to know which input elements it should trigger on. We only want it to trigger when the user actually intends to submit the form; otherwise we are wasting a lot of their CPU cycles for no reason! @@ -492,7 +499,7 @@ There are two main important parts, the form and the javascript at the bottom: > 💬 *INFO* The double curly brace elements like `{{ .Challenge }}` are Golang string template interpolations. They are specific to the example app & how it renders the page. When the page loads, the `pow-bot-deterrent.js` script will execute, querying the page for all elements with the `data-pow-bot-deterrent-challenge` -property. It will then validate each element to make sure it also has the `data-pow-bot-deterrent-url` and `data-pow-bot-deterrent-callback` properties. For each element it found, it will locate the `
` parent/grandparent enclosing the element. If none are found, it will throw an error. Otherwise, it will set up an event listener on every input element inside that form, so that as soon as the user starts filling out the form, the bot deterrent display will pop up and the Proof of Work will begin. +property. It will then validate each element to make sure it also has the `data-pow-bot-deterrent-static-assets-cross-origin-url` and `data-pow-bot-deterrent-callback` properties. For each element it found, it will locate the `` parent/grandparent enclosing the element. If none are found, it will throw an error. Otherwise, it will set up an event listener on every input element inside that form, so that as soon as the user starts filling out the form, the bot deterrent display will pop up and the Proof of Work will begin. When the Proof of Work finishes, `pow-bot-deterrent.js` will call the function specified by `data-pow-bot-deterrent-callback`, passing the winning nonce as the first argument, or throw an error if that function is not defined. diff --git a/example/index.html b/example/index.html index 57f257d..366b489 100644 --- a/example/index.html +++ b/example/index.html @@ -33,7 +33,7 @@
@@ -47,6 +47,6 @@ document.querySelector("form input[type='submit']").disabled = false; }; - + \ No newline at end of file diff --git a/example/main.go b/example/main.go index 8e59d96..9f9eab3 100644 --- a/example/main.go +++ b/example/main.go @@ -140,13 +140,13 @@ func renderPageTemplate(challenge string) ([]byte, error) { // constructing an instance of an anonymous struct type to contain all the data // that we need to pass to the template pageData := struct { - Challenge string - Items []string - PowAPIURL string + Challenge string + Items []string + CrossOriginStaticAssetsUrl string }{ - Challenge: challenge, - Items: items, - PowAPIURL: powAPIURL.String(), + Challenge: challenge, + Items: items, + CrossOriginStaticAssetsUrl: fmt.Sprintf("%s/pow-bot-deterrent-static", powAPIURL.String()), } var outputBuffer bytes.Buffer err = pageTemplate.Execute(&outputBuffer, pageData) diff --git a/go.mod b/go.mod index 7496cdf..fede427 100644 --- a/go.mod +++ b/go.mod @@ -3,6 +3,7 @@ module git.sequentialread.com/forest/pow-bot-deterrent go 1.16 require ( + git.sequentialread.com/forest/config-lite v0.0.0-20220225195944-164dc71bce04 // indirect git.sequentialread.com/forest/pkg-errors v0.9.2 // indirect golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 // indirect ) diff --git a/go.sum b/go.sum index 5e70547..0ddd251 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,9 @@ +git.sequentialread.com/forest/config-lite v0.0.0-20220225195944-164dc71bce04 h1:FmvQmRJzAgbCc/4qfECAluzd+oVBzXNJMjyLQTJ4Wq0= +git.sequentialread.com/forest/config-lite v0.0.0-20220225195944-164dc71bce04/go.mod h1:jaNfZ5BXx8OsKVZ6FuN0Lr/gIeEwbTNNHSO4RpFz6qo= git.sequentialread.com/forest/pkg-errors v0.9.2 h1:j6pwbL6E+TmE7TD0tqRtGwuoCbCfO6ZR26Nv5nest9g= git.sequentialread.com/forest/pkg-errors v0.9.2/go.mod h1:8TkJ/f8xLWFIAid20aoqgDZcCj9QQt+FU+rk415XO1w= +github.com/texttheater/golang-levenshtein/levenshtein v0.0.0-20200805054039-cae8b0eaed6c h1:HelZ2kAFadG0La9d+4htN4HzQ68Bm2iM9qKMSMES6xg= +github.com/texttheater/golang-levenshtein/levenshtein v0.0.0-20200805054039-cae8b0eaed6c/go.mod h1:JlzghshsemAMDGZLytTFY8C1JQxQPhnatWqNwUXjggo= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g= golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= diff --git a/static/pow-bot-deterrent.js b/static/pow-bot-deterrent.js index db5144d..4925c1b 100644 --- a/static/pow-bot-deterrent.js +++ b/static/pow-bot-deterrent.js @@ -17,12 +17,14 @@ const challenges = Array.from(document.querySelectorAll("[data-pow-bot-deterrent-challenge]")); const challengesMap = {}; + let staticAssetsCrossOriginURL = ""; let staticAssetsPath = trimSlashes("/pow-bot-deterrent-static/") let proofOfWorker = { postMessage: () => console.error("error: proofOfWorker was never loaded. ") }; challenges.forEach(element => { - - if(element.dataset.powBotDeterrentStaticAssetsPath) { + if(element.dataset.powBotDeterrentStaticAssetsCrossOriginUrl) { + staticAssetsCrossOriginURL = trimSlashes(element.dataset.powBotDeterrentStaticAssetsCrossOriginUrl); + } else if(element.dataset.powBotDeterrentStaticAssetsPath) { staticAssetsPath = trimSlashes(element.dataset.powBotDeterrentStaticAssetsPath); } @@ -58,7 +60,13 @@ //todo } - let cssIsAlreadyLoaded = document.querySelector(`link[href='/${staticAssetsPath}/pow-bot-deterrent.css']`); + + let cssIsAlreadyLoaded; + if(staticAssetsCrossOriginURL) { + cssIsAlreadyLoaded = document.querySelector(`link[href='/${staticAssetsPath}/pow-bot-deterrent.css']`); + } else { + cssIsAlreadyLoaded = document.querySelector(`link[href='${staticAssetsCrossOriginURL}/pow-bot-deterrent.css']`); + } cssIsAlreadyLoaded = cssIsAlreadyLoaded || Array.from(document.styleSheets).some(x => { try { @@ -74,7 +82,7 @@ "charset": "utf8", }); stylesheet.onload = () => renderProgressInfo(element); - stylesheet.setAttribute("href", `${staticAssetsPath}/pow-bot-deterrent.css`); + stylesheet.setAttribute("href", `${staticAssetsCrossOriginURL || staticAssetsPath}/pow-bot-deterrent.css`); } else { renderProgressInfo(element); } @@ -133,10 +141,28 @@ console.error("error: webworker is not support"); //todo } - + + let webWorkerPointerDataURL = null; + if(staticAssetsCrossOriginURL != "") { + // https://stackoverflow.com/questions/21913673/execute-web-worker-from-different-origin/62914052#62914052 + const webWorkerCrossOriginURL = `${staticAssetsCrossOriginURL}/proofOfWorker_CrossOrigin.js`; + + webWorkerPointerDataURL = URL.createObjectURL( + new Blob( + [ `importScripts( "${ webWorkerCrossOriginURL }" );` ], + { type: "text/javascript" } + ) + ); + } + let webWorkers; webWorkers = [...Array(numberOfWebWorkersToCreate)].map((_, i) => { - const webWorker = new Worker(`/${staticAssetsPath}/proofOfWorker.js?v=2`); + let webWorker; + if(staticAssetsCrossOriginURL != "") { + webWorker = new Worker(webWorkerPointerDataURL); + } else { + webWorker = new Worker(`/${staticAssetsPath}/proofOfWorker.js?v=2`); + } webWorker.onmessage = function(e) { const challengeState = challengesMap[e.data.challenge] if(!challengeState) { diff --git a/static/proofOfWorker.js b/static/proofOfWorker.js index 77db74b..43a688b 100644 --- a/static/proofOfWorker.js +++ b/static/proofOfWorker.js @@ -1,16 +1,16 @@ // THIS FILE IS GENERATED AUTOMATICALLY // Dont edit this file by hand. -// Either edit proofOfWorkerStub.js or edit the build located in the wasm_build folder. +// Either edit proofOfWorkerStub.js or edit the build script located in the wasm_build folder. let scrypt; let scryptPromise; -let wasm = undefined; +let wasm; let working = false; -const batchSize = 4; +const batchSize = 8; onmessage = function(e) { if(e.data.stop) { @@ -93,6 +93,8 @@ onmessage = function(e) { challenge.paralellization, challenge.keyLength ); + + //console.log(i.toString(16), hashHex); const endOfHash = hashHex.substring(hashHex.length-challenge.difficulty.length); if(endOfHash < smallestHash) { @@ -124,7 +126,7 @@ onmessage = function(e) { } }; - if(scrypt) { + if(wasm && scrypt) { doWork(); } else { scryptPromise.then(() => { @@ -365,11 +367,11 @@ let wasm_bindgen; return __wbg_finalize_init(instance, module); } - /pow-bot-deterrent-static/_bindgen = Object.assign(__wbg_init, { initSync }, __exports); + wasm_bindgen = Object.assign(__wbg_init, { initSync }, __exports); })(); scrypt = wasm_bindgen.scrypt; -scryptPromise = wasm_bindgen({module_or_path: "/pow-bot-deterrent-static/scrypt.wasm"}); +scryptPromise = wasm_bindgen({module_or_path: "/static/scrypt.wasm"}); diff --git a/static/proofOfWorker_CrossOrigin.js b/static/proofOfWorker_CrossOrigin.js new file mode 100644 index 0000000..4e41bff --- /dev/null +++ b/static/proofOfWorker_CrossOrigin.js @@ -0,0 +1,288 @@ + +// THIS FILE IS GENERATED AUTOMATICALLY +// Dont edit this file by hand. +// Either edit proofOfWorkerStub.js or edit the build script located in the wasm_build folder. + + + +let scrypt; +let scryptPromise; +let wasm; + +let working = false; +const batchSize = 8; + +onmessage = function(e) { + if(e.data.stop) { + working = false; + return; + } + + const challengeBase64 = e.data.challenge; + const workerId = e.data.workerId; + if(!challengeBase64) { + postMessage({ + type: "error", + challenge: challengeBase64, + message: `challenge was not provided` + }); + } + working = true; + let challengeJSON = null; + let challenge = null; + try { + challengeJSON = atob(challengeBase64); + } catch (err) { + postMessage({ + type: "error", + challenge: challengeBase64, + message: `couldn't decode challenge '${challengeBase64}' as base64: ${err}` + }); + } + try { + challenge = JSON.parse(challengeJSON); + } catch (err) { + postMessage({ + type: "error", + challenge: challengeBase64, + message: `couldn't parse challenge '${challengeJSON}' as json: ${err}` + }); + } + + challenge = { + cpuAndMemoryCost: challenge.N, + blockSize: challenge.r, + paralellization: challenge.p, + keyLength: challenge.klen, + preimage: challenge.i, + difficulty: challenge.d, + difficultyLevel: challenge.dl + } + + const probabilityOfFailurePerAttempt = 1-(1/Math.pow(2, challenge.difficultyLevel)); + + let i = workerId * Math.pow(2, challenge.difficultyLevel) * 1000; + const hexPreimage = base64ToHex(challenge.preimage); + let smallestHash = challenge.difficulty.split("").map(x => "f").join(""); + + postMessage({ + type: "progress", + challenge: challengeBase64, + attempts: 0, + smallestHash: smallestHash, + difficulty: challenge.difficulty, + probabilityOfFailurePerAttempt: probabilityOfFailurePerAttempt + }); + + const doWork = () => { + + var j = 0; + while(j < batchSize) { + j++; + i++; + + let nonceHex = i.toString(16); + if((nonceHex.length % 2) == 1) { + nonceHex = `0${nonceHex}`; + } + const hashHex = scrypt( + nonceHex, + hexPreimage, + challenge.cpuAndMemoryCost, + challenge.blockSize, + challenge.paralellization, + challenge.keyLength + ); + + //console.log(i.toString(16), hashHex); + + const endOfHash = hashHex.substring(hashHex.length-challenge.difficulty.length); + if(endOfHash < smallestHash) { + smallestHash = endOfHash + } + if(endOfHash <= challenge.difficulty) { + postMessage({ + type: "success", + challenge: challengeBase64, + nonce: nonceHex, + smallestHash: endOfHash, + difficulty: challenge.difficulty + }); + break + } + } + + postMessage({ + type: "progress", + challenge: challengeBase64, + attempts: batchSize, + smallestHash: smallestHash, + difficulty: challenge.difficulty, + probabilityOfFailurePerAttempt: probabilityOfFailurePerAttempt + }); + + if(working) { + this.setTimeout(doWork, 1); + } + }; + + if(wasm && scrypt) { + doWork(); + } else { + scryptPromise.then(() => { + doWork(); + }); + } +} + +// https://stackoverflow.com/questions/39460182/decode-base64-to-hexadecimal-string-with-javascript +function base64ToHex(str) { + const raw = atob(str); + let result = ''; + for (let i = 0; i < raw.length; i++) { + const hex = raw.charCodeAt(i).toString(16); + result += (hex.length === 2 ? hex : '0' + hex); + } + return result; +} + + +// https://caniuse.com/mdn-javascript_builtins_uint8array_frombase64 its at 60% in oct 2025 +if (!Uint8Array.fromBase64) { + Uint8Array.fromBase64 = function(base64String) { + const binaryString = atob(base64String); + const toReturn = new Uint8Array(binaryString.length); + for (let i = 0; i < binaryString.length; i++) { + toReturn[i] = binaryString.charCodeAt(i); + } + return toReturn; + }; +} + +const base64WASM = "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"; + +const wasmBinary = Uint8Array.fromBase64(base64WASM); + +scryptPromise = WebAssembly.instantiate(wasmBinary, {}).then(instantiatedModule => { + wasm = instantiatedModule.instance.exports; + + + + + let WASM_VECTOR_LEN = 0; + + let cachedUint8ArrayMemory0 = null; + + function getUint8ArrayMemory0() { + if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) { + cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8ArrayMemory0; + } + + const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder; + + let cachedTextEncoder = new lTextEncoder('utf-8'); + + const encodeString = (typeof cachedTextEncoder.encodeInto === 'function' + ? function (arg, view) { + return cachedTextEncoder.encodeInto(arg, view); + } + : function (arg, view) { + const buf = cachedTextEncoder.encode(arg); + view.set(buf); + return { + read: arg.length, + written: buf.length + }; + }); + + function passStringToWasm0(arg, malloc, realloc) { + + if (realloc === undefined) { + const buf = cachedTextEncoder.encode(arg); + const ptr = malloc(buf.length, 1) >>> 0; + getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf); + WASM_VECTOR_LEN = buf.length; + return ptr; + } + + let len = arg.length; + let ptr = malloc(len, 1) >>> 0; + + const mem = getUint8ArrayMemory0(); + + let offset = 0; + + for (; offset < len; offset++) { + const code = arg.charCodeAt(offset); + if (code > 0x7F) break; + mem[ptr + offset] = code; + } + + if (offset !== len) { + if (offset !== 0) { + arg = arg.slice(offset); + } + ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; + const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len); + const ret = encodeString(arg, view); + + offset += ret.written; + ptr = realloc(ptr, len, offset, 1) >>> 0; + } + + WASM_VECTOR_LEN = offset; + return ptr; + } + + const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder; + + let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true }); + + cachedTextDecoder.decode(); + + function getStringFromWasm0(ptr, len) { + ptr = ptr >>> 0; + return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len)); + } + /** + * @param {string} password + * @param {string} salt + * @param {number} n + * @param {number} r + * @param {number} p + * @param {number} dklen + * @returns {string} + */ + scrypt = function(password, salt, n, r, p, dklen) { + let deferred3_0; + let deferred3_1; + try { + const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(salt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.scrypt(ptr0, len0, ptr1, len1, n, r, p, dklen); + deferred3_0 = ret[0]; + deferred3_1 = ret[1]; + return getStringFromWasm0(ret[0], ret[1]); + } finally { + wasm.__wbindgen_free(deferred3_0, deferred3_1, 1); + } + } + + function __wbindgen_init_externref_table() { + const table = wasm.__wbindgen_export_0; + const offset = table.grow(4); + table.set(0, undefined); + table.set(offset + 0, undefined); + table.set(offset + 1, null); + table.set(offset + 2, true); + table.set(offset + 3, false); + ; + }; + + +}); + diff --git a/wasm_build/build_wasm.sh b/wasm_build/build_wasm.sh index 274a323..ade6199 100755 --- a/wasm_build/build_wasm.sh +++ b/wasm_build/build_wasm.sh @@ -36,12 +36,12 @@ fi cd ../ -cp scrypt-wasm/pkg/scrypt_wasm_bg.wasm ../static/ +cp scrypt-wasm/pkg/scrypt_wasm_bg.wasm ../static/scrypt.wasm echo ' // THIS FILE IS GENERATED AUTOMATICALLY // Dont edit this file by hand. -// Either edit proofOfWorkerStub.js or edit the build located in the wasm_build folder. +// Either edit proofOfWorkerStub.js or edit the build script located in the wasm_build folder. ' > ../static/proofOfWorker.js cat ../proofOfWorkerStub.js | tail -n +6 >> ../static/proofOfWorker.js @@ -56,4 +56,64 @@ scryptPromise = wasm_bindgen({module_or_path: "/static/scrypt.wasm"}); ' >> ../static/proofOfWorker.js + + + +## ----------------------------------------------------------- + + + +## The proofOfWorker_CrossOrigin.js version embeds the WebAssembly binary into the WebWorker script, +## This is neccesary when the pow-bot-deterrent static assets can't be hosted on the same origin +## However, it also means that the site can't use a content-security-policy which restricts external javascript + +echo ' +// THIS FILE IS GENERATED AUTOMATICALLY +// Dont edit this file by hand. +// Either edit proofOfWorkerStub.js or edit the build script located in the wasm_build folder. +' > ../static/proofOfWorker_CrossOrigin.js + +cat ../proofOfWorkerStub.js | tail -n +6 >> ../static/proofOfWorker_CrossOrigin.js + +echo ' + +// https://caniuse.com/mdn-javascript_builtins_uint8array_frombase64 its at 60% in oct 2025 +if (!Uint8Array.fromBase64) { + Uint8Array.fromBase64 = function(base64String) { + const binaryString = atob(base64String); + const toReturn = new Uint8Array(binaryString.length); + for (let i = 0; i < binaryString.length; i++) { + toReturn[i] = binaryString.charCodeAt(i); + } + return toReturn; + }; +} + +const base64WASM = "'"$(cat ../static/scrypt.wasm | base64 -w 0)"'"; + +const wasmBinary = Uint8Array.fromBase64(base64WASM); + +scryptPromise = WebAssembly.instantiate(wasmBinary, {}).then(instantiatedModule => { + wasm = instantiatedModule.instance.exports; + +' >> ../static/proofOfWorker_CrossOrigin.js + +# wasm was defined at the top of proofOfWorker.js, so don't define it again. +# tail -n +5 skips the first 4 lines. +# we are trying to skip all of: +# +# let wasm; +# export function __wbg_set_wasm(val) { +# wasm = val; +# } +# +cat scrypt-wasm/pkg/scrypt_wasm_bg.js | tail -n +5 \ + | sed 's/export function scrypt/scrypt = function/' \ + | sed 's/^export //' \ + | sed -E 's/^/ /' >> ../static/proofOfWorker_CrossOrigin.js + +echo ' +}); +' >> ../static/proofOfWorker_CrossOrigin.js + echo "Build successful!" \ No newline at end of file