aboutsummaryrefslogtreecommitdiff
path: root/static
diff options
context:
space:
mode:
Diffstat (limited to 'static')
-rw-r--r--static/solver.c182
-rw-r--r--static/solver.js34
-rw-r--r--static/style.css121
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;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-05 20:44:03 +0000