@matter/protocol 0.17.0-alpha.0-20260507-059f7763b → 0.17.0-alpha.0-20260508-29ff5ae9e

package/src/certificate/DeviceAttestationValidator.ts

@@ -0,0 +1,446 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Bytes, Crypto, EcdsaSignature, MaybePromise, PublicKey } from "@matter/general";
+import { MATTER_EPOCH_OFFSET_S, VendorId } from "@matter/types";
+import { TlvAttestation } from "../common/OperationalCredentialsTypes.js";
+import { DclCertificateService } from "../dcl/DclCertificateService.js";
+import { CommissioningError } from "../peer/CommissioningError.js";
+import { Dac, Paa, Pai } from "./kinds/AttestationCertificates.js";
+import { CertificationDeclaration } from "./kinds/CertificationDeclaration.js";
+import { CertificationType } from "./kinds/definitions/certification-declaration.js";
+
+/** Reasons a device attestation validation can fail or produce warnings. */
+export enum DeviceAttestationCheck {
+    PaaNotTrusted = "PaaNotTrusted",
+    CertificateChainInvalid = "CertificateChainInvalid",
+    CertificateExpired = "CertificateExpired",
+    VendorIdMismatch = "VendorIdMismatch",
+    AttestationSignatureInvalid = "AttestationSignatureInvalid",
+    AttestationNonceMismatch = "AttestationNonceMismatch",
+    CertificationDeclarationSignatureInvalid = "CertificationDeclarationSignatureInvalid",
+    CertificationDeclarationFieldMismatch = "CertificationDeclarationFieldMismatch",
+    CertificateRevoked = "CertificateRevoked",
+    FirmwareInfoMismatch = "FirmwareInfoMismatch",
+    CertificationTypeProvisional = "CertificationTypeProvisional",
+    CertificationTypeTest = "CertificationTypeTest",
+    CertificateIdNotVerified = "CertificateIdNotVerified",
+    CdSignerVerificationSkipped = "CdSignerVerificationSkipped",
+    PaaTrustStoreTimeMismatch = "PaaTrustStoreTimeMismatch",
+    DclServiceUnavailable = "DclServiceUnavailable",
+}
+
+/** A single finding from the attestation validation process. */
+export interface AttestationFinding {
+    /** Severity: "error" stops validation immediately, "warning"/"info" are collected. */
+    level: "error" | "warning" | "info";
+
+    /** The specific check that produced this finding. */
+    type: DeviceAttestationCheck;
+
+    /** Human-readable description. */
+    message: string;
+}
+
+/** Error thrown when device attestation validation encounters a hard failure. */
+export class DeviceAttestationError extends CommissioningError {
+    constructor(
+        readonly failure: DeviceAttestationCheck,
+        message: string,
+    ) {
+        super(message);
+    }
+}
+
+export namespace DeviceAttestationValidator {
+    export interface Context {
+        crypto: Crypto;
+        attestationChallenge: Bytes;
+
+        /**
+         * DclCertificateService for PAA trust store, chain validation, revocation checks, and
+         * CD signer lookup. When absent, DCL-dependent checks are skipped (PAA lookup, chain
+         * verification, revocation, CD signature) but local checks still run (nonce, signature,
+         * VendorID, CD fields).
+         */
+        dclCertificateService?: DclCertificateService;
+    }
+
+    export interface DeviceAttestationData {
+        dac: Bytes;
+        pai: Bytes;
+        attestationElements: Bytes;
+        attestationSignature: Bytes;
+        attestationNonce: Bytes;
+        vendorId: VendorId;
+        productId: number;
+    }
+
+    /** Result of a successful validation, including any non-fatal findings. */
+    export interface ValidationResult {
+        dacPublicKey: ReturnType<typeof PublicKey>;
+        findings: AttestationFinding[];
+    }
+
+    /**
+     * Controls behavior when attestation findings occur.
+     * - `true`: always proceed (warnings/info are logged)
+     * - `false`: reject on any finding (error, warning, or info)
+     * - `undefined`: backward-compatible accept with logging
+     * - function: receives all findings, returns whether to proceed
+     */
+    export type OnAttestationFailure = boolean | ((findings: AttestationFinding[]) => MaybePromise<boolean>);
+
+    /**
+     * Validates device attestation per Matter spec Section 6.2.3.1.
+     *
+     * Local checks (nonce, signature, VendorID, CD fields) always run. DCL-dependent checks
+     * (PAA trust store, chain verification, revocation) only run when dclCertificateService
+     * is provided.
+     *
+     * Errors (hard failures) throw immediately via {@link DeviceAttestationError}.
+     * Warnings and info findings are collected and returned for the caller to evaluate.
+     */
+    export async function validate(context: Context, data: DeviceAttestationData): Promise<ValidationResult> {
+        const { crypto, dclCertificateService } = context;
+        const findings = new Array<AttestationFinding>();
+
+        // Step 1: Parse DAC and PAI from DER
+        const dac = Dac.fromAsn1(data.dac);
+        const pai = Pai.fromAsn1(data.pai);
+
+        // === Local checks (always run, no DCL needed) ===
+
+        // Step 4 (local part): VendorID matching — DAC vendorId must match PAI vendorId
+        if (dac.cert.subject.vendorId !== pai.cert.subject.vendorId) {
+            throw new DeviceAttestationError(
+                DeviceAttestationCheck.VendorIdMismatch,
+                `DAC vendorId ${dac.cert.subject.vendorId} does not match PAI vendorId ${pai.cert.subject.vendorId}`,
+            );
+        }
+
+        // Step 6: AttestationNonce match
+        const attestationInfo = TlvAttestation.decode(data.attestationElements);
+        if (!Bytes.areEqual(attestationInfo.attestationNonce, data.attestationNonce)) {
+            throw new DeviceAttestationError(
+                DeviceAttestationCheck.AttestationNonceMismatch,
+                "AttestationNonce in response does not match the nonce sent to the device",
+            );
+        }
+
+        // Step 7: Attestation Signature verification
+        const dacPublicKey = PublicKey(dac.cert.ellipticCurvePublicKey);
+        try {
+            await crypto.verifyEcdsa(
+                dacPublicKey,
+                Bytes.concat(data.attestationElements, context.attestationChallenge),
+                new EcdsaSignature(data.attestationSignature),
+            );
+        } catch {
+            throw new DeviceAttestationError(
+                DeviceAttestationCheck.AttestationSignatureInvalid,
+                "Attestation signature verification failed against DAC public key",
+            );
+        }
+
+        // === DCL-dependent checks (only when dclCertificateService is available) ===
+
+        let paa: Paa | undefined;
+
+        if (dclCertificateService === undefined) {
+            findings.push({
+                level: "warning",
+                type: DeviceAttestationCheck.DclServiceUnavailable,
+                message:
+                    "DclCertificateService not available; skipping PAA trust store, chain, and revocation checks. " +
+                    "Register DclCertificateService in the environment for full attestation.",
+            });
+        } else {
+            // Step 2: PAA Trust Store lookup
+            const paiAkid = pai.cert.extensions.authorityKeyIdentifier;
+            const paaMetadata = dclCertificateService.getCertificate(paiAkid);
+            if (paaMetadata === undefined) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.PaaNotTrusted,
+                    `PAA not found in trust store for authority key identifier ${Bytes.toHex(paiAkid)}`,
+                );
+            }
+
+            // Step 2b: Time-based trust store check (SHOULD per spec 6.2.3.1)
+            if (paaMetadata.fetchedAt !== undefined) {
+                const dacNotBeforeUnixMs = (dac.cert.notBefore + MATTER_EPOCH_OFFSET_S) * 1000;
+                if (paaMetadata.fetchedAt > dacNotBeforeUnixMs) {
+                    findings.push({
+                        level: "info",
+                        type: DeviceAttestationCheck.PaaTrustStoreTimeMismatch,
+                        message:
+                            `PAA was fetched at ${new Date(paaMetadata.fetchedAt).toISOString()} ` +
+                            `which is after DAC notBefore ${new Date(dacNotBeforeUnixMs).toISOString()}; ` +
+                            `cannot confirm PAA was in DCL when DAC was issued`,
+                    });
+                }
+            }
+
+            // Step 3: Certificate chain signature verification
+            const paaDer = await dclCertificateService.getCertificateAsDer(paiAkid);
+            paa = Paa.fromAsn1(paaDer);
+
+            try {
+                await crypto.verifyEcdsa(
+                    PublicKey(paa.cert.ellipticCurvePublicKey),
+                    pai.asUnsignedDer(),
+                    pai.signature,
+                );
+            } catch (error) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificateChainInvalid,
+                    `PAI signature verification failed: ${error}`,
+                );
+            }
+
+            try {
+                await crypto.verifyEcdsa(
+                    PublicKey(pai.cert.ellipticCurvePublicKey),
+                    dac.asUnsignedDer(),
+                    dac.signature,
+                );
+            } catch (error) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificateChainInvalid,
+                    `DAC signature verification failed: ${error}`,
+                );
+            }
+
+            // Step 3b: Certificate validity at DAC's notBefore timestamp
+            const dacNotBefore = dac.cert.notBefore;
+
+            if (dacNotBefore < pai.cert.notBefore) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificateExpired,
+                    `DAC notBefore (${dacNotBefore}) is before PAI notBefore (${pai.cert.notBefore})`,
+                );
+            }
+            if (pai.cert.notAfter !== 0 && dacNotBefore > pai.cert.notAfter) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificateExpired,
+                    `DAC notBefore (${dacNotBefore}) is after PAI notAfter (${pai.cert.notAfter})`,
+                );
+            }
+            if (dacNotBefore < paa.cert.notBefore) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificateExpired,
+                    `DAC notBefore (${dacNotBefore}) is before PAA notBefore (${paa.cert.notBefore})`,
+                );
+            }
+            if (paa.cert.notAfter !== 0 && dacNotBefore > paa.cert.notAfter) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificateExpired,
+                    `DAC notBefore (${dacNotBefore}) is after PAA notAfter (${paa.cert.notAfter})`,
+                );
+            }
+
+            // Step 4 (DCL part): PAA VendorID matching
+            const paaVendorId = paa.cert.subject.vendorId;
+            if (paaVendorId !== undefined && paaVendorId !== pai.cert.subject.vendorId) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.VendorIdMismatch,
+                    `PAA vendorId ${paaVendorId} does not match PAI vendorId ${pai.cert.subject.vendorId}`,
+                );
+            }
+
+            // Step 5: Revocation check — composite key is (AKID, IssuerDN) per spec 6.2.4.2
+            const dacIssuerDnHex = dac.cert.issuerDer ? Bytes.toHex(dac.cert.issuerDer).toUpperCase() : undefined;
+            if (
+                await dclCertificateService.isRevoked(
+                    dac.cert.extensions.authorityKeyIdentifier,
+                    dac.cert.serialNumber,
+                    dacIssuerDnHex,
+                )
+            ) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificateRevoked,
+                    "Device Attestation Certificate has been revoked",
+                );
+            }
+
+            const paiIssuerDnHex = pai.cert.issuerDer ? Bytes.toHex(pai.cert.issuerDer).toUpperCase() : undefined;
+            if (await dclCertificateService.isRevoked(paiAkid, pai.cert.serialNumber, paiIssuerDnHex)) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificateRevoked,
+                    "Product Attestation Intermediate certificate has been revoked",
+                );
+            }
+        }
+
+        // === Remaining local checks (CD validation) ===
+
+        // Step 8: Certification Declaration signature verification
+        const cd = CertificationDeclaration.parse(attestationInfo.declaration);
+        const cdSignerSkidHex = Bytes.toHex(cd.signerSubjectKeyId);
+
+        if (dclCertificateService !== undefined) {
+            const cdSigner = await dclCertificateService.getOrFetchCdSigner(cd.signerSubjectKeyId);
+            if (cdSigner !== undefined) {
+                try {
+                    await crypto.verifyEcdsa(PublicKey(cdSigner.publicKey), cd.signedData, cd.signature);
+                } catch {
+                    throw new DeviceAttestationError(
+                        DeviceAttestationCheck.CertificationDeclarationSignatureInvalid,
+                        "Certification Declaration signature verification failed",
+                    );
+                }
+            } else {
+                findings.push({
+                    level: "warning",
+                    type: DeviceAttestationCheck.CdSignerVerificationSkipped,
+                    message: `CD signer SKID ${cdSignerSkidHex} not found in trust store or DCL; skipping CD signature verification`,
+                });
+            }
+        } else {
+            findings.push({
+                level: "warning",
+                type: DeviceAttestationCheck.CdSignerVerificationSkipped,
+                message: "No DclCertificateService provided; skipping CD signature verification",
+            });
+        }
+
+        // Step 9: Certification Declaration field validation (Matter spec Section 6.2.3.1)
+        const cdContent = cd.content;
+
+        // certification_type check (Matter 1.5.1): log and surface provisional/test CDs
+        const certType = cdContent.certificationType;
+        if (certType === CertificationType.Provisional) {
+            findings.push({
+                level: "warning",
+                type: DeviceAttestationCheck.CertificationTypeProvisional,
+                message: "Certification Declaration has certification_type=1 (provisional)",
+            });
+        } else if (certType === CertificationType.Test) {
+            findings.push({
+                level: "info",
+                type: DeviceAttestationCheck.CertificationTypeTest,
+                message: "Certification Declaration has certification_type=0 (test)",
+            });
+        }
+
+        // TODO: certificate_id SHOULD be checked against DCL DeviceSoftwareCompliance (spec 6.2.3.1)
+        // Not yet implemented — will emit CertificateIdNotVerified finding once DCL lookup is available.
+
+        // vendor_id SHALL match BasicInformation VendorID
+        if (cdContent.vendorId !== data.vendorId) {
+            throw new DeviceAttestationError(
+                DeviceAttestationCheck.CertificationDeclarationFieldMismatch,
+                `CD vendor_id ${cdContent.vendorId} does not match BasicInformation VendorID ${data.vendorId}`,
+            );
+        }
+
+        // product_id_array SHALL contain BasicInformation ProductID
+        if (!cdContent.produceIdArray.includes(data.productId)) {
+            throw new DeviceAttestationError(
+                DeviceAttestationCheck.CertificationDeclarationFieldMismatch,
+                `CD product_id_array does not contain BasicInformation ProductID ${data.productId}`,
+            );
+        }
+
+        // CD SHALL contain both or neither of dac_origin_vendor_id and dac_origin_product_id
+        const hasDacOriginVid = cdContent.dacOriginVendorId !== undefined;
+        const hasDacOriginPid = cdContent.dacOriginProductId !== undefined;
+        if (hasDacOriginVid !== hasDacOriginPid) {
+            throw new DeviceAttestationError(
+                DeviceAttestationCheck.CertificationDeclarationFieldMismatch,
+                "CD has only one of dac_origin_vendor_id and dac_origin_product_id",
+            );
+        }
+
+        if (hasDacOriginVid && hasDacOriginPid) {
+            // If BOTH dac_origin fields present: validate against dac_origin values
+            if (dac.cert.subject.vendorId !== cdContent.dacOriginVendorId) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificationDeclarationFieldMismatch,
+                    "DAC vendorId does not match CD dac_origin_vendor_id",
+                );
+            }
+            if (pai.cert.subject.vendorId !== cdContent.dacOriginVendorId) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificationDeclarationFieldMismatch,
+                    "PAI vendorId does not match CD dac_origin_vendor_id",
+                );
+            }
+            const dacProductId = dac.cert.subject.productId;
+            if (dacProductId !== undefined && dacProductId !== cdContent.dacOriginProductId) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificationDeclarationFieldMismatch,
+                    "DAC productId does not match CD dac_origin_product_id",
+                );
+            }
+            const paiProductId = pai.cert.subject.productId;
+            if (paiProductId !== undefined && paiProductId !== cdContent.dacOriginProductId) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificationDeclarationFieldMismatch,
+                    "PAI productId does not match CD dac_origin_product_id",
+                );
+            }
+        } else {
+            // NEITHER dac_origin fields: validate against vendor_id / product_id_array
+            if (dac.cert.subject.vendorId !== cdContent.vendorId) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificationDeclarationFieldMismatch,
+                    "DAC vendorId does not match CD vendor_id",
+                );
+            }
+            if (pai.cert.subject.vendorId !== cdContent.vendorId) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificationDeclarationFieldMismatch,
+                    "PAI vendorId does not match CD vendor_id",
+                );
+            }
+            const dacProductId = dac.cert.subject.productId;
+            if (dacProductId !== undefined && !cdContent.produceIdArray.includes(dacProductId)) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificationDeclarationFieldMismatch,
+                    "DAC productId not found in CD product_id_array",
+                );
+            }
+            const paiProductId = pai.cert.subject.productId;
+            if (paiProductId !== undefined && !cdContent.produceIdArray.includes(paiProductId)) {
+                throw new DeviceAttestationError(
+                    DeviceAttestationCheck.CertificationDeclarationFieldMismatch,
+                    "PAI productId not found in CD product_id_array",
+                );
+            }
+        }
+
+        // authorized_paa_list needs PAA from DCL
+        if (cdContent.authorizedPaaList !== undefined) {
+            if (paa !== undefined) {
+                const paaSki = paa.cert.extensions.subjectKeyIdentifier;
+                const found = cdContent.authorizedPaaList.some(entry => Bytes.areEqual(entry, paaSki));
+                if (!found) {
+                    throw new DeviceAttestationError(
+                        DeviceAttestationCheck.CertificationDeclarationFieldMismatch,
+                        "PAA subject key identifier not in CD authorized_paa_list",
+                    );
+                }
+            } else {
+                findings.push({
+                    level: "warning",
+                    type: DeviceAttestationCheck.DclServiceUnavailable,
+                    message: "CD has authorized_paa_list but cannot verify without DCL service",
+                });
+            }
+        }
+
+        // Step 10: Firmware information (spec 6.3.2)
+        // Commissioners MAY validate firmware_information against DCL DeviceSoftwareCompliance
+        // to confirm the firmware is authorized and not revoked. The bytes are compared as an
+        // opaque value against the expected firmware info for this CD's certificate_id + version.
+        // TODO: When DCL DeviceSoftwareCompliance API is implemented (same as certificate_id),
+        //       compare attestationInfo.firmwareInfo bytes against expected value and emit a
+        //       FirmwareInfoMismatch warning finding on mismatch. Validation is MAY per spec.
+
+        return { dacPublicKey, findings };
+    }
+}

package/src/certificate/DeviceCertification.ts

@@ -9,6 +9,7 @@ import { NodeSession } from "#session/NodeSession.js";
 import { Bytes, Construction, Crypto, ImplementationError, InternalError, PrivateKey } from "@matter/general";
 import { ProductDescription } from "@matter/types";
 import { AttestationCertificateManager } from "./AttestationCertificateManager.js";
+import { Dac, Pai } from "./kinds/AttestationCertificates.js";
 
 /**
  * Device certification used by the OperationalCredentials cluster.
@@ -76,10 +77,40 @@ export class DeviceCertification {
         });
     }
 
-    #validateCertification(_product: ProductDescription) {
-        //const { privateKey, certificate, intermediateCertificate, declaration } = this.#assertInitialized();
-        // TODO extract and validate vendorIds from certificate and intermediateCertificate and compare to product.vendorId
-        // TODO extract and validate productId from certificate and compare to product.productId
+    #validateCertification(product: ProductDescription) {
+        const certificate = this.#certificate;
+        const intermediateCertificate = this.#intermediateCertificate;
+        if (certificate === undefined || intermediateCertificate === undefined) {
+            return;
+        }
+
+        // Parse DAC and PAI
+        const dac = Dac.fromAsn1(certificate);
+        const pai = Pai.fromAsn1(intermediateCertificate);
+
+        // Validate vendorId from DAC matches product
+        const dacVendorId = dac.cert.subject.vendorId;
+        if (dacVendorId !== undefined && dacVendorId !== product.vendorId) {
+            throw new ImplementationError(
+                `DAC VendorID ${dacVendorId} does not match product VendorID ${product.vendorId}`,
+            );
+        }
+
+        // Validate productId from DAC matches product
+        const dacProductId = dac.cert.subject.productId;
+        if (dacProductId !== undefined && dacProductId !== product.productId) {
+            throw new ImplementationError(
+                `DAC ProductID ${dacProductId} does not match product ProductID ${product.productId}`,
+            );
+        }
+
+        // Validate vendorId from PAI matches product
+        const paiVendorId = pai.cert.subject.vendorId;
+        if (paiVendorId !== undefined && paiVendorId !== product.vendorId) {
+            throw new ImplementationError(
+                `PAI VendorID ${paiVendorId} does not match product VendorID ${product.vendorId}`,
+            );
+        }
     }
 
     async sign(session: NodeSession, data: Bytes) {

package/src/certificate/index.ts

@@ -7,6 +7,7 @@
 export * from "./AttestationCertificateManager.js";
 export * from "./CertificateAuthority.js";
 export * from "./ChipPAAuthorities.js";
+export * from "./DeviceAttestationValidator.js";
 export * from "./DeviceCertification.js";
 export * from "./kinds/AttestationCertificates.js";
 export * from "./kinds/Certificate.js";

package/src/certificate/kinds/AttestationCertificates.ts

@@ -32,7 +32,19 @@ export class Paa extends AttestationBaseCertificate<AttestationCertificate.Paa>
 }
 
 /** PAI (Product Attestation Intermediate) Certificate. */
-export class Pai extends AttestationBaseCertificate<AttestationCertificate.Pai> {}
+export class Pai extends AttestationBaseCertificate<AttestationCertificate.Pai> {
+    /** Construct the class from an ASN.1/DER encoded certificate */
+    static fromAsn1(asn1: Bytes): Pai {
+        const cert = Certificate.parseAsn1Certificate(asn1, Certificate.REQUIRED_EXTENSIONS);
+        return new Pai(cert as AttestationCertificate.Pai);
+    }
+}
 
 /** DAC (Device Attestation Certificate) Certificate. */
-export class Dac extends AttestationBaseCertificate<AttestationCertificate.Dac> {}
+export class Dac extends AttestationBaseCertificate<AttestationCertificate.Dac> {
+    /** Construct the class from an ASN.1/DER encoded certificate */
+    static fromAsn1(asn1: Bytes): Dac {
+        const cert = Certificate.parseAsn1Certificate(asn1, Certificate.REQUIRED_EXTENSIONS);
+        return new Dac(cert as AttestationCertificate.Dac);
+    }
+}

package/src/certificate/kinds/Certificate.ts

@@ -119,7 +119,9 @@ export abstract class Certificate<CT extends MatterCertificate> {
      * Serialize as DER without signature.
      */
     asUnsignedDer(): Bytes {
-        // Serialize
+        if (this.#cert.tbsDer !== undefined) {
+            return this.#cert.tbsDer;
+        }
         const certBytes = X509.certificateToDer(matterToX509(this.cert));
         assertCertificateDerSize(certBytes);
         return certBytes;
@@ -487,6 +489,7 @@ export namespace Certificate {
         }
 
         const [certificateNode, , signatureNode] = rootElements;
+        const tbsDer = Bytes.of(DerCodec.encode(certificateNode));
 
         // Parse TBSCertificate
         const { _elements: certElements } = certificateNode;
@@ -513,7 +516,8 @@ export namespace Certificate {
         const signatureAlgorithm = Bytes.toHex(signatureAlgorithmOid) === "2a8648ce3d040302" ? 1 : 0;
         idx++;
 
-        // Issuer
+        // Issuer — retain raw DER for exact-match comparisons (CRL revocation lookup)
+        const issuerDer = Bytes.of(DerCodec.encode(certElements[idx]));
         const issuer = parseSubjectOrIssuer(certElements[idx++]);
 
         // Validity
@@ -565,6 +569,8 @@ export namespace Certificate {
             serialNumber,
             signatureAlgorithm,
             issuer,
+            issuerDer,
+            tbsDer,
             notBefore,
             notAfter,
             subject,