Use a WebAssembly solverv0.1.10

3 files changed, 337 insertions, 0 deletions

diff --git a/static/solver.c b/static/solver.c
new file mode 100644
index 0000000..d76d020
--- /dev/null
+++ b/static/solver.c
@@ -0,0 +1,182 @@
+// This is a reference implementation of the proof of work solver in C.
+// For security reasons, it is recommended that you read and understand the
+// entire program first if you actually want to run it.
+//
+// You need to have OpenSSL, and link with -lcrypto
+
+#include <openssl/evp.h>
+#include <openssl/bio.h>
+#include <openssl/buffer.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+
+bool validate_bit_zeros(const unsigned char *bs, unsigned long n)
+{
+	unsigned long q = n / CHAR_BIT;
+	unsigned char r = n % CHAR_BIT;
+
+	for (unsigned long i = 0; i < q; i++) {
+		if (bs[i] != 0)
+			return false;
+	}
+
+	if (r > 0) {
+		unsigned char mask =
+		    (unsigned char)(UCHAR_MAX << (CHAR_BIT - r));
+		if (bs[q] & mask)
+			return false;
+	}
+
+	return true;
+}
+
+int main(int argc, char **argv)
+{
+	if (argc < 3) {
+		fprintf(stderr, "usage: %s <base64_data> <difficulty>\n",
+			argv[0]);
+		return 1;
+	}
+
+	size_t base64_data_len = strlen(argv[1]);
+	unsigned char *base64_data = malloc(base64_data_len);
+	if (!base64_data) {
+		perror("malloc");
+		return 1;
+	}
+	memcpy(base64_data, argv[1], base64_data_len);
+
+	char *endptr = NULL;
+	errno = 0;
+	unsigned long difficulty = strtoul(argv[2], &endptr, 10);
+	if ((difficulty == ULONG_MAX && errno == ERANGE) || *endptr != '\0'
+	    || difficulty > 256) {
+		fprintf(stderr, "invalid difficulty value\n");
+		free(base64_data);
+		return 1;
+	}
+
+	BIO *b64 = BIO_new(BIO_f_base64());
+	BIO *bmem = BIO_new_mem_buf(base64_data, (int)base64_data_len);
+	if (!b64 || !bmem) {
+		fprintf(stderr, "BIO_new/BIO_new_mem_buf\n");
+		free(base64_data);
+		return 1;
+	}
+
+	BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
+	b64 = BIO_push(b64, bmem);
+
+	size_t decoded_cap = base64_data_len;
+	unsigned char *decoded = malloc(decoded_cap);
+	if (!decoded) {
+		perror("malloc");
+		BIO_free_all(b64);
+		free(base64_data);
+		return 1;
+	}
+
+	int decoded_len = BIO_read(b64, decoded, (int)decoded_cap);
+	if (decoded_len < 0) {
+		fprintf(stderr, "BIO_read\n");
+		BIO_free_all(b64);
+		free(base64_data);
+		free(decoded);
+		return 1;
+	}
+	BIO_free_all(b64);
+	free(base64_data);
+
+	EVP_MD_CTX *mdctx = EVP_MD_CTX_new();
+	if (!mdctx) {
+		fprintf(stderr, "EVP_MD_CTX_new\n");
+		free(decoded);
+		return 1;
+	}
+
+	size_t len = EVP_MD_size(EVP_sha256());
+	unsigned char digest[len];
+	size_t next = 0;
+
+	while (1) {
+		if (EVP_DigestInit_ex(mdctx, EVP_sha256(), NULL) != 1) {
+			fprintf(stderr, "EVP_DigestInit_ex\n");
+			EVP_MD_CTX_free(mdctx);
+			free(decoded);
+			return 1;
+		}
+		if (EVP_DigestUpdate(mdctx, decoded, decoded_len) != 1) {
+			fprintf(stderr, "EVP_DigestUpdate(data)\n");
+			EVP_MD_CTX_free(mdctx);
+			free(decoded);
+			return 1;
+		}
+		if (EVP_DigestUpdate(mdctx, &next, sizeof(next)) != 1) {
+			fprintf(stderr, "EVP_DigestUpdate(next)\n");
+			EVP_MD_CTX_free(mdctx);
+			free(decoded);
+			return 1;
+		}
+		if (EVP_DigestFinal_ex(mdctx, digest, NULL) != 1) {
+			fprintf(stderr, "EVP_DigestFinal_ex\n");
+			EVP_MD_CTX_free(mdctx);
+			free(decoded);
+			return 1;
+		}
+		if (validate_bit_zeros(digest, difficulty)) {
+			break;
+		}
+		next++;
+		if (!next) {
+			fprintf(stderr, "unsigned integer overflow\n");
+			EVP_MD_CTX_free(mdctx);
+			free(decoded);
+			return 1;
+		}
+	}
+	EVP_MD_CTX_free(mdctx);
+	free(decoded);
+
+	BIO *b64_out = BIO_new(BIO_f_base64());
+	BIO *bmem_out = BIO_new(BIO_s_mem());
+	if (!b64_out || !bmem_out) {
+		fprintf(stderr, "BIO_new\n");
+		if (b64_out)
+			BIO_free_all(b64_out);
+		if (bmem_out)
+			BIO_free(bmem_out);
+		return 1;
+	}
+	BIO_set_flags(b64_out, BIO_FLAGS_BASE64_NO_NL);
+	b64_out = BIO_push(b64_out, bmem_out);
+
+	if (BIO_write(b64_out, &next, sizeof(next)) < 0) {
+		fprintf(stderr, "BIO_write\n");
+		BIO_free_all(b64_out);
+		return 1;
+	}
+	if (BIO_flush(b64_out) < 1) {
+		fprintf(stderr, "BIO_flush\n");
+		BIO_free_all(b64_out);
+		return 1;
+	}
+
+	BUF_MEM *bptr = NULL;
+	BIO_get_mem_ptr(b64_out, &bptr);
+	if (!bptr || !bptr->data) {
+		fprintf(stderr, "BIO_get_mem_ptr\n");
+		BIO_free_all(b64_out);
+		return 1;
+	}
+
+	write(STDOUT_FILENO, bptr->data, bptr->length);
+	write(STDOUT_FILENO, "\n", 1);
+
+	BIO_free_all(b64_out);
+	return 0;
+}
diff --git a/static/solver.js b/static/solver.js
new file mode 100644
index 0000000..a3f8366
--- /dev/null
+++ b/static/solver.js
@@ -0,0 +1,34 @@
+let wasm_instance = null;
+let wasm_exports = null;
+
+async function load_wasm() {
+	let response = await fetch("/.powxy/wasm/solver.wasm");
+	let { instance } = await WebAssembly.instantiateStreaming(response, {
+		env: {
+			memory: new WebAssembly.Memory({ initial: 1 })
+		}
+	});
+	wasm_instance = instance;
+	wasm_exports = instance.exports;
+}
+
+onmessage = async function(e) {
+	let { identifier_bytes, difficulty } = e.data;
+
+	if (!wasm_instance) {
+		await load_wasm();
+	}
+
+	let ptr = wasm_exports.get_challenge_ptr();
+	let memory = new Uint8Array(wasm_instance.exports.memory.buffer, ptr, 32);
+	memory.set(identifier_bytes);
+
+	let nonce = wasm_exports.solve(difficulty);
+
+	let buf = new ArrayBuffer(8);
+	let view = new DataView(buf);
+	view.setBigUint64(0, BigInt(nonce), true);
+	let nonce_bytes = new Uint8Array(buf);
+
+	postMessage({ nonce, nonce_bytes });
+};
diff --git a/static/style.css b/static/style.css
new file mode 100644
index 0000000..6ca536b
--- /dev/null
+++ b/static/style.css
@@ -0,0 +1,121 @@
+html {
+	font-family: sans-serif;
+	background-color: var(--background-color);
+	color: var(--text-color);
+	--radius-1: 0.32rem;
+	--background-color: hsl(0, 0%, 100%);
+	--text-color: hsl(0, 0%, 0%);
+	--link-color: hsl(320, 50%, 36%);
+	--light-text-color: hsl(0, 0%, 45%);
+	--darker-border-color: hsl(0, 0%, 72%);
+	--lighter-border-color: hsl(0, 0%, 85%);
+	--text-decoration-color: hsl(0, 0%, 72%);
+	--darker-box-background-color: hsl(0, 0%, 92%);
+	--lighter-box-background-color: hsl(0, 0%, 95%);
+	--primary-color: hsl(320, 50%, 36%);
+	--primary-color-contrast: hsl(320, 0%, 100%);
+	--danger-color: #ff0000;
+	--danger-color-contrast: #ffffff;
+}
+
+@media (prefers-color-scheme: dark) {
+	html {
+		--background-color: hsl(0, 0%, 0%);
+		--text-color: hsl(0, 0%, 100%);
+		--link-color: hsl(320, 50%, 76%);
+		--light-text-color: hsl(0, 0%, 78%);
+		--darker-border-color: hsl(0, 0%, 35%);
+		--lighter-border-color: hsl(0, 0%, 25%);
+		--text-decoration-color: hsl(0, 0%, 30%);
+		--darker-box-background-color: hsl(0, 0%, 20%);
+		--lighter-box-background-color: hsl(0, 0%, 15%);
+	}
+}
+
+body {
+	margin: 0;
+	padding: 1rem;
+}
+
+main {
+	max-width: 720px;
+	margin: 0 auto;
+}
+
+*:focus-visible {
+	outline: 1.5px var(--primary-color) solid;
+}
+
+section {
+	margin: 0;
+}
+
+label {
+	display: block;
+	font-style: italic;
+	margin-top: 1rem;
+	margin-bottom: 0.5rem;
+}
+
+h1 {
+	margin-top: 0;
+}
+
+p, summary {
+	line-height: 1.2;
+	font-size: 1rem;
+}
+
+a {
+	color: var(--link-color);
+	text-decoration-color: var(--text-decoration-color);
+}
+
+input[type="text"] {
+	font-family: monospace;
+	font-size: 1rem;
+	background-color: var(--lighter-box-background-color);
+	color: var(--text-color);
+	width: 100%;
+	padding: 0.5rem;
+	border-radius: var(--radius-1);
+	border: none;
+	box-shadow: inset 0 1px 4px rgba(0, 0, 0, 0.15);
+	margin-bottom: 1rem;
+	box-sizing: border-box;
+}
+
+input[type="submit"] {
+	padding: 0.5rem 1rem;
+	background-color: var(--primary-color);
+	color: var(--primary-color-contrast);
+	border: none;
+	border-radius: var(--radius-1);
+	cursor: pointer;
+}
+
+input[readonly] {
+	background-color: var(--lighter-box-background-color);
+	color: var(--text-color);
+	cursor: text;
+}
+
+details {
+	margin-top: 2rem;
+	background-color: var(--lighter-box-background-color);
+	padding: 0.5rem;
+	border-radius: var(--radius-1);
+	box-shadow: inset 0 1px 4px rgba(0, 0, 0, 0.15);
+}
+
+pre {
+	overflow-x: auto;
+	display: block;
+	white-space: pre-wrap;
+	word-break: break-word;
+}
+
+#solver_status {
+	color: var(--light-text-color);
+	margin-top: 1rem;
+}