@openeudi/openid4vp 0.5.0 → 0.7.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import { X509Certificate, SubjectKeyIdentifierExtension, X509Certificates, BasicConstraintsExtension, KeyUsagesExtension, KeyUsageFlags as KeyUsageFlags$1, AuthorityKeyIdentifierExtension, SubjectAlternativeNameExtension, ExtendedKeyUsageExtension, Name as Name$1 } from '@peculiar/x509';
 import { v4 } from 'uuid';
+import { SignJWT, importX509, decodeProtectedHeader, jwtVerify, importJWK, compactDecrypt } from 'jose';
 import { Encoder, Tag } from 'cbor-x';
-import { importX509, decodeProtectedHeader, jwtVerify, importJWK } from 'jose';
 import { splitSdJwt, decodeSdJwt, getClaims } from '@sd-jwt/decode';
 import { matchQuery, buildSubmission } from '@openeudi/dcql';
 export { DcqlMatchError, DcqlValidationError } from '@openeudi/dcql';
@@ -19,7 +19,7 @@ var __export = (target, all) => {
 };
 
 // src/errors.ts
-var InvalidSignatureError, ExpiredCredentialError, UnsupportedFormatError, MalformedCredentialError, NonceValidationError, HaipValidationError, OpenID4VPError, TrustAnchorNotFoundError, CertificateChainError, RevokedCertificateError, RevocationCheckFailedError, LotlFetchError, LotlSignatureError;
+var InvalidSignatureError, ExpiredCredentialError, UnsupportedFormatError, MalformedCredentialError, NonceValidationError, HaipValidationError, OpenID4VPError, TrustAnchorNotFoundError, CertificateChainError, RevokedCertificateError, RevocationCheckFailedError, LotlFetchError, LotlSignatureError, SignedRequestBuildError, UnsupportedJweError, DecryptionFailedError, MissingDecryptionKeyError, MultipleCredentialsNotSupportedError;
 var init_errors = __esm({
   "src/errors.ts"() {
     InvalidSignatureError = class extends Error {
@@ -115,6 +115,47 @@ var init_errors = __esm({
     LotlSignatureError = class extends OpenID4VPError {
       code = "lotl_signature_invalid";
     };
+    SignedRequestBuildError = class extends OpenID4VPError {
+      code;
+      constructor(code, message) {
+        super(message);
+        this.code = code;
+      }
+    };
+    UnsupportedJweError = class extends OpenID4VPError {
+      code = "unsupported_jwe";
+      alg;
+      enc;
+      constructor(alg, enc) {
+        super(`Unsupported JWE algorithms: alg=${alg}, enc=${enc}`);
+        this.alg = alg;
+        this.enc = enc;
+      }
+    };
+    DecryptionFailedError = class extends OpenID4VPError {
+      code = "decryption_failed";
+      constructor(message = "Failed to decrypt authorization response", options) {
+        super(message, options);
+      }
+    };
+    MissingDecryptionKeyError = class extends OpenID4VPError {
+      code = "missing_decryption_key";
+      constructor(message = "decryptionKey is required to verify a direct_post.jwt response") {
+        super(message);
+      }
+    };
+    MultipleCredentialsNotSupportedError = class extends OpenID4VPError {
+      code = "multi_credential_unsupported";
+      entryCount;
+      presentationCount;
+      constructor(entryCount, presentationCount) {
+        super(
+          `Multi-credential presentations are not yet supported: ${entryCount} queryId entries, ${presentationCount} presentations`
+        );
+        this.entryCount = entryCount;
+        this.presentationCount = presentationCount;
+      }
+    };
   }
 });
 
@@ -610,6 +651,9 @@ __export(index_es_exports, {
   Choice: () => Choice,
   Constructed: () => Constructed,
   DATE: () => DATE,
+  DEFAULT_MAX_CONTENT_LENGTH: () => DEFAULT_MAX_CONTENT_LENGTH,
+  DEFAULT_MAX_DEPTH: () => DEFAULT_MAX_DEPTH,
+  DEFAULT_MAX_NODES: () => DEFAULT_MAX_NODES,
   DateTime: () => DateTime,
   Duration: () => Duration,
   EndOfContent: () => EndOfContent,
@@ -704,7 +748,7 @@ function HexBlock(BaseClass) {
       this.isHexOnly = (_b = params.isHexOnly) !== null && _b !== void 0 ? _b : false;
       this.valueHexView = params.valueHex ? BufferSourceConverter.toUint8Array(params.valueHex) : EMPTY_VIEW;
     }
-    fromBER(inputBuffer, inputOffset, inputLength) {
+    fromBER(inputBuffer, inputOffset, inputLength, _context) {
       const view = inputBuffer instanceof ArrayBuffer ? new Uint8Array(inputBuffer) : inputBuffer;
       if (!checkBufferParams(this, view, inputOffset, inputLength)) {
         return -1;
@@ -748,6 +792,49 @@ function prepareIndefiniteForm(baseBlock) {
   }
   return !!((_a2 = baseBlock.lenBlock) === null || _a2 === void 0 ? void 0 : _a2.isIndefiniteForm);
 }
+function createFromBerContext(options = {}) {
+  var _a2, _b, _c;
+  return {
+    depth: 0,
+    maxDepth: (_a2 = options.maxDepth) !== null && _a2 !== void 0 ? _a2 : DEFAULT_MAX_DEPTH,
+    nodesCount: 0,
+    maxNodes: (_b = options.maxNodes) !== null && _b !== void 0 ? _b : DEFAULT_MAX_NODES,
+    maxContentLength: (_c = options.maxContentLength) !== null && _c !== void 0 ? _c : DEFAULT_MAX_CONTENT_LENGTH
+  };
+}
+function createErrorResult(error) {
+  const result = new BaseBlock({}, ValueBlock);
+  result.error = error;
+  return {
+    offset: -1,
+    result
+  };
+}
+function checkNodesLimit(context) {
+  context.nodesCount += 1;
+  if (context.nodesCount > context.maxNodes) {
+    return MAX_NODES_EXCEEDED_ERROR;
+  }
+  return void 0;
+}
+function checkContentLengthLimit(inputLength, context) {
+  if (inputLength > context.maxContentLength) {
+    return MAX_CONTENT_LENGTH_EXCEEDED_ERROR;
+  }
+  return void 0;
+}
+function localFromBERWithChildContext(inputBuffer, inputOffset, inputLength, context) {
+  const childDepth = context.depth + 1;
+  if (childDepth > context.maxDepth) {
+    return createErrorResult(MAX_DEPTH_EXCEEDED_ERROR);
+  }
+  context.depth = childDepth;
+  try {
+    return localFromBER(inputBuffer, inputOffset, inputLength, context);
+  } finally {
+    context.depth -= 1;
+  }
+}
 function localChangeType(inputObject, newType) {
   if (inputObject instanceof newType) {
     return inputObject;
@@ -759,7 +846,7 @@ function localChangeType(inputObject, newType) {
   newObject.valueBeforeDecodeView = inputObject.valueBeforeDecodeView;
   return newObject;
 }
-function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.length) {
+function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.length, context = createFromBerContext()) {
   const incomingOffset = inputOffset;
   let returnObject = new BaseBlock({}, ValueBlock);
   const baseBlock = new LocalBaseBlock();
@@ -778,6 +865,14 @@ function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.le
       result: returnObject
     };
   }
+  const nodesLimitError = checkNodesLimit(context);
+  if (nodesLimitError) {
+    returnObject.error = nodesLimitError;
+    return {
+      offset: -1,
+      result: returnObject
+    };
+  }
   let resultOffset = returnObject.idBlock.fromBER(inputBuffer, inputOffset, inputLength);
   if (returnObject.idBlock.warnings.length) {
     returnObject.warnings.concat(returnObject.idBlock.warnings);
@@ -804,6 +899,15 @@ function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.le
   }
   inputOffset = resultOffset;
   inputLength -= returnObject.lenBlock.blockLength;
+  const valueLength = returnObject.lenBlock.isIndefiniteForm ? inputLength : returnObject.lenBlock.length;
+  const contentLengthError = checkContentLengthLimit(valueLength, context);
+  if (contentLengthError) {
+    returnObject.error = contentLengthError;
+    return {
+      offset: -1,
+      result: returnObject
+    };
+  }
   if (!returnObject.idBlock.isConstructed && returnObject.lenBlock.isIndefiniteForm) {
     returnObject.error = "Indefinite length form used for primitive encoding form";
     return {
@@ -942,14 +1046,14 @@ function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.le
     }
   }
   returnObject = localChangeType(returnObject, newASN1Type);
-  resultOffset = returnObject.fromBER(inputBuffer, inputOffset, returnObject.lenBlock.isIndefiniteForm ? inputLength : returnObject.lenBlock.length);
+  resultOffset = returnObject.fromBER(inputBuffer, inputOffset, valueLength, context);
   returnObject.valueBeforeDecodeView = inputBuffer.subarray(incomingOffset, incomingOffset + returnObject.blockLength);
   return {
     offset: resultOffset,
     result: returnObject
   };
 }
-function fromBER(inputBuffer) {
+function fromBER(inputBuffer, options = {}) {
   if (!inputBuffer.byteLength) {
     const result = new BaseBlock({}, ValueBlock);
     result.error = "Input buffer has zero length";
@@ -958,7 +1062,7 @@ function fromBER(inputBuffer) {
       result
     };
   }
-  return localFromBER(BufferSourceConverter.toUint8Array(inputBuffer).slice(), 0, inputBuffer.byteLength);
+  return localFromBER(BufferSourceConverter.toUint8Array(inputBuffer).slice(), 0, inputBuffer.byteLength, createFromBerContext(options));
 }
 function checkLen(indefiniteLength, length) {
   if (indefiniteLength) {
@@ -1364,7 +1468,7 @@ function verifySchema(inputBuffer, inputSchema) {
   }
   return compareSchema(asn1.result, asn1.result, inputSchema);
 }
-var ViewWriter, powers2, digitsString, NAME, VALUE_HEX_VIEW, IS_HEX_ONLY, ID_BLOCK, TAG_CLASS, TAG_NUMBER, IS_CONSTRUCTED, FROM_BER, TO_BER, LOCAL, EMPTY_STRING, EMPTY_BUFFER, EMPTY_VIEW, END_OF_CONTENT_NAME, OCTET_STRING_NAME, BIT_STRING_NAME, LocalBaseBlock, ValueBlock, LocalIdentificationBlock, LocalLengthBlock, typeStore, BaseBlock, BaseStringBlock, LocalPrimitiveValueBlock, _a$w, Primitive, LocalConstructedValueBlock, _a$v, Constructed, LocalEndOfContentValueBlock, _a$u, EndOfContent, _a$t, Null, LocalBooleanValueBlock, _a$s, Boolean2, LocalOctetStringValueBlock, _a$r, OctetString, LocalBitStringValueBlock, _a$q, BitString, _a$p, LocalIntegerValueBlock, _a$o, Integer, _a$n, Enumerated, LocalSidValueBlock, LocalObjectIdentifierValueBlock, _a$m, ObjectIdentifier, LocalRelativeSidValueBlock, LocalRelativeObjectIdentifierValueBlock, _a$l, RelativeObjectIdentifier, _a$k, Sequence, _a$j, Set2, LocalStringValueBlock, LocalSimpleStringValueBlock, LocalSimpleStringBlock, LocalUtf8StringValueBlock, _a$i, Utf8String, LocalBmpStringValueBlock, _a$h, BmpString, LocalUniversalStringValueBlock, _a$g, UniversalString, _a$f, NumericString, _a$e, PrintableString, _a$d, TeletexString, _a$c, VideotexString, _a$b, IA5String, _a$a, GraphicString, _a$9, VisibleString, _a$8, GeneralString, _a$7, CharacterString, _a$6, UTCTime, _a$5, GeneralizedTime, _a$4, DATE, _a$3, TimeOfDay, _a$2, DateTime, _a$1, Duration, _a, TIME, Any, Choice, Repeated, RawData;
+var ViewWriter, powers2, digitsString, NAME, VALUE_HEX_VIEW, IS_HEX_ONLY, ID_BLOCK, TAG_CLASS, TAG_NUMBER, IS_CONSTRUCTED, FROM_BER, TO_BER, LOCAL, EMPTY_STRING, EMPTY_BUFFER, EMPTY_VIEW, END_OF_CONTENT_NAME, OCTET_STRING_NAME, BIT_STRING_NAME, LocalBaseBlock, ValueBlock, LocalIdentificationBlock, LocalLengthBlock, typeStore, BaseBlock, BaseStringBlock, LocalPrimitiveValueBlock, _a$w, Primitive, DEFAULT_MAX_DEPTH, DEFAULT_MAX_NODES, DEFAULT_MAX_CONTENT_LENGTH, MAX_DEPTH_EXCEEDED_ERROR, MAX_NODES_EXCEEDED_ERROR, MAX_CONTENT_LENGTH_EXCEEDED_ERROR, LocalConstructedValueBlock, _a$v, Constructed, LocalEndOfContentValueBlock, _a$u, EndOfContent, _a$t, Null, LocalBooleanValueBlock, _a$s, Boolean2, LocalOctetStringValueBlock, _a$r, OctetString, LocalBitStringValueBlock, _a$q, BitString, _a$p, LocalIntegerValueBlock, _a$o, Integer, _a$n, Enumerated, LocalSidValueBlock, LocalObjectIdentifierValueBlock, _a$m, ObjectIdentifier, LocalRelativeSidValueBlock, LocalRelativeObjectIdentifierValueBlock, _a$l, RelativeObjectIdentifier, _a$k, Sequence, _a$j, Set2, LocalStringValueBlock, LocalSimpleStringValueBlock, LocalSimpleStringBlock, LocalUtf8StringValueBlock, _a$i, Utf8String, LocalBmpStringValueBlock, _a$h, BmpString, LocalUniversalStringValueBlock, _a$g, UniversalString, _a$f, NumericString, _a$e, PrintableString, _a$d, TeletexString, _a$c, VideotexString, _a$b, IA5String, _a$a, GraphicString, _a$9, VisibleString, _a$8, GeneralString, _a$7, CharacterString, _a$6, UTCTime, _a$5, GeneralizedTime, _a$4, DATE, _a$3, TimeOfDay, _a$2, DateTime, _a$1, Duration, _a, TIME, Any, Choice, Repeated, RawData;
 var init_index_es2 = __esm({
   "node_modules/asn1js/build/index.es.js"() {
     init_index_es();
@@ -1426,7 +1530,7 @@ var init_index_es2 = __esm({
     };
     LocalBaseBlock.NAME = "baseBlock";
     ValueBlock = class extends LocalBaseBlock {
-      fromBER(_inputBuffer, _inputOffset, _inputLength) {
+      fromBER(_inputBuffer, _inputOffset, _inputLength, _context) {
         throw TypeError("User need to make a specific function in a class which extends 'ValueBlock'");
       }
       toBER(_sizeOnly, _writer) {
@@ -1539,31 +1643,21 @@ var init_index_es2 = __esm({
           this.tagNumber = tagNumberMask;
           this.blockLength = 1;
         } else {
-          let count = 1;
-          let intTagNumberBuffer = this.valueHexView = new Uint8Array(255);
-          let tagNumberBufferMaxLength = 255;
-          while (intBuffer[count] & 128) {
-            intTagNumberBuffer[count - 1] = intBuffer[count] & 127;
-            count++;
-            if (count >= intBuffer.length) {
+          let count = 0;
+          while (true) {
+            const tagByteIndex = count + 1;
+            if (tagByteIndex >= intBuffer.length) {
               this.error = "End of input reached before message was fully decoded";
               return -1;
             }
-            if (count === tagNumberBufferMaxLength) {
-              tagNumberBufferMaxLength += 255;
-              const tempBufferView2 = new Uint8Array(tagNumberBufferMaxLength);
-              for (let i = 0; i < intTagNumberBuffer.length; i++)
-                tempBufferView2[i] = intTagNumberBuffer[i];
-              intTagNumberBuffer = this.valueHexView = new Uint8Array(tagNumberBufferMaxLength);
-            }
+            count++;
+            if ((intBuffer[tagByteIndex] & 128) === 0)
+              break;
           }
           this.blockLength = count + 1;
-          intTagNumberBuffer[count - 1] = intBuffer[count] & 127;
-          const tempBufferView = new Uint8Array(count);
+          const intTagNumberBuffer = this.valueHexView = new Uint8Array(count);
           for (let i = 0; i < count; i++)
-            tempBufferView[i] = intTagNumberBuffer[i];
-          intTagNumberBuffer = this.valueHexView = new Uint8Array(count);
-          intTagNumberBuffer.set(tempBufferView);
+            intTagNumberBuffer[i] = intBuffer[i + 1] & 127;
           if (this.blockLength <= 9)
             this.tagNumber = utilFromBase(intTagNumberBuffer, 7);
           else {
@@ -1713,8 +1807,8 @@ var init_index_es2 = __esm({
         this.lenBlock = new LocalLengthBlock(parameters);
         this.valueBlock = valueBlockType ? new valueBlockType(parameters) : new ValueBlock(parameters);
       }
-      fromBER(inputBuffer, inputOffset, inputLength) {
-        const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, this.lenBlock.isIndefiniteForm ? inputLength : this.lenBlock.length);
+      fromBER(inputBuffer, inputOffset, inputLength, context) {
+        const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, this.lenBlock.isIndefiniteForm ? inputLength : this.lenBlock.length, context);
         if (resultOffset === -1) {
           this.error = this.valueBlock.error;
           return resultOffset;
@@ -1838,14 +1932,21 @@ var init_index_es2 = __esm({
       typeStore.Primitive = _a$w;
     })();
     Primitive.NAME = "PRIMITIVE";
+    DEFAULT_MAX_DEPTH = 100;
+    DEFAULT_MAX_NODES = 1e4;
+    DEFAULT_MAX_CONTENT_LENGTH = 16 * 1024 * 1024;
+    MAX_DEPTH_EXCEEDED_ERROR = "Maximum ASN.1 nesting depth exceeded";
+    MAX_NODES_EXCEEDED_ERROR = "Maximum ASN.1 node count exceeded";
+    MAX_CONTENT_LENGTH_EXCEEDED_ERROR = "Maximum ASN.1 content length exceeded";
     LocalConstructedValueBlock = class extends ValueBlock {
       constructor({ value = [], isIndefiniteForm = false, ...parameters } = {}) {
         super(parameters);
         this.value = value;
         this.isIndefiniteForm = isIndefiniteForm;
       }
-      fromBER(inputBuffer, inputOffset, inputLength) {
+      fromBER(inputBuffer, inputOffset, inputLength, context) {
         const view = BufferSourceConverter.toUint8Array(inputBuffer);
+        const parseContext = context !== null && context !== void 0 ? context : createFromBerContext();
         if (!checkBufferParams(this, view, inputOffset, inputLength)) {
           return -1;
         }
@@ -1856,7 +1957,7 @@ var init_index_es2 = __esm({
         }
         let currentOffset = inputOffset;
         while (checkLen(this.isIndefiniteForm, inputLength) > 0) {
-          const returnObject = localFromBER(view, currentOffset, inputLength);
+          const returnObject = localFromBERWithChildContext(view, currentOffset, inputLength, parseContext);
           if (returnObject.offset === -1) {
             this.error = returnObject.result.error;
             this.warnings.concat(returnObject.result.warnings);
@@ -1907,9 +2008,9 @@ var init_index_es2 = __esm({
         super(parameters, LocalConstructedValueBlock);
         this.idBlock.isConstructed = true;
       }
-      fromBER(inputBuffer, inputOffset, inputLength) {
+      fromBER(inputBuffer, inputOffset, inputLength, context) {
         this.valueBlock.isIndefiniteForm = this.lenBlock.isIndefiniteForm;
-        const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, this.lenBlock.isIndefiniteForm ? inputLength : this.lenBlock.length);
+        const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, this.lenBlock.isIndefiniteForm ? inputLength : this.lenBlock.length, context);
         if (resultOffset === -1) {
           this.error = this.valueBlock.error;
           return resultOffset;
@@ -2072,11 +2173,11 @@ ${values.join("\n")}` : `${blockName} :`;
         super(parameters);
         this.isConstructed = isConstructed;
       }
-      fromBER(inputBuffer, inputOffset, inputLength) {
+      fromBER(inputBuffer, inputOffset, inputLength, context) {
         let resultOffset = 0;
         if (this.isConstructed) {
           this.isHexOnly = false;
-          resultOffset = LocalConstructedValueBlock.prototype.fromBER.call(this, inputBuffer, inputOffset, inputLength);
+          resultOffset = LocalConstructedValueBlock.prototype.fromBER.call(this, inputBuffer, inputOffset, inputLength, context);
           if (resultOffset === -1)
             return resultOffset;
           for (let i = 0; i < this.value.length; i++) {
@@ -2132,7 +2233,7 @@ ${values.join("\n")}` : `${blockName} :`;
         this.idBlock.tagClass = 1;
         this.idBlock.tagNumber = 4;
       }
-      fromBER(inputBuffer, inputOffset, inputLength) {
+      fromBER(inputBuffer, inputOffset, inputLength, context) {
         this.valueBlock.isConstructed = this.idBlock.isConstructed;
         this.valueBlock.isIndefiniteForm = this.lenBlock.isIndefiniteForm;
         if (inputLength === 0) {
@@ -2147,7 +2248,8 @@ ${values.join("\n")}` : `${blockName} :`;
           const buf = view.subarray(inputOffset, inputOffset + inputLength);
           try {
             if (buf.byteLength) {
-              const asn = localFromBER(buf, 0, buf.byteLength);
+              const parseContext = context !== null && context !== void 0 ? context : createFromBerContext();
+              const asn = localFromBERWithChildContext(buf, 0, buf.byteLength, parseContext);
               if (asn.offset !== -1 && asn.offset === inputLength) {
                 this.valueBlock.value = [asn.result];
               }
@@ -2155,7 +2257,7 @@ ${values.join("\n")}` : `${blockName} :`;
           } catch {
           }
         }
-        return super.fromBER(inputBuffer, inputOffset, inputLength);
+        return super.fromBER(inputBuffer, inputOffset, inputLength, context);
       }
       onAsciiEncoding() {
         if (this.valueBlock.isConstructed || this.valueBlock.value && this.valueBlock.value.length) {
@@ -2190,13 +2292,13 @@ ${values.join("\n")}` : `${blockName} :`;
         this.isConstructed = isConstructed;
         this.blockLength = this.valueHexView.byteLength;
       }
-      fromBER(inputBuffer, inputOffset, inputLength) {
+      fromBER(inputBuffer, inputOffset, inputLength, context) {
         if (!inputLength) {
           return inputOffset;
         }
         let resultOffset = -1;
         if (this.isConstructed) {
-          resultOffset = LocalConstructedValueBlock.prototype.fromBER.call(this, inputBuffer, inputOffset, inputLength);
+          resultOffset = LocalConstructedValueBlock.prototype.fromBER.call(this, inputBuffer, inputOffset, inputLength, context);
           if (resultOffset === -1)
             return resultOffset;
           for (const value of this.value) {
@@ -2236,7 +2338,8 @@ ${values.join("\n")}` : `${blockName} :`;
           const buf = intBuffer.subarray(1);
           try {
             if (buf.byteLength) {
-              const asn = localFromBER(buf, 0, buf.byteLength);
+              const parseContext = context !== null && context !== void 0 ? context : createFromBerContext();
+              const asn = localFromBERWithChildContext(buf, 0, buf.byteLength, parseContext);
               if (asn.offset !== -1 && asn.offset === inputLength - 1) {
                 this.value = [asn.result];
               }
@@ -2292,10 +2395,10 @@ ${values.join("\n")}` : `${blockName} :`;
         this.idBlock.tagClass = 1;
         this.idBlock.tagNumber = 3;
       }
-      fromBER(inputBuffer, inputOffset, inputLength) {
+      fromBER(inputBuffer, inputOffset, inputLength, context) {
         this.valueBlock.isConstructed = this.idBlock.isConstructed;
         this.valueBlock.isIndefiniteForm = this.lenBlock.isIndefiniteForm;
-        return super.fromBER(inputBuffer, inputOffset, inputLength);
+        return super.fromBER(inputBuffer, inputOffset, inputLength, context);
       }
       onAsciiEncoding() {
         if (this.valueBlock.isConstructed || this.valueBlock.value && this.valueBlock.value.length) {
@@ -7962,6 +8065,135 @@ function createAuthorizationRequest(input, query) {
   };
 }
 
+// src/signed-authorization.ts
+init_errors();
+var DEFAULT_SUPPORTED_ENC_VALUES = ["A128GCM", "A256GCM"];
+var SUPPORTED_SIGNING_ALGS = /* @__PURE__ */ new Set(["ES256", "ES384", "RS256"]);
+async function createSignedAuthorizationRequest(input, query) {
+  if (input.certificateChain.length === 0) {
+    throw new SignedRequestBuildError(
+      "empty_cert_chain",
+      "certificateChain must contain at least the leaf certificate"
+    );
+  }
+  const signingAlg = input.signingAlgorithm ?? "ES256";
+  if (!SUPPORTED_SIGNING_ALGS.has(signingAlg)) {
+    throw new SignedRequestBuildError(
+      "unsupported_signing_alg",
+      `signingAlgorithm ${signingAlg} is not supported (expected ES256/ES384/RS256)`
+    );
+  }
+  if (!input.vpFormatsSupported || Object.keys(input.vpFormatsSupported).length === 0) {
+    throw new SignedRequestBuildError(
+      "missing_vp_formats",
+      "vpFormatsSupported is required and must be non-empty"
+    );
+  }
+  const leafCert = new X509Certificate(toArrayBuffer(input.certificateChain[0]));
+  const sanDnsNames = extractDnsNames(leafCert);
+  if (!sanDnsNames.includes(input.hostname)) {
+    throw new SignedRequestBuildError(
+      "hostname_cert_mismatch",
+      `leaf cert SAN DNSName values [${sanDnsNames.join(", ")}] do not include hostname "${input.hostname}"`
+    );
+  }
+  const signerPublicSpki = new Uint8Array(
+    await crypto.subtle.exportKey("spki", input.signer.publicKey)
+  );
+  const leafSpki = new Uint8Array(leafCert.publicKey.rawData);
+  if (!bytesEqual(signerPublicSpki, leafSpki)) {
+    throw new SignedRequestBuildError(
+      "signing_key_cert_mismatch",
+      "signer.publicKey SPKI does not match leaf certificate SPKI"
+    );
+  }
+  const responseMode = input.responseMode ?? "direct_post.jwt";
+  if (responseMode === "direct_post.jwt") {
+    if (!input.encryptionKey?.publicJwk) {
+      throw new SignedRequestBuildError(
+        "missing_encryption_jwk",
+        "direct_post.jwt response mode requires encryptionKey.publicJwk"
+      );
+    }
+    if (!input.encryptionKey.publicJwk.alg) {
+      throw new SignedRequestBuildError(
+        "missing_encryption_alg",
+        "encryptionKey.publicJwk must carry alg (OpenID4VP 1.0 \xA78.3)"
+      );
+    }
+  }
+  const state = input.state ?? v4();
+  const clientId = `x509_san_dns:${input.hostname}`;
+  const now = Math.floor(Date.now() / 1e3);
+  const clientMetadata = {
+    vp_formats_supported: input.vpFormatsSupported
+  };
+  if (responseMode === "direct_post.jwt" && input.encryptionKey) {
+    const enc = input.encryptionKey.supportedEncValues;
+    if (enc !== void 0 && enc.length === 0) {
+      throw new SignedRequestBuildError(
+        "empty_supported_enc_values",
+        "encryptionKey.supportedEncValues must not be empty (omit to use defaults [A128GCM, A256GCM])"
+      );
+    }
+    const jwk = { ...input.encryptionKey.publicJwk, use: "enc" };
+    clientMetadata.jwks = { keys: [jwk] };
+    clientMetadata.encrypted_response_enc_values_supported = enc ?? [...DEFAULT_SUPPORTED_ENC_VALUES];
+  }
+  const payload = {
+    iss: clientId,
+    aud: "https://self-issued.me/v2",
+    response_type: "vp_token",
+    response_mode: responseMode,
+    client_id: clientId,
+    response_uri: input.responseUri,
+    nonce: input.nonce,
+    state,
+    dcql_query: query,
+    client_metadata: clientMetadata,
+    iat: now,
+    exp: now + 120
+  };
+  const x5c = input.certificateChain.map((der) => bytesToBase64(der));
+  const jws = await new SignJWT(payload).setProtectedHeader({ typ: "oauth-authz-req+jwt", alg: signingAlg, x5c }).sign(input.signer.privateKey);
+  const uriParams = new URLSearchParams({
+    client_id: clientId,
+    request_uri: input.requestUri
+  });
+  return {
+    uri: `openid4vp://authorize?${uriParams.toString()}`,
+    requestObject: jws,
+    dcqlQuery: query,
+    nonce: input.nonce,
+    state
+  };
+}
+function extractDnsNames(cert) {
+  const SAN_OID = "2.5.29.17";
+  const ext = cert.extensions.find((e) => e.type === SAN_OID);
+  if (!ext) return [];
+  const names = ext.names;
+  const items = names?.items ?? [];
+  return items.filter((e) => e.type === "dns").map((e) => e.value);
+}
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function bytesToBase64(bytes) {
+  let s = "";
+  for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i]);
+  return btoa(s);
+}
+function toArrayBuffer(bytes) {
+  const out = new ArrayBuffer(bytes.byteLength);
+  new Uint8Array(out).set(bytes);
+  return out;
+}
+
 // src/haip.ts
 init_errors();
 var HAIP_DOCTYPE_NAMESPACES = {
@@ -8188,7 +8420,7 @@ async function computeItemDigest(itemBytes, digestAlgorithm) {
   const buf = await crypto.subtle.digest(digestAlgorithm, new Uint8Array(itemBytes));
   return new Uint8Array(buf);
 }
-function bytesEqual(a, b) {
+function bytesEqual2(a, b) {
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i++) {
     if (a[i] !== b[i]) return false;
@@ -8234,7 +8466,7 @@ async function verifyAllDigests(nameSpaces, mso) {
       if (!expectedDigest) {
         throw new MalformedCredentialError(`digestID ${digestID} missing from MSO valueDigests[${ns}]`);
       }
-      if (!bytesEqual(hash, expectedDigest)) {
+      if (!bytesEqual2(hash, expectedDigest)) {
         throw new MalformedCredentialError(`digest mismatch for ns=${ns} digestID=${digestID}`);
       }
     }
@@ -8353,7 +8585,7 @@ init_errors();
 var decoder4 = new Encoder({ mapsAsObjects: false, useRecords: false });
 var encoder = new Encoder({ mapsAsObjects: false, useRecords: false });
 var DEFAULT_ALLOWED_ALGORITHMS = ["ES256", "ES384", "ES512"];
-function bytesEqual2(a, b) {
+function bytesEqual3(a, b) {
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i++) {
     if (a[i] !== b[i]) return false;
@@ -8489,8 +8721,8 @@ var MdocParser = class {
         cache: options.cache,
         clockSkewTolerance: options.clockSkewTolerance
       });
-      const { X509Certificate: X509Certificate8 } = await import('@peculiar/x509');
-      const leaf = new X509Certificate8(issuerCertBytes);
+      const { X509Certificate: X509Certificate9 } = await import('@peculiar/x509');
+      const leaf = new X509Certificate9(issuerCertBytes);
       trustResult = await evaluator.evaluate(leaf);
     } else {
       if (options.trustedCertificates.length === 0) {
@@ -8500,7 +8732,7 @@ var MdocParser = class {
           );
         }
       } else {
-        const trusted = options.trustedCertificates.some((t) => bytesEqual2(t, issuerCertBytes));
+        const trusted = options.trustedCertificates.some((t) => bytesEqual3(t, issuerCertBytes));
         if (!trusted) {
           return {
             valid: false,
@@ -8615,7 +8847,7 @@ function base64ToBytes(base64) {
   }
   return bytes;
 }
-function bytesEqual3(a, b) {
+function bytesEqual4(a, b) {
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i++) {
     if (a[i] !== b[i]) return false;
@@ -8738,8 +8970,8 @@ var SdJwtParser = class {
         cache: options.cache,
         clockSkewTolerance: options.clockSkewTolerance
       });
-      const { X509Certificate: X509Certificate8 } = await import('@peculiar/x509');
-      const leaf = new X509Certificate8(issuerCertBytes);
+      const { X509Certificate: X509Certificate9 } = await import('@peculiar/x509');
+      const leaf = new X509Certificate9(issuerCertBytes);
       trustResult = await evaluator.evaluate(leaf);
     } else {
       if (options.trustedCertificates.length === 0) {
@@ -8749,7 +8981,7 @@ var SdJwtParser = class {
           );
         }
       } else {
-        const isTrusted = options.trustedCertificates.some((trusted) => bytesEqual3(trusted, issuerCertBytes));
+        const isTrusted = options.trustedCertificates.some((trusted) => bytesEqual4(trusted, issuerCertBytes));
         if (!isTrusted) {
           return invalidResult("Issuer certificate is not trusted");
         }
@@ -8846,42 +9078,48 @@ async function parsePresentation(vpToken, options) {
     error: "Unsupported credential format"
   };
 }
-var INTERNAL_TO_DCQL_FORMAT = {
-  "sd-jwt-vc": "dc+sd-jwt",
-  mdoc: "mso_mdoc"
-};
-function classifyMismatch(query, decoded, hasDetail) {
-  if (decoded.format !== query.format) return "format_mismatch";
-  if (query.format === "dc+sd-jwt") {
-    const allowed = query.meta?.vct_values;
-    if (allowed && allowed.length > 0 && !allowed.includes(decoded.vct ?? "")) {
-      return "vct_mismatch";
-    }
+
+// src/decrypt-response.ts
+init_errors();
+var SUPPORTED_ALG = "ECDH-ES";
+var SUPPORTED_ENC = /* @__PURE__ */ new Set(["A128GCM", "A256GCM"]);
+async function decryptAuthorizationResponse(jwe, privateKey) {
+  let header;
+  try {
+    header = decodeProtectedHeader(jwe);
+  } catch (err) {
+    throw new DecryptionFailedError("Malformed JWE header", {
+      cause: err
+    });
   }
-  if (query.format === "mso_mdoc") {
-    const expected = query.meta?.doctype_value;
-    if (expected && expected !== decoded.doctype) return "doctype_mismatch";
+  const alg = typeof header.alg === "string" ? header.alg : "";
+  const enc = typeof header.enc === "string" ? header.enc : "";
+  if (alg !== SUPPORTED_ALG || !SUPPORTED_ENC.has(enc)) {
+    throw new UnsupportedJweError(alg, enc);
   }
-  if (query.trusted_authorities && query.trusted_authorities.length > 0) {
-    const decodedAuthIds = decoded.trusted_authority_ids ?? [];
-    const anyMatch = query.trusted_authorities.some(
-      (ta) => ta.values.some((v) => decodedAuthIds.includes(v))
-    );
-    if (!anyMatch) return "trusted_authority_mismatch";
+  let plaintext;
+  try {
+    const result = await compactDecrypt(jwe, privateKey);
+    plaintext = result.plaintext;
+  } catch (err) {
+    throw new DecryptionFailedError(void 0, { cause: err });
+  }
+  try {
+    const text = new TextDecoder().decode(plaintext);
+    return JSON.parse(text);
+  } catch (err) {
+    throw new DecryptionFailedError("Decrypted plaintext is not valid JSON", {
+      cause: err
+    });
   }
-  if (hasDetail) return "missing_claims";
-  return "no_credential_found";
-}
-function refineUnmatched(query, decoded, match) {
-  if (match.unmatched.length === 0) return match;
-  const refined = match.unmatched.map((entry) => {
-    const credentialQuery = query.credentials.find((c) => c.id === entry.queryId);
-    if (!credentialQuery) return entry;
-    const specific = classifyMismatch(credentialQuery, decoded, entry.detail !== void 0);
-    return { ...entry, reason: specific };
-  });
-  return { ...match, unmatched: refined };
 }
+
+// src/verify.ts
+init_errors();
+var INTERNAL_TO_DCQL_FORMAT = {
+  "sd-jwt-vc": "dc+sd-jwt",
+  mdoc: "mso_mdoc"
+};
 async function verifyPresentation(vpToken, query, options) {
   const parsed = await parsePresentation(vpToken, options);
   const dcqlFormat = INTERNAL_TO_DCQL_FORMAT[parsed.format] ?? parsed.format;
@@ -8900,8 +9138,7 @@ async function verifyPresentation(vpToken, query, options) {
   if (parsed.trust?.trustedAuthorityIds && parsed.trust.trustedAuthorityIds.length > 0) {
     decoded.trusted_authority_ids = [...parsed.trust.trustedAuthorityIds];
   }
-  const rawMatch = matchQuery(query, [decoded]);
-  const match = refineUnmatched(query, decoded, rawMatch);
+  const match = matchQuery(query, [decoded]);
   const submission = match.satisfied ? buildSubmission(query, match) : null;
   return {
     parsed,
@@ -8910,6 +9147,48 @@ async function verifyPresentation(vpToken, query, options) {
     valid: parsed.valid && match.satisfied
   };
 }
+function isEncryptedResponse(x) {
+  return typeof x === "object" && x !== null && "response" in x && typeof x.response === "string" && Object.keys(x).length === 1;
+}
+function isAuthorizationResponse(x) {
+  return typeof x === "object" && x !== null && "vp_token" in x && typeof x.vp_token === "object" && x.vp_token !== null;
+}
+async function verifyAuthorizationResponse(envelope, query, options) {
+  if (isEncryptedResponse(envelope)) {
+    if (!options.decryptionKey) {
+      throw new MissingDecryptionKeyError();
+    }
+    const decrypted = await decryptAuthorizationResponse(
+      envelope.response,
+      options.decryptionKey
+    );
+    return verifyAuthorizationResponse(decrypted, query, options);
+  }
+  if (!isAuthorizationResponse(envelope)) {
+    throw new TypeError("envelope must contain vp_token as a JSON object per OpenID4VP 1.0 \xA78.1");
+  }
+  const vpToken = envelope.vp_token;
+  const queryIds = Object.keys(vpToken);
+  if (queryIds.length === 0) {
+    throw new TypeError("vp_token cannot be empty per OpenID4VP 1.0 \xA78.1");
+  }
+  for (const id of queryIds) {
+    if (!Array.isArray(vpToken[id])) {
+      throw new TypeError(
+        `vp_token entry "${id}" must be an array of presentations per OpenID4VP 1.0 \xA78.1`
+      );
+    }
+  }
+  const presentationCount = queryIds.reduce(
+    (sum, id) => sum + vpToken[id].length,
+    0
+  );
+  if (queryIds.length > 1 || presentationCount > 1) {
+    throw new MultipleCredentialsNotSupportedError(queryIds.length, presentationCount);
+  }
+  const presentation = vpToken[queryIds[0]][0];
+  return verifyPresentation(presentation, query, options);
+}
 
 // src/index.ts
 init_errors();
@@ -9521,7 +9800,7 @@ function equalBytes(a, b) {
 
 // src/index.ts
 init_errors();
-var VERSION = "0.5.0";
+var VERSION = "0.7.0";
 /*! Bundled license information:
 
 pvtsutils/build/index.es.js:
@@ -9591,6 +9870,6 @@ asn1js/build/index.es.js:
    *)
 */
 
-export { CertificateChainError, CompositeTrustStore, ExpiredCredentialError, HAIP_DOCTYPE_NAMESPACES, HaipValidationError, InMemoryCache, InvalidSignatureError, LotlFetchError, LotlSignatureError, LotlTrustStore, MalformedCredentialError, MdocParser, NonceValidationError, OpenID4VPError, RevocationCheckFailedError, RevokedCertificateError, SdJwtParser, StaticTrustStore, TrustAnchorNotFoundError, UnsupportedFormatError, VERSION, buildHaipQuery, createAuthorizationRequest, isHaipQuery, parsePresentation, validateHaipQuery, verifyPresentation };
+export { CertificateChainError, CompositeTrustStore, DecryptionFailedError, ExpiredCredentialError, HAIP_DOCTYPE_NAMESPACES, HaipValidationError, InMemoryCache, InvalidSignatureError, LotlFetchError, LotlSignatureError, LotlTrustStore, MalformedCredentialError, MdocParser, MissingDecryptionKeyError, MultipleCredentialsNotSupportedError, NonceValidationError, OpenID4VPError, RevocationCheckFailedError, RevokedCertificateError, SdJwtParser, SignedRequestBuildError, StaticTrustStore, TrustAnchorNotFoundError, UnsupportedFormatError, UnsupportedJweError, VERSION, buildHaipQuery, createAuthorizationRequest, createSignedAuthorizationRequest, decryptAuthorizationResponse, isHaipQuery, parsePresentation, validateHaipQuery, verifyAuthorizationResponse, verifyPresentation };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map