dredless 0.2.0

package/src/client/index.d.ts

@@ -0,0 +1,2 @@
+export {DredlessClient, WrenchMode, TurretMode} from "../index.js";
+export type {DredlessClientOptions, ClientSnapshot} from "../index.js";

package/src/client/index.js

@@ -0,0 +1 @@
+export {DredlessClient, WrenchMode, TurretMode} from "./core.js";

package/src/compression/lz4.d.ts

@@ -0,0 +1 @@
+export function decompressLz4Frame(bytes: Uint8Array | ArrayBuffer | number[]): Uint8Array;

package/src/compression/lz4.js

@@ -0,0 +1,112 @@
+import {toUint8Array} from "../protocol/codec/binary.js";
+
+// Growable typed-array sink. LZ4 block headers carry the compressed size, not
+// the decompressed size, so the output buffer starts at a generous multiple and
+// doubles on demand rather than pushing into a plain array one byte at a time.
+function ensureCapacity(buffer, needed) {
+    if (needed <= buffer.length) return buffer;
+    let size = buffer.length || 64;
+    while (size < needed) size *= 2;
+    const grown = new Uint8Array(size);
+    grown.set(buffer);
+    return grown;
+}
+
+function decompressLz4Block(block) {
+    let out = new Uint8Array(Math.max(64, block.length * 4));
+    let len = 0;
+    let pos = 0;
+
+    while (pos < block.length) {
+        const token = block[pos++];
+
+        let literalLen = token >>> 4;
+        if (literalLen === 15) {
+            let b;
+            do {
+                if (pos >= block.length) throw new Error("truncated lz4 literal length");
+                b = block[pos++];
+                literalLen += b;
+            } while (b === 255);
+        }
+
+        if (pos + literalLen > block.length) throw new Error("truncated lz4 literals");
+        if (literalLen > 0) {
+            out = ensureCapacity(out, len + literalLen);
+            out.set(block.subarray(pos, pos + literalLen), len);
+            len += literalLen;
+            pos += literalLen;
+        }
+
+        if (pos >= block.length) break;
+        if (pos + 2 > block.length) throw new Error("truncated lz4 offset");
+        const offset = block[pos] | (block[pos + 1] << 8);
+        pos += 2;
+        if (offset === 0 || offset > len) throw new Error(`invalid lz4 offset ${offset}`);
+
+        let matchLen = token & 0x0f;
+        if (matchLen === 15) {
+            let b;
+            do {
+                if (pos >= block.length) throw new Error("truncated lz4 match length");
+                b = block[pos++];
+                matchLen += b;
+            } while (b === 255);
+        }
+        matchLen += 4;
+
+        out = ensureCapacity(out, len + matchLen);
+        // Matches may overlap the region being written, so copy byte by byte rather
+        // than with copyWithin, which would read the pre-copy bytes.
+        let from = len - offset;
+        for (let i = 0; i < matchLen; i++) out[len++] = out[from++];
+    }
+
+    // Return a compact standalone array, matching the previous contract: callers
+    // must not see a view over a larger backing buffer.
+    return out.length === len ? out : out.slice(0, len);
+}
+
+function decompressLz4Frame(bytes) {
+    const buf = toUint8Array(bytes);
+    if (buf.length < 7) return buf;
+    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    if (view.getUint32(0, true) !== 0x184d2204) return buf;
+    const flg = buf[4];
+    let pos = 6;
+    if (flg & 0x08) pos += 8;
+    if (flg & 0x01) pos += 4;
+    pos += 1;
+    const chunks = [];
+    let total = 0;
+    while (pos + 4 <= buf.length) {
+        const rawSize = view.getUint32(pos, true);
+        pos += 4;
+        if (rawSize === 0) break;
+        const uncompressed = (rawSize & 0x80000000) !== 0;
+        const size = rawSize & 0x7fffffff;
+        if (pos + size > buf.length) throw new Error("truncated lz4 block");
+        const block = buf.subarray(pos, pos + size);
+        const chunk = uncompressed ? block.slice() : decompressLz4Block(block);
+        chunks.push(chunk);
+        total += chunk.length;
+        pos += size;
+        if (flg & 0x10) pos += 4;
+    }
+    // Single-chunk frames are the common case and need no concatenation pass.
+    if (chunks.length === 1) return chunks[0];
+    if (chunks.length === 0) return new Uint8Array(0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return out;
+}
+
+
+export {
+    decompressLz4Block,
+    decompressLz4Frame
+};

package/src/constants.js

@@ -0,0 +1,74 @@
+export const DEFAULT_BASE_URL = "https://drednot.io";
+export const DEFAULT_GAME_VERSION = null;
+export const DEFAULT_NOTICE_VERSION = 17;
+
+export const encoder = new TextEncoder();
+export const decoder = new TextDecoder("utf-8");
+
+export const SHARED_CHACHA_MATERIAL = Uint8Array.from([
+    0x15, 0x85, 0x59, 0xc6, 0x26, 0xc4, 0x31, 0x32,
+    0xb8, 0xed, 0xb2, 0xfe, 0x5b, 0x87, 0x5e, 0x5e,
+    0x3d, 0xd9, 0xe3, 0xcc, 0xa3, 0x9b, 0xd6, 0x58,
+    0xe2, 0xdc, 0x0e, 0x8b, 0x96, 0xb7, 0x05, 0x88,
+    0x78, 0xd1, 0xd4, 0xa4, 0x19, 0x3c, 0xb9, 0x1e,
+    0xbe, 0x78, 0x18, 0x12
+]);
+
+export const JOIN_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
+export const KEEPALIVE_INTERVAL_MS = 15_000;
+export const INITIAL_OUTFIT_MESSAGE = {
+    type: 7,
+    outfit: {
+        color_body: 4695355,
+        color_legs: 1393785,
+        color_skin: 13212550,
+        color_feet: 6242065,
+        color_hair: 1118481,
+        style_hair: 0,
+        color_hat: 16716049,
+        style_hat: 0,
+        color_face_1: 8421504,
+        style_face_1: 0,
+        color_face_2: 8421504,
+        style_face_2: 0
+    }
+};
+export const KEEPALIVE_MESSAGE = {type: 2, msg: "/"};
+
+export const COMMAND_FIELDS = [
+    "type", "n", "x", "y", "mx", "my", "vx", "vy",
+    "jump", "jump_held", "drop", "act1", "act1_held", "exit", "act2", "act_alt", "act_alt_held",
+    "wrench_mode", "turret_mode", "scr_w", "scr_h", "motion",
+    "focus_ent", "config_ent", "tip_select", "inv_slot", "blur", "drag"
+];
+
+export const COMMAND_DEFAULT_FORMATS = {
+    type: "positive-fixint",
+    n: "uint16",
+    x: "float32",
+    y: "float32",
+    mx: "float32",
+    my: "float32",
+    vx: "float32",
+    vy: "float32",
+    jump: "bool",
+    jump_held: "bool",
+    drop: "bool",
+    act1: "bool",
+    act1_held: "bool",
+    exit: "bool",
+    act2: "bool",
+    act_alt: "bool",
+    act_alt_held: "bool",
+    wrench_mode: "positive-fixint",
+    turret_mode: "positive-fixint",
+    scr_w: "uint16",
+    scr_h: "uint16",
+    motion: "float32",
+    focus_ent: "nil",
+    config_ent: "nil",
+    tip_select: "nil",
+    inv_slot: "positive-fixint",
+    blur: "bool",
+    drag: "nil"
+};

package/src/crypto/chacha-native.d.ts

@@ -0,0 +1,9 @@
+import type {ChaCha20Backend} from "./chacha.js";
+
+/**
+ * Node-only. Installs OpenSSL's `chacha20` as the ChaCha20 backend when it is
+ * available. Returns false when the cipher is not present in this build.
+ */
+export function enableNativeChaCha20(): boolean;
+
+export const nativeChaCha20: ChaCha20Backend;

package/src/crypto/chacha-native.js

@@ -0,0 +1,48 @@
+// Node-only ChaCha20 backend.
+//
+// OpenSSL exposes a raw `chacha20` stream cipher whose keystream matches
+// src/crypto/chacha.js exactly, and it is roughly 27x faster on 64 KB payloads.
+// This module is imported only from src/node.js so that browser bundles never
+// encounter a `node:crypto` specifier.
+import {createCipheriv, getCiphers} from "node:crypto";
+
+import {installNativeChaCha20} from "./chacha.js";
+
+// OpenSSL takes a 16-byte IV: a 32-bit little-endian block counter followed by
+// the 12-byte nonce. The JS implementation starts its counter at zero.
+function buildIv(nonce) {
+    const iv = new Uint8Array(16);
+    iv.set(nonce, 4);
+    return iv;
+}
+
+function nativeChaCha20(key, nonce, out, source) {
+    try {
+        const cipher = createCipheriv("chacha20", key, buildIv(nonce));
+        const input = source ?? new Uint8Array(out.length);
+        const head = cipher.update(input);
+        const tail = cipher.final();
+        if (head.length) out.set(head, 0);
+        if (tail.length) out.set(tail, head.length);
+        return out;
+    } catch (_) {
+        // Fall back to the portable implementation.
+        return null;
+    }
+}
+
+function enableNativeChaCha20() {
+    try {
+        if (!getCiphers().includes("chacha20")) return false;
+    } catch (_) {
+        return false;
+    }
+    installNativeChaCha20(nativeChaCha20);
+    return true;
+}
+
+
+export {
+    enableNativeChaCha20,
+    nativeChaCha20
+};

package/src/crypto/chacha.d.ts

@@ -0,0 +1,25 @@
+export function decryptPayload(wireBytes: Uint8Array | ArrayBuffer | number[], worldId: number, seed: number): Uint8Array;
+
+export function chacha20(key: Uint8Array, nonce: Uint8Array, length: number): Uint8Array;
+
+/** Generates the keystream and XORs it with `data` in a single pass. */
+export function chacha20Xor(key: Uint8Array, nonce: Uint8Array, data: Uint8Array): Uint8Array;
+
+export function rotl32(x: number, n: number): number;
+
+export function rotr32(x: number, n: number): number;
+
+export function quarterRound(state: Uint32Array, a: number, b: number, c: number, d: number): void;
+
+export type ChaCha20Backend = (
+    key: Uint8Array,
+    nonce: Uint8Array,
+    out: Uint8Array,
+    source?: Uint8Array
+) => Uint8Array | null;
+
+/**
+ * Installs a faster backend for large payloads. Node's entry point wires this to
+ * OpenSSL's `chacha20`; pass null to restore the portable implementation.
+ */
+export function installNativeChaCha20(cipherFactory: ChaCha20Backend | null): void;

package/src/crypto/chacha.js

@@ -0,0 +1,274 @@
+import {encoder, SHARED_CHACHA_MATERIAL} from "../constants.js";
+import {toUint8Array} from "../protocol/codec/binary.js";
+
+function rotl32(x, n) {
+    n &= 31;
+    return ((x << n) | (x >>> (32 - n))) >>> 0;
+}
+
+function rotr32(x, n) {
+    n &= 31;
+    return ((x >>> n) | (x << (32 - n))) >>> 0;
+}
+
+function quarterRound(state, a, b, c, d) {
+    state[a] = (state[a] + state[b]) >>> 0;
+    state[d] ^= state[a];
+    state[d] = rotl32(state[d], 16);
+    state[c] = (state[c] + state[d]) >>> 0;
+    state[b] ^= state[c];
+    state[b] = rotl32(state[b], 12);
+    state[a] = (state[a] + state[b]) >>> 0;
+    state[d] ^= state[a];
+    state[d] = rotl32(state[d], 8);
+    state[c] = (state[c] + state[d]) >>> 0;
+    state[b] ^= state[c];
+    state[b] = rotl32(state[b], 7);
+}
+
+// Optional native backend. Node's OpenSSL exposes a raw `chacha20` stream cipher
+// whose keystream is identical to this implementation, and it is ~27x faster on
+// large payloads. It is installed by src/node.js rather than imported here so
+// that browser bundles never see a `node:crypto` specifier.
+let nativeBlockCipher = null;
+
+function installNativeChaCha20(cipherFactory) {
+    nativeBlockCipher = typeof cipherFactory === "function" ? cipherFactory : null;
+}
+
+// Native call overhead dominates below roughly this size; measured crossover is
+// near 150 bytes, so stay in JS for the small per-tick payloads.
+const NATIVE_MIN_BYTES = 256;
+
+// Reused across blocks: the keystream words for one 64-byte block. Safe because
+// generation is synchronous and single-threaded.
+const SCRATCH_BLOCK = new Uint32Array(16);
+
+function readLe32(bytes, offset) {
+    return (bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16) | (bytes[offset + 3] << 24)) >>> 0;
+}
+
+// Writes `length` keystream bytes into `out` starting at 0, XORing against
+// `source` when supplied. Keeping generation and XOR in one pass avoids
+// allocating a full second buffer for the keystream.
+function chacha20Into(out, key, nonce, length, source) {
+    const k0 = readLe32(key, 0), k1 = readLe32(key, 4), k2 = readLe32(key, 8), k3 = readLe32(key, 12);
+    const k4 = readLe32(key, 16), k5 = readLe32(key, 20), k6 = readLe32(key, 24), k7 = readLe32(key, 28);
+    const n0 = readLe32(nonce, 0), n1 = readLe32(nonce, 4), n2 = readLe32(nonce, 8);
+
+    let counter = 0;
+    let offset = 0;
+    const block = SCRATCH_BLOCK;
+
+    while (offset < length) {
+        let x0 = 0x61707865, x1 = 0x3320646e, x2 = 0x79622d32, x3 = 0x6b206574;
+        let x4 = k0, x5 = k1, x6 = k2, x7 = k3;
+        let x8 = k4, x9 = k5, x10 = k6, x11 = k7;
+        let x12 = counter, x13 = n0, x14 = n1, x15 = n2;
+
+        for (let i = 0; i < 10; i++) {
+            // column rounds
+            x0 = (x0 + x4) >>> 0;
+            x12 ^= x0;
+            x12 = (x12 << 16) | (x12 >>> 16);
+            x8 = (x8 + x12) >>> 0;
+            x4 ^= x8;
+            x4 = (x4 << 12) | (x4 >>> 20);
+            x0 = (x0 + x4) >>> 0;
+            x12 ^= x0;
+            x12 = (x12 << 8) | (x12 >>> 24);
+            x8 = (x8 + x12) >>> 0;
+            x4 ^= x8;
+            x4 = (x4 << 7) | (x4 >>> 25);
+
+            x1 = (x1 + x5) >>> 0;
+            x13 ^= x1;
+            x13 = (x13 << 16) | (x13 >>> 16);
+            x9 = (x9 + x13) >>> 0;
+            x5 ^= x9;
+            x5 = (x5 << 12) | (x5 >>> 20);
+            x1 = (x1 + x5) >>> 0;
+            x13 ^= x1;
+            x13 = (x13 << 8) | (x13 >>> 24);
+            x9 = (x9 + x13) >>> 0;
+            x5 ^= x9;
+            x5 = (x5 << 7) | (x5 >>> 25);
+
+            x2 = (x2 + x6) >>> 0;
+            x14 ^= x2;
+            x14 = (x14 << 16) | (x14 >>> 16);
+            x10 = (x10 + x14) >>> 0;
+            x6 ^= x10;
+            x6 = (x6 << 12) | (x6 >>> 20);
+            x2 = (x2 + x6) >>> 0;
+            x14 ^= x2;
+            x14 = (x14 << 8) | (x14 >>> 24);
+            x10 = (x10 + x14) >>> 0;
+            x6 ^= x10;
+            x6 = (x6 << 7) | (x6 >>> 25);
+
+            x3 = (x3 + x7) >>> 0;
+            x15 ^= x3;
+            x15 = (x15 << 16) | (x15 >>> 16);
+            x11 = (x11 + x15) >>> 0;
+            x7 ^= x11;
+            x7 = (x7 << 12) | (x7 >>> 20);
+            x3 = (x3 + x7) >>> 0;
+            x15 ^= x3;
+            x15 = (x15 << 8) | (x15 >>> 24);
+            x11 = (x11 + x15) >>> 0;
+            x7 ^= x11;
+            x7 = (x7 << 7) | (x7 >>> 25);
+
+            // diagonal rounds
+            x0 = (x0 + x5) >>> 0;
+            x15 ^= x0;
+            x15 = (x15 << 16) | (x15 >>> 16);
+            x10 = (x10 + x15) >>> 0;
+            x5 ^= x10;
+            x5 = (x5 << 12) | (x5 >>> 20);
+            x0 = (x0 + x5) >>> 0;
+            x15 ^= x0;
+            x15 = (x15 << 8) | (x15 >>> 24);
+            x10 = (x10 + x15) >>> 0;
+            x5 ^= x10;
+            x5 = (x5 << 7) | (x5 >>> 25);
+
+            x1 = (x1 + x6) >>> 0;
+            x12 ^= x1;
+            x12 = (x12 << 16) | (x12 >>> 16);
+            x11 = (x11 + x12) >>> 0;
+            x6 ^= x11;
+            x6 = (x6 << 12) | (x6 >>> 20);
+            x1 = (x1 + x6) >>> 0;
+            x12 ^= x1;
+            x12 = (x12 << 8) | (x12 >>> 24);
+            x11 = (x11 + x12) >>> 0;
+            x6 ^= x11;
+            x6 = (x6 << 7) | (x6 >>> 25);
+
+            x2 = (x2 + x7) >>> 0;
+            x13 ^= x2;
+            x13 = (x13 << 16) | (x13 >>> 16);
+            x8 = (x8 + x13) >>> 0;
+            x7 ^= x8;
+            x7 = (x7 << 12) | (x7 >>> 20);
+            x2 = (x2 + x7) >>> 0;
+            x13 ^= x2;
+            x13 = (x13 << 8) | (x13 >>> 24);
+            x8 = (x8 + x13) >>> 0;
+            x7 ^= x8;
+            x7 = (x7 << 7) | (x7 >>> 25);
+
+            x3 = (x3 + x4) >>> 0;
+            x14 ^= x3;
+            x14 = (x14 << 16) | (x14 >>> 16);
+            x9 = (x9 + x14) >>> 0;
+            x4 ^= x9;
+            x4 = (x4 << 12) | (x4 >>> 20);
+            x3 = (x3 + x4) >>> 0;
+            x14 ^= x3;
+            x14 = (x14 << 8) | (x14 >>> 24);
+            x9 = (x9 + x14) >>> 0;
+            x4 ^= x9;
+            x4 = (x4 << 7) | (x4 >>> 25);
+        }
+
+        block[0] = (x0 + 0x61707865) >>> 0;
+        block[1] = (x1 + 0x3320646e) >>> 0;
+        block[2] = (x2 + 0x79622d32) >>> 0;
+        block[3] = (x3 + 0x6b206574) >>> 0;
+        block[4] = (x4 + k0) >>> 0;
+        block[5] = (x5 + k1) >>> 0;
+        block[6] = (x6 + k2) >>> 0;
+        block[7] = (x7 + k3) >>> 0;
+        block[8] = (x8 + k4) >>> 0;
+        block[9] = (x9 + k5) >>> 0;
+        block[10] = (x10 + k6) >>> 0;
+        block[11] = (x11 + k7) >>> 0;
+        block[12] = (x12 + counter) >>> 0;
+        block[13] = (x13 + n0) >>> 0;
+        block[14] = (x14 + n1) >>> 0;
+        block[15] = (x15 + n2) >>> 0;
+
+        const remaining = length - offset;
+        if (remaining >= 64) {
+            if (source) {
+                for (let w = 0; w < 16; w++) {
+                    const word = block[w];
+                    out[offset] = source[offset] ^ (word & 0xff);
+                    out[offset + 1] = source[offset + 1] ^ ((word >>> 8) & 0xff);
+                    out[offset + 2] = source[offset + 2] ^ ((word >>> 16) & 0xff);
+                    out[offset + 3] = source[offset + 3] ^ ((word >>> 24) & 0xff);
+                    offset += 4;
+                }
+            } else {
+                for (let w = 0; w < 16; w++) {
+                    const word = block[w];
+                    out[offset] = word & 0xff;
+                    out[offset + 1] = (word >>> 8) & 0xff;
+                    out[offset + 2] = (word >>> 16) & 0xff;
+                    out[offset + 3] = (word >>> 24) & 0xff;
+                    offset += 4;
+                }
+            }
+        } else {
+            for (let i = 0; i < remaining; i++, offset++) {
+                const stream = (block[i >> 2] >>> ((i & 3) * 8)) & 0xff;
+                out[offset] = source ? source[offset] ^ stream : stream;
+            }
+        }
+        counter++;
+    }
+
+    return out;
+}
+
+function chacha20(key, nonce, length) {
+    const out = new Uint8Array(length);
+    if (length <= 0) return out;
+    if (nativeBlockCipher && length >= NATIVE_MIN_BYTES) {
+        const native = nativeBlockCipher(key, nonce, out);
+        if (native) return native;
+    }
+    return chacha20Into(out, key, nonce, length, null);
+}
+
+// XORs `data` with the keystream in a single pass, without materialising the
+// keystream in a separate buffer.
+function chacha20Xor(key, nonce, data) {
+    const out = new Uint8Array(data.length);
+    if (data.length === 0) return out;
+    if (nativeBlockCipher && data.length >= NATIVE_MIN_BYTES) {
+        const native = nativeBlockCipher(key, nonce, out, data);
+        if (native) return native;
+    }
+    return chacha20Into(out, key, nonce, data.length, data);
+}
+
+function decryptPayload(wireBytes, worldId, seed) {
+    const wire = toUint8Array(wireBytes);
+    if (wire.length < 8) throw new Error("payload too short");
+    const view = new DataView(wire.buffer, wire.byteOffset, wire.byteLength);
+    const packetWordA = view.getUint32(0, true);
+    const packetWordB = view.getUint32(wire.length - 4, true);
+    const material = Uint8Array.from(SHARED_CHACHA_MATERIAL);
+    const worldKey = encoder.encode(`${worldId}${seed}`);
+    for (let i = 0, l = 0, r = 0; i < 44; i++, l += 7, r += 11) {
+        material[i] ^= worldKey[i % worldKey.length] ^ (rotl32(packetWordA, l) & 0xff) ^ (rotr32(packetWordB, r) & 0xff);
+    }
+    // subarray, not slice: the key and nonce are only read.
+    const ciphertext = wire.subarray(4, wire.length - 4);
+    return chacha20Xor(material.subarray(0, 32), material.subarray(32, 44), ciphertext);
+}
+
+
+export {
+    rotl32,
+    rotr32,
+    quarterRound,
+    chacha20,
+    chacha20Xor,
+    decryptPayload,
+    installNativeChaCha20
+};