sm-crypto-wasm 0.3.0 → 0.7.0

package/dist/asn1/types.js

@@ -0,0 +1,71 @@
+/**
+ * ASN.1 通用类型与常量（DER/BER 子集）。
+ *
+ * 与旧 `src/pem/asn1.ts` 的关系：
+ * - 旧实现只覆盖 PKCS#8 用到的最小类型，且不保留 `constructed` 位；
+ * - 本层是 X.509 / CMS / WebCrypto 共用的通用基础设施，覆盖
+ *   BOOLEAN、SET、字符串、时间、context/application/private 标签等。
+ *
+ * 设计要点：
+ * - 每个节点保留 `raw`（含 tag + length + value 的原始切片），X.509 的 TBS
+ *   与 CMS 的 `signedAttrs` 验签必须对原始字节做摘要，不能重新编码；
+ * - `raw` 是对输入缓冲的**视图**（不拷贝），调用方不应假定其生命周期；
+ *   需要长期持有时自行 `slice()`；
+ * - 解析错误统一为 `Asn1Error`；上层（X.509/CMS）负责转换为各自的错误类型。
+ */
+/** ASN.1 标签类别常量。 */
+export const Asn1Class = {
+    Universal: 0,
+    Application: 1,
+    ContextSpecific: 2,
+    Private: 3,
+};
+/** UNIVERSAL 类常用标签编号。 */
+export const UniversalTag = {
+    EndOfContent: 0,
+    Boolean: 1,
+    Integer: 2,
+    BitString: 3,
+    OctetString: 4,
+    Null: 5,
+    ObjectIdentifier: 6,
+    Enumerated: 10,
+    Utf8String: 12,
+    Sequence: 16,
+    Set: 17,
+    NumericString: 18,
+    PrintableString: 19,
+    TeletexString: 20,
+    VideotexString: 21,
+    Ia5String: 22,
+    UtcTime: 23,
+    GeneralizedTime: 24,
+    UniversalString: 28,
+    BmpString: 30,
+};
+/** ASN.1 解析/编码错误。 */
+export class Asn1Error extends Error {
+    name = 'Asn1Error';
+}
+/** 判断节点是否为指定 UNIVERSAL 类型。 */
+export function isUniversal(node, tag) {
+    return node.cls === Asn1Class.Universal && node.tag === tag;
+}
+/** 断言节点为指定 UNIVERSAL 类型，否则抛 `Asn1Error`。 */
+export function expectUniversal(node, tag, what) {
+    if (node === undefined) {
+        throw new Asn1Error(`${what}: missing element (expected tag ${tag})`);
+    }
+    if (!isUniversal(node, tag)) {
+        throw new Asn1Error(`${what}: expected UNIVERSAL tag ${tag}, got class ${node.cls} tag ${node.tag}`);
+    }
+    return node;
+}
+/** 断言节点为 constructed SEQUENCE 并返回子节点。 */
+export function expectSequence(node, what) {
+    const seq = expectUniversal(node, UniversalTag.Sequence, what);
+    if (!seq.children) {
+        throw new Asn1Error(`${what}: SEQUENCE is not constructed`);
+    }
+    return seq.children;
+}

package/dist/cms/errors.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CMS（PKCS#7 SignedData）错误类型。
+ */
+import { SmCryptoError } from '../runtime/errors.js';
+/** CMS 解析/签名/验签失败。 */
+export declare class CmsError extends SmCryptoError {
+    readonly name: string;
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** `verifySignedData` 的结构化失败原因。 */
+export type CmsVerifyErrorCode = 'NO_CERTIFICATE' | 'DIGEST_MISMATCH' | 'SIGNATURE_INVALID' | 'UNSUPPORTED_ALGORITHM' | 'MALFORMED';

package/dist/cms/errors.js

@@ -0,0 +1,11 @@
+/**
+ * CMS（PKCS#7 SignedData）错误类型。
+ */
+import { SmCryptoError } from '../runtime/errors.js';
+/** CMS 解析/签名/验签失败。 */
+export class CmsError extends SmCryptoError {
+    name = 'CmsError';
+    constructor(message, options) {
+        super(message, options);
+    }
+}

package/dist/cms/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CMS SignedData 子模块（`sm-crypto-wasm/cms`）。
+ *
+ * 只做签名/验签，不建立信任链；证书有效期/用途/链校验由调用方负责。
+ */
+export { CmsError, type CmsVerifyErrorCode } from './errors.js';
+export * from './oids.js';
+export type { CmsAttribute, CmsSignerIdentifier, CmsSignerInfo, ParsedSignedData, } from './parse.js';
+export { parseSignedData } from './parse.js';
+export type { SignDataOptions, SignDataResult } from './sign.js';
+export { signData } from './sign.js';
+export type { VerifySignedDataOptions, VerifySignedDataResult, VerifySignerResult, } from './verify.js';
+export { signerIdentifierHex, verifySignedData } from './verify.js';

package/dist/cms/index.js

@@ -0,0 +1,10 @@
+/**
+ * CMS SignedData 子模块（`sm-crypto-wasm/cms`）。
+ *
+ * 只做签名/验签，不建立信任链；证书有效期/用途/链校验由调用方负责。
+ */
+export { CmsError } from './errors.js';
+export * from './oids.js';
+export { parseSignedData } from './parse.js';
+export { signData } from './sign.js';
+export { signerIdentifierHex, verifySignedData } from './verify.js';

package/dist/cms/oids.d.ts

@@ -0,0 +1,17 @@
+/**
+ * CMS oid 常量。
+ */
+/** id-data（1.2.840.113549.1.7.1）。 */
+export declare const OID_CMS_DATA = "1.2.840.113549.1.7.1";
+/** id-signedData（1.2.840.113549.1.7.2）。 */
+export declare const OID_CMS_SIGNED_DATA = "1.2.840.113549.1.7.2";
+/** contentType 签名属性（1.2.840.113549.1.9.3）。 */
+export declare const OID_CMS_CONTENT_TYPE = "1.2.840.113549.1.9.3";
+/** messageDigest 签名属性（1.2.840.113549.1.9.4）。 */
+export declare const OID_CMS_MESSAGE_DIGEST = "1.2.840.113549.1.9.4";
+/** signingTime 签名属性（1.2.840.113549.1.9.5）。 */
+export declare const OID_CMS_SIGNING_TIME = "1.2.840.113549.1.9.5";
+/** SM3 摘要算法（1.2.156.10197.1.401）。 */
+export declare const OID_SM3 = "1.2.156.10197.1.401";
+/** SM3withSM2（1.2.156.10197.1.501）。 */
+export declare const OID_SM3_WITH_SM2 = "1.2.156.10197.1.501";

package/dist/cms/oids.js

@@ -0,0 +1,17 @@
+/**
+ * CMS oid 常量。
+ */
+/** id-data（1.2.840.113549.1.7.1）。 */
+export const OID_CMS_DATA = '1.2.840.113549.1.7.1';
+/** id-signedData（1.2.840.113549.1.7.2）。 */
+export const OID_CMS_SIGNED_DATA = '1.2.840.113549.1.7.2';
+/** contentType 签名属性（1.2.840.113549.1.9.3）。 */
+export const OID_CMS_CONTENT_TYPE = '1.2.840.113549.1.9.3';
+/** messageDigest 签名属性（1.2.840.113549.1.9.4）。 */
+export const OID_CMS_MESSAGE_DIGEST = '1.2.840.113549.1.9.4';
+/** signingTime 签名属性（1.2.840.113549.1.9.5）。 */
+export const OID_CMS_SIGNING_TIME = '1.2.840.113549.1.9.5';
+/** SM3 摘要算法（1.2.156.10197.1.401）。 */
+export const OID_SM3 = '1.2.156.10197.1.401';
+/** SM3withSM2（1.2.156.10197.1.501）。 */
+export const OID_SM3_WITH_SM2 = '1.2.156.10197.1.501';

package/dist/cms/parse.d.ts

@@ -0,0 +1,75 @@
+/**
+ * CMS SignedData 解析（只读）。
+ *
+ * 关键点（红线 #1）：
+ * `signedAttrs` 的签名输入是**原始 DER 字节**（SET OF Attribute），而不是
+ * 解析后重新编码的结果。这里保留：
+ * - `raw`：把 `[0] IMPLICIT` 的首字节（0xA0）换成 SET（0x31）后的字节；
+ * - 对 BER indefinite-length，先编码为 definite-length 再替换首字节。
+ * 除首字节外不做任何重编码，避免 SET 顺序/长度编码差异破坏合法签名。
+ *
+ * BER 只在 CMS 路径启用；证书本身仍按 DER 严格解析。
+ */
+import { type Asn1Node } from '../asn1/index.js';
+import type { Certificate } from '../x509/types.js';
+/** 一个签名属性（Attribute ::= SEQUENCE { attrType, attrValues SET OF }). */
+export interface CmsAttribute {
+    readonly oid: string;
+    /** AttributeValue 节点（原始视图）。 */
+    readonly values: readonly Asn1Node[];
+    /** 整个 Attribute 的原始 DER。 */
+    readonly raw: Uint8Array;
+}
+/** 签名者标识。 */
+export type CmsSignerIdentifier = {
+    readonly type: 'issuerAndSerialNumber';
+    /** 签发者 Name 的原始 DER，用于按字节匹配证书。 */
+    readonly issuerRaw: Uint8Array;
+    readonly serialNumber: bigint;
+} | {
+    readonly type: 'subjectKeyIdentifier';
+    readonly keyIdentifier: Uint8Array;
+};
+/** 解析后的 SignerInfo。 */
+export interface CmsSignerInfo {
+    readonly version: number;
+    readonly sid: CmsSignerIdentifier;
+    readonly digestAlgorithm: string;
+    /**
+     * signedAttrs 的签名输入字节（SET tag 0x31）。
+     * 没有 signedAttrs 时为 `undefined`（直接签内容）。
+     */
+    readonly signedAttrs?: {
+        readonly raw: Uint8Array;
+        readonly attributes: readonly CmsAttribute[];
+    };
+    readonly signatureAlgorithm: string;
+    readonly signature: Uint8Array;
+}
+/** 解析后的 SignedData。 */
+export interface ParsedSignedData {
+    readonly version: number;
+    readonly digestAlgorithms: readonly string[];
+    readonly eContentType: string;
+    /** 内嵌内容；detached 时为 `undefined`。 */
+    readonly eContent?: Uint8Array;
+    readonly certificates: readonly Certificate[];
+    readonly signerInfos: readonly CmsSignerInfo[];
+    /** 整个 ContentInfo 的原始 DER。 */
+    readonly raw: Uint8Array;
+}
+/**
+ * 解析 CMS ContentInfo（仅接受 SignedData）。
+ *
+ * @param input PEM（`CMS` / `PKCS7`）、base64、hex 或 DER/BER 字节。
+ * @throws CmsError 结构非法、不是 SignedData、或尾部有多余字节。
+ */
+export declare function parseSignedData(input: string | Uint8Array): ParsedSignedData;
+/** 读取签名属性中的时间值（供验签层使用）。 */
+export declare function attributeTime(attribute: CmsAttribute | undefined): Date | undefined;
+/** 读取签名属性中的 OCTET STRING 值（messageDigest）。 */
+export declare function attributeOctets(attribute: CmsAttribute | undefined): Uint8Array | undefined;
+/** 读取签名属性中的 OID 值（contentType）。 */
+export declare function attributeOid(attribute: CmsAttribute | undefined): string | undefined;
+/** 十六进制便捷函数（供错误信息/调试使用）。 */
+export declare function cmsHex(bytes: Uint8Array): string;

package/dist/cms/parse.js

@@ -0,0 +1,326 @@
+/**
+ * CMS SignedData 解析（只读）。
+ *
+ * 关键点（红线 #1）：
+ * `signedAttrs` 的签名输入是**原始 DER 字节**（SET OF Attribute），而不是
+ * 解析后重新编码的结果。这里保留：
+ * - `raw`：把 `[0] IMPLICIT` 的首字节（0xA0）换成 SET（0x31）后的字节；
+ * - 对 BER indefinite-length，先编码为 definite-length 再替换首字节。
+ * 除首字节外不做任何重编码，避免 SET 顺序/长度编码差异破坏合法签名。
+ *
+ * BER 只在 CMS 路径启用；证书本身仍按 DER 严格解析。
+ */
+import { Asn1Class, encode, expectSequence, expectUniversal, parseBer, readInteger, readOid, readTime, UniversalTag, } from '../asn1/index.js';
+import { base64ToBytes, bytesToHex, hexToBytes } from '../runtime/convert.js';
+import { parseCertificate } from '../x509/parse.js';
+import { CmsError } from './errors.js';
+import { OID_CMS_SIGNED_DATA } from './oids.js';
+/**
+ * 解析 CMS ContentInfo（仅接受 SignedData）。
+ *
+ * @param input PEM（`CMS` / `PKCS7`）、base64、hex 或 DER/BER 字节。
+ * @throws CmsError 结构非法、不是 SignedData、或尾部有多余字节。
+ */
+export function parseSignedData(input) {
+    const der = decodeCmsInput(input);
+    let top;
+    try {
+        top = parseBer(der);
+    }
+    catch (err) {
+        throw new CmsError(`parseSignedData: invalid DER/BER (${errorMessage(err)})`, { cause: err });
+    }
+    try {
+        return signedDataFromContentInfo(top, der);
+    }
+    catch (err) {
+        if (err instanceof CmsError)
+            throw err;
+        throw new CmsError(`parseSignedData: ${errorMessage(err)}`, { cause: err });
+    }
+}
+function signedDataFromContentInfo(top, raw) {
+    const kids = expectSequence(top, 'ContentInfo');
+    const contentType = readOid(kids[0], 'ContentInfo.contentType');
+    if (contentType !== OID_CMS_SIGNED_DATA) {
+        throw new CmsError(`parseSignedData: content type ${contentType} is not signedData`);
+    }
+    const wrapper = kids[1];
+    if (wrapper === undefined || wrapper.cls !== Asn1Class.ContextSpecific || wrapper.tag !== 0) {
+        throw new CmsError('parseSignedData: missing [0] EXPLICIT content');
+    }
+    const signedData = wrapper.children?.[0];
+    if (signedData === undefined) {
+        throw new CmsError('parseSignedData: empty SignedData content');
+    }
+    return parseSignedDataNode(signedData, raw);
+}
+function parseSignedDataNode(node, raw) {
+    const kids = expectSequence(node, 'SignedData');
+    if (kids.length < 4) {
+        throw new CmsError(`SignedData: expected at least 4 elements, got ${kids.length}`);
+    }
+    let index = 0;
+    const version = Number(readInteger(kids[index++], 'SignedData.version'));
+    const digestAlgorithms = parseAlgorithmSet(kids[index++], 'digestAlgorithms');
+    const encap = parseEncapContentInfo(kids[index++]);
+    let certificates = [];
+    const maybeCerts = kids[index];
+    if (maybeCerts !== undefined && maybeCerts.cls === Asn1Class.ContextSpecific) {
+        if (maybeCerts.tag === 0) {
+            certificates = parseCertificates(maybeCerts);
+            index++;
+        }
+        else if (maybeCerts.tag === 1) {
+            // crls：v1 不处理。
+            index++;
+        }
+    }
+    const signerSet = kids[index];
+    if (signerSet === undefined)
+        throw new CmsError('SignedData: missing signerInfos');
+    const signerInfos = (signerSet.children ?? []).map((child) => parseSignerInfo(expectSequence(child, 'SignerInfo')));
+    return {
+        version,
+        digestAlgorithms,
+        eContentType: encap.eContentType,
+        ...(encap.eContent === undefined ? {} : { eContent: encap.eContent }),
+        certificates,
+        signerInfos,
+        raw: new Uint8Array(raw),
+    };
+}
+function parseAlgorithmSet(node, what) {
+    const entries = node?.children ?? [];
+    return entries.map((entry) => {
+        const kids = expectSequence(entry, what);
+        return readOid(kids[0], what);
+    });
+}
+function parseEncapContentInfo(node) {
+    const kids = expectSequence(node, 'EncapsulatedContentInfo');
+    const eContentType = readOid(kids[0], 'eContentType');
+    const wrapper = kids[1];
+    if (wrapper === undefined || wrapper.cls !== Asn1Class.ContextSpecific || wrapper.tag !== 0) {
+        return { eContentType };
+    }
+    const octets = wrapper.children?.[0];
+    if (octets === undefined) {
+        throw new CmsError('EncapsulatedContentInfo: empty eContent');
+    }
+    return { eContentType, eContent: octetStringBytes(octets) };
+}
+function parseCertificates(node) {
+    const certificates = [];
+    for (const child of node.children ?? []) {
+        // CertificateChoices 还可能是其它证书类型；解析失败的项跳过，不影响 SignedData。
+        try {
+            certificates.push(parseCertificate(child.raw));
+        }
+        catch {
+            // 非 X.509 证书或损坏项：忽略。
+        }
+    }
+    return certificates;
+}
+function parseSignerInfo(kids) {
+    let index = 0;
+    const version = Number(readInteger(kids[index++], 'SignerInfo.version'));
+    const sidNode = kids[index++];
+    if (sidNode === undefined)
+        throw new CmsError('SignerInfo: missing sid');
+    const sid = parseSignerIdentifier(sidNode);
+    const digestNode = kids[index++];
+    const digestKids = expectSequence(digestNode, 'digestAlgorithm');
+    const digestAlgorithm = readOid(digestKids[0], 'digestAlgorithm');
+    let signedAttrs;
+    const attrsNode = kids[index];
+    if (attrsNode !== undefined &&
+        attrsNode.cls === Asn1Class.ContextSpecific &&
+        attrsNode.tag === 0) {
+        signedAttrs = parseSignedAttrs(attrsNode);
+        index++;
+    }
+    const signatureAlgKids = expectSequence(kids[index++], 'signatureAlgorithm');
+    const signatureAlgorithm = readOid(signatureAlgKids[0], 'signatureAlgorithm');
+    const signatureNode = kids[index++];
+    if (signatureNode === undefined)
+        throw new CmsError('SignerInfo: missing signature');
+    const signature = octetStringBytes(signatureNode);
+    return {
+        version,
+        sid,
+        digestAlgorithm,
+        ...(signedAttrs === undefined ? {} : { signedAttrs }),
+        signatureAlgorithm,
+        signature,
+    };
+}
+function parseSignerIdentifier(node) {
+    if (node.cls === Asn1Class.Universal && node.tag === UniversalTag.Sequence) {
+        const kids = expectSequence(node, 'IssuerAndSerialNumber');
+        const issuer = kids[0];
+        const serial = kids[1];
+        if (issuer === undefined || serial === undefined) {
+            throw new CmsError('IssuerAndSerialNumber: missing issuer/serialNumber');
+        }
+        return {
+            type: 'issuerAndSerialNumber',
+            issuerRaw: new Uint8Array(issuer.raw),
+            serialNumber: readInteger(serial, 'IssuerAndSerialNumber.serialNumber'),
+        };
+    }
+    if (node.cls === Asn1Class.ContextSpecific && node.tag === 0) {
+        return { type: 'subjectKeyIdentifier', keyIdentifier: new Uint8Array(node.value) };
+    }
+    throw new CmsError('SignerInfo: unsupported signer identifier');
+}
+function parseSignedAttrs(node) {
+    const attributes = (node.children ?? []).map((child) => {
+        const kids = expectSequence(child, 'Attribute');
+        const oidNode = kids[0];
+        const valuesNode = kids[1];
+        if (oidNode === undefined || valuesNode === undefined) {
+            throw new CmsError('Attribute: missing attrType or attrValues');
+        }
+        return {
+            oid: readOid(oidNode, 'Attribute.attrType'),
+            values: valuesNode.children ?? [],
+            raw: new Uint8Array(child.raw),
+        };
+    });
+    return { raw: signedAttrsDer(node), attributes };
+}
+/**
+ * 还原 signedAttrs 的签名输入字节。
+ *
+ * `[0] IMPLICIT` 与 `SET` 的唯一区别是首字节（0xA0 vs 0x31），长度和内容
+ * 完全相同。definite-length 时只改首字节；BER indefinite-length 时先编码为
+ * definite-length（子节点顺序不变），再改首字节。
+ */
+function signedAttrsDer(node) {
+    if (!node.indefinite) {
+        const copy = new Uint8Array(node.raw);
+        copy[0] = 0x31;
+        return copy;
+    }
+    const encoded = encode(node);
+    encoded[0] = 0x31;
+    return encoded;
+}
+function octetStringBytes(node) {
+    const target = expectUniversal(node, UniversalTag.OctetString, 'OCTET STRING');
+    if (!target.constructed)
+        return new Uint8Array(target.value);
+    // constructed OCTET STRING（BER 分块）：拼接子节点内容。
+    const parts = (target.children ?? []).map((child) => octetStringBytes(child));
+    let total = 0;
+    for (const part of parts)
+        total += part.length;
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+// ---------- 输入解码 ----------
+function decodeCmsInput(input) {
+    if (input instanceof Uint8Array) {
+        if (input.length === 0)
+            throw new CmsError('parseSignedData: empty input');
+        if (isPemText(input))
+            return decodeCmsInput(new TextDecoder().decode(input));
+        return input;
+    }
+    if (typeof input !== 'string') {
+        throw new TypeError('parseSignedData: expected string or Uint8Array');
+    }
+    const text = input.trim();
+    if (text.length === 0)
+        throw new CmsError('parseSignedData: empty input');
+    const pem = /-----BEGIN (?:CMS|PKCS7)-----([\s\S]*?)-----END (?:CMS|PKCS7)-----/.exec(text);
+    if (pem !== null) {
+        try {
+            return base64ToBytes(pem[1].replace(/\s+/g, ''), 'cms');
+        }
+        catch (err) {
+            throw new CmsError('parseSignedData: invalid base64 in PEM block', { cause: err });
+        }
+    }
+    const compact = text.replace(/\s+/g, '');
+    const candidates = [];
+    if (/^[0-9a-fA-F]+$/.test(compact) && compact.length % 2 === 0) {
+        candidates.push(hexToBytes(compact, 'cms'));
+    }
+    try {
+        candidates.push(base64ToBytes(compact, 'cms'));
+    }
+    catch {
+        // 不是 base64。
+    }
+    for (const candidate of candidates) {
+        try {
+            parseBer(candidate);
+            return candidate;
+        }
+        catch {
+            // 尝试下一个。
+        }
+    }
+    throw new CmsError('parseSignedData: input is neither PEM, hex nor base64 DER');
+}
+function isPemText(bytes) {
+    const prefix = '-----BEGIN ';
+    if (bytes.length < prefix.length)
+        return false;
+    for (let i = 0; i < prefix.length; i++) {
+        if (bytes[i] !== prefix.charCodeAt(i))
+            return false;
+    }
+    return true;
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/** 读取签名属性中的时间值（供验签层使用）。 */
+export function attributeTime(attribute) {
+    const value = attribute?.values[0];
+    if (value === undefined)
+        return undefined;
+    try {
+        return readTime(value, 'signingTime');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 读取签名属性中的 OCTET STRING 值（messageDigest）。 */
+export function attributeOctets(attribute) {
+    const value = attribute?.values[0];
+    if (value === undefined)
+        return undefined;
+    try {
+        return octetStringBytes(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 读取签名属性中的 OID 值（contentType）。 */
+export function attributeOid(attribute) {
+    const value = attribute?.values[0];
+    if (value === undefined)
+        return undefined;
+    try {
+        return readOid(value, 'contentType');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 十六进制便捷函数（供错误信息/调试使用）。 */
+export function cmsHex(bytes) {
+    return bytesToHex(bytes);
+}

package/dist/cms/sign.d.ts

@@ -0,0 +1,43 @@
+/**
+ * CMS SignedData 签名（detached / attached）。
+ *
+ * 签名的计算对象是 `signedAttrs` 的 DER 编码（SET tag 0x31）——与验签层
+ * 使用完全相同的规则；`contentType` / `messageDigest` / `signingTime` 三个
+ * 属性按 DER SET OF 排序后编码。
+ *
+ * 只做 SignedData，不做 EnvelopedData / RFC 3161 时间戳。
+ */
+import type { Certificate } from '../x509/types.js';
+/** `signData` 的输入。 */
+export interface SignDataOptions {
+    /** 待签名数据；字符串按 UTF-8 编码（不是 hex/base64）。 */
+    readonly data: string | Uint8Array;
+    /** PKCS#8 / SEC1 PEM、32 字节私钥或其 hex。 */
+    readonly privateKey: string | Uint8Array;
+    /** 签名者证书；省略时取 `certificates[0]`。 */
+    readonly certificate?: Certificate | string | Uint8Array;
+    /** 额外证书（链）。 */
+    readonly certificates?: readonly (Certificate | string | Uint8Array)[];
+    /** 默认 `true`：只输出签名，内容由调用方另行传输。 */
+    readonly detached?: boolean;
+    /** 默认当前时间；`false` 表示不加入 signingTime 属性。 */
+    readonly signingTime?: Date | false;
+    /** SM2 用户标识；默认空（与 OpenSSL 的 CMS 路径一致）。 */
+    readonly userID?: Uint8Array;
+}
+/** `signData` 的结果。 */
+export interface SignDataResult {
+    readonly der: Uint8Array;
+    readonly pem: string;
+    readonly base64: string;
+}
+/**
+ * 生成 CMS SignedData（单签名者）。
+ *
+ * 调用前需要预热 wasm：`await sm2.ensureLoaded(); await sm3.ensureLoaded();`
+ *
+ * @throws CmsError 缺少签名者证书或输入不合法。
+ */
+export declare function signData(opts: SignDataOptions): SignDataResult;
+/** 证书集合中的证书原始 DER（供外部检查）。 */
+export declare function certificateChainDer(certificates: readonly Certificate[]): Uint8Array[];