@openeudi/openid4vp 0.6.0 → 0.7.0

package/dist/index.d.cts

@@ -15,9 +15,49 @@ interface AuthorizationRequest {
     nonce: string;
     state: string;
 }
+interface SignedAuthorizationRequestInput {
+    hostname: string;
+    requestUri: string;
+    responseUri: string;
+    nonce: string;
+    state?: string;
+    responseMode?: 'direct_post' | 'direct_post.jwt';
+    signer: CryptoKeyPair;
+    signingAlgorithm?: 'ES256' | 'ES384' | 'RS256';
+    certificateChain: Uint8Array[];
+    encryptionKey?: {
+        publicJwk: JsonWebKey;
+        supportedEncValues?: string[];
+    };
+    vpFormatsSupported: Record<string, unknown>;
+}
+interface SignedAuthorizationRequest {
+    uri: string;
+    requestObject: string;
+    dcqlQuery: DcqlQuery;
+    nonce: string;
+    state: string;
+}
+interface AuthorizationResponse {
+    vp_token: Record<string, Array<string | object>>;
+    state?: string;
+    [key: string]: unknown;
+}
 
 declare function createAuthorizationRequest(input: AuthorizationRequestInput, query: DcqlQuery): AuthorizationRequest;
 
+/**
+ * Build a signed authorization request (JAR) per OpenID4VP 1.0 §5.10 / RFC 9101.
+ *
+ * Validates that the signing key is bound to the leaf certificate and that the
+ * leaf cert's SAN DNSName equals the declared hostname. Emits a short URI
+ * carrying only `client_id` + `request_uri`, plus the JWS string the caller
+ * must host at `requestUri` with Content-Type `application/oauth-authz-req+jwt`.
+ *
+ * Client Identifier Prefix is always `x509_san_dns` — other prefixes deferred.
+ */
+declare function createSignedAuthorizationRequest(input: SignedAuthorizationRequestInput, query: DcqlQuery): Promise<SignedAuthorizationRequest>;
+
 interface HaipQueryInput {
     credentialId: string;
     format: 'dc+sd-jwt' | 'mso_mdoc';
@@ -293,6 +333,12 @@ interface VerifyResult {
     submission: DcqlSubmission | null;
     valid: boolean;
 }
+interface EncryptedResponse {
+    response: string;
+}
+type VerifyAuthorizationResponseOptions = VerifyOptions & {
+    decryptionKey?: CryptoKey;
+};
 
 /**
  * Parses a VP token, then matches it against a DCQL query.
@@ -306,6 +352,34 @@ interface VerifyResult {
  * @param options parse + verify options (nonce, trusted issuers, etc.)
  */
 declare function verifyPresentation(vpToken: unknown, query: DcqlQuery, options: VerifyOptions): Promise<VerifyResult>;
+/**
+ * Verify an OpenID4VP 1.0 §8.1 Authorization Response envelope.
+ *
+ * Accepts either the unencrypted envelope (object-keyed `vp_token`) or a
+ * JWE-wrapped envelope `{ response: '<JWE>' }` for response_mode =
+ * direct_post.jwt. When encrypted, decrypts with `options.decryptionKey`
+ * first. For this release only single-credential single-presentation is
+ * supported — multi-credential envelopes throw
+ * {@link MultipleCredentialsNotSupportedError}. Otherwise delegates the
+ * extracted single presentation to the existing {@link verifyPresentation}.
+ *
+ * Callers MUST compare the envelope's `state` against the value they issued
+ * themselves — library is stateless and does not track state.
+ */
+declare function verifyAuthorizationResponse(envelope: AuthorizationResponse | EncryptedResponse, query: DcqlQuery, options: VerifyAuthorizationResponseOptions): Promise<VerifyResult>;
+
+/**
+ * Decrypt a JWE-wrapped OpenID4VP Authorization Response (response_mode =
+ * direct_post.jwt). Returns the inner §8.1 envelope.
+ *
+ * Supported JWE algorithms (others throw UnsupportedJweError):
+ *   - alg: ECDH-ES
+ *   - enc: A128GCM, A256GCM (HAIP requires both)
+ *
+ * Cryptographic failures (wrong key, tampered ciphertext) throw
+ * DecryptionFailedError.
+ */
+declare function decryptAuthorizationResponse(jwe: string, privateKey: CryptoKey): Promise<AuthorizationResponse>;
 
 /**
  * SD-JWT VC credential parser.
@@ -416,6 +490,33 @@ declare class LotlFetchError extends OpenID4VPError {
 declare class LotlSignatureError extends OpenID4VPError {
     readonly code: "lotl_signature_invalid";
 }
+type SignedRequestBuildErrorCode = 'empty_cert_chain' | 'hostname_cert_mismatch' | 'signing_key_cert_mismatch' | 'missing_encryption_jwk' | 'missing_encryption_alg' | 'missing_vp_formats' | 'unsupported_signing_alg' | 'empty_supported_enc_values';
+declare class SignedRequestBuildError extends OpenID4VPError {
+    readonly code: SignedRequestBuildErrorCode;
+    constructor(code: SignedRequestBuildErrorCode, message: string);
+}
+declare class UnsupportedJweError extends OpenID4VPError {
+    readonly code: "unsupported_jwe";
+    readonly alg: string;
+    readonly enc: string;
+    constructor(alg: string, enc: string);
+}
+declare class DecryptionFailedError extends OpenID4VPError {
+    readonly code: "decryption_failed";
+    constructor(message?: string, options?: {
+        cause?: Error;
+    });
+}
+declare class MissingDecryptionKeyError extends OpenID4VPError {
+    readonly code: "missing_decryption_key";
+    constructor(message?: string);
+}
+declare class MultipleCredentialsNotSupportedError extends OpenID4VPError {
+    readonly code: "multi_credential_unsupported";
+    readonly entryCount: number;
+    readonly presentationCount: number;
+    constructor(entryCount: number, presentationCount: number);
+}
 
 interface LotlTrustStoreOptions {
     /** Override the bundled signing anchors. Empty is rejected. */
@@ -454,6 +555,6 @@ declare class LotlTrustStore implements TrustStore {
     private refresh;
 }
 
-declare const VERSION = "0.5.0";
+declare const VERSION = "0.7.0";
 
-export { type AuthorizationRequest, type AuthorizationRequestInput, type Cache, CertificateChainError, type ChainErrorReason, CompositeTrustStore, type CredentialClaims, type CredentialFormat, ExpiredCredentialError, type Fetcher, HAIP_DOCTYPE_NAMESPACES, type HaipQueryInput, type HaipValidationCode, HaipValidationError, type ICredentialParser, InMemoryCache, InvalidSignatureError, type IssuerInfo, type LotlAnchorMetadata, LotlFetchError, LotlSignatureError, LotlTrustStore, type LotlTrustStoreOptions, MalformedCredentialError, MdocParser, NonceValidationError, OpenID4VPError, type ParseOptions, type PresentationResult, RevocationCheckFailedError, RevokedCertificateError, SdJwtParser, StaticTrustStore, type TrustAnchor, TrustAnchorNotFoundError, type TrustStore, type TrustStoreHint, type TrustStoreInput, UnsupportedFormatError, VERSION, type VerifyOptions, type VerifyResult, buildHaipQuery, createAuthorizationRequest, isHaipQuery, parsePresentation, validateHaipQuery, verifyPresentation };
+export { type AuthorizationRequest, type AuthorizationRequestInput, type AuthorizationResponse, type Cache, CertificateChainError, type ChainErrorReason, CompositeTrustStore, type CredentialClaims, type CredentialFormat, DecryptionFailedError, type EncryptedResponse, ExpiredCredentialError, type Fetcher, HAIP_DOCTYPE_NAMESPACES, type HaipQueryInput, type HaipValidationCode, HaipValidationError, type ICredentialParser, InMemoryCache, InvalidSignatureError, type IssuerInfo, type LotlAnchorMetadata, LotlFetchError, LotlSignatureError, LotlTrustStore, type LotlTrustStoreOptions, MalformedCredentialError, MdocParser, MissingDecryptionKeyError, MultipleCredentialsNotSupportedError, NonceValidationError, OpenID4VPError, type ParseOptions, type PresentationResult, RevocationCheckFailedError, RevokedCertificateError, SdJwtParser, type SignedAuthorizationRequest, type SignedAuthorizationRequestInput, SignedRequestBuildError, type SignedRequestBuildErrorCode, StaticTrustStore, type TrustAnchor, TrustAnchorNotFoundError, type TrustStore, type TrustStoreHint, type TrustStoreInput, UnsupportedFormatError, UnsupportedJweError, VERSION, type VerifyAuthorizationResponseOptions, type VerifyOptions, type VerifyResult, buildHaipQuery, createAuthorizationRequest, createSignedAuthorizationRequest, decryptAuthorizationResponse, isHaipQuery, parsePresentation, validateHaipQuery, verifyAuthorizationResponse, verifyPresentation };

package/dist/index.d.ts

@@ -15,9 +15,49 @@ interface AuthorizationRequest {
     nonce: string;
     state: string;
 }
+interface SignedAuthorizationRequestInput {
+    hostname: string;
+    requestUri: string;
+    responseUri: string;
+    nonce: string;
+    state?: string;
+    responseMode?: 'direct_post' | 'direct_post.jwt';
+    signer: CryptoKeyPair;
+    signingAlgorithm?: 'ES256' | 'ES384' | 'RS256';
+    certificateChain: Uint8Array[];
+    encryptionKey?: {
+        publicJwk: JsonWebKey;
+        supportedEncValues?: string[];
+    };
+    vpFormatsSupported: Record<string, unknown>;
+}
+interface SignedAuthorizationRequest {
+    uri: string;
+    requestObject: string;
+    dcqlQuery: DcqlQuery;
+    nonce: string;
+    state: string;
+}
+interface AuthorizationResponse {
+    vp_token: Record<string, Array<string | object>>;
+    state?: string;
+    [key: string]: unknown;
+}
 
 declare function createAuthorizationRequest(input: AuthorizationRequestInput, query: DcqlQuery): AuthorizationRequest;
 
+/**
+ * Build a signed authorization request (JAR) per OpenID4VP 1.0 §5.10 / RFC 9101.
+ *
+ * Validates that the signing key is bound to the leaf certificate and that the
+ * leaf cert's SAN DNSName equals the declared hostname. Emits a short URI
+ * carrying only `client_id` + `request_uri`, plus the JWS string the caller
+ * must host at `requestUri` with Content-Type `application/oauth-authz-req+jwt`.
+ *
+ * Client Identifier Prefix is always `x509_san_dns` — other prefixes deferred.
+ */
+declare function createSignedAuthorizationRequest(input: SignedAuthorizationRequestInput, query: DcqlQuery): Promise<SignedAuthorizationRequest>;
+
 interface HaipQueryInput {
     credentialId: string;
     format: 'dc+sd-jwt' | 'mso_mdoc';
@@ -293,6 +333,12 @@ interface VerifyResult {
     submission: DcqlSubmission | null;
     valid: boolean;
 }
+interface EncryptedResponse {
+    response: string;
+}
+type VerifyAuthorizationResponseOptions = VerifyOptions & {
+    decryptionKey?: CryptoKey;
+};
 
 /**
  * Parses a VP token, then matches it against a DCQL query.
@@ -306,6 +352,34 @@ interface VerifyResult {
  * @param options parse + verify options (nonce, trusted issuers, etc.)
  */
 declare function verifyPresentation(vpToken: unknown, query: DcqlQuery, options: VerifyOptions): Promise<VerifyResult>;
+/**
+ * Verify an OpenID4VP 1.0 §8.1 Authorization Response envelope.
+ *
+ * Accepts either the unencrypted envelope (object-keyed `vp_token`) or a
+ * JWE-wrapped envelope `{ response: '<JWE>' }` for response_mode =
+ * direct_post.jwt. When encrypted, decrypts with `options.decryptionKey`
+ * first. For this release only single-credential single-presentation is
+ * supported — multi-credential envelopes throw
+ * {@link MultipleCredentialsNotSupportedError}. Otherwise delegates the
+ * extracted single presentation to the existing {@link verifyPresentation}.
+ *
+ * Callers MUST compare the envelope's `state` against the value they issued
+ * themselves — library is stateless and does not track state.
+ */
+declare function verifyAuthorizationResponse(envelope: AuthorizationResponse | EncryptedResponse, query: DcqlQuery, options: VerifyAuthorizationResponseOptions): Promise<VerifyResult>;
+
+/**
+ * Decrypt a JWE-wrapped OpenID4VP Authorization Response (response_mode =
+ * direct_post.jwt). Returns the inner §8.1 envelope.
+ *
+ * Supported JWE algorithms (others throw UnsupportedJweError):
+ *   - alg: ECDH-ES
+ *   - enc: A128GCM, A256GCM (HAIP requires both)
+ *
+ * Cryptographic failures (wrong key, tampered ciphertext) throw
+ * DecryptionFailedError.
+ */
+declare function decryptAuthorizationResponse(jwe: string, privateKey: CryptoKey): Promise<AuthorizationResponse>;
 
 /**
  * SD-JWT VC credential parser.
@@ -416,6 +490,33 @@ declare class LotlFetchError extends OpenID4VPError {
 declare class LotlSignatureError extends OpenID4VPError {
     readonly code: "lotl_signature_invalid";
 }
+type SignedRequestBuildErrorCode = 'empty_cert_chain' | 'hostname_cert_mismatch' | 'signing_key_cert_mismatch' | 'missing_encryption_jwk' | 'missing_encryption_alg' | 'missing_vp_formats' | 'unsupported_signing_alg' | 'empty_supported_enc_values';
+declare class SignedRequestBuildError extends OpenID4VPError {
+    readonly code: SignedRequestBuildErrorCode;
+    constructor(code: SignedRequestBuildErrorCode, message: string);
+}
+declare class UnsupportedJweError extends OpenID4VPError {
+    readonly code: "unsupported_jwe";
+    readonly alg: string;
+    readonly enc: string;
+    constructor(alg: string, enc: string);
+}
+declare class DecryptionFailedError extends OpenID4VPError {
+    readonly code: "decryption_failed";
+    constructor(message?: string, options?: {
+        cause?: Error;
+    });
+}
+declare class MissingDecryptionKeyError extends OpenID4VPError {
+    readonly code: "missing_decryption_key";
+    constructor(message?: string);
+}
+declare class MultipleCredentialsNotSupportedError extends OpenID4VPError {
+    readonly code: "multi_credential_unsupported";
+    readonly entryCount: number;
+    readonly presentationCount: number;
+    constructor(entryCount: number, presentationCount: number);
+}
 
 interface LotlTrustStoreOptions {
     /** Override the bundled signing anchors. Empty is rejected. */
@@ -454,6 +555,6 @@ declare class LotlTrustStore implements TrustStore {
     private refresh;
 }
 
-declare const VERSION = "0.5.0";
+declare const VERSION = "0.7.0";
 
-export { type AuthorizationRequest, type AuthorizationRequestInput, type Cache, CertificateChainError, type ChainErrorReason, CompositeTrustStore, type CredentialClaims, type CredentialFormat, ExpiredCredentialError, type Fetcher, HAIP_DOCTYPE_NAMESPACES, type HaipQueryInput, type HaipValidationCode, HaipValidationError, type ICredentialParser, InMemoryCache, InvalidSignatureError, type IssuerInfo, type LotlAnchorMetadata, LotlFetchError, LotlSignatureError, LotlTrustStore, type LotlTrustStoreOptions, MalformedCredentialError, MdocParser, NonceValidationError, OpenID4VPError, type ParseOptions, type PresentationResult, RevocationCheckFailedError, RevokedCertificateError, SdJwtParser, StaticTrustStore, type TrustAnchor, TrustAnchorNotFoundError, type TrustStore, type TrustStoreHint, type TrustStoreInput, UnsupportedFormatError, VERSION, type VerifyOptions, type VerifyResult, buildHaipQuery, createAuthorizationRequest, isHaipQuery, parsePresentation, validateHaipQuery, verifyPresentation };
+export { type AuthorizationRequest, type AuthorizationRequestInput, type AuthorizationResponse, type Cache, CertificateChainError, type ChainErrorReason, CompositeTrustStore, type CredentialClaims, type CredentialFormat, DecryptionFailedError, type EncryptedResponse, ExpiredCredentialError, type Fetcher, HAIP_DOCTYPE_NAMESPACES, type HaipQueryInput, type HaipValidationCode, HaipValidationError, type ICredentialParser, InMemoryCache, InvalidSignatureError, type IssuerInfo, type LotlAnchorMetadata, LotlFetchError, LotlSignatureError, LotlTrustStore, type LotlTrustStoreOptions, MalformedCredentialError, MdocParser, MissingDecryptionKeyError, MultipleCredentialsNotSupportedError, NonceValidationError, OpenID4VPError, type ParseOptions, type PresentationResult, RevocationCheckFailedError, RevokedCertificateError, SdJwtParser, type SignedAuthorizationRequest, type SignedAuthorizationRequestInput, SignedRequestBuildError, type SignedRequestBuildErrorCode, StaticTrustStore, type TrustAnchor, TrustAnchorNotFoundError, type TrustStore, type TrustStoreHint, type TrustStoreInput, UnsupportedFormatError, UnsupportedJweError, VERSION, type VerifyAuthorizationResponseOptions, type VerifyOptions, type VerifyResult, buildHaipQuery, createAuthorizationRequest, createSignedAuthorizationRequest, decryptAuthorizationResponse, isHaipQuery, parsePresentation, validateHaipQuery, verifyAuthorizationResponse, verifyPresentation };

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;
+      }
+    };
   }
 });
 
@@ -8024,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 = {
@@ -8250,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;
@@ -8296,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}`);
       }
     }
@@ -8415,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;
@@ -8551,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) {
@@ -8562,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,
@@ -8677,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;
@@ -8800,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) {
@@ -8811,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");
         }
@@ -8908,6 +9078,44 @@ async function parsePresentation(vpToken, options) {
     error: "Unsupported credential format"
   };
 }
+
+// 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
+    });
+  }
+  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);
+  }
+  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
+    });
+  }
+}
+
+// src/verify.ts
+init_errors();
 var INTERNAL_TO_DCQL_FORMAT = {
   "sd-jwt-vc": "dc+sd-jwt",
   mdoc: "mso_mdoc"
@@ -8939,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();
@@ -9550,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:
@@ -9620,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