sm-crypto-wasm 0.3.0 → 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/runtime/base64.core.d.ts

@@ -0,0 +1,22 @@
+/**
+ * base64 纯 JS 实现（宿主既没有 `Buffer`、也没有 `btoa` / `atob` 时的兜底）。
+ *
+ * 存在理由：微信小程序等运行时没有 `btoa` / `atob`，而 SM2 / SM9 的 PEM 密钥
+ * 生成与解析需要 base64。base64 是确定性编码、不属于密码学原语，因此在库内兜底
+ * 不需要像 RNG 那样 fail-closed。
+ *
+ * 只在 `runtime/convert.ts` 的最后一级回退里使用；Node 有 `Buffer`、浏览器有
+ * `btoa` / `atob` 时都不会走到这里。零 `node:*` 引用，可安全进入浏览器/小程序产物。
+ */
+/** 标准 base64 编码（带 `=` padding）。 */
+export declare function encodeBase64(bytes: Uint8Array): string;
+/**
+ * 标准 base64 解码。
+ *
+ * 与 `atob` 的宽松度对齐：允许空白字符与缺失 padding；非法字符、非法长度抛
+ * `TypeError`（`convert.base64ToBytes` 的契约是失败抛 TypeError）。
+ *
+ * @param b64 base64 字符串。
+ * @param label 错误信息里的字段名。
+ */
+export declare function decodeBase64(b64: string, label?: string): Uint8Array;

package/dist/runtime/base64.core.js

@@ -0,0 +1,68 @@
+/**
+ * base64 纯 JS 实现（宿主既没有 `Buffer`、也没有 `btoa` / `atob` 时的兜底）。
+ *
+ * 存在理由：微信小程序等运行时没有 `btoa` / `atob`，而 SM2 / SM9 的 PEM 密钥
+ * 生成与解析需要 base64。base64 是确定性编码、不属于密码学原语，因此在库内兜底
+ * 不需要像 RNG 那样 fail-closed。
+ *
+ * 只在 `runtime/convert.ts` 的最后一级回退里使用；Node 有 `Buffer`、浏览器有
+ * `btoa` / `atob` 时都不会走到这里。零 `node:*` 引用，可安全进入浏览器/小程序产物。
+ */
+const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+/** 标准 base64 编码（带 `=` padding）。 */
+export function encodeBase64(bytes) {
+    let out = '';
+    for (let i = 0; i < bytes.length; i += 3) {
+        const a = bytes[i] ?? 0;
+        const hasB = i + 1 < bytes.length;
+        const hasC = i + 2 < bytes.length;
+        const b = hasB ? (bytes[i + 1] ?? 0) : 0;
+        const c = hasC ? (bytes[i + 2] ?? 0) : 0;
+        const n = (a << 16) | (b << 8) | c;
+        out += B64.charAt((n >> 18) & 63);
+        out += B64.charAt((n >> 12) & 63);
+        out += hasB ? B64.charAt((n >> 6) & 63) : '=';
+        out += hasC ? B64.charAt(n & 63) : '=';
+    }
+    return out;
+}
+/**
+ * 标准 base64 解码。
+ *
+ * 与 `atob` 的宽松度对齐：允许空白字符与缺失 padding；非法字符、非法长度抛
+ * `TypeError`（`convert.base64ToBytes` 的契约是失败抛 TypeError）。
+ *
+ * @param b64 base64 字符串。
+ * @param label 错误信息里的字段名。
+ */
+export function decodeBase64(b64, label = 'base64') {
+    const stripped = b64.replace(/[\t\n\f\r ]/g, '');
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(stripped)) {
+        throw new TypeError(`${label}: invalid base64`);
+    }
+    const pad = stripped.endsWith('==') ? 2 : stripped.endsWith('=') ? 1 : 0;
+    if (pad > 0 && stripped.length % 4 !== 0) {
+        throw new TypeError(`${label}: invalid base64 padding`);
+    }
+    const body = pad > 0 ? stripped.slice(0, -pad) : stripped;
+    if (body.length % 4 === 1) {
+        throw new TypeError(`${label}: invalid base64 length`);
+    }
+    const out = new Uint8Array(Math.floor((body.length * 3) / 4));
+    let buffer = 0;
+    let bits = 0;
+    let pos = 0;
+    for (let i = 0; i < body.length; i++) {
+        const v = B64.indexOf(body.charAt(i));
+        if (v < 0)
+            throw new TypeError(`${label}: invalid base64 character at index ${i}`);
+        buffer = (buffer << 6) | v;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out[pos++] = (buffer >> bits) & 0xff;
+            buffer &= (1 << bits) - 1;
+        }
+    }
+    return out.subarray(0, pos);
+}

package/dist/runtime/convert.d.ts

@@ -40,10 +40,19 @@ export declare function fromBytes(bytes: Uint8Array, format?: OutputFormat): str
 export declare function bytesToHex(bytes: Uint8Array): string;
 /** hex 字符串 → bytes。支持 `0x` 前缀。奇数位长度或非法字符抛错。 */
 export declare function hexToBytes(hex: string, label?: string): Uint8Array;
-/** bytes → base64。Node `Buffer` 优先，浏览器回落到 `btoa`。 */
+/**
+ * bytes → base64。优先级：Node `Buffer` → 宿主 `btoa` → 纯 JS 兜底。
+ *
+ * 微信小程序既没有 `Buffer` 也没有 `btoa`，会走最后一级；不需要宿主再安装
+ * base64 polyfill。
+ */
 export declare function bytesToBase64(bytes: Uint8Array): string;
-/** base64 字符串 → bytes。失败抛 TypeError。 */
-export declare function base64ToBytes(b64: string, _label?: string): Uint8Array;
+/**
+ * base64 字符串 → bytes。失败抛 TypeError。
+ *
+ * 优先级：Node `Buffer` → 宿主 `atob` → 纯 JS 兜底（微信小程序等）。
+ */
+export declare function base64ToBytes(b64: string, label?: string): Uint8Array;
 /** PEM → bytes。剥去 BEGIN/END armor，base64 解码。 */
 export declare function pemToBytes(pem: string, label?: string): Uint8Array;
 /** bytes → PEM（带 BEGIN/END 头）。`kind` 例：`SM2 PRIVATE KEY`。 */

package/dist/runtime/convert.js

@@ -16,6 +16,7 @@
  *
  * spec/plan 对应：plan Task 2；spec §6 API 默认 hex、§9 安全姿态。
  */
+import { decodeBase64, encodeBase64 } from './base64.core.js';
 /**
  * 把任意 `Input` 归一化为 `Uint8Array`。
  *
@@ -106,20 +107,32 @@ export function hexToBytes(hex, label = 'hex') {
     // tryParseHex 已覆盖全部合法情形，走到这里说明上面漏判，兜底抛错。
     throw new TypeError(`hexToBytes(${label}): invalid hex`);
 }
-/** bytes → base64。Node `Buffer` 优先，浏览器回落到 `btoa`。 */
+/**
+ * bytes → base64。优先级：Node `Buffer` → 宿主 `btoa` → 纯 JS 兜底。
+ *
+ * 微信小程序既没有 `Buffer` 也没有 `btoa`，会走最后一级；不需要宿主再安装
+ * base64 polyfill。
+ */
 export function bytesToBase64(bytes) {
     if (HAS_BUFFER) {
         return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('base64');
     }
-    let bin = '';
-    for (let i = 0; i < bytes.length; i++)
-        bin += String.fromCharCode(bytes[i] ?? 0);
-    return btoa(bin);
+    if (HAS_BTOA) {
+        let bin = '';
+        for (let i = 0; i < bytes.length; i++)
+            bin += String.fromCharCode(bytes[i] ?? 0);
+        return btoa(bin);
+    }
+    return encodeBase64(bytes);
 }
 /** base64 合法字符集（含结尾 padding）。 */
 const B64_RE = /^[A-Za-z0-9+/]*={0,2}$/;
-/** base64 字符串 → bytes。失败抛 TypeError。 */
-export function base64ToBytes(b64, _label = 'base64') {
+/**
+ * base64 字符串 → bytes。失败抛 TypeError。
+ *
+ * 优先级：Node `Buffer` → 宿主 `atob` → 纯 JS 兜底（微信小程序等）。
+ */
+export function base64ToBytes(b64, label = 'base64') {
     // Node 快路径。`Buffer.from(..., 'base64')` 对非法字符是静默丢弃的，
     // 先用正则挡掉，非法的落到 `atob` 去抛错，保持与浏览器一致的行为。
     if (HAS_BUFFER && B64_RE.test(b64)) {
@@ -128,11 +141,14 @@ export function base64ToBytes(b64, _label = 'base64') {
         out.set(buf);
         return out;
     }
-    const bin = atob(b64);
-    const out = new Uint8Array(bin.length);
-    for (let i = 0; i < bin.length; i++)
-        out[i] = bin.charCodeAt(i);
-    return out;
+    if (HAS_ATOB) {
+        const bin = atob(b64);
+        const out = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; i++)
+            out[i] = bin.charCodeAt(i);
+        return out;
+    }
+    return decodeBase64(b64, label);
 }
 /** PEM → bytes。剥去 BEGIN/END armor，base64 解码。 */
 export function pemToBytes(pem, label = 'pem') {
@@ -169,6 +185,9 @@ export function bytesToPem(bytes, kind) {
  * （实测 4 KB 输入：hex 编码 52.6 µs → 1.9 µs）。
  */
 const HAS_BUFFER = typeof Buffer !== 'undefined' && typeof Buffer.from === 'function';
+/** 宿主是否提供 `btoa` / `atob`（现代浏览器有；微信小程序没有）。 */
+const HAS_BTOA = typeof btoa === 'function';
+const HAS_ATOB = typeof atob === 'function';
 /** 16 进制数字查表（浏览器路径）。 */
 const HEX_CHARS = '0123456789abcdef';
 /**