@vess-id/mdl 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+export { Verifier } from './mdoc/Verifier';
+export { parse } from './mdoc/parser';
+export { DataItem } from './cbor/DataItem';
+export { DiagnosticInformation as DianosticInformation } from './mdoc/model/types';
+export { MDoc } from './mdoc/model/MDoc';
+export { Document } from './mdoc/model/Document';
+export { IssuerSignedDocument } from './mdoc/model/IssuerSignedDocument';
+export { DeviceSignedDocument } from './mdoc/model/DeviceSignedDocument';
+export { DeviceResponse } from './mdoc/model/DeviceResponse';
+export { MDLError, MDLParseError } from './mdoc/errors';
+export { VerificationAssessmentId } from './mdoc/checkCallback';
+export { getCborEncodeDecodeOptions, setCborEncodeDecodeOptions } from './cbor';

package/lib/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCborEncodeDecodeOptions = exports.getCborEncodeDecodeOptions = exports.VerificationAssessmentId = exports.MDLParseError = exports.MDLError = exports.DeviceResponse = exports.DeviceSignedDocument = exports.IssuerSignedDocument = exports.Document = exports.MDoc = exports.DataItem = exports.parse = exports.Verifier = void 0;
+var Verifier_1 = require("./mdoc/Verifier");
+Object.defineProperty(exports, "Verifier", { enumerable: true, get: function () { return Verifier_1.Verifier; } });
+var parser_1 = require("./mdoc/parser");
+Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parser_1.parse; } });
+var DataItem_1 = require("./cbor/DataItem");
+Object.defineProperty(exports, "DataItem", { enumerable: true, get: function () { return DataItem_1.DataItem; } });
+var MDoc_1 = require("./mdoc/model/MDoc");
+Object.defineProperty(exports, "MDoc", { enumerable: true, get: function () { return MDoc_1.MDoc; } });
+var Document_1 = require("./mdoc/model/Document");
+Object.defineProperty(exports, "Document", { enumerable: true, get: function () { return Document_1.Document; } });
+var IssuerSignedDocument_1 = require("./mdoc/model/IssuerSignedDocument");
+Object.defineProperty(exports, "IssuerSignedDocument", { enumerable: true, get: function () { return IssuerSignedDocument_1.IssuerSignedDocument; } });
+var DeviceSignedDocument_1 = require("./mdoc/model/DeviceSignedDocument");
+Object.defineProperty(exports, "DeviceSignedDocument", { enumerable: true, get: function () { return DeviceSignedDocument_1.DeviceSignedDocument; } });
+var DeviceResponse_1 = require("./mdoc/model/DeviceResponse");
+Object.defineProperty(exports, "DeviceResponse", { enumerable: true, get: function () { return DeviceResponse_1.DeviceResponse; } });
+var errors_1 = require("./mdoc/errors");
+Object.defineProperty(exports, "MDLError", { enumerable: true, get: function () { return errors_1.MDLError; } });
+Object.defineProperty(exports, "MDLParseError", { enumerable: true, get: function () { return errors_1.MDLParseError; } });
+var checkCallback_1 = require("./mdoc/checkCallback");
+Object.defineProperty(exports, "VerificationAssessmentId", { enumerable: true, get: function () { return checkCallback_1.VerificationAssessmentId; } });
+var cbor_1 = require("./cbor");
+Object.defineProperty(exports, "getCborEncodeDecodeOptions", { enumerable: true, get: function () { return cbor_1.getCborEncodeDecodeOptions; } });
+Object.defineProperty(exports, "setCborEncodeDecodeOptions", { enumerable: true, get: function () { return cbor_1.setCborEncodeDecodeOptions; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsNENBQTJDO0FBQWxDLG9HQUFBLFFBQVEsT0FBQTtBQUNqQix3Q0FBc0M7QUFBN0IsK0ZBQUEsS0FBSyxPQUFBO0FBQ2QsNENBQTJDO0FBQWxDLG9HQUFBLFFBQVEsT0FBQTtBQUVqQiwwQ0FBeUM7QUFBaEMsNEZBQUEsSUFBSSxPQUFBO0FBQ2Isa0RBQWlEO0FBQXhDLG9HQUFBLFFBQVEsT0FBQTtBQUNqQiwwRUFBeUU7QUFBaEUsNEhBQUEsb0JBQW9CLE9BQUE7QUFDN0IsMEVBQXlFO0FBQWhFLDRIQUFBLG9CQUFvQixPQUFBO0FBQzdCLDhEQUE2RDtBQUFwRCxnSEFBQSxjQUFjLE9BQUE7QUFDdkIsd0NBQXdEO0FBQS9DLGtHQUFBLFFBQVEsT0FBQTtBQUFFLHVHQUFBLGFBQWEsT0FBQTtBQUNoQyxzREFBZ0U7QUFBdkQseUhBQUEsd0JBQXdCLE9BQUE7QUFDakMsK0JBQWdGO0FBQXZFLGtIQUFBLDBCQUEwQixPQUFBO0FBQUUsa0hBQUEsMEJBQTBCLE9BQUEifQ==

package/lib/mdoc/IssuerSignedItem.d.ts

@@ -0,0 +1,18 @@
+import { DataItem } from '../cbor/DataItem';
+import IssuerAuth from './model/IssuerAuth';
+export type IssuerSignedDataItem = DataItem<Map<keyof IssuerSignedItem, unknown>>;
+export declare class IssuerSignedItem {
+    #private;
+    constructor(dataItem: IssuerSignedDataItem);
+    encode(): Uint8Array<ArrayBufferLike>;
+    get dataItem(): IssuerSignedDataItem;
+    private get decodedData();
+    get digestID(): number;
+    get random(): Uint8Array;
+    get elementIdentifier(): string;
+    get elementValue(): any;
+    calculateDigest(alg: Parameters<SubtleCrypto['digest']>[0]): Promise<ArrayBuffer>;
+    isValid(nameSpace: string, { decodedPayload: { valueDigests, digestAlgorithm }, }: IssuerAuth): Promise<boolean>;
+    matchCertificate(nameSpace: string, { countryName, stateOrProvince }: IssuerAuth): boolean | undefined;
+    static create(digestID: number, elementIdentifier: string, elementValue: any): IssuerSignedItem;
+}

package/lib/mdoc/IssuerSignedItem.js

@@ -0,0 +1,101 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _IssuerSignedItem_dataItem, _IssuerSignedItem_isValid;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssuerSignedItem = void 0;
+const uncrypto_1 = require("uncrypto");
+const cbor_1 = require("../cbor");
+const DataItem_1 = require("../cbor/DataItem");
+const buffer_utils_1 = require("../buffer_utils");
+const utils_1 = require("./utils");
+const MDL_NAMESPACE = 'org.iso.18013.5.1';
+const supportedDigestAlgorithms = ['SHA-256', 'SHA-384', 'SHA-512'];
+class IssuerSignedItem {
+    constructor(dataItem) {
+        _IssuerSignedItem_dataItem.set(this, void 0);
+        _IssuerSignedItem_isValid.set(this, void 0);
+        __classPrivateFieldSet(this, _IssuerSignedItem_dataItem, dataItem, "f");
+    }
+    encode() {
+        return __classPrivateFieldGet(this, _IssuerSignedItem_dataItem, "f").buffer;
+    }
+    get dataItem() {
+        return __classPrivateFieldGet(this, _IssuerSignedItem_dataItem, "f");
+    }
+    get decodedData() {
+        if (!__classPrivateFieldGet(this, _IssuerSignedItem_dataItem, "f").data.has('digestID')) {
+            throw new Error('Invalid data item');
+        }
+        return __classPrivateFieldGet(this, _IssuerSignedItem_dataItem, "f").data;
+    }
+    get digestID() {
+        return this.decodedData.get('digestID');
+    }
+    get random() {
+        return this.decodedData.get('random');
+    }
+    get elementIdentifier() {
+        return this.decodedData.get('elementIdentifier');
+    }
+    get elementValue() {
+        return this.decodedData.get('elementValue');
+    }
+    async calculateDigest(alg) {
+        const bytes = (0, cbor_1.cborEncode)(__classPrivateFieldGet(this, _IssuerSignedItem_dataItem, "f"));
+        const result = await uncrypto_1.subtle.digest(alg, bytes);
+        return result;
+    }
+    async isValid(nameSpace, { decodedPayload: { valueDigests, digestAlgorithm }, }) {
+        if (typeof __classPrivateFieldGet(this, _IssuerSignedItem_isValid, "f") !== 'undefined') {
+            return __classPrivateFieldGet(this, _IssuerSignedItem_isValid, "f");
+        }
+        if (!supportedDigestAlgorithms.includes(digestAlgorithm)) {
+            __classPrivateFieldSet(this, _IssuerSignedItem_isValid, false, "f");
+            return false;
+        }
+        const digest = await this.calculateDigest(digestAlgorithm);
+        const digests = valueDigests.get(nameSpace);
+        if (typeof digests === 'undefined') {
+            return false;
+        }
+        const expectedDigest = digests.get(this.digestID);
+        __classPrivateFieldSet(this, _IssuerSignedItem_isValid, expectedDigest &&
+            (0, buffer_utils_1.areEqual)(new Uint8Array(digest), expectedDigest), "f");
+        return __classPrivateFieldGet(this, _IssuerSignedItem_isValid, "f");
+    }
+    matchCertificate(nameSpace, { countryName, stateOrProvince }) {
+        if (nameSpace !== MDL_NAMESPACE) {
+            return undefined;
+        }
+        if (this.elementIdentifier === 'issuing_country') {
+            return countryName === this.elementValue;
+        }
+        if (this.elementIdentifier === 'issuing_jurisdiction' && stateOrProvince) {
+            return stateOrProvince === this.elementValue;
+        }
+        return undefined;
+    }
+    static create(digestID, elementIdentifier, elementValue) {
+        const random = (0, utils_1.getRandomBytes)(32);
+        const dataItem = DataItem_1.DataItem.fromData(new Map([
+            ['digestID', digestID],
+            ['elementIdentifier', elementIdentifier],
+            ['elementValue', elementValue],
+            ['random', random],
+        ]));
+        return new IssuerSignedItem(dataItem);
+    }
+}
+exports.IssuerSignedItem = IssuerSignedItem;
+_IssuerSignedItem_dataItem = new WeakMap(), _IssuerSignedItem_isValid = new WeakMap();
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mdoc/Verifier.d.ts

@@ -0,0 +1,33 @@
+import { Buffer } from 'buffer';
+import { MDoc } from './model/MDoc';
+import { DiagnosticInformation } from './model/types';
+import { UserDefinedVerificationCallback } from './checkCallback';
+export declare class Verifier {
+    readonly issuersRootCertificates: string[];
+    /**
+     *
+     * @param issuersRootCertificates The IACA root certificates list of the supported issuers.
+     */
+    constructor(issuersRootCertificates: string[]);
+    private verifyIssuerSignature;
+    private verifyDeviceSignature;
+    private verifyData;
+    /**
+     * Parse and validate a DeviceResponse as specified in ISO/IEC 18013-5 (Device Retrieval section).
+     *
+     * @param encodedDeviceResponse
+     * @param options.encodedSessionTranscript The CBOR encoded SessionTranscript.
+     * @param options.ephemeralReaderKey The private part of the ephemeral key used in the session where the DeviceResponse was obtained. This is only required if the DeviceResponse is using the MAC method for device authentication.
+     */
+    verify(encodedDeviceResponse: Uint8Array, options?: {
+        encodedSessionTranscript?: Uint8Array;
+        ephemeralReaderKey?: Uint8Array;
+        disableCertificateChainValidation?: boolean;
+        onCheck?: UserDefinedVerificationCallback;
+    }): Promise<MDoc>;
+    getDiagnosticInformation(encodedDeviceResponse: Buffer, options: {
+        encodedSessionTranscript?: Buffer;
+        ephemeralReaderKey?: Buffer;
+        disableCertificateChainValidation?: boolean;
+    }): Promise<DiagnosticInformation>;
+}

package/lib/mdoc/Verifier.js

@@ -0,0 +1,405 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Verifier = void 0;
+const compare_versions_1 = require("compare-versions");
+const x509_1 = require("@peculiar/x509");
+const jose_1 = require("jose");
+const buffer_1 = require("buffer");
+const cose_kit_1 = require("cose-kit");
+const uncrypto_1 = __importDefault(require("uncrypto"));
+const utils_1 = require("./utils");
+const checkCallback_1 = require("./checkCallback");
+const parser_1 = require("./parser");
+const DeviceSignedDocument_1 = require("./model/DeviceSignedDocument");
+const MDL_NAMESPACE = 'org.iso.18013.5.1';
+const DIGEST_ALGS = {
+    'SHA-256': 'sha256',
+    'SHA-384': 'sha384',
+    'SHA-512': 'sha512',
+};
+class Verifier {
+    /**
+     *
+     * @param issuersRootCertificates The IACA root certificates list of the supported issuers.
+     */
+    constructor(issuersRootCertificates) {
+        this.issuersRootCertificates = issuersRootCertificates;
+    }
+    async verifyIssuerSignature(issuerAuth, disableCertificateChainValidation, onCheckG) {
+        const onCheck = (0, checkCallback_1.onCatCheck)(onCheckG, 'ISSUER_AUTH');
+        const { certificate, countryName } = issuerAuth;
+        const verificationKey = certificate ? (await (0, jose_1.importX509)(certificate.toString(), issuerAuth.algName)) : undefined;
+        if (!disableCertificateChainValidation) {
+            try {
+                await issuerAuth.verifyX509Chain(this.issuersRootCertificates);
+                onCheck({
+                    status: 'PASSED',
+                    check: 'Issuer certificate must be valid',
+                    id: checkCallback_1.VerificationAssessmentId.ISSUER_AUTH.IssuerCertificateValidity,
+                });
+            }
+            catch (err) {
+                onCheck({
+                    status: 'FAILED',
+                    check: 'Issuer certificate must be valid',
+                    id: checkCallback_1.VerificationAssessmentId.ISSUER_AUTH.IssuerCertificateValidity,
+                    reason: err.message,
+                });
+            }
+        }
+        const verificationResult = verificationKey && await issuerAuth.verify(verificationKey);
+        onCheck({
+            status: verificationResult ? 'PASSED' : 'FAILED',
+            check: 'Issuer signature must be valid',
+            id: checkCallback_1.VerificationAssessmentId.ISSUER_AUTH.IssuerSignatureValidity,
+        });
+        // Validity
+        const { validityInfo } = issuerAuth.decodedPayload;
+        const now = new Date();
+        onCheck({
+            status: certificate && validityInfo && (validityInfo.signed < certificate.notBefore || validityInfo.signed > certificate.notAfter) ? 'FAILED' : 'PASSED',
+            check: 'The MSO signed date must be within the validity period of the certificate',
+            id: checkCallback_1.VerificationAssessmentId.ISSUER_AUTH.MsoSignedDateWithinCertificateValidity,
+            reason: `The MSO signed date (${validityInfo.signed.toUTCString()}) must be within the validity period of the certificate (${certificate.notBefore.toUTCString()} to ${certificate.notAfter.toUTCString()})`,
+        });
+        onCheck({
+            status: validityInfo && (now < validityInfo.validFrom || now > validityInfo.validUntil) ? 'FAILED' : 'PASSED',
+            check: 'The MSO must be valid at the time of verification',
+            id: checkCallback_1.VerificationAssessmentId.ISSUER_AUTH.MsoValidityAtVerificationTime,
+            reason: `The MSO must be valid at the time of verification (${now.toUTCString()})`,
+        });
+        onCheck({
+            status: countryName ? 'PASSED' : 'FAILED',
+            check: 'Country name (C) must be present in the issuer certificate\'s subject distinguished name',
+            id: checkCallback_1.VerificationAssessmentId.ISSUER_AUTH.IssuerSubjectCountryNamePresence,
+        });
+    }
+    async verifyDeviceSignature(document, options) {
+        const onCheck = (0, checkCallback_1.onCatCheck)(options.onCheck, 'DEVICE_AUTH');
+        if (!(document instanceof DeviceSignedDocument_1.DeviceSignedDocument)) {
+            onCheck({
+                status: 'FAILED',
+                check: 'The document is not signed by the device.',
+                id: checkCallback_1.VerificationAssessmentId.DEVICE_AUTH.DocumentDeviceSignaturePresence,
+            });
+            return;
+        }
+        const { deviceAuth, nameSpaces } = document.deviceSigned;
+        const { docType } = document;
+        const { deviceKeyInfo } = document.issuerSigned.issuerAuth.decodedPayload;
+        const { deviceKey: deviceKeyCoseKey } = deviceKeyInfo || {};
+        // Prevent cloning of the mdoc and mitigate man in the middle attacks
+        if (!deviceAuth.deviceMac && !deviceAuth.deviceSignature) {
+            onCheck({
+                status: 'FAILED',
+                check: 'Device Auth must contain a deviceSignature or deviceMac element',
+                id: checkCallback_1.VerificationAssessmentId.DEVICE_AUTH.DeviceAuthSignatureOrMacPresence,
+            });
+            return;
+        }
+        if (!options.sessionTranscriptBytes) {
+            onCheck({
+                status: 'FAILED',
+                check: 'Session Transcript Bytes missing from options, aborting device signature check',
+                id: checkCallback_1.VerificationAssessmentId.DEVICE_AUTH.SessionTranscriptProvided,
+            });
+            return;
+        }
+        const deviceAuthenticationBytes = (0, utils_1.calculateDeviceAutenticationBytes)(options.sessionTranscriptBytes, docType, nameSpaces);
+        if (!deviceKeyCoseKey) {
+            onCheck({
+                status: 'FAILED',
+                check: 'Issuer signature must contain the device key.',
+                id: checkCallback_1.VerificationAssessmentId.DEVICE_AUTH.DeviceKeyAvailableInIssuerAuth,
+                reason: 'Unable to verify deviceAuth signature: missing device key in issuerAuth',
+            });
+            return;
+        }
+        if (deviceAuth.deviceSignature) {
+            const deviceKey = await (0, cose_kit_1.importCOSEKey)(deviceKeyCoseKey);
+            // ECDSA/EdDSA authentication
+            try {
+                const ds = deviceAuth.deviceSignature;
+                const verificationResult = await new cose_kit_1.Sign1(ds.protectedHeaders, ds.unprotectedHeaders, deviceAuthenticationBytes, ds.signature).verify(deviceKey);
+                onCheck({
+                    status: verificationResult ? 'PASSED' : 'FAILED',
+                    check: 'Device signature must be valid',
+                    id: checkCallback_1.VerificationAssessmentId.DEVICE_AUTH.DeviceSignatureValidity,
+                });
+            }
+            catch (err) {
+                onCheck({
+                    status: 'FAILED',
+                    check: 'Device signature must be valid',
+                    id: checkCallback_1.VerificationAssessmentId.DEVICE_AUTH.DeviceSignatureValidity,
+                    reason: `Unable to verify deviceAuth signature (ECDSA/EdDSA): ${err.message}`,
+                });
+            }
+            return;
+        }
+        // MAC authentication
+        onCheck({
+            status: deviceAuth.deviceMac ? 'PASSED' : 'FAILED',
+            check: 'Device MAC must be present when using MAC authentication',
+            id: checkCallback_1.VerificationAssessmentId.DEVICE_AUTH.DeviceMacPresence,
+        });
+        if (!deviceAuth.deviceMac) {
+            return;
+        }
+        onCheck({
+            status: deviceAuth.deviceMac.hasSupportedAlg() ? 'PASSED' : 'FAILED',
+            check: 'Device MAC must use alg 5 (HMAC 256/256)',
+            id: checkCallback_1.VerificationAssessmentId.DEVICE_AUTH.DeviceMacAlgorithmCorrectness,
+        });
+        if (!deviceAuth.deviceMac.hasSupportedAlg()) {
+            return;
+        }
+        onCheck({
+            status: options.ephemeralPrivateKey ? 'PASSED' : 'FAILED',
+            check: 'Ephemeral private key must be present when using MAC authentication',
+            id: checkCallback_1.VerificationAssessmentId.DEVICE_AUTH.EphemeralKeyPresence,
+        });
+        if (!options.ephemeralPrivateKey) {
+            return;
+        }
+        try {
+            const ephemeralMacKey = await (0, utils_1.calculateEphemeralMacKey)(options.ephemeralPrivateKey, deviceKeyCoseKey, options.sessionTranscriptBytes);
+            const isValid = await deviceAuth.deviceMac.verify(ephemeralMacKey, undefined, deviceAuthenticationBytes);
+            onCheck({
+                status: isValid ? 'PASSED' : 'FAILED',
+                check: 'Device MAC must be valid',
+                id: checkCallback_1.VerificationAssessmentId.DEVICE_AUTH.DeviceMacValidity,
+            });
+        }
+        catch (err) {
+            onCheck({
+                status: 'FAILED',
+                check: 'Device MAC must be valid',
+                id: checkCallback_1.VerificationAssessmentId.DEVICE_AUTH.DeviceMacValidity,
+                reason: `Unable to verify deviceAuth MAC: ${err.message}`,
+            });
+        }
+    }
+    async verifyData(mdoc, onCheckG) {
+        // Confirm that the mdoc data has not changed since issuance
+        const { issuerAuth } = mdoc.issuerSigned;
+        const { valueDigests, digestAlgorithm } = issuerAuth.decodedPayload;
+        const onCheck = (0, checkCallback_1.onCatCheck)(onCheckG, 'DATA_INTEGRITY');
+        onCheck({
+            status: digestAlgorithm && DIGEST_ALGS[digestAlgorithm] ? 'PASSED' : 'FAILED',
+            check: 'Issuer Auth must include a supported digestAlgorithm element',
+            id: checkCallback_1.VerificationAssessmentId.DATA_INTEGRITY.IssuerAuthDigestAlgorithmSupported,
+        });
+        const nameSpaces = mdoc.issuerSigned.nameSpaces || {};
+        await Promise.all(Object.keys(nameSpaces).map(async (ns) => {
+            onCheck({
+                status: valueDigests.has(ns) ? 'PASSED' : 'FAILED',
+                check: `Issuer Auth must include digests for namespace: ${ns}`,
+                id: checkCallback_1.VerificationAssessmentId.DATA_INTEGRITY.IssuerAuthNamespaceDigestPresence,
+            });
+            const verifications = await Promise.all(nameSpaces[ns].map(async (ev) => {
+                const isValid = await ev.isValid(ns, issuerAuth);
+                return { ev, ns, isValid };
+            }));
+            verifications.filter((v) => v.isValid).forEach((v) => {
+                onCheck({
+                    status: 'PASSED',
+                    check: `The calculated digest for ${ns}/${v.ev.elementIdentifier} attribute must match the digest in the issuerAuth element`,
+                    id: checkCallback_1.VerificationAssessmentId.DATA_INTEGRITY.AttributeDigestMatch,
+                });
+            });
+            verifications.filter((v) => !v.isValid).forEach((v) => {
+                onCheck({
+                    status: 'FAILED',
+                    check: `The calculated digest for ${ns}/${v.ev.elementIdentifier} attribute must match the digest in the issuerAuth element`,
+                    id: checkCallback_1.VerificationAssessmentId.DATA_INTEGRITY.AttributeDigestMatch,
+                });
+            });
+            if (ns === MDL_NAMESPACE) {
+                const issuer = issuerAuth.certificate.issuerName;
+                if (!issuer) {
+                    onCheck({
+                        status: 'FAILED',
+                        check: "The 'issuing_country' if present must match the 'countryName' in the subject field within the DS certificate",
+                        id: checkCallback_1.VerificationAssessmentId.DATA_INTEGRITY.IssuingCountryMatchesCertificate,
+                        reason: "The 'issuing_country' and 'issuing_jurisdiction' cannot be verified because the DS certificate was not provided",
+                    });
+                }
+                else {
+                    const invalidCountry = verifications.filter((v) => v.ns === ns && v.ev.elementIdentifier === 'issuing_country')
+                        .find((v) => !v.isValid || !v.ev.matchCertificate(ns, issuerAuth));
+                    onCheck({
+                        status: invalidCountry ? 'FAILED' : 'PASSED',
+                        check: "The 'issuing_country' if present must match the 'countryName' in the subject field within the DS certificate",
+                        id: checkCallback_1.VerificationAssessmentId.DATA_INTEGRITY.IssuingCountryMatchesCertificate,
+                        reason: invalidCountry ?
+                            `The 'issuing_country' (${invalidCountry.ev.elementValue}) must match the 'countryName' (${issuerAuth.countryName}) in the subject field within the issuer certificate` :
+                            undefined,
+                    });
+                    const invalidJurisdiction = verifications.filter((v) => v.ns === ns && v.ev.elementIdentifier === 'issuing_jurisdiction')
+                        .find((v) => !v.isValid || (issuerAuth.stateOrProvince && !v.ev.matchCertificate(ns, issuerAuth)));
+                    onCheck({
+                        status: invalidJurisdiction ? 'FAILED' : 'PASSED',
+                        check: "The 'issuing_jurisdiction' if present must match the 'stateOrProvinceName' in the subject field within the DS certificate",
+                        id: checkCallback_1.VerificationAssessmentId.DATA_INTEGRITY.IssuingJurisdictionMatchesCertificate,
+                        reason: invalidJurisdiction ?
+                            `The 'issuing_jurisdiction' (${invalidJurisdiction.ev.elementValue}) must match the 'stateOrProvinceName' (${issuerAuth.stateOrProvince}) in the subject field within the issuer certificate` :
+                            undefined,
+                    });
+                }
+            }
+        }));
+    }
+    /**
+     * Parse and validate a DeviceResponse as specified in ISO/IEC 18013-5 (Device Retrieval section).
+     *
+     * @param encodedDeviceResponse
+     * @param options.encodedSessionTranscript The CBOR encoded SessionTranscript.
+     * @param options.ephemeralReaderKey The private part of the ephemeral key used in the session where the DeviceResponse was obtained. This is only required if the DeviceResponse is using the MAC method for device authentication.
+     */
+    async verify(encodedDeviceResponse, options = {}) {
+        const onCheck = (0, checkCallback_1.buildCallback)(options.onCheck);
+        const dr = (0, parser_1.parse)(encodedDeviceResponse);
+        onCheck({
+            status: dr.version ? 'PASSED' : 'FAILED',
+            check: 'Device Response must include "version" element.',
+            id: checkCallback_1.VerificationAssessmentId.DOCUMENT_FORMAT.DeviceResponseVersionPresence,
+            category: 'DOCUMENT_FORMAT',
+        });
+        onCheck({
+            status: (0, compare_versions_1.compareVersions)(dr.version, '1.0') >= 0 ? 'PASSED' : 'FAILED',
+            check: 'Device Response version must be 1.0 or greater',
+            id: checkCallback_1.VerificationAssessmentId.DOCUMENT_FORMAT.DeviceResponseVersionSupported,
+            category: 'DOCUMENT_FORMAT',
+        });
+        onCheck({
+            status: dr.documents && dr.documents.length > 0 ? 'PASSED' : 'FAILED',
+            check: 'Device Response must include at least one document.',
+            id: checkCallback_1.VerificationAssessmentId.DOCUMENT_FORMAT.DeviceResponseDocumentPresence,
+            category: 'DOCUMENT_FORMAT',
+        });
+        for (const document of dr.documents) {
+            const { issuerAuth } = document.issuerSigned;
+            await this.verifyIssuerSignature(issuerAuth, options.disableCertificateChainValidation, onCheck);
+            await this.verifyDeviceSignature(document, {
+                ephemeralPrivateKey: options.ephemeralReaderKey,
+                sessionTranscriptBytes: options.encodedSessionTranscript,
+                onCheck,
+            });
+            await this.verifyData(document, onCheck);
+        }
+        return dr;
+    }
+    async getDiagnosticInformation(encodedDeviceResponse, options) {
+        const dr = [];
+        const decoded = await this.verify(
+        // @ts-ignore
+        encodedDeviceResponse, {
+            ...options,
+            onCheck: (check) => dr.push(check),
+        });
+        const document = decoded.documents[0];
+        const { issuerAuth } = document.issuerSigned;
+        const issuerCert = issuerAuth.x5chain &&
+            issuerAuth.x5chain.length > 0 &&
+            new x509_1.X509Certificate(issuerAuth.x5chain[0]);
+        const attributes = (await Promise.all(Object.keys(document.issuerSigned.nameSpaces).map(async (ns) => {
+            const items = document.issuerSigned.nameSpaces[ns];
+            return Promise.all(items.map(async (item) => {
+                const isValid = await item.isValid(ns, issuerAuth);
+                return {
+                    ns,
+                    id: item.elementIdentifier,
+                    value: item.elementValue,
+                    isValid,
+                    matchCertificate: item.matchCertificate(ns, issuerAuth),
+                };
+            }));
+        }))).flat();
+        const deviceAttributes = document instanceof DeviceSignedDocument_1.DeviceSignedDocument ?
+            Object.entries(document.deviceSigned.nameSpaces).map(([ns, items]) => {
+                return Object.entries(items).map(([id, value]) => {
+                    return {
+                        ns,
+                        id,
+                        value,
+                    };
+                });
+            }).flat() : undefined;
+        let deviceKey;
+        if (document?.issuerSigned.issuerAuth) {
+            const { deviceKeyInfo } = document.issuerSigned.issuerAuth.decodedPayload;
+            if (deviceKeyInfo?.deviceKey) {
+                deviceKey = (0, cose_kit_1.COSEKeyToJWK)(deviceKeyInfo.deviceKey);
+            }
+        }
+        const disclosedAttributes = attributes.filter((attr) => attr.isValid).length;
+        const totalAttributes = Array.from(document
+            .issuerSigned
+            .issuerAuth
+            .decodedPayload
+            .valueDigests
+            .entries()).reduce((prev, [, digests]) => prev + digests.size, 0);
+        return {
+            general: {
+                version: decoded.version,
+                type: 'DeviceResponse',
+                status: decoded.status,
+                documents: decoded.documents.length,
+            },
+            validityInfo: document.issuerSigned.issuerAuth.decodedPayload.validityInfo,
+            issuerCertificate: issuerCert ? {
+                subjectName: issuerCert.subjectName.toString(),
+                pem: issuerCert.toString(),
+                notBefore: issuerCert.notBefore,
+                notAfter: issuerCert.notAfter,
+                serialNumber: issuerCert.serialNumber,
+                thumbprint: buffer_1.Buffer.from(await issuerCert.getThumbprint(uncrypto_1.default)).toString('hex'),
+            } : undefined,
+            issuerSignature: {
+                alg: document.issuerSigned.issuerAuth.algName,
+                isValid: dr
+                    .filter((check) => check.category === 'ISSUER_AUTH')
+                    .every((check) => check.status === 'PASSED'),
+                reasons: dr
+                    .filter((check) => check.category === 'ISSUER_AUTH' && check.status === 'FAILED')
+                    .map((check) => check.reason ?? check.check),
+                digests: Object.fromEntries(Array.from(document
+                    .issuerSigned
+                    .issuerAuth
+                    .decodedPayload
+                    .valueDigests
+                    .entries()).map(([ns, digests]) => [ns, digests.size])),
+            },
+            deviceKey: {
+                jwk: deviceKey,
+            },
+            deviceSignature: document instanceof DeviceSignedDocument_1.DeviceSignedDocument ? {
+                alg: document.deviceSigned.deviceAuth.deviceSignature?.algName ??
+                    document.deviceSigned.deviceAuth.deviceMac?.algName,
+                isValid: dr
+                    .filter((check) => check.category === 'DEVICE_AUTH')
+                    .every((check) => check.status === 'PASSED'),
+                reasons: dr
+                    .filter((check) => check.category === 'DEVICE_AUTH' && check.status === 'FAILED')
+                    .map((check) => check.reason ?? check.check),
+            } : undefined,
+            dataIntegrity: {
+                disclosedAttributes: `${disclosedAttributes} of ${totalAttributes}`,
+                isValid: dr
+                    .filter((check) => check.category === 'DATA_INTEGRITY')
+                    .every((check) => check.status === 'PASSED'),
+                reasons: dr
+                    .filter((check) => check.category === 'DATA_INTEGRITY' && check.status === 'FAILED')
+                    .map((check) => check.reason ?? check.check),
+            },
+            attributes,
+            deviceAttributes,
+        };
+    }
+}
+exports.Verifier = Verifier;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Verifier.js","sourceRoot":"","sources":["../../src/mdoc/Verifier.ts"],"names":[],"mappings":"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"}