Verifier calculating encodedSessionTranscript

[dalebowie]

A Holder performing a presentation uses this library's helper functions of the form usingSessionTranscript_____. Under the covers these construct appropriately formed CBOR-encodings of a DataItem using custom extensions to an external CBOR library. Without access to those custom CBOR extensions, how can a Verifier make the same calculation?

I could see two potential solutions:

1. the library exports its cborEncode function so that verifiers can use it to calculate what the session transcript bytes should be; or
2. additional helper functions like the usingSessionTranscript_____ on DeviceResponse are added to the Verifier class so that they can be called instead.

[siacomuzzi]

+1, there is no need for the verifier to know how to construct the session transcript. We are implementing option 2 for v2 (see #16)
In the meantime, you need to install cbor-x as dependency (DataItem is already exported by the lib):

import { DataItem } from '@auth0/mdl';
import { Encoder } from 'cbor-x';

const cborEncode = (
  obj: unknown,
): Buffer => {
  const enc = new Encoder({
    tagUint8Array: false,
    useRecords: false,
    mapsAsObjects: false,
    useTag259ForMaps: false,
  });

  return enc.encode(obj);
};

const getSessionTranscriptBytes = (clId: string, respUri: string, nonce: string, mdocNonce: string) => cborEncode(
  DataItem.fromData([
    null, // DeviceEngagementBytes
    null, // EReaderKeyBytes
    [mdocNonce, clId, respUri, nonce], // Handover = OID4VPHandover
  ]),
);

const verifier = new Verifier(ISSUERS_CERTIFICATES);
await verifier.verify(encodedDeviceResponse, {
  encodedSessionTranscript: getSessionTranscriptBytes(clientId, responseUri, verifierGeneratedNonce, mdocGeneratedNonce),
});

[rober12]

Good morning, I am trying to verify the signature of the deviceResponse in the following way:

let deviceResponseMDoc = await DeviceResponse.from(issuerMDoc)
  .usingPresentationDefinition(presentationDefinition)
  .usingSessionTranscriptForOID4VP(
    mdocGeneratedNonce,
    clientId,
    responseUri,
    verifierGeneratedNonce
  )
  .authenticateWithSignature(deviceKeys.privateKeyJWK, "ES256")
  .sign();

This correctly creates a deviceResponseMDoc without any errors, but when I try to perform the verification:

const verifier = new Verifier(trustedCertsIssuer);
const mdocVerifier = await verifier.verify(deviceResponseMDoc.encode(), {
  encodedSessionTranscript: encodedSessionTranscript,
});

I get the following error:

throw new errors_1.MDLError(verification.reason ?? verification.check, verification.id);
          ^

MDLError: Unable to verify deviceAuth signature (ECDSA/EdDSA): Device signature must be valid

To create the encodedSessionTranscript used in the verifier, I am using the code I found in this issue:

// Consistent CBOR function using cbor-x
function cborEncode(obj) {
  const enc = new Encoder({
    tagUint8Array: false,
    useRecords: false,
    mapsAsObjects: false,
    useTag259ForMaps: false,
  });
  return enc.encode(obj);
}

// Generates the session transcript bytes for the Verifier
function getSessionTranscriptBytes(
  clientId,
  responseUri,
  verifierGeneratedNonce,
  mdocGeneratedNonce
) {
  return cborEncode(
    DataItem.fromData([
      null, // DeviceEngagementBytes
      null, // EReaderKeyBytes
      [mdocGeneratedNonce, clientId, responseUri, verifierGeneratedNonce], // Handover = OID4VPHandover
    ])
  );
}

const encodedSessionTranscript = getSessionTranscriptBytes(
  clientId,
  responseUri,
  verifierGeneratedNonce,
  mdocGeneratedNonce
);

And the encodedSessionTranscript is what I pass to verify.

However, I don’t fully understand where the error is occurring, since the keys I am using are the correct device keys. That’s why I assume the error is in the parameters of the encodedSessionTranscript.

I’m not sure if this is the appropriate place for this type of Q&A, but I haven’t seen the “Discussions” option on GitHub to open one regarding this.

Thank you very much in advance.

[siacomuzzi]

It’s very hard to know what’s wrong when it comes to a signature verification, but you could try using the same version of cbor-x that the library uses (1.6.0), and the same defaults (import { getCborEncodeDecodeOptions } from '@auth0/mdl'):

mdl/src/cbor/index.ts

Lines 36 to 43 in 50e51a0

	let encoderDefaults: Options = {
	tagUint8Array: false,
	useRecords: false,
	mapsAsObjects: false,
	// @ts-ignore
	useTag259ForMaps: false,
	variableMapSize: true,
	};

The last one (variableMapSize: true) was introduced in a recent version, prior to this issue.

[rober12]

Thank you very much for the response, but I am still getting the same error. I’ll give you more information:

The version of cbor-x I am using is the same as you indicated: "cbor-x": "^1.6.0".

When I create the Document, I do the following:

const document = await new Document("org.iso.18013.5.1.mDL")
  .addIssuerNameSpace("org.iso.18013.5.1", [
    { family_name: "Jones", given_name: "Ava", birth_date: "2007-03-25" },
  ])
  .useDigestAlgorithm("SHA-256")
  .addValidityInfo({
    signed: new Date("2025-09-12T10:13:49Z"),
    validUntil: new Date("2050-10-24"),
  })
  .addDeviceKeyInfo({
    deviceKey: deviceKeys.publicKeyJWK,
  })
  .sign({
    issuerPrivateKey: issuerPrivateKeyJwk,   
    issuerCertificate: trustedCertsIssuer,
    alg: "ES256",
  });

When I create the DeviceResponse, I do the following:

let deviceResponseMDoc = await DeviceResponse.from(issuerMDoc)
  .usingPresentationDefinition(presentationDefinition)
  .usingSessionTranscriptForOID4VP(
    mdocGeneratedNonce,
    clientId,
    responseUri,
    verifierGeneratedNonce
  )
  .authenticateWithSignature(deviceKeys.privateKeyJWK, "ES256")
  .sign();

And when creating the verifier, I do what I sent you before:

const verifier = new Verifier(trustedCertsIssuer);

const encodedSessionTranscript = getSessionTranscriptBytes(
  clientId,
  responseUri,
  verifierGeneratedNonce,
  mdocGeneratedNonce
);

const mdocVerifier = await verifier.verify(deviceResponseMDoc.encode(), {
  encodedSessionTranscript: encodedSessionTranscript,
});

To create the encodedSessionTranscript, I updated it with what you suggested:

function cborEncodeWithMdlOptions(obj) {
  const options = getCborEncodeDecodeOptions();
  const encoder = new Encoder(options);
  return encoder.encode(obj);
}

function getSessionTranscriptBytes(
  clientId,
  responseUri,
  verifierGeneratedNonce,
  mdocGeneratedNonce
) {
  return Buffer.from(
    cborEncodeWithMdlOptions(
      DataItem.fromData([
        null, // DeviceEngagementBytes
        null, // EReaderKeyBytes
        [mdocGeneratedNonce, clientId, responseUri, verifierGeneratedNonce], // OID4VPHandover
      ])
    )
  );
}

And the error I get is still the same at the same point:

const mdocVerifier = await verifier.verify(deviceResponseMDoc.encode(), {
  encodedSessionTranscript: encodedSessionTranscript,
});

Error:

throw new errors_1.MDLError(verification.reason ?? verification.check, verification.id);
          ^

MDLError: Unable to verify deviceAuth signature (ECDSA/EdDSA): Device signature must be valid

Thank you very much for your help.

[siacomuzzi]

Try starting with one of our samples/tests and gradually add your configuration until you find what's wrong.

[rober12]

Good morning,

I’ve managed to get it working. Indeed, the error was in generating the encodedSessionTranscript exactly as the library does in the .usingSessionTranscriptForOID4VP part.

Thank you very much for your help.

Best regards.