sm-crypto-wasm 0.3.1 → 0.7.0

package/dist/x509/errors.js

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

package/dist/x509/extensions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * X.509 扩展解析。
+ *
+ * 原则（红线 #9）：未知扩展、未知值类型一律保留原始字节，不抛错；
+ * 已知扩展内容损坏时返回 `undefined`，由调用方按“扩展缺失”处理。
+ */
+import type { AuthorityKeyIdentifier, BasicConstraints, GeneralName, KeyUsage } from './types.js';
+/** 解析 KeyUsage（BIT STRING）。 */
+export declare function parseKeyUsage(value: Uint8Array): KeyUsage;
+/** 解析 BasicConstraints。 */
+export declare function parseBasicConstraints(value: Uint8Array): BasicConstraints;
+/** 解析 SubjectAltName（SEQUENCE OF GeneralName）。 */
+export declare function parseSubjectAltName(value: Uint8Array): GeneralName[];
+/** 解析 SubjectKeyIdentifier（OCTET STRING）。 */
+export declare function parseSubjectKeyIdentifier(value: Uint8Array): Uint8Array;
+/** 解析 AuthorityKeyIdentifier。 */
+export declare function parseAuthorityKeyIdentifier(value: Uint8Array): AuthorityKeyIdentifier;
+/** 解析 ExtendedKeyUsage（SEQUENCE OF OID）。 */
+export declare function parseExtendedKeyUsage(value: Uint8Array): string[];
+/**
+ * 按扩展 OID 解析已知扩展；未知 OID 返回 `undefined`，不抛错。
+ *
+ * @internal 供 `parse.ts` 与签发逻辑复用。
+ */
+export declare function parseKnownExtension(oid: string, value: Uint8Array): KeyUsage | BasicConstraints | GeneralName[] | Uint8Array | AuthorityKeyIdentifier | string[] | undefined;
+/** 4 字节 IPv4 / 16 字节 IPv6 → 文本。 */
+export declare function formatIp(bytes: Uint8Array): string;

package/dist/x509/extensions.js

@@ -0,0 +1,215 @@
+/**
+ * X.509 扩展解析。
+ *
+ * 原则（红线 #9）：未知扩展、未知值类型一律保留原始字节，不抛错；
+ * 已知扩展内容损坏时返回 `undefined`，由调用方按“扩展缺失”处理。
+ */
+import { Asn1Class, expectSequence, parseDer, readBitString, readOctetString, readOid, readString, UniversalTag, } from '../asn1/index.js';
+import { bytesToHex } from '../runtime/convert.js';
+import { OID_AUTHORITY_KEY_IDENTIFIER, OID_BASIC_CONSTRAINTS, OID_EXTENDED_KEY_USAGE, OID_KEY_USAGE, OID_SUBJECT_ALT_NAME, OID_SUBJECT_KEY_IDENTIFIER, } from './oids.js';
+/** 解析 KeyUsage（BIT STRING）。 */
+export function parseKeyUsage(value) {
+    const node = parseExtensionValue(value, 'KeyUsage');
+    const bits = readBitString(node, 'KeyUsage');
+    const get = (index) => {
+        const byte = bits.bytes[Math.floor(index / 8)];
+        if (byte === undefined)
+            return false;
+        return ((byte >> (7 - (index % 8))) & 1) === 1;
+    };
+    return {
+        digitalSignature: get(0),
+        nonRepudiation: get(1),
+        keyEncipherment: get(2),
+        dataEncipherment: get(3),
+        keyAgreement: get(4),
+        keyCertSign: get(5),
+        cRLSign: get(6),
+        encipherOnly: get(7),
+        decipherOnly: get(8),
+    };
+}
+/** 解析 BasicConstraints。 */
+export function parseBasicConstraints(value) {
+    const node = parseExtensionValue(value, 'BasicConstraints');
+    const children = expectSequence(node, 'BasicConstraints');
+    let ca = false;
+    let pathLen;
+    let index = 0;
+    const first = children[0];
+    if (first !== undefined && first.cls === Asn1Class.Universal && first.tag === 1) {
+        if (first.value.length !== 1)
+            throw new Error('BasicConstraints: bad BOOLEAN');
+        ca = first.value[0] !== 0;
+        index = 1;
+    }
+    const lenNode = children[index];
+    if (lenNode !== undefined) {
+        if (lenNode.cls !== Asn1Class.Universal || lenNode.tag !== UniversalTag.Integer) {
+            throw new Error('BasicConstraints: pathLenConstraint is not INTEGER');
+        }
+        let n = 0;
+        for (let i = 0; i < lenNode.value.length; i++) {
+            n = n * 256 + lenNode.value[i];
+            if (!Number.isSafeInteger(n))
+                throw new Error('BasicConstraints: pathLen too large');
+        }
+        pathLen = n;
+    }
+    return pathLen === undefined ? { ca } : { ca, pathLen };
+}
+/** 解析 SubjectAltName（SEQUENCE OF GeneralName）。 */
+export function parseSubjectAltName(value) {
+    const node = parseExtensionValue(value, 'SubjectAltName');
+    const children = expectSequence(node, 'SubjectAltName');
+    return children.map(parseGeneralName);
+}
+/** 解析 SubjectKeyIdentifier（OCTET STRING）。 */
+export function parseSubjectKeyIdentifier(value) {
+    const node = parseExtensionValue(value, 'SubjectKeyIdentifier');
+    return new Uint8Array(readOctetString(node, 'SubjectKeyIdentifier'));
+}
+/** 解析 AuthorityKeyIdentifier。 */
+export function parseAuthorityKeyIdentifier(value) {
+    const node = parseExtensionValue(value, 'AuthorityKeyIdentifier');
+    const children = expectSequence(node, 'AuthorityKeyIdentifier');
+    let keyIdentifier;
+    let authorityCertSerialNumber;
+    for (const child of children) {
+        if (child.cls !== Asn1Class.ContextSpecific)
+            continue;
+        if (child.tag === 0) {
+            keyIdentifier = new Uint8Array(child.value);
+        }
+        else if (child.tag === 2) {
+            authorityCertSerialNumber = positiveIntegerFromBytes(child.value);
+        }
+    }
+    return authorityCertSerialNumber === undefined
+        ? keyIdentifier === undefined
+            ? {}
+            : { keyIdentifier }
+        : keyIdentifier === undefined
+            ? { authorityCertSerialNumber }
+            : { keyIdentifier, authorityCertSerialNumber };
+}
+/** 解析 ExtendedKeyUsage（SEQUENCE OF OID）。 */
+export function parseExtendedKeyUsage(value) {
+    const node = parseExtensionValue(value, 'ExtendedKeyUsage');
+    const children = expectSequence(node, 'ExtendedKeyUsage');
+    return children.map((child) => readOid(child, 'ExtendedKeyUsage'));
+}
+/**
+ * 按扩展 OID 解析已知扩展；未知 OID 返回 `undefined`，不抛错。
+ *
+ * @internal 供 `parse.ts` 与签发逻辑复用。
+ */
+export function parseKnownExtension(oid, value) {
+    try {
+        switch (oid) {
+            case OID_KEY_USAGE:
+                return parseKeyUsage(value);
+            case OID_BASIC_CONSTRAINTS:
+                return parseBasicConstraints(value);
+            case OID_SUBJECT_ALT_NAME:
+                return parseSubjectAltName(value);
+            case OID_SUBJECT_KEY_IDENTIFIER:
+                return parseSubjectKeyIdentifier(value);
+            case OID_AUTHORITY_KEY_IDENTIFIER:
+                return parseAuthorityKeyIdentifier(value);
+            case OID_EXTENDED_KEY_USAGE:
+                return parseExtendedKeyUsage(value);
+            default:
+                return undefined;
+        }
+    }
+    catch {
+        // 已知扩展损坏：按“扩展缺失”处理，绝不让整张证书解析失败。
+        return undefined;
+    }
+}
+function parseExtensionValue(value, what) {
+    try {
+        return parseDer(value);
+    }
+    catch (err) {
+        throw new Error(`${what}: invalid extension value`, { cause: err });
+    }
+}
+function parseGeneralName(node) {
+    if (node.cls !== Asn1Class.ContextSpecific) {
+        throw new Error(`GeneralName: unexpected class ${node.cls}`);
+    }
+    const raw = node.raw;
+    switch (node.tag) {
+        case 1:
+            return { type: 'email', value: readString(asStringNode(node), 'GeneralName'), raw };
+        case 2:
+            return { type: 'dns', value: readString(asStringNode(node), 'GeneralName'), raw };
+        case 6:
+            return { type: 'uri', value: readString(asStringNode(node), 'GeneralName'), raw };
+        case 7:
+            return { type: 'ip', value: formatIp(node.value), raw };
+        default:
+            return { type: 'other', tag: node.tag, value: `#${bytesToHex(node.value)}`, raw };
+    }
+}
+/** IMPLICIT IA5String：把内容字节包装成 UNIVERSAL IA5String 节点供 readString 使用。 */
+function asStringNode(node) {
+    return {
+        cls: Asn1Class.Universal,
+        tag: UniversalTag.Ia5String,
+        constructed: false,
+        indefinite: false,
+        length: node.value.length,
+        value: node.value,
+        raw: node.raw,
+    };
+}
+/** 4 字节 IPv4 / 16 字节 IPv6 → 文本。 */
+export function formatIp(bytes) {
+    if (bytes.length === 4) {
+        return `${bytes[0]}.${bytes[1]}.${bytes[2]}.${bytes[3]}`;
+    }
+    if (bytes.length !== 16)
+        return `#${bytesToHex(bytes)}`;
+    const groups = [];
+    for (let i = 0; i < 16; i += 2) {
+        groups.push((bytes[i] << 8) | bytes[i + 1]);
+    }
+    // 找出最长的一段连续 0（长度 >= 2）压缩为 `::`。
+    let bestStart = -1;
+    let bestLen = 0;
+    for (let i = 0; i < 8;) {
+        if (groups[i] !== 0) {
+            i++;
+            continue;
+        }
+        let j = i;
+        while (j < 8 && groups[j] === 0)
+            j++;
+        if (j - i > bestLen) {
+            bestStart = i;
+            bestLen = j - i;
+        }
+        i = j;
+    }
+    if (bestLen < 2)
+        return groups.map((g) => g.toString(16)).join(':');
+    const left = groups
+        .slice(0, bestStart)
+        .map((g) => g.toString(16))
+        .join(':');
+    const right = groups
+        .slice(bestStart + bestLen)
+        .map((g) => g.toString(16))
+        .join(':');
+    return `${left}::${right}`;
+}
+/** 正 INTEGER 内容字节 → bigint（用于 [2] IMPLICIT INTEGER）。 */
+function positiveIntegerFromBytes(bytes) {
+    let v = 0n;
+    for (let i = 0; i < bytes.length; i++)
+        v = (v << 8n) | BigInt(bytes[i]);
+    return v;
+}

package/dist/x509/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * X.509 子模块（`sm-crypto-wasm/x509`）。
+ *
+ * 范围：证书解析、单证书签名验证、自签/CA 签发。**不做证书链路径校验**、
+ * 不拉 CRL/OCSP；调用方需要按 issuer 逐级调用 `verifySignature`。
+ */
+export { CertificateError } from './errors.js';
+export type { SelfSignedCertificateOptions } from './issue.js';
+export { createSelfSignedCertificate, issueCertificate, parseDistinguishedName, } from './issue.js';
+export * from './oids.js';
+export { parseCertificate, parseCertificates } from './parse.js';
+export type { AlgorithmIdentifier, AuthorityKeyIdentifier, BasicConstraints, BasicConstraintsInput, Certificate, CertificateInput, CertificateSigner, DistinguishedNameInput, Extension, GeneralName, IssueCertificateOptions, IssueCertificateResult, KeyUsage, KeyUsageName, Name, NameAttribute, SubjectAltNameInput, SubjectPublicKeyInfo, Validity, } from './types.js';
+export type { VerifySignatureOptions } from './verify.js';
+export { DEFAULT_SM2_USER_ID, isWithinValidity, verifyCertificateSignature } from './verify.js';

package/dist/x509/index.js

@@ -0,0 +1,11 @@
+/**
+ * X.509 子模块（`sm-crypto-wasm/x509`）。
+ *
+ * 范围：证书解析、单证书签名验证、自签/CA 签发。**不做证书链路径校验**、
+ * 不拉 CRL/OCSP；调用方需要按 issuer 逐级调用 `verifySignature`。
+ */
+export { CertificateError } from './errors.js';
+export { createSelfSignedCertificate, issueCertificate, parseDistinguishedName, } from './issue.js';
+export * from './oids.js';
+export { parseCertificate, parseCertificates } from './parse.js';
+export { DEFAULT_SM2_USER_ID, isWithinValidity, verifyCertificateSignature } from './verify.js';

package/dist/x509/ip.d.ts

@@ -0,0 +1,12 @@
+/**
+ * IP 地址解析（用于 SubjectAltName 的 iPAddress）。
+ *
+ * 输出 4 字节（IPv4）或 16 字节（IPv6）。IPv6 支持 `::` 压缩与
+ * 末尾内嵌 IPv4（如 `::ffff:192.168.0.1`）。
+ */
+/**
+ * 把 IPv4 / IPv6 文本解析为地址字节。
+ *
+ * @throws CertificateError 格式非法。
+ */
+export declare function parseIpAddress(value: string): Uint8Array;

package/dist/x509/ip.js

@@ -0,0 +1,101 @@
+/**
+ * IP 地址解析（用于 SubjectAltName 的 iPAddress）。
+ *
+ * 输出 4 字节（IPv4）或 16 字节（IPv6）。IPv6 支持 `::` 压缩与
+ * 末尾内嵌 IPv4（如 `::ffff:192.168.0.1`）。
+ */
+import { CertificateError } from './errors.js';
+/**
+ * 把 IPv4 / IPv6 文本解析为地址字节。
+ *
+ * @throws CertificateError 格式非法。
+ */
+export function parseIpAddress(value) {
+    const text = value.trim();
+    if (text.length === 0)
+        throw new CertificateError('subjectAltName: empty IP address');
+    if (text.includes(':'))
+        return parseIpv6(text);
+    return parseIpv4(text);
+}
+function parseIpv4(text) {
+    const parts = text.split('.');
+    if (parts.length !== 4)
+        throw new CertificateError(`invalid IPv4 address "${text}"`);
+    const out = new Uint8Array(4);
+    for (let i = 0; i < 4; i++) {
+        const part = parts[i];
+        if (!/^(0|[1-9][0-9]{0,2})$/.test(part)) {
+            throw new CertificateError(`invalid IPv4 address "${text}"`);
+        }
+        const n = Number(part);
+        if (n > 255)
+            throw new CertificateError(`invalid IPv4 address "${text}"`);
+        out[i] = n;
+    }
+    return out;
+}
+function parseIpv6(text) {
+    const doubleColon = text.indexOf('::');
+    let headParts;
+    let tailParts;
+    let compressed = false;
+    if (doubleColon >= 0) {
+        if (text.indexOf('::', doubleColon + 2) >= 0) {
+            throw new CertificateError(`invalid IPv6 address "${text}"`);
+        }
+        compressed = true;
+        headParts = splitPart(text.slice(0, doubleColon));
+        tailParts = splitPart(text.slice(doubleColon + 2));
+    }
+    else {
+        headParts = splitPart(text);
+        tailParts = [];
+    }
+    const head = groupsOf(headParts, false, text);
+    const tail = groupsOf(tailParts, true, text);
+    let groups;
+    if (!compressed) {
+        if (head.length !== 8)
+            throw new CertificateError(`invalid IPv6 address "${text}"`);
+        groups = head;
+    }
+    else {
+        const total = head.length + tail.length;
+        if (total > 7)
+            throw new CertificateError(`invalid IPv6 address "${text}"`);
+        groups = [...head, ...new Array(8 - total).fill(0), ...tail];
+    }
+    const out = new Uint8Array(16);
+    for (let i = 0; i < 8; i++) {
+        const group = groups[i];
+        out[i * 2] = (group >> 8) & 0xff;
+        out[i * 2 + 1] = group & 0xff;
+    }
+    return out;
+}
+function splitPart(part) {
+    if (part.length === 0)
+        return [];
+    return part.split(':').filter((item) => item !== '');
+}
+function groupsOf(parts, allowIpv4AtEnd, text) {
+    const out = [];
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part.includes('.')) {
+            if (!allowIpv4AtEnd || i !== parts.length - 1) {
+                throw new CertificateError(`invalid IPv6 address "${text}"`);
+            }
+            const v4 = parseIpv4(part);
+            out.push((v4[0] << 8) | v4[1]);
+            out.push((v4[2] << 8) | v4[3]);
+            continue;
+        }
+        if (!/^[0-9a-fA-F]{1,4}$/.test(part)) {
+            throw new CertificateError(`invalid IPv6 address "${text}"`);
+        }
+        out.push(Number.parseInt(part, 16));
+    }
+    return out;
+}

package/dist/x509/issue.d.ts

@@ -0,0 +1,44 @@
+/**
+ * X.509 证书签发（自签 + 用 CA 证书签发终端证书）。
+ *
+ * 安全边界（红线 #4 / #5 / #6）：
+ * - 证书版本固定 v3；
+ * - `basicConstraints.ca=false` 的证书不得用于签发子证书，且该证书不能带
+ *   `keyUsage: keyCertSign`；
+ * - 用作签发者的证书必须是 CA（`basicConstraints.ca === true`），若带 KeyUsage
+ *   必须包含 `keyCertSign`；
+ * - CA 证书的 KeyUsage（若提供）必须包含 `keyCertSign`；
+ * - 序列号为正整数；默认生成 16 字节随机数并把最高位清零；
+ * - SAN 的 dNSName / rfc822Name / URI 必须为 ASCII，iPAddress 必须是合法 4/16 字节。
+ *
+ * 本模块**不生成密钥、不管理私钥**：私钥由调用方提供，签名后不驻留。
+ */
+import type { Certificate, DistinguishedNameInput, IssueCertificateOptions, IssueCertificateResult } from './types.js';
+/** `createSelfSignedCertificate` 的选项。 */
+export type SelfSignedCertificateOptions = Omit<IssueCertificateOptions, 'issuer' | 'signer'> & {
+    readonly privateKey: string | Uint8Array;
+};
+/**
+ * 签发一张 SM2 证书。
+ *
+ * @throws CertificateError 输入不满足证书约束。
+ * @throws RangeError 序列号/有效期/路径长度越界。
+ */
+export declare function issueCertificate(opts: IssueCertificateOptions): IssueCertificateResult;
+/**
+ * 生成自签证书（issuer = subject）。
+ *
+ * @throws CertificateError / RangeError 同 `issueCertificate`。
+ */
+export declare function createSelfSignedCertificate(opts: SelfSignedCertificateOptions): IssueCertificateResult;
+/**
+ * 解析 RFC 4514 子集形式的 DN 字符串，如 `"C=CN,O=Example,CN=Example CA"`。
+ *
+ * 支持反斜杠转义（`\,`、`\=`、`\\`）；不做完整 RFC 4514（多值 RDN、
+ * `#hex` 编码、十六进制转义等）。
+ *
+ * @throws CertificateError 格式非法或属性名未知。
+ */
+export declare function parseDistinguishedName(input: string): DistinguishedNameInput;
+/** 保留类型引用，供生成的声明文件使用。 */
+export type { Certificate };