sm-crypto-wasm 0.3.1 → 0.7.0

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";
+};

package/dist/x509/encode.js

@@ -0,0 +1,175 @@
+/**
+ * X.509 证书 DER 编码（签发侧）。
+ *
+ * 只负责把结构化输入编码为 RFC 5280 证书；签名算法固定为 SM3withSM2。
+ * 编码复用 `src/asn1/`，不重复实现任何算法。
+ */
+import { bitString, boolean, explicit, ia5String, implicit, integer, octetString, oid, printableString, seq, set, time, utf8String, } from '../asn1/index.js';
+import { CertificateError } from './errors.js';
+import { parseIpAddress } from './ip.js';
+import { OID_AUTHORITY_KEY_IDENTIFIER, OID_BASIC_CONSTRAINTS, OID_COMMON_NAME, OID_COUNTRY, OID_EMAIL_ADDRESS, OID_EXTENDED_KEY_USAGE, OID_ID_EC_PUBLIC_KEY, OID_KEY_USAGE, OID_LOCALITY, OID_ORGANIZATION, OID_ORGANIZATIONAL_UNIT, OID_SM2_CURVE, OID_SM3_WITH_SM2, OID_STATE, OID_SUBJECT_ALT_NAME, OID_SUBJECT_KEY_IDENTIFIER, } from './oids.js';
+/** KeyUsage 的位顺序（RFC 5280）。 */
+const KEY_USAGE_ORDER = [
+    'digitalSignature',
+    'nonRepudiation',
+    'keyEncipherment',
+    'dataEncipherment',
+    'keyAgreement',
+    'keyCertSign',
+    'cRLSign',
+    'encipherOnly',
+    'decipherOnly',
+];
+/** 编码 Name（RDNSequence）。 */
+export function encodeName(dn) {
+    const rdns = [];
+    const add = (value, attrOid, encodeValue) => {
+        if (value === undefined || value.length === 0)
+            return;
+        rdns.push(set([seq([oid(attrOid), encodeValue(value)])]));
+    };
+    add(dn.country, OID_COUNTRY, printableString);
+    add(dn.state, OID_STATE, utf8String);
+    add(dn.locality, OID_LOCALITY, utf8String);
+    add(dn.organization, OID_ORGANIZATION, utf8String);
+    add(dn.organizationalUnit, OID_ORGANIZATIONAL_UNIT, utf8String);
+    add(dn.commonName, OID_COMMON_NAME, utf8String);
+    add(dn.emailAddress, OID_EMAIL_ADDRESS, ia5String);
+    if (rdns.length === 0) {
+        throw new CertificateError('Name: at least one attribute is required');
+    }
+    return seq(rdns);
+}
+/** 编码 SM2 的 SubjectPublicKeyInfo。 */
+export function encodeSubjectPublicKeyInfo(publicKey) {
+    const point = normalizePublicKey(publicKey);
+    return seq([seq([oid(OID_ID_EC_PUBLIC_KEY), oid(OID_SM2_CURVE)]), bitString(point)]);
+}
+/** 编码 Validity。 */
+export function encodeValidity(validity) {
+    return seq([time(validity.notBefore), time(validity.notAfter)]);
+}
+/** 编码 AlgorithmIdentifier（SM3withSM2，无参数）。 */
+export function encodeSignatureAlgorithm() {
+    return seq([oid(OID_SM3_WITH_SM2)]);
+}
+/** 编码 BasicConstraints 的 extnValue。 */
+export function encodeBasicConstraints(input) {
+    if (!input.ca && input.pathLen !== undefined) {
+        throw new RangeError('basicConstraints.pathLen is only valid for CA certificates');
+    }
+    if (input.pathLen !== undefined && (!Number.isInteger(input.pathLen) || input.pathLen < 0)) {
+        throw new RangeError(`basicConstraints.pathLen must be a non-negative integer`);
+    }
+    const children = [];
+    if (input.ca)
+        children.push(boolean(true));
+    if (input.pathLen !== undefined)
+        children.push(integer(BigInt(input.pathLen)));
+    return seq(children).raw;
+}
+/** 编码 KeyUsage 的 extnValue（BIT STRING）。 */
+export function encodeKeyUsage(names) {
+    let maxBit = -1;
+    for (const name of names) {
+        const index = KEY_USAGE_ORDER.indexOf(name);
+        if (index < 0)
+            throw new CertificateError(`keyUsage: unknown bit "${name}"`);
+        if (index > maxBit)
+            maxBit = index;
+    }
+    if (maxBit < 0)
+        throw new CertificateError('keyUsage: at least one bit is required');
+    const bytes = new Uint8Array(Math.floor(maxBit / 8) + 1);
+    for (const name of names) {
+        const index = KEY_USAGE_ORDER.indexOf(name);
+        const byteIndex = Math.floor(index / 8);
+        bytes[byteIndex] = bytes[byteIndex] | (0x80 >> (index % 8));
+    }
+    const unusedBits = bytes.length * 8 - (maxBit + 1);
+    return bitString(bytes, unusedBits).raw;
+}
+/** 编码 ExtendedKeyUsage 的 extnValue（SEQUENCE OF OID）。 */
+export function encodeExtendedKeyUsage(oids) {
+    return seq(oids.map((value) => oid(value))).raw;
+}
+/** 编码 SubjectAltName 的 extnValue（SEQUENCE OF GeneralName）。 */
+export function encodeSubjectAltName(names) {
+    return seq(names.map(encodeGeneralName)).raw;
+}
+function encodeGeneralName(name) {
+    switch (name.type) {
+        case 'dns':
+            return implicit(2, ia5String(name.value));
+        case 'ip':
+            return implicit(7, octetString(parseIpAddress(name.value)));
+        case 'email':
+            return implicit(1, ia5String(name.value));
+        case 'uri':
+            return implicit(6, ia5String(name.value));
+        default: {
+            const exhaustive = name.type;
+            throw new CertificateError(`subjectAltName: unknown type ${String(exhaustive)}`);
+        }
+    }
+}
+/** 编码 SubjectKeyIdentifier 的 extnValue（OCTET STRING）。 */
+export function encodeSubjectKeyIdentifier(keyIdentifier) {
+    return octetString(keyIdentifier).raw;
+}
+/** 编码 AuthorityKeyIdentifier 的 extnValue（[0] keyIdentifier）。 */
+export function encodeAuthorityKeyIdentifier(keyIdentifier) {
+    return seq([implicit(0, octetString(keyIdentifier))]).raw;
+}
+/** 把扩展列表编码为 `[3] EXPLICIT Extensions`。 */
+export function encodeExtensions(extensions) {
+    const entries = extensions.map((ext) => {
+        const children = [oid(ext.oid)];
+        if (ext.critical)
+            children.push(boolean(true));
+        children.push(octetString(ext.value));
+        return seq(children);
+    });
+    return explicit(3, seq(entries));
+}
+/** 编码 TBSCertificate。 */
+export function encodeTbsCertificate(input) {
+    const children = [
+        explicit(0, integer(BigInt(input.version - 1))),
+        integer(input.serialNumber),
+        encodeSignatureAlgorithm(),
+        encodeName(input.issuer),
+        encodeValidity(input.validity),
+        encodeName(input.subject),
+        encodeSubjectPublicKeyInfo(input.publicKey),
+    ];
+    if (input.extensions.length > 0) {
+        children.push(encodeExtensions(input.extensions));
+    }
+    return seq(children);
+}
+/** 组装 Certificate ::= SEQUENCE { tbs, signatureAlgorithm, signatureValue }。 */
+export function encodeCertificate(tbs, signatureDer) {
+    return seq([tbs, encodeSignatureAlgorithm(), bitString(signatureDer)]).raw;
+}
+/** 64/65 字节公钥 → 65 字节未压缩点。 */
+export function normalizePublicKey(publicKey) {
+    if (publicKey.length === 65 && publicKey[0] === 0x04)
+        return new Uint8Array(publicKey);
+    if (publicKey.length === 64) {
+        const out = new Uint8Array(65);
+        out[0] = 0x04;
+        out.set(publicKey, 1);
+        return out;
+    }
+    throw new CertificateError('publicKey: expected 64 or 65 (uncompressed) bytes');
+}
+/** 扩展 OID 常量（供签发逻辑使用）。 */
+export const EXTENSION_OIDS = {
+    basicConstraints: OID_BASIC_CONSTRAINTS,
+    keyUsage: OID_KEY_USAGE,
+    extendedKeyUsage: OID_EXTENDED_KEY_USAGE,
+    subjectAltName: OID_SUBJECT_ALT_NAME,
+    subjectKeyIdentifier: OID_SUBJECT_KEY_IDENTIFIER,
+    authorityKeyIdentifier: OID_AUTHORITY_KEY_IDENTIFIER,
+};

package/dist/x509/errors.d.ts

@@ -0,0 +1,14 @@
+/**
+ * X.509 错误类型。
+ *
+ * 所有证书结构/校验错误都是 `CertificateError`（`SmCryptoError` 的子类），
+ * 便于调用方与其它库错误一起捕获。
+ */
+import { SmCryptoError } from '../runtime/errors.js';
+/** 证书解析或校验失败。 */
+export declare class CertificateError extends SmCryptoError {
+    readonly name: string;
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}