sm-crypto-wasm 0.3.1 → 0.7.0

package/dist/pem/asn1.js

@@ -1,297 +1,15 @@
 /**
- * 最小化 ASN.1 DER 解析器与编码器（BER/DER 子集）。
+ * 旧 ASN.1 入口（兼容层）。
  *
- * 本仓库只用到以下类型，刻意不做全 BER：
- * - INTEGER (0x02)、BIT STRING (0x03)、OCTET STRING (0x04)、NULL (0x05)
- * - OBJECT IDENTIFIER (0x06)、SEQUENCE (0x30, constructed)
+ * 实现已迁移到 `src/asn1/`（DER/BER 通用层）。本文件只保留历史导出名，
+ * 使 `src/pem/*` 与既有测试无需改动：
  *
- * 不支持 indefinite-length encoding（length byte = 0x80），国密 PKCS#8
- * 也用不到。长度只支持 definite-length（短/长两种格式）。
+ * - `parseDer` → `src/asn1/decode.ts`
+ * - `encodeDer` → `src/asn1/encode.ts` 的 `encode`
+ * - `asn1Int` / `asn1Octets` / `asn1Oid` / `asn1Null` / `asn1Seq` → 对应构造器
+ * - `encodeOid` / `decodeOid` / `asn1IntValue` → OID 与 INTEGER 解码
  *
- * spec/plan 对应：plan Task 4；spec §12.1 Q3（SM9 PKCS#8 + 自定义 OID）。
+ * spec/plan 对应：X.509/CMS plan 阶段 0「迁移」。
  */
-/** 抛错信息统一封装。 */
-export class Asn1Error extends Error {
-    name = 'Asn1Error';
-}
-const TAG_INTEGER = 0x02;
-const _TAG_BIT_STRING = 0x03;
-const TAG_OCTET_STRING = 0x04;
-const TAG_NULL = 0x05;
-const TAG_OID = 0x06;
-const TAG_SEQUENCE = 0x30; // constructed
-/**
- * 解析一段 DER 字节。
- *
- * @param buf DER 字节。
- * @returns 解析后的根节点（通常为 SEQUENCE）。
- * @throws Asn1Error 输入截断、tag/length 不合法、不支持的构造。
- */
-export function parseDer(buf) {
-    const reader = new Reader(buf);
-    const node = reader.readNode();
-    // 允许根节点之后留 0 字节尾巴；多余字节视为错误。
-    if (reader.remaining() !== 0) {
-        throw new Asn1Error(`parseDer: ${reader.remaining()} trailing bytes after root node`);
-    }
-    return node;
-}
-/**
- * 将 Asn1Node 编码回 DER 字节。**重新计算 length 与 raw**。
- *
- * @param node 待编码节点。
- * @returns DER 字节。
- */
-export function encodeDer(node) {
-    // 值字节：primitive 直接取 value；constructed 递归子节点。
-    const parts = [];
-    if (node.children) {
-        for (const child of node.children)
-            parts.push(encodeDer(child));
-    }
-    const value = node.children ? concat(parts) : node.value;
-    const lengthBytes = encodeLength(value.length);
-    const tagByte = node.tag & 0xff;
-    const out = new Uint8Array(1 + lengthBytes.length + value.length);
-    out[0] = tagByte;
-    for (let i = 0; i < lengthBytes.length; i++)
-        out[1 + i] = lengthBytes[i] ?? 0;
-    for (let i = 0; i < value.length; i++) {
-        out[1 + lengthBytes.length + i] = value[i] ?? 0;
-    }
-    return out;
-}
-/**
- * 便捷构造函数：构造一个 INTEGER 节点。
- *
- * @param value 大端整数（可为负：负数用二进制补码表示）。
- */
-export function asn1Int(value) {
-    const bytes = bigintToBytes(BigInt(value));
-    const raw = concat([new Uint8Array([TAG_INTEGER]), encodeLength(bytes.length), bytes]);
-    return {
-        cls: 0,
-        tag: TAG_INTEGER,
-        length: bytes.length,
-        value: bytes,
-        raw,
-    };
-}
-/** 便捷构造函数：构造一个 OCTET STRING 节点。 */
-export function asn1Octets(value) {
-    const raw = concat([new Uint8Array([TAG_OCTET_STRING]), encodeLength(value.length), value]);
-    return {
-        cls: 0,
-        tag: TAG_OCTET_STRING,
-        length: value.length,
-        value,
-        raw,
-    };
-}
-/** 便捷构造函数：构造一个 OID 节点（输入如 `"1.2.156.10197.1.100"`）。 */
-export function asn1Oid(oid) {
-    const bytes = encodeOid(oid);
-    const raw = concat([new Uint8Array([TAG_OID]), encodeLength(bytes.length), bytes]);
-    return { cls: 0, tag: TAG_OID, length: bytes.length, value: bytes, raw };
-}
-/** 便捷构造函数：构造一个 NULL 节点。 */
-export function asn1Null() {
-    const raw = new Uint8Array([TAG_NULL, 0x00]);
-    return { cls: 0, tag: TAG_NULL, length: 0, value: new Uint8Array(0), raw };
-}
-/** 便捷构造函数：构造一个 SEQUENCE 节点。 */
-export function asn1Seq(children) {
-    const parts = children.map((c) => c.raw);
-    const value = concat(parts);
-    const raw = concat([new Uint8Array([TAG_SEQUENCE]), encodeLength(value.length), value]);
-    // tag 字段统一存 UNIVERSAL 编号 16（0x10），与 Reader 输出一致；
-    // raw 首字节保留完整 0x30 以便序列化。
-    return {
-        cls: 0,
-        tag: 0x10,
-        length: value.length,
-        value,
-        children,
-        raw,
-    };
-}
-// ----------------- 内部：长度编码 -----------------
-function encodeLength(len) {
-    if (len < 0 || !Number.isInteger(len)) {
-        throw new Asn1Error(`encodeLength: bad length ${len}`);
-    }
-    if (len < 0x80)
-        return new Uint8Array([len]);
-    // 长格式：首个字节 0x80|n（n = 后续字节数），后续 big-endian 长度。
-    const bytes = [];
-    let v = len;
-    while (v > 0) {
-        bytes.unshift(v & 0xff);
-        v >>= 8;
-    }
-    return new Uint8Array([0x80 | bytes.length, ...bytes]);
-}
-// ----------------- 内部：OID 编码 -----------------
-/**
- * OID 编码：第一个子标识符 = a*40 + b，后续每个子标识符按 7-bit 编码。
- *
- * 例：`1.2.156.10197.1.100` → [0x2a, 0x86, 0x48, 0xce, 0x3d, 0x01, 0x01, 0x64]
- *     1*40+2 = 42 = 0x2a；156、10197、1、100 都用 base-128 编码。
- *
- * @param oid 点分 OID 字符串。
- * @returns OID 内容字节（不含 tag 和 length）。
- */
-export function encodeOid(oid) {
-    const parts = oid.split('.').map((s) => parseInt(s, 10));
-    if (parts.length < 2 || parts.some((n) => !Number.isFinite(n) || n < 0)) {
-        throw new Asn1Error(`encodeOid: bad oid "${oid}"`);
-    }
-    const first = (parts[0] ?? 0) * 40 + (parts[1] ?? 0);
-    const out = [first];
-    for (let i = 2; i < parts.length; i++) {
-        out.push(...encodeBase128(parts[i] ?? 0));
-    }
-    return new Uint8Array(out);
-}
-/** 反向解码。 */
-export function decodeOid(bytes) {
-    if (bytes.length === 0)
-        throw new Asn1Error('decodeOid: empty');
-    const first = bytes[0] ?? 0;
-    const a = Math.floor(first / 40);
-    const b = first % 40;
-    const parts = [a, b];
-    let value = 0;
-    for (let i = 1; i < bytes.length; i++) {
-        const octet = bytes[i] ?? 0;
-        value = (value << 7) | (octet & 0x7f);
-        if ((octet & 0x80) === 0) {
-            parts.push(value);
-            value = 0;
-        }
-    }
-    if (value !== 0)
-        throw new Asn1Error('decodeOid: truncated');
-    return parts.join('.');
-}
-function encodeBase128(n) {
-    if (n < 0 || !Number.isInteger(n)) {
-        throw new Asn1Error(`encodeBase128: bad ${n}`);
-    }
-    if (n < 0x80)
-        return [n];
-    const out = [];
-    let v = n;
-    do {
-        out.unshift((v & 0x7f) | 0x80);
-        v >>= 7;
-    } while (v > 0);
-    out[out.length - 1] = (out[out.length - 1] ?? 0) & 0x7f;
-    return out;
-}
-// ----------------- 内部：大端整数 -----------------
-function bigintToBytes(n) {
-    if (n === 0n)
-        return new Uint8Array([0]);
-    const negative = n < 0n;
-    let v = negative ? -n : n;
-    const tmp = [];
-    while (v > 0n) {
-        tmp.unshift(Number(v & 0xffn));
-        v >>= 8n;
-    }
-    // 负数采用补码：高位加 0xff 让最高位为 1。
-    if (negative) {
-        // 简化处理：本仓库不需要负 INTEGER。
-        throw new Asn1Error('bigintToBytes: negative integers not supported');
-    }
-    // 正数：补 0x00 前缀以免被当成负数（最高位为 1 时必须）。
-    if ((tmp[0] ?? 0) & 0x80)
-        tmp.unshift(0);
-    return new Uint8Array(tmp);
-}
-/** 读一个 INTEGER 返回 bigint。 */
-export function asn1IntValue(node) {
-    if (node.tag !== TAG_INTEGER) {
-        throw new Asn1Error(`asn1IntValue: tag ${node.tag}, expected INTEGER`);
-    }
-    let v = 0n;
-    for (let i = 0; i < node.value.length; i++) {
-        v = (v << 8n) | BigInt(node.value[i] ?? 0);
-    }
-    return v;
-}
-// ----------------- 内部：Reader -----------------
-class Reader {
-    buf;
-    pos = 0;
-    constructor(buf) {
-        this.buf = buf;
-    }
-    remaining() {
-        return this.buf.length - this.pos;
-    }
-    take(n) {
-        if (this.pos + n > this.buf.length) {
-            throw new Asn1Error(`Reader: truncated, need ${n} bytes at pos ${this.pos}`);
-        }
-        const out = this.buf.subarray(this.pos, this.pos + n);
-        this.pos += n;
-        return out;
-    }
-    readTag() {
-        if (this.remaining() < 1)
-            throw new Asn1Error('Reader: empty tag');
-        return this.buf[this.pos++] ?? 0;
-    }
-    readLength() {
-        if (this.remaining() < 1)
-            throw new Asn1Error('Reader: empty length');
-        const first = this.buf[this.pos++] ?? 0;
-        if ((first & 0x80) === 0)
-            return first;
-        const n = first & 0x7f;
-        if (n === 0)
-            throw new Asn1Error('Reader: indefinite length not supported');
-        if (this.remaining() < n)
-            throw new Asn1Error('Reader: truncated long length');
-        let len = 0;
-        for (let i = 0; i < n; i++) {
-            len = (len << 8) | (this.buf[this.pos++] ?? 0);
-        }
-        return len;
-    }
-    readNode() {
-        const tagStart = this.pos;
-        const tag = this.readTag();
-        const length = this.readLength();
-        const cls = (tag & 0xc0) >> 6;
-        const tagNum = tag & 0x1f;
-        const valueStart = this.pos;
-        const value = this.take(length);
-        const raw = this.buf.subarray(tagStart, valueStart + length);
-        const constructed = (tag & 0x20) !== 0;
-        if (constructed) {
-            // SEQUENCE 等：递归子节点。
-            const inner = new Reader(value);
-            const children = [];
-            while (inner.remaining() > 0) {
-                children.push(inner.readNode());
-            }
-            return { cls, tag: tagNum, length, value, children, raw };
-        }
-        return { cls, tag: tagNum, length, value, raw };
-    }
-}
-function concat(parts) {
-    let total = 0;
-    for (const p of parts)
-        total += p.length;
-    const out = new Uint8Array(total);
-    let off = 0;
-    for (const p of parts) {
-        out.set(p, off);
-        off += p.length;
-    }
-    return out;
-}
+export { decodeOid, encode as encodeDer, encodeOid, integer as asn1Int, nullValue as asn1Null, octetString as asn1Octets, oid as asn1Oid, parseDer, readInteger as asn1IntValue, seq as asn1Seq, } from '../asn1/index.js';
+export { Asn1Error } from '../asn1/types.js';

package/dist/pem/pkcs8.js

@@ -155,7 +155,15 @@ function bitStringNode(value) {
     for (let i = 0; i < value.length; i++) {
         raw[1 + lengthBytes.length + i] = value[i] ?? 0;
     }
-    return { cls: 0, tag: 0x03, length: value.length, value, raw };
+    return {
+        cls: 0,
+        tag: 0x03,
+        constructed: false,
+        indefinite: false,
+        length: value.length,
+        value,
+        raw,
+    };
 }
 function encodeLen(n) {
     if (n < 0x80)

package/dist/pem/sm2.d.ts

@@ -37,12 +37,24 @@ export declare const OID_SM2_CURVE = "1.2.156.10197.1.301";
  * @throws InvalidKeyError PEM/DER 结构非法、或曲线不是 SM2。
  */
 export declare function parseSm2PrivateKeyPem(pem: string): Uint8Array;
+/**
+ * 解析 SM2 私钥 DER（PKCS#8 或 SEC1），返回 32 字节私钥 d。
+ *
+ * WebCrypto 的 `importKey('pkcs8', ...)` 使用这个入口。
+ */
+export declare function parseSm2PrivateKeyDer(der: Uint8Array): Uint8Array;
 /**
  * 解析 SM2 公钥 PEM，返回 65 字节未压缩点 `04 || X || Y`。
  *
  * @throws InvalidKeyError PEM/DER 结构非法、曲线不是 SM2、或点不是未压缩形式。
  */
 export declare function parseSm2PublicKeyPem(pem: string): Uint8Array;
+/**
+ * 解析 SM2 公钥 DER（SPKI），返回 65 字节未压缩点。
+ *
+ * WebCrypto 的 `importKey('spki', ...)` 使用这个入口。
+ */
+export declare function parseSm2PublicKeyDer(der: Uint8Array): Uint8Array;
 /**
  * 编码 SM2 私钥为 PKCS#8 PEM（`BEGIN PRIVATE KEY`）。
  *
@@ -50,9 +62,13 @@ export declare function parseSm2PublicKeyPem(pem: string): Uint8Array;
  * @param pub 可选公钥（64 或 65 字节）；给出则内嵌到 ECPrivateKey 的 `[1]`。
  */
 export declare function encodeSm2PrivateKeyPem(d: string | Uint8Array, pub?: string | Uint8Array): string;
+/** 编码 SM2 私钥为 PKCS#8 DER。 */
+export declare function encodeSm2PrivateKeyDer(d: string | Uint8Array, pub?: string | Uint8Array): Uint8Array;
 /**
  * 编码 SM2 公钥为 SPKI PEM（`BEGIN PUBLIC KEY`）。
  *
  * @param pub 64（X || Y）或 65（04 || X || Y）字节公钥。
  */
 export declare function encodeSm2PublicKeyPem(pub: string | Uint8Array): string;
+/** 编码 SM2 公钥为 SPKI DER。 */
+export declare function encodeSm2PublicKeyDer(pub: string | Uint8Array): Uint8Array;

package/dist/pem/sm2.js

@@ -47,7 +47,14 @@ const CLS_CONTEXT = 2;
  * @throws InvalidKeyError PEM/DER 结构非法、或曲线不是 SM2。
  */
 export function parseSm2PrivateKeyPem(pem) {
-    const der = pemToBytes(pem, 'sm2.privateKey');
+    return parseSm2PrivateKeyDer(pemToBytes(pem, 'sm2.privateKey'));
+}
+/**
+ * 解析 SM2 私钥 DER（PKCS#8 或 SEC1），返回 32 字节私钥 d。
+ *
+ * WebCrypto 的 `importKey('pkcs8', ...)` 使用这个入口。
+ */
+export function parseSm2PrivateKeyDer(der) {
     const top = parseOrThrow(der, 'parseSm2PrivateKeyPem');
     const kids = top.children;
     if (top.tag !== TAG_SEQUENCE || !kids) {
@@ -92,7 +99,14 @@ export function parseSm2PrivateKeyPem(pem) {
  * @throws InvalidKeyError PEM/DER 结构非法、曲线不是 SM2、或点不是未压缩形式。
  */
 export function parseSm2PublicKeyPem(pem) {
-    const der = pemToBytes(pem, 'sm2.publicKey');
+    return parseSm2PublicKeyDer(pemToBytes(pem, 'sm2.publicKey'));
+}
+/**
+ * 解析 SM2 公钥 DER（SPKI），返回 65 字节未压缩点。
+ *
+ * WebCrypto 的 `importKey('spki', ...)` 使用这个入口。
+ */
+export function parseSm2PublicKeyDer(der) {
     const top = parseOrThrow(der, 'parseSm2PublicKeyPem');
     const kids = top.children;
     if (top.tag !== TAG_SEQUENCE || !kids || kids.length < 2) {
@@ -118,6 +132,10 @@ export function parseSm2PublicKeyPem(pem) {
  * @param pub 可选公钥（64 或 65 字节）；给出则内嵌到 ECPrivateKey 的 `[1]`。
  */
 export function encodeSm2PrivateKeyPem(d, pub) {
+    return bytesToPem(encodeSm2PrivateKeyDer(d, pub), 'PRIVATE KEY');
+}
+/** 编码 SM2 私钥为 PKCS#8 DER。 */
+export function encodeSm2PrivateKeyDer(d, pub) {
     const scalar = normalizeScalar(d);
     const ecChildren = [
         asn1Int(1),
@@ -136,7 +154,7 @@ export function encodeSm2PrivateKeyPem(d, pub) {
         asn1Seq([asn1Oid(OID_ID_EC_PUBLIC_KEY), asn1Oid(OID_SM2_CURVE)]),
         asn1Octets(ec.raw),
     ]);
-    return bytesToPem(pkcs8.raw, 'PRIVATE KEY');
+    return pkcs8.raw;
 }
 /**
  * 编码 SM2 公钥为 SPKI PEM（`BEGIN PUBLIC KEY`）。
@@ -144,6 +162,10 @@ export function encodeSm2PrivateKeyPem(d, pub) {
  * @param pub 64（X || Y）或 65（04 || X || Y）字节公钥。
  */
 export function encodeSm2PublicKeyPem(pub) {
+    return bytesToPem(encodeSm2PublicKeyDer(pub), 'PUBLIC KEY');
+}
+/** 编码 SM2 公钥为 SPKI DER。 */
+export function encodeSm2PublicKeyDer(pub) {
     const point = normalizeUncompressed(pub);
     const bits = new Uint8Array(point.length + 1);
     bits.set(point, 1);
@@ -151,7 +173,7 @@ export function encodeSm2PublicKeyPem(pub) {
         asn1Seq([asn1Oid(OID_ID_EC_PUBLIC_KEY), asn1Oid(OID_SM2_CURVE)]),
         bitStringNode(bits),
     ]);
-    return bytesToPem(spki.raw, 'PUBLIC KEY');
+    return spki.raw;
 }
 // ---------- 内部 ----------
 function parseOrThrow(der, where) {
@@ -229,7 +251,15 @@ function normalizeUncompressed(pub) {
 /** 构造 BIT STRING 节点（value 需自带首字节「未使用位数」）。 */
 function bitStringNode(value) {
     const raw = concat([new Uint8Array([TAG_BIT_STRING]), encodeLen(value.length), value]);
-    return { cls: 0, tag: TAG_BIT_STRING, length: value.length, value, raw };
+    return {
+        cls: 0,
+        tag: TAG_BIT_STRING,
+        constructed: false,
+        indefinite: false,
+        length: value.length,
+        value,
+        raw,
+    };
 }
 /** 构造 [n] EXPLICIT 包装节点。 */
 function explicit(tagNum, inner) {
@@ -237,6 +267,8 @@ function explicit(tagNum, inner) {
     return {
         cls: CLS_CONTEXT,
         tag: tagNum,
+        constructed: true,
+        indefinite: false,
         length: inner.raw.length,
         value: inner.raw,
         children: [inner],

package/dist/sm2/index.d.ts

@@ -120,12 +120,81 @@ export declare function createSignaturePointPool(n: number): Promise<SignaturePo
  * @returns 64 字节签名（r || s）的 hex。
  */
 export declare function sign(privateKey: string | Uint8Array, message: string | Uint8Array, opts?: SignOptions): string;
+/**
+ * SM2 签名（自定义用户标识）。
+ *
+ * 与 `sign` 的区别仅在于 Z 值使用 `userID` 计算。X.509 签发需要它：
+ * OpenSSL 的 X.509 路径默认使用空标识，GM/T 证书使用 `1234567812345678`。
+ *
+ * 不支持 `pointPool`（签发场景不需要；需要时用 `sign` 的默认标识路径）。
+ *
+ * @param privateKey 32 字节私钥（hex / Uint8Array / PEM）。
+ * @param message 待签名消息。
+ * @param userID 用户标识（可为空数组）。
+ * @returns 64 字节签名 `r ‖ s` 的 hex。
+ */
+export declare function signWithID(privateKey: string | Uint8Array, message: string | Uint8Array, userID: Uint8Array): string;
 /**
  * SM2 验签。
  *
  * @returns true 有效。
  */
 export declare function verify(publicKey: string | Uint8Array, message: string | Uint8Array, signature: string | Uint8Array): boolean;
+/**
+ * SM2 验签（自定义用户标识）。
+ *
+ * 与 `verify` 的区别仅在于 Z 值使用 `userID` 计算。X.509 证书签名需要它：
+ * GM/T 证书使用默认标识 `1234567812345678`，而 OpenSSL 的 X.509 路径
+ * 默认使用空标识。
+ *
+ * @param publicKey 64/65 字节公钥。
+ * @param message 消息。
+ * @param signature 64 字节 `r ‖ s`。
+ * @param userID 用户标识（可为空数组）。
+ * @returns true 有效。
+ */
+export declare function verifyWithID(publicKey: string | Uint8Array, message: string | Uint8Array, signature: string | Uint8Array, userID: Uint8Array): boolean;
+/** 多槽公钥缓存的配置。 */
+export interface PreparedKeyCacheOptions {
+    /** 槽位上限，1..8，默认 8。 */
+    capacity?: number;
+}
+/**
+ * 配置多槽公钥缓存（默认 8 槽，满了按 LRU 淘汰）。
+ *
+ * 缩小容量不会立即清除高槽位，只是之后的查找与 `getPreparedPublicKeys` 不再考虑它们；
+ * 需要释放时调用 `clearPreparedPublicKeys()`。wasm 未加载时只记录，首次
+ * `preparePublicKey` 会应用。
+ */
+export declare function configurePreparedKeyCache(opts?: PreparedKeyCacheOptions): void;
+/**
+ * 为一对**固定公钥**预计算 comb 表（默认 8 槽，满了 LRU 淘汰）。
+ *
+ * 之后 `encrypt` / `kemEncrypt` / `hybridEncrypt` 对该公钥会把 `k·P` 从 wNAF
+ * （256 次倍点）切到 comb（52 次倍点）：本机端到端约 486 → 260 µs。建表一次性
+ * 约 280 µs，**约 1.2 次加密回本**。
+ *
+ * **只有显式 prepare 才会建表**：`encrypt` 命中就走 comb，不命中直接回退 wNAF，
+ * 绝不隐式建表 —— 否则外部可控的公钥能反复触发建表，形成放大面。
+ *
+ * 公钥是公开信息，缓存它不引入新的密钥材料驻留；8 槽共占 wasm 永久区固定 24 KiB。
+ *
+ * @param publicKey 64/65 字节公钥（hex / Uint8Array / PEM）。
+ * @throws {InvalidPublicKeyError} 公钥不在 SM2 曲线上。
+ */
+export declare function preparePublicKey(publicKey: string | Uint8Array): Promise<void>;
+/** 清空所有公钥预计算槽，之后的 `encrypt` 全部回退到 wNAF。未加载 wasm 时也安全。 */
+export declare function clearPreparedPublicKeys(): void;
+/** @deprecated 用 `clearPreparedPublicKeys()`（保留单数别名）。 */
+export declare function clearPreparedPublicKey(): void;
+/**
+ * 当前槽位中的公钥（hex，按槽序）。
+ *
+ * wasm 未加载时返回空数组。
+ */
+export declare function getPreparedPublicKeys(): string[];
+/** 最后一次 `preparePublicKey` 的公钥（hex）；没有则为 `null`。 */
+export declare function getPreparedPublicKey(): string | null;
 /**
  * SM2 加密。
  *