sm-crypto-wasm 0.1.0 → 0.1.1

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.1",
   "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",