9router-proxy 0.6.20 → 0.6.21

package/app/open-sse/lib/deepseek-pow-hash.js

@@ -1,450 +1,136 @@
-// Clean-room reference derived from NIST FIPS 202, Algorithms 1-9. FIPS SHA3-256
-// uses KECCAK-p[1600,24]. Differential testing against the supplied black-box
-// vectors identifies DeepSeekHashV1 as the same sponge construction with
-// KECCAK-p[1600,23] (the last 23 rounds, with round indices 1 through 23).
-
-const LANE_MASK = (1n << 64n) - 1n;
-const SHA3_256_RATE_BYTES = 136;
-const SHA3_DOMAIN_SUFFIX = 0x06;
-const SHA3_256_OUTPUT_BYTES = 32;
-
-// Indexed as x + 5*y, matching the FIPS 202 state coordinates.
-const ROTATION_OFFSETS = [
-  0, 1, 62, 28, 27, 36, 44, 6, 55, 20, 3, 10, 43, 25, 39, 41, 45, 15, 21, 8, 18, 2, 61, 56, 14,
-];
-
-const ROUND_CONSTANTS = [
-  0x0000000000000001n,
-  0x0000000000008082n,
-  0x800000000000808an,
-  0x8000000080008000n,
-  0x000000000000808bn,
-  0x0000000080000001n,
-  0x8000000080008081n,
-  0x8000000000008009n,
-  0x000000000000008an,
-  0x0000000000000088n,
-  0x0000000080008009n,
-  0x000000008000000an,
-  0x000000008000808bn,
-  0x800000000000008bn,
-  0x8000000000008089n,
-  0x8000000000008003n,
-  0x8000000000008002n,
-  0x8000000000000080n,
-  0x000000000000800an,
-  0x800000008000000an,
-  0x8000000080008081n,
-  0x8000000000008080n,
-  0x0000000080000001n,
-  0x8000000080008008n,
-];
-
-/**
- * @param {bigint} value
- * @param {number} amount
- * @returns {bigint}
- */
-function rotateLeft64(value, amount) {
-  if (amount === 0) return value;
-  const shift = BigInt(amount);
-  return ((value << shift) | (value >> (64n - shift))) & LANE_MASK;
-}
-
-/**
- * Apply the last `roundCount` rounds of KECCAK-p[1600, roundCount].
- *
- * @param {bigint[]} state
- * @param {number} roundCount
- */
-function keccakP1600Reference(state, roundCount) {
-  /** @type {bigint[]} */
-  const columnParity = new Array(5).fill(0n);
-  /** @type {bigint[]} */
-  const thetaMix = new Array(5).fill(0n);
-  /** @type {bigint[]} */
-  const rhoPiState = new Array(25).fill(0n);
-  const firstRound = ROUND_CONSTANTS.length - roundCount;
-
-  for (let round = firstRound; round < ROUND_CONSTANTS.length; round++) {
-    for (let x = 0; x < 5; x++) {
-      columnParity[x] = state[x] ^ state[x + 5] ^ state[x + 10] ^ state[x + 15] ^ state[x + 20];
-    }
-    for (let x = 0; x < 5; x++) {
-      thetaMix[x] = columnParity[(x + 4) % 5] ^ rotateLeft64(columnParity[(x + 1) % 5], 1);
-    }
-    for (let y = 0; y < 5; y++) {
-      for (let x = 0; x < 5; x++) state[x + 5 * y] ^= thetaMix[x];
+// DeepSeekHashV1: SHA3-256 (Keccak-f[1600]) with round 0 skipped.
+// Ported from noble-hashes keccak implementation.
+
+const B = new Uint32Array(10);
+
+const SHA3_PI = [];
+const SHA3_ROTL = [];
+const SHA3_IOTA_H = new Uint32Array(24);
+const SHA3_IOTA_L = new Uint32Array(24);
+
+{
+  let R = 1n;
+  let x = 1;
+  let y = 0;
+  for (let round = 0; round < 24; round++) {
+    const nx = y;
+    const ny = (2 * x + 3 * y) % 5;
+    x = nx;
+    y = ny;
+    SHA3_PI.push(2 * (5 * y + x));
+    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
+    let t = 0n;
+    for (let j = 0; j < 7; j++) {
+      R = ((R << 1n) ^ ((R >> 7n) * 0x71n)) % 256n;
+      if (R & 2n) t ^= 1n << ((1n << BigInt(j)) - 1n);
     }
-
-    for (let y = 0; y < 5; y++) {
-      for (let x = 0; x < 5; x++) {
-        const destinationX = y;
-        const destinationY = (2 * x + 3 * y) % 5;
-        const lane = x + 5 * y;
-        rhoPiState[destinationX + 5 * destinationY] = rotateLeft64(
-          state[lane],
-          ROTATION_OFFSETS[lane]
-        );
-      }
-    }
-
-    for (let y = 0; y < 5; y++) {
-      const row = 5 * y;
-      for (let x = 0; x < 5; x++) {
-        state[x + row] =
-          rhoPiState[x + row] ^
-          (~rhoPiState[((x + 1) % 5) + row] & LANE_MASK & rhoPiState[((x + 2) % 5) + row]);
-      }
-    }
-    state[0] ^= ROUND_CONSTANTS[round];
-  }
-}
-
-/**
- * @param {bigint[]} state
- * @param {Uint8Array} block
- * @param {number} roundCount
- */
-function absorbReferenceBlock(state, block, roundCount) {
-  for (let index = 0; index < SHA3_256_RATE_BYTES; index++) {
-    const lane = Math.floor(index / 8);
-    const shift = BigInt((index % 8) * 8);
-    state[lane] ^= BigInt(block[index]) << shift;
+    SHA3_IOTA_H[round] = Number(t & 0xFFFFFFFFn);
+    SHA3_IOTA_L[round] = Number((t >> 32n) & 0xFFFFFFFFn);
   }
-  keccakP1600Reference(state, roundCount);
 }
 
-/**
- * SHA3-256's sponge parameters with a selectable KECCAK-p round count.
- *
- * @param {string} input
- * @param {number} roundCount
- * @returns {string}
- */
-function sha3_256ReferenceWithRoundCount(input, roundCount) {
-  const bytes = new TextEncoder().encode(input);
-  /** @type {bigint[]} */
-  const state = new Array(25).fill(0n);
-  let offset = 0;
-
-  while (offset + SHA3_256_RATE_BYTES <= bytes.length) {
-    absorbReferenceBlock(state, bytes.subarray(offset, offset + SHA3_256_RATE_BYTES), roundCount);
-    offset += SHA3_256_RATE_BYTES;
-  }
-
-  const finalBlock = new Uint8Array(SHA3_256_RATE_BYTES);
-  finalBlock.set(bytes.subarray(offset));
-  finalBlock[bytes.length - offset] ^= SHA3_DOMAIN_SUFFIX;
-  finalBlock[SHA3_256_RATE_BYTES - 1] ^= 0x80;
-  absorbReferenceBlock(state, finalBlock, roundCount);
-
-  const output = new Uint8Array(SHA3_256_OUTPUT_BYTES);
-  for (let index = 0; index < output.length; index++) {
-    const lane = Math.floor(index / 8);
-    const shift = BigInt((index % 8) * 8);
-    output[index] = Number((state[lane] >> shift) & 0xffn);
-  }
-  return Array.from(output, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-
-/**
- * Readable FIPS 202 control implementation used to validate the permutation,
- * byte order, padding, and multi-block absorption against `node:crypto`.
- *
- * @param {string} input
- * @returns {string}
- */
-export function sha3_256Fips202Reference(input) {
-  return sha3_256ReferenceWithRoundCount(input, 24);
-}
-
-/**
- * Readable DeepSeekHashV1 reference model. Runtime searches use an equivalent
- * 32-bit implementation below so a bounded synchronous compatibility call does
- * not turn a 144k challenge into minutes of BigInt work.
- *
- * @param {string} input
- * @returns {string}
- */
-export function deepSeekHashV1Reference(input) {
-  return sha3_256ReferenceWithRoundCount(input, 23);
-}
-
-const DEEPSEEK_HASH_ROUNDS = 23;
-const DIGEST_HEX_PATTERN = /^[a-f0-9]{64}$/i;
-const ROUND_CONSTANTS_LOW = Uint32Array.from(ROUND_CONSTANTS, (value) =>
-  Number(value & 0xffffffffn)
-);
-const ROUND_CONSTANTS_HIGH = Uint32Array.from(ROUND_CONSTANTS, (value) =>
-  Number((value >> 32n) & 0xffffffffn)
-);
-const RHO_PI_DESTINATION_WORDS = Uint8Array.from({ length: 25 }, (_, lane) => {
-  const x = lane % 5;
-  const y = Math.floor(lane / 5);
-  return 2 * (y + 5 * ((2 * x + 3 * y) % 5));
-});
-const CHI_NEXT_WORDS = Uint8Array.from({ length: 25 }, (_, lane) => {
-  const x = lane % 5;
-  const row = lane - x;
-  return 2 * (row + ((x + 1) % 5));
-});
-const CHI_NEXT_NEXT_WORDS = Uint8Array.from({ length: 25 }, (_, lane) => {
-  const x = lane % 5;
-  const row = lane - x;
-  return 2 * (row + ((x + 2) % 5));
-});
-const HEX_DIGITS = "0123456789abcdef";
-
-export const MAX_DEEPSEEK_POW_DIFFICULTY = 250_000;
-
-/**
- * Equivalent 32-bit form of the reference permutation. Each 64-bit lane is
- * stored as adjacent little-endian low/high uint32 words.
- *
- * @param {Uint32Array} state
- * @param {Uint32Array} rhoPiState
- * @param {Uint32Array} columnParity
- * @param {Uint32Array} thetaMix
- * @param {number} roundCount
- */
-function keccakP1600Uint32(state, rhoPiState, columnParity, thetaMix, roundCount) {
-  const firstRound = ROUND_CONSTANTS.length - roundCount;
-
-  for (let round = firstRound; round < ROUND_CONSTANTS.length; round++) {
-    for (let x = 0; x < 5; x++) {
-      const word = 2 * x;
-      columnParity[word] =
-        state[word] ^ state[word + 10] ^ state[word + 20] ^ state[word + 30] ^ state[word + 40];
-      columnParity[word + 1] =
-        state[word + 1] ^ state[word + 11] ^ state[word + 21] ^ state[word + 31] ^ state[word + 41];
-    }
-
-    for (let x = 0; x < 5; x++) {
-      const previous = 2 * ((x + 4) % 5);
-      const next = 2 * ((x + 1) % 5);
-      const rotatedLow = (columnParity[next] << 1) | (columnParity[next + 1] >>> 31);
-      const rotatedHigh = (columnParity[next + 1] << 1) | (columnParity[next] >>> 31);
-      thetaMix[2 * x] = columnParity[previous] ^ rotatedLow;
-      thetaMix[2 * x + 1] = columnParity[previous + 1] ^ rotatedHigh;
-    }
-
-    for (let x = 0; x < 5; x++) {
-      const word = 2 * x;
-      const low = thetaMix[word];
-      const high = thetaMix[word + 1];
-      state[word] ^= low;
-      state[word + 1] ^= high;
-      state[word + 10] ^= low;
-      state[word + 11] ^= high;
-      state[word + 20] ^= low;
-      state[word + 21] ^= high;
-      state[word + 30] ^= low;
-      state[word + 31] ^= high;
-      state[word + 40] ^= low;
-      state[word + 41] ^= high;
-    }
-
-    rhoPiState[0] = state[0];
-    rhoPiState[1] = state[1];
-    for (let lane = 1; lane < 25; lane++) {
-      const source = 2 * lane;
-      const destination = RHO_PI_DESTINATION_WORDS[lane];
-      const amount = ROTATION_OFFSETS[lane];
-      const low = state[source];
-      const high = state[source + 1];
-
-      if (amount < 32) {
-        rhoPiState[destination] = (low << amount) | (high >>> (32 - amount));
-        rhoPiState[destination + 1] = (high << amount) | (low >>> (32 - amount));
-      } else {
-        const reduced = amount - 32;
-        rhoPiState[destination] = (high << reduced) | (low >>> (32 - reduced));
-        rhoPiState[destination + 1] = (low << reduced) | (high >>> (32 - reduced));
+function rotlSH(h, l, s) { return (h << s) | (l >>> (32 - s)); }
+function rotlSL(h, l, s) { return (l << s) | (h >>> (32 - s)); }
+function rotlBH(h, l, s) { return (l << (s - 32)) | (h >>> (64 - s)); }
+function rotlBL(h, l, s) { return (h << (s - 32)) | (l >>> (64 - s)); }
+function rotlH(h, l, s) { return s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s); }
+function rotlL(h, l, s) { return s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s); }
+
+const ROUNDS = 23;
+const BLOCK = 136;
+
+function keccakP(s, rounds) {
+  for (let round = 24 - rounds; round < 24; round++) {
+    for (let x = 0; x < 10; x++) B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0; x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0; y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
       }
     }
-
-    for (let lane = 0; lane < 25; lane++) {
-      const word = 2 * lane;
-      const nextWord = CHI_NEXT_WORDS[lane];
-      const nextNextWord = CHI_NEXT_NEXT_WORDS[lane];
-      state[word] = rhoPiState[word] ^ (~rhoPiState[nextWord] & rhoPiState[nextNextWord]);
-      state[word + 1] =
-        rhoPiState[word + 1] ^ (~rhoPiState[nextWord + 1] & rhoPiState[nextNextWord + 1]);
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0; t < 24; t++) {
+      const shift = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift);
+      const Tl = rotlL(curH, curL, shift);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
     }
-
-    state[0] ^= ROUND_CONSTANTS_LOW[round];
-    state[1] ^= ROUND_CONSTANTS_HIGH[round];
-  }
-}
-
-/**
- * @param {Uint32Array} state
- * @param {Uint8Array} bytes
- * @param {number} offset
- * @param {Uint32Array} rhoPiState
- * @param {Uint32Array} columnParity
- * @param {Uint32Array} thetaMix
- * @param {number} roundCount
- */
-function absorbFullUint32Block(
-  state,
-  bytes,
-  offset,
-  rhoPiState,
-  columnParity,
-  thetaMix,
-  roundCount
-) {
-  for (let index = 0; index < SHA3_256_RATE_BYTES; index++) {
-    const word = index >>> 2;
-    state[word] ^= bytes[offset + index] << ((index & 3) * 8);
-  }
-  keccakP1600Uint32(state, rhoPiState, columnParity, thetaMix, roundCount);
-}
-
-/**
- * @param {Uint32Array} state
- * @returns {string}
- */
-function digestStateToHex(state) {
-  let digest = "";
-  for (let index = 0; index < SHA3_256_OUTPUT_BYTES; index++) {
-    const byte = (state[index >>> 2] >>> ((index & 3) * 8)) & 0xff;
-    digest += HEX_DIGITS[byte >>> 4] + HEX_DIGITS[byte & 0x0f];
-  }
-  return digest;
-}
-
-/**
- * @param {string} input
- * @param {number} roundCount
- * @returns {string}
- */
-function sha3_256Uint32WithRoundCount(input, roundCount) {
-  const bytes = new TextEncoder().encode(input);
-  const state = new Uint32Array(50);
-  const rhoPiState = new Uint32Array(50);
-  const columnParity = new Uint32Array(10);
-  const thetaMix = new Uint32Array(10);
-  let offset = 0;
-
-  while (offset + SHA3_256_RATE_BYTES <= bytes.length) {
-    absorbFullUint32Block(state, bytes, offset, rhoPiState, columnParity, thetaMix, roundCount);
-    offset += SHA3_256_RATE_BYTES;
-  }
-
-  const remaining = bytes.length - offset;
-  for (let index = 0; index < remaining; index++) {
-    state[index >>> 2] ^= bytes[offset + index] << ((index & 3) * 8);
+    for (let y = 0; y < 50; y += 10) {
+      const b0 = s[y];
+      const b1 = s[y + 1];
+      const b2 = s[y + 2];
+      const b3 = s[y + 3];
+      s[y] ^= ~s[y + 2] & s[y + 4];
+      s[y + 1] ^= ~s[y + 3] & s[y + 5];
+      s[y + 2] ^= ~s[y + 4] & s[y + 6];
+      s[y + 3] ^= ~s[y + 5] & s[y + 7];
+      s[y + 4] ^= ~s[y + 6] & s[y + 8];
+      s[y + 5] ^= ~s[y + 7] & s[y + 9];
+      s[y + 6] ^= ~s[y + 8] & b0;
+      s[y + 7] ^= ~s[y + 9] & b1;
+      s[y + 8] ^= ~b0 & b2;
+      s[y + 9] ^= ~b1 & b3;
+    }
+    s[0] ^= SHA3_IOTA_H[round];
+    s[1] ^= SHA3_IOTA_L[round];
   }
-  state[remaining >>> 2] ^= SHA3_DOMAIN_SUFFIX << ((remaining & 3) * 8);
-  state[(SHA3_256_RATE_BYTES - 1) >>> 2] ^= 0x80 << 24;
-  keccakP1600Uint32(state, rhoPiState, columnParity, thetaMix, roundCount);
-  return digestStateToHex(state);
 }
 
-/**
- * Optimized, allocation-bounded DeepSeekHashV1 digest.
- *
- * @param {string} input
- * @returns {string}
- */
-export function deepSeekHashV1(input) {
-  return sha3_256Uint32WithRoundCount(input, DEEPSEEK_HASH_ROUNDS);
-}
+export const MAX_DEEPSEEK_POW_DIFFICULTY = 250000;
 
-/**
- * @param {string} digestHex
- * @returns {Uint32Array}
- */
-function parseDigestWords(digestHex) {
-  const words = new Uint32Array(SHA3_256_OUTPUT_BYTES / 4);
-  for (let index = 0; index < SHA3_256_OUTPUT_BYTES; index++) {
-    const byte = Number.parseInt(digestHex.slice(index * 2, index * 2 + 2), 16);
-    words[index >>> 2] |= byte << ((index & 3) * 8);
-  }
-  return words;
-}
-
-/**
- * Search `prefix + nonce` without allocating a digest or re-encoding the prefix
- * for every candidate. Inputs are validated here as well as at the public solver
- * boundary so the worker cannot be coerced into an unbounded loop.
- *
- * @param {string} prefix
- * @param {string} challenge
- * @param {number} difficulty
- * @returns {number}
- */
 export function findDeepSeekPowNonce(prefix, challenge, difficulty) {
-  if (typeof prefix !== "string") throw new TypeError("DeepSeek PoW prefix must be a string");
-  if (!DIGEST_HEX_PATTERN.test(challenge)) {
-    throw new TypeError("DeepSeek PoW challenge must be a 64-character hex digest");
-  }
-  if (
-    !Number.isSafeInteger(difficulty) ||
-    difficulty < 1 ||
-    difficulty > MAX_DEEPSEEK_POW_DIFFICULTY
-  ) {
-    throw new RangeError(
-      `DeepSeek PoW difficulty must be an integer from 1 to ${MAX_DEEPSEEK_POW_DIFFICULTY}`
-    );
-  }
+  const target = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) target[i] = parseInt(challenge.slice(i * 2, i * 2 + 2), 16);
 
   const prefixBytes = new TextEncoder().encode(prefix);
-  const baseState = new Uint32Array(50);
-  const rhoPiState = new Uint32Array(50);
-  const columnParity = new Uint32Array(10);
-  const thetaMix = new Uint32Array(10);
-  let prefixOffset = 0;
 
-  while (prefixOffset + SHA3_256_RATE_BYTES <= prefixBytes.length) {
-    absorbFullUint32Block(
-      baseState,
-      prefixBytes,
-      prefixOffset,
-      rhoPiState,
-      columnParity,
-      thetaMix,
-      DEEPSEEK_HASH_ROUNDS
-    );
-    prefixOffset += SHA3_256_RATE_BYTES;
-  }
-
-  const tailLength = prefixBytes.length - prefixOffset;
-  const tailWords = new Uint32Array(Math.ceil(tailLength / 4));
-  for (let index = 0; index < tailLength; index++) {
-    tailWords[index >>> 2] ^= prefixBytes[prefixOffset + index] << ((index & 3) * 8);
+  // absorb prefix
+  const state = new Uint8Array(200);
+  const state32 = new Uint32Array(state.buffer);
+  let pos = 0;
+  for (let i = 0; i < prefixBytes.length; i++) {
+    state[pos++] ^= prefixBytes[i];
+    if (pos === BLOCK) {
+      keccakP(state32, ROUNDS);
+      pos = 0;
+    }
   }
-
-  const targetWords = parseDigestWords(challenge.toLowerCase());
-  const state = new Uint32Array(50);
-
-  nonceLoop: for (let nonce = 0; nonce < difficulty; nonce++) {
-    state.set(baseState);
-    for (let word = 0; word < tailWords.length; word++) state[word] ^= tailWords[word];
-
-    let position = tailLength;
-    const nonceText = String(nonce);
-    for (let index = 0; index < nonceText.length; index++) {
-      state[position >>> 2] ^= nonceText.charCodeAt(index) << ((position & 3) * 8);
-      position += 1;
-      if (position === SHA3_256_RATE_BYTES) {
-        keccakP1600Uint32(state, rhoPiState, columnParity, thetaMix, DEEPSEEK_HASH_ROUNDS);
-        position = 0;
+  const snapState = state32.slice();
+  const snapPos = pos;
+
+  for (let nonce = 0; nonce < difficulty; nonce++) {
+    const st = snapState.slice();
+    const bytes = new Uint8Array(st.buffer);
+    let p = snapPos;
+    const str = String(nonce);
+    for (let i = 0; i < str.length; i++) {
+      bytes[p++] ^= str.charCodeAt(i);
+      if (p === BLOCK) {
+        keccakP(st, ROUNDS);
+        p = 0;
       }
     }
-
-    state[position >>> 2] ^= SHA3_DOMAIN_SUFFIX << ((position & 3) * 8);
-    state[(SHA3_256_RATE_BYTES - 1) >>> 2] ^= 0x80 << 24;
-    keccakP1600Uint32(state, rhoPiState, columnParity, thetaMix, DEEPSEEK_HASH_ROUNDS);
-
-    for (let word = 0; word < targetWords.length; word++) {
-      if (state[word] !== targetWords[word]) continue nonceLoop;
+    // finish
+    bytes[p] ^= 0x06;
+    bytes[BLOCK - 1] ^= 0x80;
+    keccakP(st, ROUNDS);
+    // compare
+    let ok = true;
+    for (let i = 0; i < 32; i++) {
+      if (bytes[i] !== target[i]) { ok = false; break; }
     }
-    return nonce;
+    if (ok) return nonce;
   }
-
   return -1;
 }

package/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "9router-app",
-  "version": "0.6.20",
+  "version": "0.6.21",
   "description": "9Router web dashboard",
   "private": true,
   "scripts": {