@owf/x509 0.0.0-stage → 0.0.0

package/dist/index.d.mts

@@ -0,0 +1,600 @@
+import { IAsnParseOptions } from "@peculiar/asn1-schema";
+import { AlgorithmIdentifier, Certificate as Certificate$1, Extension, GeneralName, KeyUsageType, Name, SubjectPublicKeyInfo } from "@peculiar/asn1-x509";
+import { IdentityException, JsonWebKey, OrPromise } from "@owf/identity-common";
+import "asn1js";
+//#region src/constants.d.ts
+/** X.520 attribute types and PKCS#9 emailAddress, as used in distinguished names */
+export declare const ATTRIBUTE_TYPES: {
+  readonly commonName: '2.5.4.3';
+  readonly surname: '2.5.4.4';
+  readonly serialNumber: '2.5.4.5';
+  readonly countryName: '2.5.4.6';
+  readonly localityName: '2.5.4.7';
+  readonly stateOrProvinceName: '2.5.4.8';
+  readonly streetAddress: '2.5.4.9';
+  readonly organizationName: '2.5.4.10';
+  readonly organizationalUnitName: '2.5.4.11';
+  readonly title: '2.5.4.12';
+  readonly postalCode: '2.5.4.17';
+  readonly telephoneNumber: '2.5.4.20';
+  readonly givenName: '2.5.4.42';
+  readonly initials: '2.5.4.43';
+  readonly generationQualifier: '2.5.4.44';
+  readonly pseudonym: '2.5.4.65';
+  readonly organizationIdentifier: '2.5.4.97';
+  readonly emailAddress: '1.2.840.113549.1.9.1';
+};
+type AttributeName = keyof typeof ATTRIBUTE_TYPES;
+/** Policy qualifier identifiers (RFC 5280 clause 4.2.1.4) */
+export declare const POLICY_QUALIFIERS: {
+  readonly cps: '1.3.6.1.5.5.7.2.1';
+  readonly unotice: '1.3.6.1.5.5.7.2.2';
+};
+/** Access methods for the Authority Information Access extension (RFC 5280 clause 4.2.2.1) */
+export declare const ACCESS_METHODS: {
+  readonly ocsp: '1.3.6.1.5.5.7.48.1';
+  readonly caIssuers: '1.3.6.1.5.5.7.48.2';
+};
+/** QCStatements extension (RFC 3739) and statements from ETSI EN 319 412-5 */
+export declare const QC_STATEMENTS: {
+  readonly extension: "1.3.6.1.5.5.7.1.3";
+  readonly qcCompliance: "0.4.0.1862.1.1";
+  readonly qcSSCD: "0.4.0.1862.1.4";
+  readonly qcPDS: "0.4.0.1862.1.5";
+  readonly qcType: "0.4.0.1862.1.6";
+  readonly qcCClegislation: "0.4.0.1862.1.7";
+};
+/** QcType values (ETSI EN 319 412-5 clause 4.2.3) */
+export declare const QC_TYPES: {
+  readonly esign: "0.4.0.1862.1.6.1";
+  readonly eseal: "0.4.0.1862.1.6.2";
+  readonly web: "0.4.0.1862.1.6.3";
+};
+type QcType = keyof typeof QC_TYPES;
+/** Signature algorithms supported for creating and describing certificates and CRLs */
+export declare const SIGNATURE_ALGORITHMS: {
+  readonly ES256: {
+    readonly oid: '1.2.840.10045.4.3.2';
+    readonly hash: 'SHA-256';
+    readonly family: 'ecdsa';
+  };
+  readonly ES384: {
+    readonly oid: '1.2.840.10045.4.3.3';
+    readonly hash: 'SHA-384';
+    readonly family: 'ecdsa';
+  };
+  readonly ES512: {
+    readonly oid: '1.2.840.10045.4.3.4';
+    readonly hash: 'SHA-512';
+    readonly family: 'ecdsa';
+  };
+  readonly RS256: {
+    readonly oid: '1.2.840.113549.1.1.11';
+    readonly hash: 'SHA-256';
+    readonly family: 'rsa';
+  };
+  readonly RS384: {
+    readonly oid: '1.2.840.113549.1.1.12';
+    readonly hash: 'SHA-384';
+    readonly family: 'rsa';
+  };
+  readonly RS512: {
+    readonly oid: '1.2.840.113549.1.1.13';
+    readonly hash: 'SHA-512';
+    readonly family: 'rsa';
+  };
+};
+type SignatureAlgorithm = keyof typeof SIGNATURE_ALGORITHMS;
+/** Public key algorithm and curve identifiers */
+export declare const KEY_ALGORITHMS: {
+  readonly ecPublicKey: '1.2.840.10045.2.1';
+  readonly rsaEncryption: '1.2.840.113549.1.1.1';
+  readonly 'P-256': '1.2.840.10045.3.1.7';
+  readonly 'P-384': '1.3.132.0.34';
+  readonly 'P-521': '1.3.132.0.35';
+};
+/** CRL entry revocation reasons (RFC 5280 clause 5.3.1) */
+export declare const CRL_REASONS: {
+  readonly unspecified: 0;
+  readonly keyCompromise: 1;
+  readonly cACompromise: 2;
+  readonly affiliationChanged: 3;
+  readonly superseded: 4;
+  readonly cessationOfOperation: 5;
+  readonly certificateHold: 6;
+  readonly removeFromCRL: 8;
+  readonly privilegeWithdrawn: 9;
+  readonly aACompromise: 10;
+};
+type CrlReason = keyof typeof CRL_REASONS;
+//#endregion
+//#region src/encoding.d.ts
+/** DER bytes, a base64 encoded DER string, or a PEM string */
+type DerInput = Uint8Array | ArrayBuffer | string;
+/** A DER encoded certificate as bytes, a base64 DER string, or a PEM string */
+type CertificateInput = DerInput;
+/** A DER encoded CRL as bytes, a base64 DER string, or a PEM string (`X509 CRL`) */
+type CrlInput = DerInput;
+export declare const PEM_LABELS: {
+  readonly certificate: 'CERTIFICATE';
+  readonly crl: 'X509 CRL';
+};
+/**
+ * Normalize a {@link DerInput} to DER bytes. PEM strings must use the given label; the
+ * first matching block is used.
+ */
+export declare function toDer(input: DerInput, label?: string): Uint8Array;
+/** Encode DER bytes as PEM. */
+export declare function toPem(der: Uint8Array, label?: string): string;
+//#endregion
+//#region src/name.d.ts
+/** One name attribute: a well-known attribute name or an attribute type OID, and its value */
+type NameAttributeInput = readonly [AttributeName | string, string | undefined];
+/**
+ * Compare two distinguished names attribute by attribute, ignoring case and insignificant
+ * whitespace in the values (a simplification of the RFC 5280 clause 7.1 matching rules).
+ */
+export declare function namesEqual(a: DistinguishedName, b: DistinguishedName): boolean;
+//#endregion
+//#region src/types.d.ts
+/** A single attribute of a distinguished name */
+interface DistinguishedNameAttribute {
+  /** Attribute type OID */
+  type: string;
+  /** Well-known attribute name, when the OID is known */
+  name?: AttributeName;
+  /** Attribute value as string (non-string values are `#` followed by the hex encoded DER) */
+  value: string;
+}
+/** A distinguished name with accessors for common attributes */
+interface DistinguishedName {
+  /** All attributes in encoding order (multi-valued RDNs are flattened) */
+  attributes: DistinguishedNameAttribute[];
+  /** RFC 4514 string representation, most specific RDN first */
+  rfc4514: string;
+  commonName?: string;
+  organizationName?: string;
+  organizationIdentifier?: string;
+  organizationalUnitNames: string[];
+  countryName?: string;
+  localityName?: string;
+  stateOrProvinceName?: string;
+  serialNumber?: string;
+  givenName?: string;
+  surname?: string;
+  pseudonym?: string;
+}
+interface ParsedPublicKey {
+  /** Key algorithm OID */
+  algorithm: string;
+  /** Named curve OID for EC keys */
+  namedCurve?: string;
+  /** DER encoded SubjectPublicKeyInfo */
+  spki: Uint8Array;
+  /** JWK representation, for EC (P-256, P-384, P-521) and RSA keys */
+  jwk?: JsonWebKey;
+}
+interface X509Extension {
+  oid: string;
+  critical: boolean;
+  /** DER encoded extension value (content of extnValue) */
+  value: Uint8Array;
+}
+/** Result of a signature over a DER structure (certificate or CRL) */
+interface SignedStructure {
+  /** Signature algorithm OID */
+  signatureAlgorithm: string;
+  /** Signature algorithm name, when supported by this package */
+  signatureAlgorithmName?: SignatureAlgorithm;
+  /** The signature value as encoded in the structure (DER for ECDSA) */
+  signature: Uint8Array;
+}
+/** A certificate policy entry (RFC 5280 clause 4.2.1.4) */
+interface CertificatePolicyInformation {
+  oid: string;
+  cpsUris: string[];
+  /** Explicit text of any user notice qualifiers */
+  userNotices: string[];
+}
+interface OtherNameValue {
+  typeId: string;
+  /** DER encoding of the value */
+  value: Uint8Array;
+  /** The decoded value when it is an ASN.1 string type */
+  text?: string;
+}
+interface SubjectAlternativeNames {
+  dnsNames: string[];
+  uris: string[];
+  emails: string[];
+  ipAddresses: string[];
+  directoryNames: DistinguishedName[];
+  otherNames: OtherNameValue[];
+}
+/** QCStatements (RFC 3739, ETSI EN 319 412-5) */
+interface QcStatements {
+  /** All statement ids present, in order */
+  statementIds: string[];
+  /** id-etsi-qcs-QcCompliance present */
+  qcCompliance: boolean;
+  /** id-etsi-qcs-QcSSCD present */
+  qcSSCD: boolean;
+  /** Known QcType values; unknown type OIDs are returned as-is */
+  qcTypes: (QcType | string)[];
+  /** PKI disclosure statements */
+  pds: {
+    url: string;
+    language: string;
+  }[];
+  /** QcCClegislation country codes */
+  legislationCountries: string[];
+}
+/** A parsed X.509 certificate */
+interface Certificate extends SignedStructure {
+  /** DER encoding of the certificate */
+  der: Uint8Array;
+  /** PEM encoding of the certificate */
+  pem: string;
+  /** X.509 version (1, 2 or 3) */
+  version: number;
+  /** Lowercase hex encoded serial number, as encoded (including a leading 00 octet if present) */
+  serialNumber: string;
+  issuer: DistinguishedName;
+  subject: DistinguishedName;
+  notBefore: Date;
+  notAfter: Date;
+  publicKey: ParsedPublicKey;
+  /** DER encoded TBSCertificate, i.e. the signed bytes */
+  tbsCertificate: Uint8Array;
+  policies: CertificatePolicyInformation[];
+  subjectAlternativeNames: SubjectAlternativeNames;
+  keyUsage?: KeyUsageType[];
+  extendedKeyUsage?: string[];
+  basicConstraints?: {
+    cA: boolean;
+    pathLenConstraint?: number;
+  };
+  /** Lowercase hex */
+  subjectKeyIdentifier?: string;
+  /** Lowercase hex */
+  authorityKeyIdentifier?: string;
+  /** URIs of the full names of all CRL distribution points */
+  crlDistributionPoints: string[];
+  ocspUrls: string[];
+  caIssuersUrls: string[];
+  qcStatements?: QcStatements;
+  extensions: X509Extension[];
+}
+interface RevokedCertificate {
+  /** Lowercase hex encoded serial number, as encoded */
+  serialNumber: string;
+  revocationDate: Date;
+  /** Absent means unspecified */
+  reason?: CrlReason;
+  invalidityDate?: Date;
+  /** Issuer of the revoked certificate for indirect CRLs (applies to this and following entries) */
+  certificateIssuer?: DistinguishedName;
+  extensions: X509Extension[];
+}
+interface IssuingDistributionPoint {
+  /** URIs of the distribution point full name */
+  distributionPointUris: string[];
+  onlyContainsUserCerts: boolean;
+  onlyContainsCACerts: boolean;
+  onlyContainsAttributeCerts: boolean;
+  indirectCRL: boolean;
+  /** Reason flags when the CRL covers only some reasons */
+  onlySomeReasons?: string[];
+}
+/** A parsed X.509 certificate revocation list (RFC 5280 clause 5) */
+interface Crl extends SignedStructure {
+  der: Uint8Array;
+  pem: string;
+  /** CRL version (1 or 2) */
+  version: number;
+  issuer: DistinguishedName;
+  thisUpdate: Date;
+  nextUpdate?: Date;
+  /** DER encoded TBSCertList, i.e. the signed bytes */
+  tbsCertList: Uint8Array;
+  crlNumber?: bigint;
+  /** Set for delta CRLs: the CRL number of the base CRL */
+  deltaCrlIndicator?: bigint;
+  /** Lowercase hex */
+  authorityKeyIdentifier?: string;
+  issuingDistributionPoint?: IssuingDistributionPoint;
+  /** URIs of freshest CRL (delta CRL) distribution points */
+  freshestCrl: string[];
+  revokedCertificates: RevokedCertificate[];
+  extensions: X509Extension[];
+}
+/**
+ * Signs DER encoded to-be-signed bytes (TBSCertificate or TBSCertList) with the issuer key.
+ *
+ * The private key never has to be handed to this package: implement the callback with
+ * WebCrypto, a KMS, an HSM or a remote signing service.
+ */
+type TbsSigner = (tbs: Uint8Array) => OrPromise<Uint8Array>;
+/** Encoding of ECDSA signatures returned by a signer: `ieee-p1363` (r || s, WebCrypto) or `der` */
+type SignatureEncoding = 'ieee-p1363' | 'der';
+/**
+ * Hash function used to derive key identifiers. Receives the subject public key bytes and is
+ * called with `sha-256`; the first 160 bits are used (RFC 7093 method 1). Compatible with
+ * `digest` from `@owf/crypto`.
+ */
+type KeyIdentifierHasher = (data: ArrayBuffer, alg: string) => OrPromise<Uint8Array>;
+interface SignatureVerificationInput {
+  /** DER encoded to-be-signed bytes */
+  data: Uint8Array;
+  /** Signature as encoded in the structure (DER for ECDSA) */
+  signature: Uint8Array;
+  /** Signature as r || s for ECDSA, as expected by WebCrypto; same as `signature` for RSA */
+  signatureP1363: Uint8Array;
+  /** Signature algorithm OID */
+  signatureAlgorithm: string;
+  signatureAlgorithmName?: SignatureAlgorithm;
+  /** Public key of the signer */
+  publicKey: ParsedPublicKey;
+}
+type SignatureVerifier = (input: SignatureVerificationInput) => OrPromise<boolean>;
+interface SubjectAlternativeNamesInput {
+  dnsNames?: string[];
+  uris?: string[];
+  emails?: string[];
+  /** otherName entries; use {@link stringOtherName} for string valued types */
+  otherNames?: {
+    typeId: string;
+    value: Uint8Array;
+  }[];
+}
+interface CertificateTemplate {
+  /** Subject attributes in encoding order, most general first (e.g. C, O, CN) */
+  subject: readonly NameAttributeInput[];
+  /** Public key of the subject as DER SubjectPublicKeyInfo or public JWK (private JWKs are rejected) */
+  subjectPublicKey: Uint8Array | JsonWebKey;
+  /**
+   * Certificate of the issuing CA; supplies the issuer name, authority key identifier and
+   * the key type for signature encoding. Omit for a self-signed certificate.
+   */
+  issuerCertificate?: CertificateInput;
+  /** Positive serial number as bytes or hex string (at most 20 octets) */
+  serialNumber: Uint8Array | string;
+  notBefore: Date;
+  notAfter: Date;
+  /** Algorithm the issuer key signs with */
+  signatureAlgorithm: SignatureAlgorithm;
+  /** Marked critical. Defaults to `{ cA: false }` */
+  basicConstraints?: {
+    cA: boolean;
+    pathLenConstraint?: number;
+  };
+  /** Marked critical. Defaults to `['digitalSignature']`, or `['keyCertSign', 'crlSign']` for CAs */
+  keyUsage?: KeyUsageType[];
+  extendedKeyUsage?: string[];
+  certificatePolicies?: {
+    oid: string;
+    cpsUris?: string[];
+  }[];
+  subjectAlternativeNames?: SubjectAlternativeNamesInput;
+  crlDistributionPoints?: string[];
+  ocspUrls?: string[];
+  caIssuersUrls?: string[];
+  /** QCStatements; QcCompliance is always included when set */
+  qcStatements?: {
+    qcTypes?: QcType[];
+    qcSSCD?: boolean;
+    pds?: {
+      url: string;
+      language: string;
+    }[];
+    legislationCountries?: string[];
+  };
+  /** Adds a subject key identifier (and the authority key identifier of self-signed certificates) */
+  hasher?: KeyIdentifierHasher;
+  /** Additional extensions, appended as-is */
+  extensions?: X509Extension[];
+}
+/** The to-be-signed bytes of a certificate or CRL, plus what is needed to assemble it */
+interface PreparedSignedStructure {
+  tbs: Uint8Array;
+  signatureAlgorithm: SignatureAlgorithm;
+  /** Public key of the signer, used to encode ECDSA signatures */
+  signerPublicKey: ParsedPublicKey;
+}
+interface SignOptions {
+  signer: TbsSigner;
+  /** Encoding of ECDSA signatures returned by the signer; defaults to `ieee-p1363` (WebCrypto) */
+  signatureEncoding?: SignatureEncoding;
+}
+interface CrlTemplate {
+  /** Certificate of the CRL issuer */
+  issuerCertificate: CertificateInput;
+  thisUpdate: Date;
+  nextUpdate: Date;
+  /** Monotonically increasing CRL number (RFC 5280 clause 5.2.3) */
+  crlNumber: bigint | number;
+  signatureAlgorithm: SignatureAlgorithm;
+  revokedCertificates?: {
+    serialNumber: Uint8Array | string;
+    revocationDate: Date;
+    reason?: CrlReason;
+    invalidityDate?: Date;
+  }[];
+  /** Scope of the CRL; marked critical */
+  issuingDistributionPoint?: {
+    distributionPointUris?: string[];
+    onlyContainsUserCerts?: boolean;
+    onlyContainsCACerts?: boolean;
+  };
+  /** Additional CRL extensions, appended as-is */
+  extensions?: X509Extension[];
+}
+type RevocationStatus = {
+  status: 'good';
+} | {
+  status: 'revoked';
+  revocationDate: Date;
+  reason?: CrlReason;
+  invalidityDate?: Date;
+} | {
+  status: 'unknown';
+  reason: RevocationUnknownReason;
+  message: string;
+};
+type RevocationUnknownReason = 'issuer_mismatch' | 'crl_not_yet_valid' | 'crl_expired' | 'out_of_scope' | 'delta_crl' | 'unsupported_critical_extension' | 'invalid_signature';
+interface RevocationCheckOptions {
+  /** Reference time for the CRL freshness check; defaults to now. `false` skips it. */
+  now?: Date | false;
+}
+//#endregion
+//#region src/certificate.d.ts
+/**
+ * Parse an X.509 certificate.
+ *
+ * Decodes the standard extensions of RFC 5280 plus QCStatements. Parsing does not verify the
+ * signature; use {@link verifyCertificateSignature} for that.
+ *
+ * @param input DER bytes, base64 encoded DER, or PEM
+ * @param options Resource limits forwarded to asn1js (`berOptions`)
+ * @throws X509Exception when the input is not a well-formed X.509 certificate
+ */
+export declare function parseCertificate(input: CertificateInput, options?: IAsnParseOptions): Certificate;
+//#endregion
+//#region src/create.d.ts
+/**
+ * Encode an otherName whose value is a PrintableString (or UTF8String for non-printable
+ * values), e.g. an `id-at-telephoneNumber` subject alternative name.
+ */
+export declare function stringOtherName(typeId: string, value: string): {
+  typeId: string;
+  value: Uint8Array;
+};
+/**
+ * Build the TBSCertificate for a certificate template.
+ *
+ * Sign the returned `tbs` bytes with the issuer key wherever that key lives and pass the
+ * signature to {@link assembleCertificate}. {@link createCertificate} wraps both steps
+ * around a signer callback.
+ */
+export declare function prepareCertificate(template: CertificateTemplate): Promise<PreparedSignedStructure>;
+/**
+ * Combine a prepared TBSCertificate with the issuer signature.
+ *
+ * @param signatureEncoding Encoding of ECDSA signatures; WebCrypto produces `ieee-p1363` (default)
+ */
+export declare function assembleCertificate(prepared: PreparedSignedStructure, signature: Uint8Array, signatureEncoding?: SignatureEncoding): Certificate;
+/**
+ * Create an X.509 v3 certificate.
+ *
+ * The issuer key is never passed in: the `signer` callback receives the DER encoded
+ * TBSCertificate and returns the signature, so the key can stay in WebCrypto, a KMS or an
+ * HSM. Only the public key of the subject is needed; a JWK with private key material is
+ * rejected.
+ */
+export declare function createCertificate(template: CertificateTemplate & SignOptions): Promise<Certificate>;
+//#endregion
+//#region src/crl.d.ts
+interface ParseCrlOptions extends IAsnParseOptions {
+  /**
+   * Upper bound for the number of revoked certificate entries, protecting against resource
+   * exhaustion by untrusted input. Defaults to 100 000. Ignored when `berOptions.maxNodes`
+   * is set explicitly.
+   */
+  maxEntries?: number;
+}
+/**
+ * Parse an X.509 certificate revocation list (RFC 5280 clause 5).
+ *
+ * Parsing does not verify the signature; use {@link verifyCrlSignature} or {@link checkRevocation}.
+ *
+ * @param input DER bytes, base64 encoded DER, or PEM (`X509 CRL`)
+ * @throws X509Exception when the input is not a well-formed CRL or exceeds the size limits
+ */
+export declare function parseCrl(input: CrlInput, options?: ParseCrlOptions): Crl;
+/**
+ * Look up the revocation status of `certificate` in `crl`.
+ *
+ * This does **not** verify the CRL signature; use {@link checkRevocation} unless the CRL
+ * has already been verified. The CRL must be issued by the certificate issuer (or be an
+ * indirect CRL naming it), must be current, and must cover the certificate. Otherwise the
+ * status is `unknown` with the reason, and the caller should find a suitable CRL or fall
+ * back to OCSP.
+ */
+export declare function getRevocationStatus(certificate: Certificate, crl: Crl, options?: RevocationCheckOptions): RevocationStatus;
+/**
+ * Verify the CRL signature against `crlIssuerCertificate`, then look up the revocation
+ * status of `certificate` (see {@link getRevocationStatus}).
+ *
+ * The signature check is delegated to `verifier`; an invalid signature yields `unknown`
+ * with reason `invalid_signature`. Fetching the CRL (see `crlDistributionPoints` on the
+ * certificate) is up to the caller.
+ */
+export declare function checkRevocation(options: {
+  certificate: Certificate;
+  crl: Crl;
+  crlIssuerCertificate: Certificate | CertificateInput;
+  verifier: SignatureVerifier;
+  now?: Date | false;
+}): Promise<RevocationStatus>;
+/**
+ * Build the TBSCertList of a v2 CRL. Sign the returned `tbs` bytes with the CRL issuer key
+ * and pass the signature to {@link assembleCrl}, or use {@link createCrl} with a signer.
+ */
+export declare function prepareCrl(template: CrlTemplate): PreparedSignedStructure;
+/** Combine a prepared TBSCertList with the issuer signature. */
+export declare function assembleCrl(prepared: PreparedSignedStructure, signature: Uint8Array, signatureEncoding?: SignatureEncoding): Crl;
+/**
+ * Create a v2 CRL. The CRL issuer key is never passed in: the `signer` callback receives the
+ * DER encoded TBSCertList and returns the signature.
+ */
+export declare function createCrl(template: CrlTemplate & SignOptions): Promise<Crl>;
+//#endregion
+//#region src/der.d.ts
+/** Convert an IEEE P1363 (r || s) ECDSA signature to DER. */
+export declare function ecdsaP1363ToDer(signature: Uint8Array, coordinateLength: number): Uint8Array;
+/** Convert a DER ECDSA signature to IEEE P1363 (r || s). */
+export declare function ecdsaDerToP1363(signature: Uint8Array, coordinateLength: number): Uint8Array;
+/**
+ * Convert a public JWK to a DER SubjectPublicKeyInfo. Refuses private keys: only the
+ * public part of the wallet-relying party key is needed to issue its certificate.
+ */
+export declare function publicJwkToSpki(jwk: JsonWebKey): Uint8Array;
+//#endregion
+//#region src/extensions.d.ts
+/** Telephone numbers from otherName entries with type-id id-at-telephoneNumber */
+export declare function telephoneNumbers(names: SubjectAlternativeNames): string[];
+//#endregion
+//#region src/signature.d.ts
+/**
+ * Combine prepared to-be-signed bytes with their signature into the DER encoding of the
+ * signed structure: `SEQUENCE { tbs, signatureAlgorithm, BIT STRING signature }`.
+ */
+export declare function assembleSignedStructure(prepared: PreparedSignedStructure, signature: Uint8Array, signatureEncoding?: SignatureEncoding): Uint8Array;
+/**
+ * Verify that `certificate` was signed by the key of `issuerCertificate`.
+ *
+ * The issuer name and, when both are present, the authority / subject key identifiers must
+ * match. The cryptographic check is delegated to `verifier`, so no global crypto is needed:
+ * with WebCrypto, import `publicKey.jwk` and verify `signatureP1363` over `data`.
+ *
+ * This checks a single link, not a path to a trust anchor.
+ */
+export declare function verifyCertificateSignature(certificate: Certificate | CertificateInput, issuerCertificate: Certificate | CertificateInput, verifier: SignatureVerifier): Promise<boolean>;
+/**
+ * Verify that `crl` was signed by `issuerCertificate`.
+ *
+ * The CRL issuer name and, when both are present, the key identifiers must match, and the
+ * issuer key usage (if present) must allow cRLSign (RFC 5280 clause 6.3.3).
+ */
+export declare function verifyCrlSignature(crl: Crl, issuerCertificate: Certificate | CertificateInput, verifier: SignatureVerifier): Promise<boolean>;
+//#endregion
+//#region src/x509-exception.d.ts
+/**
+ * X509Exception is thrown when a certificate or CRL cannot be parsed or created.
+ */
+export declare class X509Exception extends IdentityException {
+  constructor(message: string, details?: unknown);
+}
+//#endregion
+export type { AttributeName, Certificate, CertificateInput, CertificatePolicyInformation, CertificateTemplate, Crl, CrlInput, CrlReason, CrlTemplate, DerInput, DistinguishedName, DistinguishedNameAttribute, IssuingDistributionPoint, KeyIdentifierHasher, KeyUsageType, NameAttributeInput, OtherNameValue, ParseCrlOptions, ParsedPublicKey, PreparedSignedStructure, QcStatements, QcType, RevocationCheckOptions, RevocationStatus, RevocationUnknownReason, RevokedCertificate, SignOptions, SignatureAlgorithm, SignatureEncoding, SignatureVerificationInput, SignatureVerifier, SubjectAlternativeNames, SubjectAlternativeNamesInput, TbsSigner, X509Extension };
+//# sourceMappingURL=index.d.mts.map