sm-crypto-wasm 0.1.0 → 0.1.2

package/dist/runtime/random.browser.js

@@ -0,0 +1,50 @@
+/**
+ * 宿主随机数包装（**浏览器版**）。
+ *
+ * 打包时由 package.json 的 `browser` 字段替换 `random.js`。存在的唯一理由是：
+ * `node:crypto` 会让 Webpack 5 / esbuild / Rspack 在解析期构建失败。
+ * 与宿主无关的拒绝采样逻辑在 `random.core.ts`。本文件**零 `node:*` 引用**。
+ *
+ * 安全姿态与 Node 版一致：**只认 `globalThis.crypto`，取不到就抛错
+ * （fail-closed），绝不降级到非密码学随机源。**
+ */
+import { scalarBelowFrom } from './random.core.js';
+/**
+ * 解析宿主 CSPRNG。浏览器里只有 `globalThis.crypto` 一个来源，
+ * 拿不到就抛错 —— 宁可不可用，也不用弱随机。
+ */
+function resolveHostCrypto() {
+    const g = globalThis.crypto;
+    if (g && typeof g.getRandomValues === 'function')
+        return g;
+    throw new Error('sm-crypto-wasm: 当前环境没有 WebCrypto（crypto.getRandomValues）。' +
+        '浏览器需要安全上下文（https 或 localhost）；若已被移除或未提供，' +
+        '请勿继续 —— 本库不会用非密码学随机源代替。');
+}
+/** 宿主 CSPRNG 引用；模块加载时即解析。 */
+const c = resolveHostCrypto();
+/**
+ * 取 `n` 字节 CSPRNG 随机数。
+ *
+ * @param n 字节数，范围 `[0, 65536]`（WebCrypto `getRandomValues` 的规范上限）。
+ * @returns 新分配的字节数组（拷贝）。
+ * @throws RangeError n 不在范围内或不是整数。
+ */
+export function randomBytes(n) {
+    if (!Number.isInteger(n) || n < 0 || n > 65536) {
+        throw new RangeError(`randomBytes: length must be integer in [0, 65536], got ${n}`);
+    }
+    const out = new Uint8Array(n);
+    if (n > 0)
+        c.getRandomValues(out);
+    return out;
+}
+/**
+ * 在 `[1, order)` 区间均匀取一个随机标量（用于 SM2 / SM9 椭圆曲线 k）。
+ *
+ * @param order 椭圆曲线子群阶（如 SM2 的 n、SM9 的 BN256 n）。
+ * @returns 满足 `1 ≤ k < order` 的大整数。
+ */
+export function randomScalarBelow(order) {
+    return scalarBelowFrom(order, randomBytes);
+}

package/dist/runtime/random.core.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 随机数共享核心（Node 版与浏览器版共用）。
+ *
+ * **零 `node:*` 引用** —— 浏览器版的模块图里不能出现 node 内置模块
+ * （Webpack / esbuild / Rspack 解析期即失败）。宿主 CSPRNG 的获取方式由
+ * `random.ts`（Node）与 `random.browser.ts`（浏览器）各自实现。
+ */
+/**
+ * 在 `[1, order)` 区间均匀取一个随机标量（用于 SM2 / SM9 椭圆曲线 k）。
+ *
+ * 算法：256-bit 候选 + 拒绝采样。从宿主 CSPRNG 取 32 字节拼成大整数，
+ * 若为 0 或 ≥ `order` 则重抽。SM2 的 n 几乎等于 2²⁵⁶（一次命中），
+ * SM9 的 n ≈ 0.712 × 2²⁵⁶（平均约 1.4 次）。偏置上界 ≈ `order / 2²⁵⁶`，
+ * 量级在 2⁻¹²⁸ 以下。
+ *
+ * @param order 椭圆曲线子群阶（如 SM2 的 n、SM9 的 BN256 n）。
+ * @param randomBytes 宿主 CSPRNG 取字节函数（由调用方注入，保证两侧实现一致）。
+ * @returns 满足 `1 ≤ k < order` 的大整数。
+ */
+export declare function scalarBelowFrom(order: bigint, randomBytes: (n: number) => Uint8Array): bigint;

package/dist/runtime/random.core.js

@@ -0,0 +1,35 @@
+/**
+ * 随机数共享核心（Node 版与浏览器版共用）。
+ *
+ * **零 `node:*` 引用** —— 浏览器版的模块图里不能出现 node 内置模块
+ * （Webpack / esbuild / Rspack 解析期即失败）。宿主 CSPRNG 的获取方式由
+ * `random.ts`（Node）与 `random.browser.ts`（浏览器）各自实现。
+ */
+/**
+ * 在 `[1, order)` 区间均匀取一个随机标量（用于 SM2 / SM9 椭圆曲线 k）。
+ *
+ * 算法：256-bit 候选 + 拒绝采样。从宿主 CSPRNG 取 32 字节拼成大整数，
+ * 若为 0 或 ≥ `order` 则重抽。SM2 的 n 几乎等于 2²⁵⁶（一次命中），
+ * SM9 的 n ≈ 0.712 × 2²⁵⁶（平均约 1.4 次）。偏置上界 ≈ `order / 2²⁵⁶`，
+ * 量级在 2⁻¹²⁸ 以下。
+ *
+ * @param order 椭圆曲线子群阶（如 SM2 的 n、SM9 的 BN256 n）。
+ * @param randomBytes 宿主 CSPRNG 取字节函数（由调用方注入，保证两侧实现一致）。
+ * @returns 满足 `1 ≤ k < order` 的大整数。
+ */
+export function scalarBelowFrom(order, randomBytes) {
+    if (order <= 1n)
+        throw new RangeError('randomScalarBelow: order must be > 1');
+    // 用 256-bit 候选：4 个 64-bit big-endian limb。
+    while (true) {
+        const buf = randomBytes(32); // 256 bits
+        let candidate = 0n;
+        for (let i = 0; i < 32; i++) {
+            candidate = (candidate << 8n) | BigInt(buf[i] ?? 0);
+        }
+        // 严格 < order（不允许 0）。
+        if (candidate > 0n && candidate < order)
+            return candidate;
+        // 否则重抽；理论上不到一次。
+    }
+}

package/dist/runtime/random.d.ts

@@ -1,3 +1,18 @@
+/**
+ * 宿主随机数包装（**Node 版**）。
+ *
+ * 浏览器打包时本文件被 `random.browser.ts` 替换（package.json 的 `browser` 字段），
+ * 因为 `node:crypto` 会让 Webpack / esbuild / Rspack 在解析期构建失败。
+ * 与宿主无关的拒绝采样逻辑在 `random.core.ts`。
+ *
+ * 设计要点（spec §9 安全姿态）：
+ * - **永远走宿主 CSPRNG**：Node 19+ 用 `globalThis.crypto`，Node 18 回退
+ *   `node:crypto` 的 `webcrypto`（`globalThis.crypto` 直到 Node 19 才默认暴露）。
+ * - **取不到就抛错（fail-closed）**：绝不实例化本地 RNG，也绝不静默降级到
+ *   非密码学随机源。
+ * - **长度边界**：输入 `n ∈ [0, 65536]`，溢出抛 `RangeError`
+ *   （65536 是 WebCrypto `getRandomValues` 的规范上限）。
+ */
 /**
  * 取 `n` 字节 CSPRNG 随机数。
  *
@@ -7,10 +22,7 @@
  */
 export declare function randomBytes(n: number): Uint8Array;
 /**
- * 在 `[1, order)` 区间均匀取一个随机标量（用于 SM2/SM9 椭圆曲线 k）。
- *
- * 算法：64-bit limb rejection sampling。从 `getRandomValues` 取 4 个 64-bit
- * limb 拼接成 256-bit 候选值；若 ≥ `order` 则重抽。偏置 ≤ 2^-128，足够低。
+ * 在 `[1, order)` 区间均匀取一个随机标量（用于 SM2 / SM9 椭圆曲线 k）。
  *
  * @param order 椭圆曲线子群阶（如 SM2 的 n、SM9 的 BN256 n）。
  * @returns 满足 `1 ≤ k < order` 的大整数。

package/dist/runtime/random.js

@@ -1,18 +1,39 @@
 /**
- * 宿主随机数包装（host-backed randomness）。
+ * 宿主随机数包装（**Node 版**）。
+ *
+ * 浏览器打包时本文件被 `random.browser.ts` 替换（package.json 的 `browser` 字段），
+ * 因为 `node:crypto` 会让 Webpack / esbuild / Rspack 在解析期构建失败。
+ * 与宿主无关的拒绝采样逻辑在 `random.core.ts`。
  *
  * 设计要点（spec §9 安全姿态）：
- * - **永远走宿主 CSPRNG**：浏览器 `globalThis.crypto.getRandomValues`、
- *   Node `webcrypto.getRandomValues`。**绝不**实例化本地 RNG。
- * - **拒绝采样（rejection sampling）**：用于 SM2/SM9 椭圆曲线私钥 k；
- *   按 64-bit limb 切分，从 256-bit 候选中重抽直至 < order。
- * - **长度边界**：输入 `n ∈ [0, 65536]`，溢出抛 `RangeError`。
+ * - **永远走宿主 CSPRNG**：Node 19+ 用 `globalThis.crypto`，Node 18 回退
+ *   `node:crypto` 的 `webcrypto`（`globalThis.crypto` 直到 Node 19 才默认暴露）。
+ * - **取不到就抛错（fail-closed）**：绝不实例化本地 RNG，也绝不静默降级到
+ *   非密码学随机源。
+ * - **长度边界**：输入 `n ∈ [0, 65536]`，溢出抛 `RangeError`
+ *   （65536 是 WebCrypto `getRandomValues` 的规范上限）。
+ */
+import * as nodeCrypto from 'node:crypto';
+import { scalarBelowFrom } from './random.core.js';
+/**
+ * 解析宿主 CSPRNG。**取不到就抛错，绝不静默降级到非密码学随机源。**
  *
- * spec/plan 对应：plan Task 3；spec §9 安全姿态、§6 SM2/SM9 API。
+ * - Node 19+：`globalThis.crypto`（WebCrypto）；
+ * - Node 18：`node:crypto` 的 `webcrypto` —— `globalThis.crypto` 直到 Node 19 才
+ *   默认暴露，Node 18 需要 `--experimental-global-webcrypto`，所以回退是必要的。
  */
-import { webcrypto } from 'node:crypto';
-/** 宿主 CSPRNG 引用；优先 `globalThis.crypto`（浏览器 / Node 19+）。 */
-const c = globalThis.crypto ?? webcrypto;
+function resolveHostCrypto() {
+    const g = globalThis.crypto;
+    if (g && typeof g.getRandomValues === 'function')
+        return g;
+    const wc = nodeCrypto.webcrypto;
+    if (wc && typeof wc.getRandomValues === 'function')
+        return wc;
+    throw new Error('sm-crypto-wasm: 找不到宿主 CSPRNG（需要 WebCrypto 的 crypto.getRandomValues）；' +
+        'Node 18 请加 --experimental-global-webcrypto，或先 polyfill globalThis.crypto。');
+}
+/** 宿主 CSPRNG 引用；模块加载时即解析。 */
+const c = resolveHostCrypto();
 /**
  * 取 `n` 字节 CSPRNG 随机数。
  *
@@ -30,27 +51,11 @@ export function randomBytes(n) {
     return out;
 }
 /**
- * 在 `[1, order)` 区间均匀取一个随机标量（用于 SM2/SM9 椭圆曲线 k）。
- *
- * 算法：64-bit limb rejection sampling。从 `getRandomValues` 取 4 个 64-bit
- * limb 拼接成 256-bit 候选值；若 ≥ `order` 则重抽。偏置 ≤ 2^-128，足够低。
+ * 在 `[1, order)` 区间均匀取一个随机标量（用于 SM2 / SM9 椭圆曲线 k）。
  *
  * @param order 椭圆曲线子群阶（如 SM2 的 n、SM9 的 BN256 n）。
  * @returns 满足 `1 ≤ k < order` 的大整数。
  */
 export function randomScalarBelow(order) {
-    if (order <= 1n)
-        throw new RangeError('randomScalarBelow: order must be > 1');
-    // 用 256-bit 候选：4 个 64-bit big-endian limb。
-    while (true) {
-        const buf = randomBytes(32); // 256 bits
-        let candidate = 0n;
-        for (let i = 0; i < 32; i++) {
-            candidate = (candidate << 8n) | BigInt(buf[i] ?? 0);
-        }
-        // 严格 < order（不允许 0）。
-        if (candidate > 0n && candidate < order)
-            return candidate;
-        // 否则重抽；理论上不到一次。
-    }
+    return scalarBelowFrom(order, randomBytes);
 }

package/dist/sm2/index.js

@@ -65,6 +65,24 @@ function getModule() {
         throw new Error('sm2: 未初始化，请先 `await ensureLoaded()`。');
     return mod;
 }
+/**
+ * 现取 WASM memory 视图。
+ *
+ * **每次都用**，绝不在多次 `alloc` / wasm 调用之间缓存 `new Uint8Array(memory.buffer)`：
+ * 任何一次分配都可能让 WASM 堆增长（`memory.grow`），旧的 ArrayBuffer 会被 detach，
+ * 复用旧视图会抛 `TypeError: Cannot perform Construct on a detached ArrayBuffer`。
+ */
+function memView() {
+    return new Uint8Array(getModule().memory.buffer);
+}
+/** 写入字节到 WASM 内存（现取视图）。 */
+function putBytes(b, ptr) {
+    memView().set(b, ptr);
+}
+/** 读出 WASM 内存的拷贝（现取视图后 slice，不向上层交出会失效的视图）。 */
+function readBytes(ptr, len) {
+    return new Uint8Array(getModule().memory.buffer, ptr, len).slice();
+}
 /**
  * 从私钥派生公钥。
  *
@@ -80,13 +98,13 @@ export function getPublicKey(privateKey) {
  * `getPublicKey` 与缓存未命中时的 `derivePublicKeyBytes` 都走这里。
  */
 function derivePublicKeyRaw(d) {
-    const { exports, memory } = getModule();
+    const { exports } = getModule();
     const dp = exports.alloc(32);
     const op = exports.alloc(64);
     try {
-        new Uint8Array(memory.buffer).set(d, dp);
+        putBytes(d, dp);
         exports.publicKeyOut(dp, op);
-        return new Uint8Array(memory.buffer, op, 64).slice();
+        return readBytes(op, 64);
     }
     finally {
         exports.freeAll();
@@ -209,7 +227,6 @@ export function sign(privateKey, message) {
     const m = toBytes(message, 'message');
     const pub = derivePublicKeyBytes(d);
     const { exports } = getModule();
-    const mem = new Uint8Array(getModule().memory.buffer);
     const dp = exports.alloc(32);
     const pxp = exports.alloc(32);
     const pyp = exports.alloc(32);
@@ -217,17 +234,17 @@ export function sign(privateKey, message) {
     const kp = exports.alloc(32);
     const op = exports.alloc(64);
     try {
-        mem.set(d, dp);
-        mem.set(pub.subarray(0, 32), pxp);
-        mem.set(pub.subarray(32, 64), pyp);
-        mem.set(m, mp);
+        putBytes(d, dp);
+        putBytes(pub.subarray(0, 32), pxp);
+        putBytes(pub.subarray(32, 64), pyp);
+        putBytes(m, mp);
         // 最多重试几次 k（极小概率 r/s 为 0 或 r+k==n）。
         for (let attempt = 0; attempt < 16; attempt++) {
             const k = randomK();
-            mem.set(k, kp);
+            putBytes(k, kp);
             const rc = exports.signOut(dp, pxp, pyp, mp, m.length, kp, op);
             if (rc === 0) {
-                return fromBytes(new Uint8Array(mem.buffer, op, 64).slice(), 'hex');
+                return fromBytes(readBytes(op, 64), 'hex');
             }
         }
         throw new Error('sm2.sign: failed to produce a valid signature after retries');
@@ -251,16 +268,15 @@ export function verify(publicKey, message, signature) {
     if (sig.length !== 64)
         throw new InvalidCiphertextError('sm2: signature must be 64 bytes');
     const { exports } = getModule();
-    const mem = new Uint8Array(getModule().memory.buffer);
     const pxp = exports.alloc(32);
     const pyp = exports.alloc(32);
     const mp = exports.alloc(m.length);
     const sigp = exports.alloc(64);
     try {
-        mem.set(x, pxp);
-        mem.set(y, pyp);
-        mem.set(m, mp);
-        mem.set(sig, sigp);
+        putBytes(x, pxp);
+        putBytes(y, pyp);
+        putBytes(m, mp);
+        putBytes(sig, sigp);
         return exports.verifyOut(pxp, pyp, mp, m.length, sigp) === 1;
     }
     finally {
@@ -286,21 +302,20 @@ export function encrypt(publicKey, message, opts = {}) {
     }
     const m = toBytes(message, 'message');
     const { exports } = getModule();
-    const mem = new Uint8Array(getModule().memory.buffer);
     const pxp = exports.alloc(32);
     const pyp = exports.alloc(32);
     const mp = exports.alloc(m.length);
     const kp = exports.alloc(32);
     const ctp = exports.alloc(97 + m.length);
     try {
-        mem.set(x, pxp);
-        mem.set(y, pyp);
-        mem.set(m, mp);
+        putBytes(x, pxp);
+        putBytes(y, pyp);
+        putBytes(m, mp);
         for (let attempt = 0; attempt < 16; attempt++) {
-            mem.set(randomK(), kp);
+            putBytes(randomK(), kp);
             const rc = exports.encryptOut(pxp, pyp, mp, m.length, kp, ctp);
             if (rc === 1) {
-                const raw = new Uint8Array(mem.buffer, ctp, 97 + m.length).slice();
+                const raw = readBytes(ctp, 97 + m.length);
                 return fromBytes(format === 'C1C2C3' ? c1c3c2ToC1c2c3(raw) : raw, 'hex');
             }
         }
@@ -354,18 +369,17 @@ function decryptUnsafe(privateKey, ciphertext, opts) {
 /** 按 C1C3C2 布局解密（wasm 侧约定的布局）。 */
 function decryptRaw(d, ct) {
     const { exports } = getModule();
-    const mem = new Uint8Array(getModule().memory.buffer);
     const dp = exports.alloc(32);
     const ctp = exports.alloc(ct.length);
     const outLen = ct.length - 97;
     const ptp = exports.alloc(outLen === 0 ? 1 : outLen);
     try {
-        mem.set(d, dp);
-        mem.set(ct, ctp);
+        putBytes(d, dp);
+        putBytes(ct, ctp);
         const rc = exports.decryptOut(dp, ctp, ct.length, ptp);
         if (rc !== 1)
             throw new DecryptionError('sm2.decrypt: C3 verification failed');
-        return fromBytes(new Uint8Array(mem.buffer, ptp, outLen).slice(), 'hex');
+        return fromBytes(readBytes(ptp, outLen), 'hex');
     }
     finally {
         exports.freeAll();

package/dist/sm4/index.js

@@ -34,7 +34,7 @@ function withBuffers(key, data, outLen, fn) {
         const mem = new Uint8Array(memory.buffer);
         mem.set(key, keyPtr);
         mem.set(data, inPtr);
-        return fn(keyPtr, inPtr, outPtr, new Uint8Array(memory.buffer));
+        return fn(keyPtr, inPtr, outPtr);
     }
     finally {
         exports.freeAll();
@@ -244,7 +244,7 @@ function withGcmBuffers(k, v, a, data, fn) {
             mem.set(a, aadPtr);
         if (data.length !== 0)
             mem.set(data, inPtr);
-        return fn({ keyPtr, ivPtr, aadPtr, inPtr, outPtr, tagPtr }, mem);
+        return fn({ keyPtr, ivPtr, aadPtr, inPtr, outPtr, tagPtr });
     }
     finally {
         exports.freeAll();

package/dist/sm9/index.js

@@ -354,17 +354,21 @@ export function encrypt(publicKey, id, msg, r) {
     const idP = exports.alloc(idB.length);
     const msgP = exports.alloc(msgB.length);
     const rP = exports.alloc(32);
-    const ctP = exports.alloc(4096);
+    // 密文布局 C1(65) || C3(32) || C2(|msg|)，长度随明文增长 —— 按实际长度分配，
+    // 并把容量一并交给 wasm 侧校验。曾硬编码 alloc(4096)：明文超过 3999 字节时
+    // sm9Encrypt 会写越界、破坏 GC 堆（几轮后 RuntimeError: memory access out of bounds）。
+    const ctCap = 65 + 32 + msgB.length;
+    const ctP = exports.alloc(ctCap);
     try {
         putBytes(key.bytes, keyP);
         putBytes(idB, idP);
         putBytes(msgB, msgP);
         putBytes(rB, rP);
         const ctLen = key.kind === 'public'
-            ? exports.sm9EncryptPubOut(keyP, idP, idB.length, msgP, msgB.length, rP, ctP)
-            : exports.sm9EncryptOut(keyP, idP, idB.length, msgP, msgB.length, rP, ctP);
+            ? exports.sm9EncryptPubOut(keyP, idP, idB.length, msgP, msgB.length, rP, ctP, ctCap)
+            : exports.sm9EncryptOut(keyP, idP, idB.length, msgP, msgB.length, rP, ctP, ctCap);
         if (ctLen < 0)
-            throw new Error('sm9: encrypt 失败');
+            throw new Error('sm9: encrypt 失败（密文缓冲容量不足）');
         return readHex(ctP, ctLen);
     }
     finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sm-crypto-wasm",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "国密 SM2/SM3/SM4/SM9/ZUC 的 WASM 实现，Node 18+ 与现代浏览器均可使用，按算法分包懒加载。",
   "description:en": "SM2/SM3/SM4/SM9/ZUC (China crypto) implemented in AssemblyScript -> WASM. Node 18+ & modern browsers, per-algorithm lazy loading.",
   "license": "Apache-2.0",
@@ -30,6 +30,10 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "browser": {
+    "./dist/runtime/loadWasm.js": "./dist/runtime/loadWasm.browser.js",
+    "./dist/runtime/random.js": "./dist/runtime/random.browser.js"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -55,6 +59,10 @@
       "types": "./dist/zuc/index.d.ts",
       "import": "./dist/zuc/index.js"
     },
+    "./esbuild-plugin": {
+      "types": "./dist/esbuild-plugin.d.ts",
+      "import": "./dist/esbuild-plugin.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [