sm-crypto-wasm 0.3.0 → 0.7.0

package/dist/cms/sign.js

@@ -0,0 +1,142 @@
+/**
+ * CMS SignedData 签名（detached / attached）。
+ *
+ * 签名的计算对象是 `signedAttrs` 的 DER 编码（SET tag 0x31）——与验签层
+ * 使用完全相同的规则；`contentType` / `messageDigest` / `signingTime` 三个
+ * 属性按 DER SET OF 排序后编码。
+ *
+ * 只做 SignedData，不做 EnvelopedData / RFC 3161 时间戳。
+ */
+import { explicit, implicit, integer, octetString, oid, parseDer, seq, setOf, time, } from '../asn1/index.js';
+import { bytesToBase64, bytesToPem, hexToBytes } from '../runtime/convert.js';
+import * as sm2 from '../sm2/index.js';
+import * as sm3 from '../sm3/index.js';
+import { parseCertificate } from '../x509/parse.js';
+import { rawSignatureToDer } from '../x509/sig.js';
+import { CmsError } from './errors.js';
+import { OID_CMS_CONTENT_TYPE, OID_CMS_DATA, OID_CMS_MESSAGE_DIGEST, OID_CMS_SIGNED_DATA, OID_CMS_SIGNING_TIME, OID_SM3, OID_SM3_WITH_SM2, } from './oids.js';
+/**
+ * 生成 CMS SignedData（单签名者）。
+ *
+ * 调用前需要预热 wasm：`await sm2.ensureLoaded(); await sm3.ensureLoaded();`
+ *
+ * @throws CmsError 缺少签名者证书或输入不合法。
+ */
+export function signData(opts) {
+    const content = toDataBytes(opts.data);
+    const signerCertificate = resolveSignerCertificate(opts);
+    const chain = (opts.certificates ?? []).map((item) => resolveCertificate(item));
+    const certificates = dedupeCertificates([signerCertificate, ...chain]);
+    const digest = hexToBytes(sm3.hash(content), 'messageDigest');
+    const signingTime = opts.signingTime === false ? undefined : (opts.signingTime ?? new Date());
+    const attributes = [
+        attribute(OID_CMS_CONTENT_TYPE, setOf([oid(OID_CMS_DATA)])),
+        attribute(OID_CMS_MESSAGE_DIGEST, setOf([octetString(digest)])),
+    ];
+    if (signingTime !== undefined) {
+        attributes.push(attribute(OID_CMS_SIGNING_TIME, setOf([time(signingTime)])));
+    }
+    const signedAttrs = setOf(attributes);
+    const signature = hexToBytes(sm2.signWithID(opts.privateKey, signedAttrs.raw, opts.userID ?? new Uint8Array(0)), 'signature');
+    const signatureDer = rawSignatureToDer(signature);
+    const signerInfo = seq([
+        integer(1),
+        issuerAndSerialNumber(signerCertificate),
+        algorithmIdentifier(OID_SM3),
+        implicit(0, signedAttrs),
+        algorithmIdentifier(OID_SM3_WITH_SM2),
+        octetString(signatureDer),
+    ]);
+    const encapContentInfo = opts.detached === false
+        ? seq([oid(OID_CMS_DATA), explicit(0, octetString(content))])
+        : seq([oid(OID_CMS_DATA)]);
+    const signedDataChildren = [
+        integer(1),
+        setOf([algorithmIdentifier(OID_SM3)]),
+        encapContentInfo,
+    ];
+    if (certificates.length > 0) {
+        signedDataChildren.push(implicit(0, setOf(certificates.map((cert) => parseDer(cert.raw)))));
+    }
+    signedDataChildren.push(setOf([signerInfo]));
+    const signedData = seq(signedDataChildren);
+    const contentInfo = seq([oid(OID_CMS_SIGNED_DATA), explicit(0, signedData)]);
+    const der = new Uint8Array(contentInfo.raw);
+    return {
+        der,
+        pem: bytesToPem(der, 'CMS'),
+        base64: bytesToBase64(der),
+    };
+}
+// ---------- 编码辅助 ----------
+function attribute(attrOid, values) {
+    return seq([oid(attrOid), values]);
+}
+function algorithmIdentifier(oidValue) {
+    return seq([oid(oidValue)]);
+}
+function issuerAndSerialNumber(cert) {
+    let issuer;
+    try {
+        issuer = parseDer(cert.issuer.raw);
+    }
+    catch (err) {
+        throw new CmsError('signData: failed to re-encode issuer name', { cause: err });
+    }
+    return seq([issuer, integer(cert.serialNumber)]);
+}
+// ---------- 输入辅助 ----------
+/** 字符串按 UTF-8 处理；CMS 的 data 语义是报文内容，不是 hex。 */
+function toDataBytes(data) {
+    if (data instanceof Uint8Array)
+        return new Uint8Array(data);
+    if (typeof data === 'string')
+        return new TextEncoder().encode(data);
+    throw new TypeError('signData: data must be a string or Uint8Array');
+}
+function resolveSignerCertificate(opts) {
+    const input = opts.certificate ?? opts.certificates?.[0];
+    if (input === undefined) {
+        throw new CmsError('signData: certificate is required to build the SignerInfo');
+    }
+    return resolveCertificate(input);
+}
+function resolveCertificate(input) {
+    if (isCertificateLike(input))
+        return input;
+    try {
+        return parseCertificate(input);
+    }
+    catch (err) {
+        throw new CmsError('signData: invalid certificate', { cause: err });
+    }
+}
+function isCertificateLike(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !(value instanceof Uint8Array) &&
+        'tbsCertificate' in value &&
+        'subjectPublicKey' in value);
+}
+function dedupeCertificates(certificates) {
+    const seen = new Set();
+    const out = [];
+    for (const cert of certificates) {
+        const key = base64Key(cert.raw);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(cert);
+    }
+    return out;
+}
+function base64Key(bytes) {
+    let key = '';
+    for (let i = 0; i < bytes.length; i++)
+        key += String.fromCharCode(bytes[i]);
+    return key;
+}
+/** 证书集合中的证书原始 DER（供外部检查）。 */
+export function certificateChainDer(certificates) {
+    return certificates.map((cert) => new Uint8Array(cert.raw));
+}

package/dist/cms/verify.d.ts

@@ -0,0 +1,42 @@
+/**
+ * CMS SignedData 验签。
+ *
+ * 只验证签名与 messageDigest，**不建立信任链**、不检查证书有效期/用途；
+ * 需要信任判断时由调用方对 `signers[i].certificate` 另行处理。
+ */
+import type { Certificate } from '../x509/types.js';
+import { type CmsVerifyErrorCode } from './errors.js';
+import { type CmsSignerInfo } from './parse.js';
+/** `verifySignedData` 的选项。 */
+export interface VerifySignedDataOptions {
+    /** detached 模式下的原始内容（字符串按 UTF-8 编码）。 */
+    readonly detachedData?: string | Uint8Array;
+    /** 额外候选证书（CMS 未内嵌签名者证书时使用）。 */
+    readonly certificates?: readonly (Certificate | string | Uint8Array)[];
+    /** 显式指定 SM2 用户标识；省略时依次尝试空标识与 GM/T 默认标识。 */
+    readonly userID?: Uint8Array;
+}
+/** 单个签名者的验签结果。 */
+export interface VerifySignerResult {
+    readonly valid: boolean;
+    readonly certificate?: Certificate;
+    readonly signingTime?: Date;
+    /** 人类可读的补充说明。 */
+    readonly error?: string;
+    /** 结构化失败原因（`valid === true` 时不存在）。 */
+    readonly errorCode?: CmsVerifyErrorCode;
+}
+/** `verifySignedData` 的结果。 */
+export interface VerifySignedDataResult {
+    readonly valid: boolean;
+    readonly signers: readonly VerifySignerResult[];
+}
+/**
+ * 验证 CMS SignedData。
+ *
+ * 结构完全无法解析时返回 `{ valid: false, signers: [{ errorCode: 'MALFORMED' }] }`，
+ * 而不是抛错；wasm 未预热等环境错误仍会抛出。
+ */
+export declare function verifySignedData(cms: string | Uint8Array, opts?: VerifySignedDataOptions): VerifySignedDataResult;
+/** 供调试：签名者标识的十六进制表示。 */
+export declare function signerIdentifierHex(signer: CmsSignerInfo): string;

package/dist/cms/verify.js

@@ -0,0 +1,173 @@
+/**
+ * CMS SignedData 验签。
+ *
+ * 只验证签名与 messageDigest，**不建立信任链**、不检查证书有效期/用途；
+ * 需要信任判断时由调用方对 `signers[i].certificate` 另行处理。
+ */
+import { bytesToHex, hexToBytes } from '../runtime/convert.js';
+import * as sm2 from '../sm2/index.js';
+import * as sm3 from '../sm3/index.js';
+import { parseCertificate } from '../x509/parse.js';
+import { derSignatureToRaw } from '../x509/sig.js';
+import { DEFAULT_SM2_USER_ID } from '../x509/verify.js';
+import { CmsError } from './errors.js';
+import { OID_CMS_CONTENT_TYPE, OID_CMS_MESSAGE_DIGEST, OID_CMS_SIGNING_TIME, OID_SM3, OID_SM3_WITH_SM2, } from './oids.js';
+import { attributeOctets, attributeOid, attributeTime, parseSignedData, } from './parse.js';
+/** SM2 空用户标识（OpenSSL CMS 默认）。 */
+const EMPTY_USER_ID = new Uint8Array(0);
+/**
+ * 验证 CMS SignedData。
+ *
+ * 结构完全无法解析时返回 `{ valid: false, signers: [{ errorCode: 'MALFORMED' }] }`，
+ * 而不是抛错；wasm 未预热等环境错误仍会抛出。
+ */
+export function verifySignedData(cms, opts = {}) {
+    let parsed;
+    try {
+        parsed = parseSignedData(cms);
+    }
+    catch (err) {
+        return {
+            valid: false,
+            signers: [
+                {
+                    valid: false,
+                    errorCode: 'MALFORMED',
+                    error: err instanceof Error ? err.message : String(err),
+                },
+            ],
+        };
+    }
+    const certificates = [
+        ...parsed.certificates,
+        ...(opts.certificates ?? []).map((cert) => resolveCertificate(cert)),
+    ];
+    const detachedData = opts.detachedData === undefined ? undefined : toDataBytes(opts.detachedData);
+    const signers = parsed.signerInfos.map((signer) => verifySigner(parsed, signer, certificates, detachedData, opts.userID));
+    return {
+        valid: signers.length > 0 && signers.every((signer) => signer.valid),
+        signers,
+    };
+}
+function verifySigner(parsed, signer, certificates, detachedData, userID) {
+    if (signer.digestAlgorithm !== OID_SM3) {
+        return fail('UNSUPPORTED_ALGORITHM', `unsupported digest algorithm ${signer.digestAlgorithm}`);
+    }
+    if (signer.signatureAlgorithm !== OID_SM3_WITH_SM2) {
+        return fail('UNSUPPORTED_ALGORITHM', `unsupported signature algorithm ${signer.signatureAlgorithm}`);
+    }
+    const certificate = findCertificate(signer, certificates);
+    if (certificate === undefined) {
+        return fail('NO_CERTIFICATE', 'signer certificate is not embedded and was not provided');
+    }
+    if (!certificate.supported) {
+        return fail('UNSUPPORTED_ALGORITHM', 'signer certificate public key is not SM2');
+    }
+    const content = parsed.eContent ?? detachedData;
+    let signingInput;
+    let signingTime;
+    if (signer.signedAttrs !== undefined) {
+        if (content === undefined) {
+            return fail('MALFORMED', 'detached data is required but was not supplied');
+        }
+        const attributes = signer.signedAttrs.attributes;
+        const contentType = attributeOid(attributeByOid(attributes, OID_CMS_CONTENT_TYPE));
+        if (contentType !== parsed.eContentType) {
+            return fail('DIGEST_MISMATCH', `contentType attribute ${String(contentType)} does not match ${parsed.eContentType}`);
+        }
+        const expectedDigest = attributeOctets(attributeByOid(attributes, OID_CMS_MESSAGE_DIGEST));
+        if (expectedDigest === undefined) {
+            return fail('MALFORMED', 'missing messageDigest attribute');
+        }
+        const actualDigest = hexToBytes(sm3.hash(content), 'messageDigest');
+        if (!equalBytes(expectedDigest, actualDigest)) {
+            return fail('DIGEST_MISMATCH', 'messageDigest does not match the content');
+        }
+        signingInput = signer.signedAttrs.raw;
+        signingTime = attributeTime(attributeByOid(attributes, OID_CMS_SIGNING_TIME));
+    }
+    else {
+        if (content === undefined) {
+            return fail('MALFORMED', 'detached data is required but was not supplied');
+        }
+        signingInput = content;
+    }
+    let signature;
+    try {
+        signature = derSignatureToRaw(signer.signature);
+    }
+    catch {
+        return fail('SIGNATURE_INVALID', 'malformed DER signature');
+    }
+    const valid = verifyWithUserId(certificate.subjectPublicKey, signingInput, signature, userID);
+    if (!valid)
+        return fail('SIGNATURE_INVALID', 'SM2 signature verification failed');
+    return {
+        valid: true,
+        certificate,
+        ...(signingTime === undefined ? {} : { signingTime }),
+    };
+}
+function verifyWithUserId(publicKey, message, signature, userID) {
+    if (userID !== undefined) {
+        return sm2.verifyWithID(publicKey, message, signature, userID);
+    }
+    // 先试 OpenSSL CMS 的空标识，再试 GM/T 默认标识。
+    if (sm2.verifyWithID(publicKey, message, signature, EMPTY_USER_ID))
+        return true;
+    return sm2.verifyWithID(publicKey, message, signature, DEFAULT_SM2_USER_ID);
+}
+function findCertificate(signer, certificates) {
+    const sid = signer.sid;
+    if (sid.type === 'issuerAndSerialNumber') {
+        return certificates.find((cert) => cert.serialNumber === sid.serialNumber && equalBytes(cert.issuer.raw, sid.issuerRaw));
+    }
+    return certificates.find((cert) => cert.subjectKeyIdentifier !== undefined &&
+        equalBytes(cert.subjectKeyIdentifier, sid.keyIdentifier));
+}
+function attributeByOid(attributes, target) {
+    return attributes.find((attribute) => attribute.oid === target);
+}
+function resolveCertificate(input) {
+    if (isCertificateLike(input))
+        return input;
+    try {
+        return parseCertificate(input);
+    }
+    catch (err) {
+        throw new CmsError('verifySignedData: invalid certificate', { cause: err });
+    }
+}
+function isCertificateLike(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !(value instanceof Uint8Array) &&
+        'tbsCertificate' in value &&
+        'subjectPublicKey' in value);
+}
+function toDataBytes(data) {
+    if (data instanceof Uint8Array)
+        return new Uint8Array(data);
+    if (typeof data === 'string')
+        return new TextEncoder().encode(data);
+    throw new TypeError('verifySignedData: detachedData must be a string or Uint8Array');
+}
+function equalBytes(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+function fail(code, message) {
+    return { valid: false, errorCode: code, error: message };
+}
+/** 供调试：签名者标识的十六进制表示。 */
+export function signerIdentifierHex(signer) {
+    if (signer.sid.type === 'subjectKeyIdentifier') {
+        return bytesToHex(signer.sid.keyIdentifier);
+    }
+    return `${bytesToHex(signer.sid.issuerRaw)}#${signer.sid.serialNumber.toString(16)}`;
+}

package/dist/index.d.ts

@@ -16,6 +16,7 @@
  *
  * spec/plan 对应：plan Task 12；spec §5 产物结构、§6 API。
  */
+export * as cms from './cms/index.js';
 export { bytesToHex, fromBytes, hexToBytes, toBytes } from './runtime/convert.js';
 export { CiphertextError, DecryptionError, InvalidCiphertextError, InvalidKeyError, InvalidPublicKeyError, isSmCryptoError, SmCryptoError, } from './runtime/errors.js';
 export { loadWasm, loadWasmSync } from './runtime/loadWasm.js';
@@ -23,4 +24,6 @@ export * as sm2 from './sm2/index.js';
 export * as sm3 from './sm3/index.js';
 export * as sm4 from './sm4/index.js';
 export * as sm9 from './sm9/index.js';
+export * as webcrypto from './webcrypto/index.js';
+export * as x509 from './x509/index.js';
 export * as zuc from './zuc/index.js';

package/dist/index.js

@@ -16,6 +16,7 @@
  *
  * spec/plan 对应：plan Task 12；spec §5 产物结构、§6 API。
  */
+export * as cms from './cms/index.js';
 export { bytesToHex, fromBytes, hexToBytes, toBytes } from './runtime/convert.js';
 // 运行时工具（错误类型、编解码）也导出，便于调用方捕获本库错误。
 export { CiphertextError, DecryptionError, InvalidCiphertextError, InvalidKeyError, InvalidPublicKeyError, isSmCryptoError, SmCryptoError, } from './runtime/errors.js';
@@ -24,4 +25,6 @@ export * as sm2 from './sm2/index.js';
 export * as sm3 from './sm3/index.js';
 export * as sm4 from './sm4/index.js';
 export * as sm9 from './sm9/index.js';
+export * as webcrypto from './webcrypto/index.js';
+export * as x509 from './x509/index.js';
 export * as zuc from './zuc/index.js';

package/dist/pem/asn1.d.ts

@@ -1,74 +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「迁移」。
  */
-/** ASN.1 节点。children 仅对 constructed 类型存在。 */
-export interface Asn1Node {
-    /** UNIVERSAL=0、APPLICATION=1、CONTEXT=2、PRIVATE=3。 */
-    readonly cls: number;
-    /** UNIVERSAL 标签值（如 INTEGER=2、SEQUENCE=16）；其它类自行解释。 */
-    readonly tag: number;
-    /** 长度（DER 存储的是真实字节长度）。 */
-    readonly length: number;
-    /** 节点原始字节（含 tag+length+value），用于 round-trip 与错误诊断。 */
-    readonly raw: Uint8Array;
-    /** primitive 节点的 value；OCTET STRING/BIT STRING/INTEGER 等直接看这里。 */
-    readonly value: Uint8Array;
-    /** constructed 节点的子节点。 */
-    readonly children?: Asn1Node[];
-}
-/** 抛错信息统一封装。 */
-export declare class Asn1Error extends Error {
-    readonly name = "Asn1Error";
-}
-/**
- * 解析一段 DER 字节。
- *
- * @param buf DER 字节。
- * @returns 解析后的根节点（通常为 SEQUENCE）。
- * @throws Asn1Error 输入截断、tag/length 不合法、不支持的构造。
- */
-export declare function parseDer(buf: Uint8Array): Asn1Node;
-/**
- * 将 Asn1Node 编码回 DER 字节。**重新计算 length 与 raw**。
- *
- * @param node 待编码节点。
- * @returns DER 字节。
- */
-export declare function encodeDer(node: Asn1Node): Uint8Array;
-/**
- * 便捷构造函数：构造一个 INTEGER 节点。
- *
- * @param value 大端整数（可为负：负数用二进制补码表示）。
- */
-export declare function asn1Int(value: bigint | number): Asn1Node;
-/** 便捷构造函数：构造一个 OCTET STRING 节点。 */
-export declare function asn1Octets(value: Uint8Array): Asn1Node;
-/** 便捷构造函数：构造一个 OID 节点（输入如 `"1.2.156.10197.1.100"`）。 */
-export declare function asn1Oid(oid: string): Asn1Node;
-/** 便捷构造函数：构造一个 NULL 节点。 */
-export declare function asn1Null(): Asn1Node;
-/** 便捷构造函数：构造一个 SEQUENCE 节点。 */
-export declare function asn1Seq(children: Asn1Node[]): Asn1Node;
-/**
- * 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 declare function encodeOid(oid: string): Uint8Array;
-/** 反向解码。 */
-export declare function decodeOid(bytes: Uint8Array): string;
-/** 读一个 INTEGER 返回 bigint。 */
-export declare function asn1IntValue(node: Asn1Node): bigint;
+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, type Asn1Node } from '../asn1/types.js';