@credithub/jurischain-node 1.0.2

package/binding.gyp

@@ -0,0 +1,14 @@
+{
+  "targets": [
+    {
+      "include_dirs": [
+        "<!(node -e \"require('nan')\")",
+        ".",
+        "../../include",
+      ],
+      "cflags": ["-Wstack-protector", "-Wall", "-g"],
+      "target_name": "Jurischain",
+      "sources": [ 'main.cpp' ]
+    }
+  ]
+}

package/index.d.ts

@@ -0,0 +1,10 @@
+declare class Jurischain {
+  constructor(difficulty: number, seed: string);
+  challengeResponse(response: string): boolean;
+  readChallenge(): string;
+  solveStep(): boolean;
+  verify(): boolean;
+}
+
+export { Jurischain };
+export default Jurischain;

package/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+const { Jurischain } = require('bindings')('Jurischain');
+module.exports = { Jurischain, default: Jurischain };

package/jurischain.h

@@ -0,0 +1,254 @@
+#ifndef H_JURISCHAIN
+#define H_JURISCHAIN
+
+#define JURISCHAIN_VERSION "1.1.3"
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#ifndef KECCAKF_ROUNDS
+#define KECCAKF_ROUNDS 24
+#endif
+
+#ifndef ROTL64
+#define ROTL64(x, y) (((x) << (y)) | ((x) >> (64 - (y))))
+#endif
+
+#ifndef HASH_LEN
+#define HASH_LEN 32
+#endif
+
+/*
+ * Header-only library: every function has internal linkage (static inline)
+ * so the header can be #included in multiple translation units without
+ * causing duplicate-symbol errors at link time.
+ */
+
+/* state context */
+typedef struct {
+  union {           /* state */
+    uint8_t b[200]; /* 8-bit bytes */
+    uint64_t q[25]; /* 64-bit words */
+  } st;
+  int pt, rsiz, mdlen; /* these don't overflow */
+} sha3_ctx_t;
+
+typedef struct {
+  uint8_t payload[HASH_LEN + 1];
+  uint8_t seed[HASH_LEN];
+} jurischain_ctx_t;
+
+/* Compression function */
+static inline void sha3_keccakf(uint64_t st[25]) {
+  /* constants */
+  const uint64_t keccakf_rndc[24] = {
+      0x0000000000000001, 0x0000000000008082, 0x800000000000808a,
+      0x8000000080008000, 0x000000000000808b, 0x0000000080000001,
+      0x8000000080008081, 0x8000000000008009, 0x000000000000008a,
+      0x0000000000000088, 0x0000000080008009, 0x000000008000000a,
+      0x000000008000808b, 0x800000000000008b, 0x8000000000008089,
+      0x8000000000008003, 0x8000000000008002, 0x8000000000000080,
+      0x000000000000800a, 0x800000008000000a, 0x8000000080008081,
+      0x8000000000008080, 0x0000000080000001, 0x8000000080008008};
+  const int keccakf_rotc[24] = {1,  3,  6,  10, 15, 21, 28, 36, 45, 55, 2,  14,
+                                27, 41, 56, 8,  25, 43, 62, 18, 39, 61, 20, 44};
+  const int keccakf_piln[24] = {10, 7,  11, 17, 18, 3, 5,  16, 8,  21, 24, 4,
+                                15, 23, 19, 13, 12, 2, 20, 14, 22, 9,  6,  1};
+
+  /* variables */
+  int i = 0, j = 0, r = 0;
+  uint64_t t = 0, bc[5] = {
+                      0,
+                  };
+
+#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
+  uint8_t *v;
+
+  /* endianess conversion. this is redundant on little-endian targets */
+  for (i = 0; i < 25; i++) {
+    v = (uint8_t *)&st[i];
+    st[i] = ((uint64_t)v[0]) | (((uint64_t)v[1]) << 8) |
+            (((uint64_t)v[2]) << 16) | (((uint64_t)v[3]) << 24) |
+            (((uint64_t)v[4]) << 32) | (((uint64_t)v[5]) << 40) |
+            (((uint64_t)v[6]) << 48) | (((uint64_t)v[7]) << 56);
+  }
+#endif
+
+  /* actual iteration */
+  for (r = 0; r < KECCAKF_ROUNDS; r++) {
+    /*  Theta */
+    for (i = 0; i < 5; i++)
+      bc[i] = st[i] ^ st[i + 5] ^ st[i + 10] ^ st[i + 15] ^ st[i + 20];
+
+    for (i = 0; i < 5; i++) {
+      t = bc[(i + 4) % 5] ^ ROTL64(bc[(i + 1) % 5], 1);
+      for (j = 0; j < 25; j += 5) st[j + i] ^= t;
+    }
+
+    /*  Rho Pi */
+    t = st[1];
+    for (i = 0; i < 24; i++) {
+      j = keccakf_piln[i];
+      bc[0] = st[j];
+      st[j] = ROTL64(t, keccakf_rotc[i]);
+      t = bc[0];
+    }
+
+    /*   Chi */
+    for (j = 0; j < 25; j += 5) {
+      for (i = 0; i < 5; i++) bc[i] = st[j + i];
+      for (i = 0; i < 5; i++) st[j + i] ^= (~bc[(i + 1) % 5]) & bc[(i + 2) % 5];
+    }
+
+    /*   Iota */
+    st[0] ^= keccakf_rndc[r];
+  }
+
+#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
+#error WebAssembly should be little endian
+  /*  endianess conversion. this is redundant on little-endian targets */
+  for (i = 0; i < 25; i++) {
+    v = (uint8_t *)&st[i];
+    t = st[i];
+    v[0] = t & 0xFF;
+    v[1] = (t >> 8) & 0xFF;
+    v[2] = (t >> 16) & 0xFF;
+    v[3] = (t >> 24) & 0xFF;
+    v[4] = (t >> 32) & 0xFF;
+    v[5] = (t >> 40) & 0xFF;
+    v[6] = (t >> 48) & 0xFF;
+    v[7] = (t >> 56) & 0xFF;
+  }
+#endif
+}
+
+/*  Initialize the context for SHA3 (mdlen = hash output in bytes) */
+static inline int sha3_init(sha3_ctx_t *c, int mdlen) {
+  int i = 0;
+
+  for (i = 0; i < 25; i++) c->st.q[i] = 0;
+  c->mdlen = mdlen;
+  c->rsiz = 200 - 2 * mdlen;
+  c->pt = 0;
+
+  return 1;
+}
+
+/*  update state with more data */
+static inline int sha3_update(sha3_ctx_t *c, const void *data, size_t len) {
+  size_t i = 0;
+  int j = 0;
+
+  j = c->pt;
+  for (i = 0; i < len; i++) {
+    c->st.b[j++] ^= ((const uint8_t *)data)[i];
+    if (j >= c->rsiz) {
+      sha3_keccakf(c->st.q);
+      j = 0;
+    }
+  }
+  c->pt = j;
+
+  return 1;
+}
+
+/*  finalize and output a hash (digest goes to md) */
+static inline int sha3_final(void *md, sha3_ctx_t *c) {
+  int i = 0;
+
+  c->st.b[c->pt] ^= 0x06;
+  c->st.b[c->rsiz - 1] ^= 0x80;
+  sha3_keccakf(c->st.q);
+
+  for (i = 0; i < c->mdlen; i++) {
+    ((uint8_t *)md)[i] = c->st.b[i];
+  }
+
+  return 1;
+}
+
+/*  compute a SHA-3 hash (md) of given byte length from "in" */
+static inline void *sha3(const void *in, size_t inlen, void *md, int mdlen) {
+  sha3_ctx_t sha3;
+
+  memset(&sha3, 0, sizeof(sha3));
+
+  sha3_init(&sha3, mdlen);
+  sha3_update(&sha3, in, inlen);
+  sha3_final(md, &sha3);
+
+  return md;
+}
+
+static inline void jurischain_gen(jurischain_ctx_t *challenge, uint8_t d, const void *seed, size_t inlen) {
+  uint8_t rand_hash[HASH_LEN] = { 0, };
+  if (!challenge || !seed || inlen == 0) return;
+  memset(challenge, 0, sizeof(jurischain_ctx_t));
+  sha3(seed, inlen, rand_hash, HASH_LEN);
+  memcpy(challenge->seed, rand_hash, sizeof(rand_hash));
+  memcpy(challenge->payload, rand_hash, sizeof(rand_hash));
+  challenge->payload[HASH_LEN] = d;
+}
+
+static inline jurischain_ctx_t *jurischain_init(void) {
+    jurischain_ctx_t *ptr = (jurischain_ctx_t *)malloc(sizeof(jurischain_ctx_t));
+    if (ptr) memset(ptr, 0, sizeof(jurischain_ctx_t));
+    return ptr;
+}
+
+static inline void jurischain_destroy(jurischain_ctx_t **ptr) {
+    if (!ptr || !*ptr) return;
+    memset(*ptr, 0, sizeof(jurischain_ctx_t));
+    free(*ptr);
+    *ptr = NULL;
+}
+
+static inline int jurischain_verify(jurischain_ctx_t *challenge) {
+  uint8_t hash_concat[HASH_LEN * 2] = { 0, },
+          response[HASH_LEN] = { 0, };
+  uint64_t res64[HASH_LEN / 8] = { 0, };
+  uint64_t mask = 0, valid = 1, i = 0;
+  uint8_t d = 0;
+
+  if (!challenge) return 0;
+
+  memcpy(hash_concat, challenge->seed, HASH_LEN);
+  memcpy(&hash_concat[HASH_LEN], challenge->payload, HASH_LEN);
+
+  d = challenge->payload[HASH_LEN];
+
+  sha3(hash_concat, HASH_LEN * 2, response, HASH_LEN);
+
+  /*
+   * Interpret the digest as little-endian 64-bit words. memcpy avoids the
+   * strict-aliasing and unaligned-access undefined behaviour that a raw
+   * (uint64_t *) cast over a byte buffer would introduce. WebAssembly and
+   * all supported native targets are little-endian.
+   */
+  memcpy(res64, response, HASH_LEN);
+
+  /* check that the first `d` bits are zero */
+  for (i = 0; i < (d / 64u); i++)
+    if (res64[i] != 0) valid = 0;
+
+  if ((d % 64u) != 0) {
+    /* guard: shifting a 64-bit value by 64 is undefined behaviour, so this
+     * mask is only ever computed when (d % 64) is in the range 1..63 */
+    mask = (uint64_t)0xFFFFFFFFFFFFFFFFULL >> (64u - (d % 64u));
+    if ((res64[d / 64u] & mask) != 0) valid = 0;
+  }
+
+  return (int)valid;
+}
+
+static inline int jurischain_try(jurischain_ctx_t *challenge) {
+  uint8_t rand_hash[HASH_LEN] = { 0, };
+  if (!challenge) return 0;
+  sha3(challenge->seed, HASH_LEN, rand_hash, HASH_LEN);
+  memcpy(challenge->seed, rand_hash, HASH_LEN);
+
+  return jurischain_verify(challenge);
+}
+
+#endif

package/main.cpp

@@ -0,0 +1,141 @@
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <nan.h>
+
+#include "jurischain.h"
+
+class Jurischain : public Nan::ObjectWrap {
+public:
+  static NAN_MODULE_INIT(Init) {
+    v8::Local<v8::FunctionTemplate> ctor =
+        Nan::New<v8::FunctionTemplate>(Jurischain::New);
+    static Nan::Persistent<v8::Function> constructor;
+
+    ctor->SetClassName(Nan::New("Jurischain").ToLocalChecked());
+    ctor->InstanceTemplate()->SetInternalFieldCount(1);
+
+    Nan::SetPrototypeMethod(ctor, "challengeResponse", Define);
+    Nan::SetPrototypeMethod(ctor, "readChallenge", Retrieve);
+    Nan::SetPrototypeMethod(ctor, "solveStep", Solve);
+    Nan::SetPrototypeMethod(ctor, "verify", Verify);
+
+    constructor.Reset(Nan::GetFunction(ctor).ToLocalChecked());
+    Nan::Set(target, Nan::New("Jurischain").ToLocalChecked(),
+             Nan::GetFunction(ctor).ToLocalChecked());
+  }
+
+private:
+  jurischain_ctx_t context;
+
+  explicit Jurischain(uint8_t d, const void *seed, size_t inlen) {
+    std::memset(&context, 0, sizeof(context));
+    jurischain_gen(&context, d, seed, inlen);
+  }
+
+  ~Jurischain() {
+    std::memset(&context, 0, sizeof(context));
+  }
+
+  static NAN_METHOD(New) {
+    if (!info.IsConstructCall()) {
+      return Nan::ThrowError("Jurischain must be called with the new keyword");
+    }
+
+    if (info.Length() < 2) {
+      return Nan::ThrowTypeError("expected 2 arguments: difficulty (number) and seed (string)");
+    }
+
+    if (!info[0]->IsNumber()) {
+      return Nan::ThrowTypeError("difficulty must be a number");
+    }
+
+    double rawDifficulty = Nan::To<double>(info[0]).FromMaybe(0.0);
+
+    if (rawDifficulty != static_cast<int>(rawDifficulty)) {
+      return Nan::ThrowTypeError("difficulty must be an integer");
+    }
+
+    if (rawDifficulty < 1 || rawDifficulty > 255) {
+      return Nan::ThrowRangeError("difficulty must be between 1 and 255");
+    }
+
+    if (!info[1]->IsString()) {
+      return Nan::ThrowTypeError("seed must be a string");
+    }
+
+    Nan::Utf8String seed(info[1]);
+
+    if (seed.length() <= 0 || *seed == nullptr) {
+      return Nan::ThrowTypeError("seed must be a non-empty string");
+    }
+
+    uint8_t difficulty = static_cast<uint8_t>(rawDifficulty);
+    Jurischain *obj = new Jurischain(difficulty,
+        static_cast<const void *>(*seed), seed.length());
+    obj->Wrap(info.This());
+    info.GetReturnValue().Set(info.This());
+  }
+
+  static NAN_METHOD(Verify) {
+    Jurischain *obj = Nan::ObjectWrap::Unwrap<Jurischain>(info.This());
+    info.GetReturnValue().Set(
+        Nan::New<v8::Boolean>(jurischain_verify(&obj->context) != 0));
+  }
+
+  static NAN_METHOD(Solve) {
+    Jurischain *obj = Nan::ObjectWrap::Unwrap<Jurischain>(info.This());
+    info.GetReturnValue().Set(
+        Nan::New<v8::Boolean>(jurischain_try(&obj->context) != 0));
+  }
+
+  static NAN_METHOD(Define) {
+    if (info.Length() < 1) {
+      return Nan::ThrowTypeError("expected 1 argument: hex response string");
+    }
+
+    if (!info[0]->IsString()) {
+      return Nan::ThrowTypeError("response must be a string");
+    }
+
+    Nan::Utf8String response(info[0]);
+    const int expectedLen = HASH_LEN * 2;
+
+    if (response.length() != expectedLen) {
+      return Nan::ThrowRangeError(
+          "response must be exactly 64 hex characters");
+    }
+
+    const char *hex = *response;
+    if (hex == nullptr) {
+      return Nan::ThrowTypeError("response string is invalid");
+    }
+
+    Jurischain *obj = Nan::ObjectWrap::Unwrap<Jurischain>(info.This());
+
+    for (size_t i = 0; i < HASH_LEN; i++) {
+      if (std::sscanf(hex + (i * 2), "%02hhX", &obj->context.seed[i]) != 1) {
+        std::memset(obj->context.seed, 0, HASH_LEN);
+        char errmsg[64];
+        std::snprintf(errmsg, sizeof(errmsg),
+            "response contains invalid hex at position %zu", i * 2);
+        return Nan::ThrowError(errmsg);
+      }
+    }
+
+    info.GetReturnValue().Set(Nan::New<v8::Boolean>(true));
+  }
+
+  static NAN_METHOD(Retrieve) {
+    Jurischain *obj = Nan::ObjectWrap::Unwrap<Jurischain>(info.This());
+
+    char str[(HASH_LEN * 2) + 1] = { 0 };
+    for (int i = 0; i < HASH_LEN; i++) {
+      std::snprintf(str + (i * 2), 3, "%02hhX", obj->context.seed[i]);
+    }
+
+    info.GetReturnValue().Set(Nan::New(str).ToLocalChecked());
+  }
+};
+
+NODE_MODULE(Jurischain, Jurischain::Init);

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@credithub/jurischain-node",
+  "version": "1.0.2",
+  "description": "Native Node.js binding for JurisChain Proof-of-Work CAPTCHA. Challenges terminals instead of humans to mitigate DDoS attacks.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "main.cpp",
+    "jurischain.h",
+    "binding.gyp"
+  ],
+  "scripts": {
+    "prepack": "node -e \"require('fs').copyFileSync('../../include/jurischain.h','jurischain.h')\"",
+    "install": "node-gyp rebuild",
+    "rebuild": "node-gyp rebuild",
+    "test": "node -e \"const { Jurischain } = require('.'); const j = new Jurischain(1, 'test'); console.log('OK:', j.readChallenge());\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/credithub/jurischain.git"
+  },
+  "keywords": [
+    "captcha",
+    "proof-of-work",
+    "sha3",
+    "blockchain"
+  ],
+  "author": "CreditHub <tech@credithub.com.br>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/credithub/jurischain/issues"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "bindings": "^1.5.0",
+    "nan": "^2.19.0"
+  },
+  "devDependencies": {
+    "node-gyp": "^10.0.0"
+  },
+  "homepage": "https://github.com/credithub/jurischain#readme"
+}