sm-crypto-wasm 0.3.0 → 0.7.0

package/dist/webcrypto/errors.js

@@ -0,0 +1,45 @@
+/**
+ * WebCrypto 适配层的错误映射。
+ *
+ * 对外的所有失败都映射为 `DOMException`（WebCrypto 的约定）：
+ * - `NotSupportedError`：未知算法/格式/不支持的参数；
+ * - `InvalidAccessError`：密钥用途或 `extractable` 不允许；
+ * - `DataError`：密钥/数据格式非法；
+ * - `OperationError`：加解密/验签失败。
+ */
+import { CiphertextError, DecryptionError, InvalidKeyError, NotImplementedError, SmCryptoError, } from '../runtime/errors.js';
+/** 构造 `DOMException` 的便捷函数。 */
+export function notSupported(message) {
+    return new DOMException(message, 'NotSupportedError');
+}
+/** 构造 `InvalidAccessError`。 */
+export function invalidAccess(message) {
+    return new DOMException(message, 'InvalidAccessError');
+}
+/** 构造 `DataError`。 */
+export function dataError(message) {
+    return new DOMException(message, 'DataError');
+}
+/** 构造 `OperationError`。 */
+export function operationError(message) {
+    return new DOMException(message, 'OperationError');
+}
+/** 把库内错误映射为 `DOMException`；已经是 `DOMException` 时原样返回。 */
+export function toDOMException(err, fallback = 'OperationError') {
+    if (err instanceof DOMException)
+        return err;
+    const message = err instanceof Error ? err.message : String(err);
+    if (err instanceof NotImplementedError)
+        return notSupported(message);
+    if (err instanceof DecryptionError)
+        return operationError(message);
+    if (err instanceof InvalidKeyError)
+        return dataError(message);
+    if (err instanceof CiphertextError)
+        return dataError(message);
+    if (err instanceof SmCryptoError)
+        return operationError(message);
+    if (err instanceof TypeError || err instanceof RangeError)
+        return dataError(message);
+    return new DOMException(message, fallback);
+}

package/dist/webcrypto/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WebCrypto 适配层（`sm-crypto-wasm/webcrypto`）。
+ *
+ * 这是一个**独立**的 `subtle` 对象，不是原生 `crypto.subtle` 的 polyfill：
+ * 浏览器不允许注册自定义算法，第三方库也不会自动识别它。
+ *
+ * 范围：SM3、HMAC(SM3)、SM2、SM4-ECB/CBC/CTR/CFB/OFB/GCM。
+ * 不做 JWK、deriveKey/deriveBits、wrapKey/unwrapKey、postMessage 克隆语义。
+ */
+export type { AlgorithmInput, NormalizedAlgorithm } from './algorithms.js';
+export type { KeyAlgorithm, KeyMaterial, KeyProvider, KeyType, KeyUsage } from './cryptoKey.js';
+export { CryptoKey } from './cryptoKey.js';
+export type { SmCryptoKeyPair, SmKeyFormat } from './subtle.js';
+export { subtle } from './subtle.js';

package/dist/webcrypto/index.js

@@ -0,0 +1,11 @@
+/**
+ * WebCrypto 适配层（`sm-crypto-wasm/webcrypto`）。
+ *
+ * 这是一个**独立**的 `subtle` 对象，不是原生 `crypto.subtle` 的 polyfill：
+ * 浏览器不允许注册自定义算法，第三方库也不会自动识别它。
+ *
+ * 范围：SM3、HMAC(SM3)、SM2、SM4-ECB/CBC/CTR/CFB/OFB/GCM。
+ * 不做 JWK、deriveKey/deriveBits、wrapKey/unwrapKey、postMessage 克隆语义。
+ */
+export { CryptoKey } from './cryptoKey.js';
+export { subtle } from './subtle.js';

package/dist/webcrypto/subtle.d.ts

@@ -0,0 +1,68 @@
+/**
+ * `crypto.subtle` 风格的 SM2 / SM3 / SM4 适配层。
+ *
+ * 注意：这是**独立对象**，不是原生 `crypto.subtle` 的 polyfill —— 浏览器
+ * 不允许注册自定义算法，生态库也不会自动识别它。
+ *
+ * 所有方法都是异步的（WebCrypto 语义），内部调用仍是同步的 wasm 计算；
+ * 首次使用时按算法自动 `ensureLoaded()`。
+ */
+import { type AlgorithmInput } from './algorithms.js';
+import { CryptoKey } from './cryptoKey.js';
+/** 密钥对（结构兼容 WebCrypto 的 `CryptoKeyPair`）。 */
+export interface SmCryptoKeyPair {
+    readonly privateKey: CryptoKey;
+    readonly publicKey: CryptoKey;
+}
+/** 支持的密钥格式。JWK 不在范围内。 */
+export type SmKeyFormat = 'raw' | 'pkcs8' | 'spki' | 'jwk';
+/** `sm-crypto-wasm/webcrypto` 的 `subtle` 对象。 */
+export declare const subtle: {
+    /**
+     * 摘要。仅支持 `{ name: 'SM3' }`。
+     */
+    digest(algorithm: AlgorithmInput, data: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
+    /**
+     * 生成密钥。
+     *
+     * - `{ name: 'SM2' }` → `{ privateKey, publicKey }`
+     * - `{ name: 'HMAC', hash: 'SM3', length?: bits }` → secret key
+     * - `{ name: 'SM4-*', length: 128 }` → secret key
+     */
+    generateKey(algorithm: AlgorithmInput, extractable: boolean, keyUsages: readonly string[]): Promise<CryptoKey | SmCryptoKeyPair>;
+    /**
+     * 导入密钥。
+     *
+     * - `raw`：HMAC / SM4
+     * - `pkcs8`：SM2 私钥 DER
+     * - `spki`：SM2 公钥 DER
+     */
+    importKey(format: SmKeyFormat, keyData: ArrayBuffer | ArrayBufferView, algorithm: AlgorithmInput, extractable: boolean, keyUsages: readonly string[]): Promise<CryptoKey>;
+    /**
+     * 导出密钥。
+     *
+     * `extractable === false` 时抛 `InvalidAccessError`（红线 #7）。
+     */
+    exportKey(format: SmKeyFormat, key: CryptoKey): Promise<ArrayBuffer>;
+    /**
+     * 签名。
+     *
+     * - `HMAC` + `hash: 'SM3'`
+     * - `SM2`（64 字节 `r ‖ s`，与 `sm2.sign` 一致）
+     */
+    sign(algorithm: AlgorithmInput, key: CryptoKey, data: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
+    /**
+     * 验签。
+     */
+    verify(algorithm: AlgorithmInput, key: CryptoKey, signature: ArrayBuffer | ArrayBufferView, data: ArrayBuffer | ArrayBufferView): Promise<boolean>;
+    /**
+     * 加密。
+     *
+     * SM4-GCM 输出 `ciphertext ‖ tag`（tag 在尾部，与原生 AES-GCM 一致）。
+     */
+    encrypt(algorithm: AlgorithmInput, key: CryptoKey, data: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
+    /**
+     * 解密。
+     */
+    decrypt(algorithm: AlgorithmInput, key: CryptoKey, data: ArrayBuffer | ArrayBufferView): Promise<ArrayBuffer>;
+};

package/dist/webcrypto/subtle.js

@@ -0,0 +1,358 @@
+/**
+ * `crypto.subtle` 风格的 SM2 / SM3 / SM4 适配层。
+ *
+ * 注意：这是**独立对象**，不是原生 `crypto.subtle` 的 polyfill —— 浏览器
+ * 不允许注册自定义算法，生态库也不会自动识别它。
+ *
+ * 所有方法都是异步的（WebCrypto 语义），内部调用仍是同步的 wasm 计算；
+ * 首次使用时按算法自动 `ensureLoaded()`。
+ */
+import { encodeSm2PrivateKeyDer, encodeSm2PublicKeyDer, parseSm2PrivateKeyDer, parseSm2PrivateKeyPem, parseSm2PublicKeyDer, parseSm2PublicKeyPem, } from '../pem/sm2.js';
+import { hexToBytes } from '../runtime/convert.js';
+import { randomBytes } from '../runtime/random.js';
+import * as sm2 from '../sm2/index.js';
+import * as sm3 from '../sm3/index.js';
+import * as sm4 from '../sm4/index.js';
+import { bufferSourceBytes, hashName, isSm4, normalizeAlgorithm, optionalAad, optionalUserId, requireAesLength, requireCtrLength, requireGcmTagLength, requireIv, } from './algorithms.js';
+import { assertKeyAlgorithm, assertKeyType, assertUsage, assertUsagesAllowed, CryptoKey, createBytesKey, filterUsages, getKeyBytes, normalizeUsages, } from './cryptoKey.js';
+import { dataError, invalidAccess, notSupported, toDOMException } from './errors.js';
+const SM2_PRIVATE_USAGES = ['sign', 'decrypt'];
+const SM2_PUBLIC_USAGES = ['verify', 'encrypt'];
+const HMAC_USAGES = ['sign', 'verify'];
+const SM4_USAGES = ['encrypt', 'decrypt'];
+/** `sm-crypto-wasm/webcrypto` 的 `subtle` 对象。 */
+export const subtle = {
+    /**
+     * 摘要。仅支持 `{ name: 'SM3' }`。
+     */
+    async digest(algorithm, data) {
+        try {
+            const alg = normalizeAlgorithm(algorithm);
+            if (alg.name !== 'SM3')
+                throw notSupported(`digest does not support ${alg.name}`);
+            const bytes = bufferSourceBytes(data, 'data');
+            await sm3.ensureLoaded();
+            return toArrayBuffer(hexToBytes(sm3.hash(bytes), 'digest'));
+        }
+        catch (err) {
+            throw toDOMException(err);
+        }
+    },
+    /**
+     * 生成密钥。
+     *
+     * - `{ name: 'SM2' }` → `{ privateKey, publicKey }`
+     * - `{ name: 'HMAC', hash: 'SM3', length?: bits }` → secret key
+     * - `{ name: 'SM4-*', length: 128 }` → secret key
+     */
+    async generateKey(algorithm, extractable, keyUsages) {
+        try {
+            const alg = normalizeAlgorithm(algorithm);
+            const usages = normalizeUsages(keyUsages);
+            if (alg.name === 'SM2') {
+                await sm2.ensureLoaded();
+                const pair = await sm2.generateKeyPair();
+                // 复用既有 PEM 解析器，不重复实现 PEM 解包。
+                const priv = new Uint8Array(parseSm2PrivateKeyPem(pair.privateKeyPem));
+                const pub = new Uint8Array(parseSm2PublicKeyPem(pair.publicKeyPem));
+                return {
+                    privateKey: createBytesKey('private', { name: 'SM2' }, extractable, filterUsages(usages, SM2_PRIVATE_USAGES), priv),
+                    publicKey: createBytesKey('public', { name: 'SM2' }, extractable, filterUsages(usages, SM2_PUBLIC_USAGES), pub),
+                };
+            }
+            if (alg.name === 'HMAC') {
+                await sm3.ensureLoaded();
+                assertUsagesAllowed(usages, HMAC_USAGES, 'HMAC');
+                const hash = hashName(alg.hash);
+                const rawLength = alg.length;
+                const lengthBits = rawLength === undefined ? 256 : rawLength;
+                if (typeof lengthBits !== 'number' ||
+                    !Number.isInteger(lengthBits) ||
+                    lengthBits <= 0 ||
+                    lengthBits % 8 !== 0) {
+                    throw dataError('HMAC length must be a positive multiple of 8 bits');
+                }
+                return createBytesKey('secret', { name: 'HMAC', hash: { name: hash }, length: lengthBits }, extractable, usages, randomBytes(lengthBits / 8));
+            }
+            if (isSm4(alg.name)) {
+                requireAesLength(alg);
+                assertUsagesAllowed(usages, SM4_USAGES, alg.name);
+                return createBytesKey('secret', { name: alg.name, length: 128 }, extractable, usages, randomBytes(16));
+            }
+            throw notSupported(`generateKey does not support ${alg.name}`);
+        }
+        catch (err) {
+            throw toDOMException(err);
+        }
+    },
+    /**
+     * 导入密钥。
+     *
+     * - `raw`：HMAC / SM4
+     * - `pkcs8`：SM2 私钥 DER
+     * - `spki`：SM2 公钥 DER
+     */
+    async importKey(format, keyData, algorithm, extractable, keyUsages) {
+        try {
+            if (format === 'jwk')
+                throw notSupported('JWK is not supported');
+            if (format !== 'raw' && format !== 'pkcs8' && format !== 'spki') {
+                throw notSupported(`unsupported key format "${String(format)}"`);
+            }
+            const alg = normalizeAlgorithm(algorithm);
+            const usages = normalizeUsages(keyUsages);
+            const bytes = keyDataBytes(keyData);
+            if (format === 'raw') {
+                if (alg.name === 'HMAC') {
+                    assertUsagesAllowed(usages, HMAC_USAGES, 'HMAC');
+                    const hash = hashName(alg.hash);
+                    return createBytesKey('secret', { name: 'HMAC', hash: { name: hash }, length: bytes.length * 8 }, extractable, usages, bytes);
+                }
+                if (isSm4(alg.name)) {
+                    requireAesLength(alg);
+                    if (bytes.length !== 16)
+                        throw dataError('SM4 key must be 16 bytes');
+                    assertUsagesAllowed(usages, SM4_USAGES, alg.name);
+                    return createBytesKey('secret', { name: alg.name, length: 128 }, extractable, usages, bytes);
+                }
+                throw notSupported(`importKey('raw') does not support ${alg.name}`);
+            }
+            if (alg.name !== 'SM2') {
+                throw notSupported(`importKey('${format}') only supports SM2`);
+            }
+            if (format === 'pkcs8') {
+                return createBytesKey('private', { name: 'SM2' }, extractable, filterUsages(usages, SM2_PRIVATE_USAGES), parseSm2PrivateKeyDer(bytes));
+            }
+            return createBytesKey('public', { name: 'SM2' }, extractable, filterUsages(usages, SM2_PUBLIC_USAGES), parseSm2PublicKeyDer(bytes));
+        }
+        catch (err) {
+            throw toDOMException(err);
+        }
+    },
+    /**
+     * 导出密钥。
+     *
+     * `extractable === false` 时抛 `InvalidAccessError`（红线 #7）。
+     */
+    async exportKey(format, key) {
+        try {
+            if (!(key instanceof CryptoKey))
+                throw new TypeError('exportKey: key must be a CryptoKey');
+            if (!key.extractable)
+                throw invalidAccess('exportKey: key is not extractable');
+            if (format === 'raw') {
+                if (key.type !== 'secret') {
+                    throw invalidAccess('exportKey: raw export requires a secret key');
+                }
+                return toArrayBuffer(getKeyBytes(key));
+            }
+            if (format === 'pkcs8') {
+                if (key.type !== 'private' || key.algorithm.name !== 'SM2') {
+                    throw invalidAccess('exportKey: pkcs8 export requires an SM2 private key');
+                }
+                return toArrayBuffer(encodeSm2PrivateKeyDer(getKeyBytes(key)));
+            }
+            if (format === 'spki') {
+                if (key.type !== 'public' || key.algorithm.name !== 'SM2') {
+                    throw invalidAccess('exportKey: spki export requires an SM2 public key');
+                }
+                return toArrayBuffer(encodeSm2PublicKeyDer(getKeyBytes(key)));
+            }
+            throw notSupported(`exportKey format "${String(format)}" is not supported`);
+        }
+        catch (err) {
+            throw toDOMException(err);
+        }
+    },
+    /**
+     * 签名。
+     *
+     * - `HMAC` + `hash: 'SM3'`
+     * - `SM2`（64 字节 `r ‖ s`，与 `sm2.sign` 一致）
+     */
+    async sign(algorithm, key, data) {
+        try {
+            const alg = normalizeAlgorithm(algorithm);
+            const bytes = bufferSourceBytes(data, 'data');
+            if (alg.name === 'HMAC') {
+                assertKeyType(key, 'secret', 'sign');
+                assertUsage(key, 'sign', 'sign');
+                assertKeyAlgorithm(key, 'HMAC', 'sign');
+                assertHmacHash(key);
+                await sm3.ensureLoaded();
+                return toArrayBuffer(hexToBytes(sm3.hmac(getKeyBytes(key), bytes), 'signature'));
+            }
+            if (alg.name === 'SM2') {
+                assertKeyType(key, 'private', 'sign');
+                assertUsage(key, 'sign', 'sign');
+                assertKeyAlgorithm(key, 'SM2', 'sign');
+                await sm2.ensureLoaded();
+                const userID = optionalUserId(alg);
+                const signature = userID === undefined
+                    ? sm2.sign(getKeyBytes(key), bytes)
+                    : sm2.signWithID(getKeyBytes(key), bytes, userID);
+                return toArrayBuffer(hexToBytes(signature, 'signature'));
+            }
+            throw notSupported(`sign does not support ${alg.name}`);
+        }
+        catch (err) {
+            throw toDOMException(err);
+        }
+    },
+    /**
+     * 验签。
+     */
+    async verify(algorithm, key, signature, data) {
+        try {
+            const alg = normalizeAlgorithm(algorithm);
+            const bytes = bufferSourceBytes(data, 'data');
+            const signatureBytes = bufferSourceBytes(signature, 'signature');
+            if (alg.name === 'HMAC') {
+                assertKeyType(key, 'secret', 'verify');
+                assertUsage(key, 'verify', 'verify');
+                assertKeyAlgorithm(key, 'HMAC', 'verify');
+                assertHmacHash(key);
+                await sm3.ensureLoaded();
+                const expected = hexToBytes(sm3.hmac(getKeyBytes(key), bytes), 'signature');
+                return constantTimeEqual(expected, signatureBytes);
+            }
+            if (alg.name === 'SM2') {
+                assertKeyType(key, 'public', 'verify');
+                assertUsage(key, 'verify', 'verify');
+                assertKeyAlgorithm(key, 'SM2', 'verify');
+                if (signatureBytes.length !== 64) {
+                    throw dataError('SM2 signature must be 64 bytes (r || s)');
+                }
+                await sm2.ensureLoaded();
+                const userID = optionalUserId(alg);
+                return userID === undefined
+                    ? sm2.verify(getKeyBytes(key), bytes, signatureBytes)
+                    : sm2.verifyWithID(getKeyBytes(key), bytes, signatureBytes, userID);
+            }
+            throw notSupported(`verify does not support ${alg.name}`);
+        }
+        catch (err) {
+            throw toDOMException(err);
+        }
+    },
+    /**
+     * 加密。
+     *
+     * SM4-GCM 输出 `ciphertext ‖ tag`（tag 在尾部，与原生 AES-GCM 一致）。
+     */
+    async encrypt(algorithm, key, data) {
+        try {
+            const alg = normalizeAlgorithm(algorithm);
+            const bytes = bufferSourceBytes(data, 'data');
+            assertKeyType(key, 'secret', 'encrypt');
+            assertUsage(key, 'encrypt', 'encrypt');
+            assertKeyAlgorithm(key, alg.name, 'encrypt');
+            await sm4.ensureLoaded();
+            const k = getKeyBytes(key);
+            switch (alg.name) {
+                case 'SM4-GCM': {
+                    requireGcmTagLength(alg);
+                    const iv = requireIv(alg);
+                    const aad = optionalAad(alg);
+                    const { ct, tag } = sm4.encryptGCM(k, iv, bytes, aad);
+                    return toArrayBuffer(concat(hexToBytes(ct, 'ciphertext'), hexToBytes(tag, 'tag')));
+                }
+                case 'SM4-CBC':
+                    return toArrayBuffer(hexToBytes(sm4.encryptCBC(k, requireIv(alg), bytes), 'ciphertext'));
+                case 'SM4-CTR': {
+                    requireCtrLength(alg);
+                    return toArrayBuffer(hexToBytes(sm4.cryptCTR(k, requireIv(alg), bytes), 'ciphertext'));
+                }
+                case 'SM4-CFB':
+                    return toArrayBuffer(hexToBytes(sm4.encryptCFB(k, requireIv(alg), bytes), 'ciphertext'));
+                case 'SM4-OFB':
+                    return toArrayBuffer(hexToBytes(sm4.cryptOFB(k, requireIv(alg), bytes), 'ciphertext'));
+                case 'SM4-ECB':
+                    return toArrayBuffer(hexToBytes(sm4.encryptECB(k, bytes), 'ciphertext'));
+                default:
+                    throw notSupported(`encrypt does not support ${alg.name}`);
+            }
+        }
+        catch (err) {
+            throw toDOMException(err);
+        }
+    },
+    /**
+     * 解密。
+     */
+    async decrypt(algorithm, key, data) {
+        try {
+            const alg = normalizeAlgorithm(algorithm);
+            const bytes = bufferSourceBytes(data, 'data');
+            assertKeyType(key, 'secret', 'decrypt');
+            assertUsage(key, 'decrypt', 'decrypt');
+            assertKeyAlgorithm(key, alg.name, 'decrypt');
+            await sm4.ensureLoaded();
+            const k = getKeyBytes(key);
+            switch (alg.name) {
+                case 'SM4-GCM': {
+                    requireGcmTagLength(alg);
+                    if (bytes.length < 16)
+                        throw dataError('SM4-GCM ciphertext is shorter than the tag');
+                    const iv = requireIv(alg);
+                    const aad = optionalAad(alg);
+                    const ct = bytes.subarray(0, bytes.length - 16);
+                    const tag = bytes.subarray(bytes.length - 16);
+                    const plaintext = sm4.decryptGCM(k, iv, ct, tag, { aad });
+                    return toArrayBuffer(hexToBytes(plaintext, 'plaintext'));
+                }
+                case 'SM4-CBC':
+                    return toArrayBuffer(hexToBytes(sm4.decryptCBC(k, requireIv(alg), bytes), 'plaintext'));
+                case 'SM4-CTR': {
+                    requireCtrLength(alg);
+                    return toArrayBuffer(hexToBytes(sm4.cryptCTR(k, requireIv(alg), bytes), 'plaintext'));
+                }
+                case 'SM4-CFB':
+                    return toArrayBuffer(hexToBytes(sm4.decryptCFB(k, requireIv(alg), bytes), 'plaintext'));
+                case 'SM4-OFB':
+                    return toArrayBuffer(hexToBytes(sm4.cryptOFB(k, requireIv(alg), bytes), 'plaintext'));
+                case 'SM4-ECB':
+                    return toArrayBuffer(hexToBytes(sm4.decryptECB(k, bytes), 'plaintext'));
+                default:
+                    throw notSupported(`decrypt does not support ${alg.name}`);
+            }
+        }
+        catch (err) {
+            throw toDOMException(err);
+        }
+    },
+};
+// ---------- 内部 ----------
+function assertHmacHash(key) {
+    const hash = key.algorithm.hash;
+    if (hash?.name !== 'SM3') {
+        throw invalidAccess('HMAC key is not bound to SM3');
+    }
+}
+function keyDataBytes(keyData) {
+    if (keyData instanceof ArrayBuffer)
+        return new Uint8Array(keyData.slice(0));
+    if (ArrayBuffer.isView(keyData)) {
+        return new Uint8Array(keyData.buffer, keyData.byteOffset, keyData.byteLength).slice();
+    }
+    throw dataError('keyData must be an ArrayBuffer or ArrayBufferView');
+}
+function toArrayBuffer(bytes) {
+    const copy = new Uint8Array(bytes.length);
+    copy.set(bytes);
+    return copy.buffer;
+}
+function concat(a, b) {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a, 0);
+    out.set(b, a.length);
+    return out;
+}
+function constantTimeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < a.length; i++)
+        diff |= a[i] ^ b[i];
+    return diff === 0;
+}

package/dist/x509/encode.d.ts

@@ -0,0 +1,59 @@
+/**
+ * X.509 证书 DER 编码（签发侧）。
+ *
+ * 只负责把结构化输入编码为 RFC 5280 证书；签名算法固定为 SM3withSM2。
+ * 编码复用 `src/asn1/`，不重复实现任何算法。
+ */
+import { type Asn1Node } from '../asn1/index.js';
+import type { BasicConstraintsInput, DistinguishedNameInput, SubjectAltNameInput, Validity } from './types.js';
+/** 待编码的一个扩展。 */
+export interface EncodedExtension {
+    readonly oid: string;
+    readonly critical: boolean;
+    readonly value: Uint8Array;
+}
+/** 编码 Name（RDNSequence）。 */
+export declare function encodeName(dn: DistinguishedNameInput): Asn1Node;
+/** 编码 SM2 的 SubjectPublicKeyInfo。 */
+export declare function encodeSubjectPublicKeyInfo(publicKey: Uint8Array): Asn1Node;
+/** 编码 Validity。 */
+export declare function encodeValidity(validity: Validity): Asn1Node;
+/** 编码 AlgorithmIdentifier（SM3withSM2，无参数）。 */
+export declare function encodeSignatureAlgorithm(): Asn1Node;
+/** 编码 BasicConstraints 的 extnValue。 */
+export declare function encodeBasicConstraints(input: BasicConstraintsInput): Uint8Array;
+/** 编码 KeyUsage 的 extnValue（BIT STRING）。 */
+export declare function encodeKeyUsage(names: readonly string[]): Uint8Array;
+/** 编码 ExtendedKeyUsage 的 extnValue（SEQUENCE OF OID）。 */
+export declare function encodeExtendedKeyUsage(oids: readonly string[]): Uint8Array;
+/** 编码 SubjectAltName 的 extnValue（SEQUENCE OF GeneralName）。 */
+export declare function encodeSubjectAltName(names: readonly SubjectAltNameInput[]): Uint8Array;
+/** 编码 SubjectKeyIdentifier 的 extnValue（OCTET STRING）。 */
+export declare function encodeSubjectKeyIdentifier(keyIdentifier: Uint8Array): Uint8Array;
+/** 编码 AuthorityKeyIdentifier 的 extnValue（[0] keyIdentifier）。 */
+export declare function encodeAuthorityKeyIdentifier(keyIdentifier: Uint8Array): Uint8Array;
+/** 把扩展列表编码为 `[3] EXPLICIT Extensions`。 */
+export declare function encodeExtensions(extensions: readonly EncodedExtension[]): Asn1Node;
+/** 编码 TBSCertificate。 */
+export declare function encodeTbsCertificate(input: {
+    version: 1 | 2 | 3;
+    serialNumber: bigint;
+    issuer: DistinguishedNameInput;
+    validity: Validity;
+    subject: DistinguishedNameInput;
+    publicKey: Uint8Array;
+    extensions: readonly EncodedExtension[];
+}): Asn1Node;
+/** 组装 Certificate ::= SEQUENCE { tbs, signatureAlgorithm, signatureValue }。 */
+export declare function encodeCertificate(tbs: Asn1Node, signatureDer: Uint8Array): Uint8Array;
+/** 64/65 字节公钥 → 65 字节未压缩点。 */
+export declare function normalizePublicKey(publicKey: Uint8Array): Uint8Array;
+/** 扩展 OID 常量（供签发逻辑使用）。 */
+export declare const EXTENSION_OIDS: {
+    readonly basicConstraints: "2.5.29.19";
+    readonly keyUsage: "2.5.29.15";
+    readonly extendedKeyUsage: "2.5.29.37";
+    readonly subjectAltName: "2.5.29.17";
+    readonly subjectKeyIdentifier: "2.5.29.14";
+    readonly authorityKeyIdentifier: "2.5.29.35";
+};