feat(openid4vci): client compliance (issue #3152)

auth/api/iam/session.go

@@ -55,6 +55,12 @@ type OAuthSession struct {
 	UseDPoP   bool   `json:"use_dpop,omitempty"`
 	// IssuerCredentialEndpoint: endpoint to exchange the access_token for a credential in the OpenID4VCI flow
 	IssuerCredentialEndpoint string `json:"issuer_credential_endpoint,omitempty"`
+	// IssuerNonceEndpoint: endpoint to request a fresh c_nonce in the OpenID4VCI flow (v1.0 Section 7)
+	IssuerNonceEndpoint string `json:"issuer_nonce_endpoint,omitempty"`
+	// IssuerCredentialConfigurationID: the credential_configuration_id for the credential request in the OpenID4VCI flow
+	IssuerCredentialConfigurationID string `json:"issuer_credential_configuration_id,omitempty"`
+	// ProofSigningAlgValuesSupported: algorithms the issuer accepts for proof JWTs (v1.0 Appendix F.1)
+	ProofSigningAlgValuesSupported []string `json:"proof_signing_alg_values_supported,omitempty"`
 }
 
 // oauthClientFlow is used by a client to identify the flow a particular callback is part of

auth/client/iam/client.go

@@ -21,6 +21,7 @@ package iam
 import (
 	"bytes"
 	"context"
+	stdcrypto "crypto"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -38,6 +39,7 @@ import (
 	"github.com/nuts-foundation/nuts-node/auth/log"
 	"github.com/nuts-foundation/nuts-node/auth/oauth"
 	"github.com/nuts-foundation/nuts-node/core"
+	"github.com/nuts-foundation/nuts-node/vcr/openid4vci"
 	"github.com/nuts-foundation/nuts-node/vcr/pe"
 )
 
@@ -242,6 +244,35 @@ func (hb HTTPClient) PostAuthorizationResponse(ctx context.Context, vp vc.Verifi
 	return hb.postFormExpectRedirect(ctx, data, verifierResponseURI)
 }
 
+func (hb HTTPClient) RequestNonce(ctx context.Context, nonceEndpoint string) (string, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodPost, nonceEndpoint, http.NoBody)
+	if err != nil {
+		return "", err
+	}
+	response, err := hb.httpClient.Do(request)
+	if err != nil {
+		return "", fmt.Errorf("nonce request failed: %w", err)
+	}
+	defer response.Body.Close()
+	data, err := io.ReadAll(response.Body)
+	if err != nil {
+		return "", fmt.Errorf("unable to read nonce response: %w", err)
+	}
+	if response.StatusCode < 200 || response.StatusCode > 299 {
+		return "", fmt.Errorf("nonce endpoint returned status %d", response.StatusCode)
+	}
+	var nonceResponse struct {
+		CNonce string `json:"c_nonce"`
+	}
+	if err = json.Unmarshal(data, &nonceResponse); err != nil {
+		return "", fmt.Errorf("unable to unmarshal nonce response: %w", err)
+	}
+	if nonceResponse.CNonce == "" {
+		return "", errors.New("nonce endpoint returned empty c_nonce")
+	}
+	return nonceResponse.CNonce, nil
+}
+
 func (hb HTTPClient) OpenIdCredentialIssuerMetadata(ctx context.Context, oauthIssuerURI string) (*oauth.OpenIDCredentialIssuerMetadata, error) {
 	metadataURL, err := oauth.IssuerIdToWellKnown(oauthIssuerURI, oauth.OpenIdCredIssuerWellKnown, hb.strictMode)
 	if err != nil {
@@ -252,7 +283,56 @@ func (hb HTTPClient) OpenIdCredentialIssuerMetadata(ctx context.Context, oauthIs
 	if err != nil {
 		return nil, err
 	}
-	return &metadata, err
+	if metadata.SignedMetadata != "" {
+		if err = hb.verifySignedMetadata(ctx, &metadata); err != nil {
+			return nil, fmt.Errorf("signed_metadata verification failed: %w", err)
+		}
+	}
+	return &metadata, nil
+}
+
+// verifySignedMetadata verifies the signed_metadata JWT against the issuer's key (v1.0 Section 12.2.3).
+// It validates the JWT signature, typ header, required claims (sub, iat), and compares
+// key metadata claims (credential_issuer, credential_endpoint) against the unsigned metadata.
+func (hb HTTPClient) verifySignedMetadata(ctx context.Context, metadata *oauth.OpenIDCredentialIssuerMetadata) error {
+	// Verify typ header to prevent JWT type confusion attacks
+	typ, err := crypto.JWTTyp(metadata.SignedMetadata)
+	if err != nil {
+		return fmt.Errorf("invalid JWT: %w", err)
+	}
+	if typ != "openidvci-issuer-metadata+jwt" {
+		return fmt.Errorf("typ header must be openidvci-issuer-metadata+jwt, got %q", typ)
+	}
+	// Parse, verify signature, and validate standard claims using shared infrastructure
+	token, err := crypto.ParseJWT(metadata.SignedMetadata, func(kid string) (stdcrypto.PublicKey, error) {
+		return hb.keyResolver.ResolveKeyByID(kid, nil, resolver.AssertionMethod)
+	}, jwt.WithValidate(true), jwt.WithAcceptableSkew(5*time.Second))
+	if err != nil {
+		return fmt.Errorf("invalid JWT: %w", err)
+	}
+	// sub is REQUIRED, must match credential_issuer. iss is OPTIONAL per spec.
+	if token.Subject() != metadata.CredentialIssuer {
+		return fmt.Errorf("sub %q does not match credential_issuer %q", token.Subject(), metadata.CredentialIssuer)
+	}
+	if token.IssuedAt().IsZero() {
+		return fmt.Errorf("iat claim is required")
+	}
+	// Compare metadata claims from JWT payload against unsigned metadata
+	claims, err := token.AsMap(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to extract claims: %w", err)
+	}
+	if ci, _ := claims["credential_issuer"].(string); ci != metadata.CredentialIssuer {
+		return fmt.Errorf("credential_issuer claim %q does not match metadata %q", ci, metadata.CredentialIssuer)
+	}
+	ce, _ := claims["credential_endpoint"].(string)
+	if ce == "" {
+		return fmt.Errorf("credential_endpoint claim is required in signed metadata")
+	}
+	if ce != metadata.CredentialEndpoint {
+		return fmt.Errorf("credential_endpoint claim %q does not match metadata %q", ce, metadata.CredentialEndpoint)
+	}
+	return nil
 }
 
 func (hb HTTPClient) OpenIDConfiguration(ctx context.Context, issuerURL string) (*oauth.OpenIDConfiguration, error) {
@@ -308,34 +388,49 @@ func (hb HTTPClient) KeyProvider() jws.KeyProviderFunc {
 	}
 }
 
-// CredentialRequest represents ths request to fetch a credential, the JSON object holds the proof as
-// CredentialRequestProof.
-type CredentialRequest struct {
-	Proof CredentialRequestProof `json:"proof"`
-}
-
-// CredentialRequestProof holds the ProofType and Jwt for a credential request
-type CredentialRequestProof struct {
-	ProofType string `json:"proof_type"`
-	Jwt       string `json:"jwt"`
-}
-
-// CredentialResponse represents the response of a verifiable credential request.
-// It contains the Format and the actual Credential in JSON format.
-type CredentialResponse struct {
-	Credential string `json:"credential"`
+func (hb HTTPClient) PushedAuthorizationRequest(ctx context.Context, parEndpoint string, params url.Values) (*PARResponse, error) {
+	request, err := http.NewRequestWithContext(ctx, http.MethodPost, parEndpoint, strings.NewReader(params.Encode()))
+	if err != nil {
+		return nil, err
+	}
+	request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	response, err := hb.httpClient.Do(request)
+	if err != nil {
+		return nil, fmt.Errorf("PAR request failed: %w", err)
+	}
+	defer response.Body.Close()
+	data, err := io.ReadAll(response.Body)
+	if err != nil {
+		return nil, fmt.Errorf("unable to read PAR response: %w", err)
+	}
+	if response.StatusCode != http.StatusCreated {
+		bodySnippet := string(data)
+		if len(bodySnippet) > core.HttpResponseBodyLogClipAt {
+			bodySnippet = bodySnippet[:core.HttpResponseBodyLogClipAt] + "...(clipped)"
+		}
+		return nil, fmt.Errorf("PAR endpoint returned HTTP %d (expected: 201): %s", response.StatusCode, bodySnippet)
+	}
+	var parResponse PARResponse
+	if err = json.Unmarshal(data, &parResponse); err != nil {
+		return nil, fmt.Errorf("unable to unmarshal PAR response: %w", err)
+	}
+	if !strings.HasPrefix(parResponse.RequestURI, "urn:ietf:params:oauth:request_uri:") {
+		return nil, fmt.Errorf("PAR response contains invalid request_uri: %q", parResponse.RequestURI)
+	}
+	return &parResponse, nil
 }
 
-func (hb HTTPClient) VerifiableCredentials(ctx context.Context, credentialEndpoint string, accessToken string, proofJwt string) (*CredentialResponse, error) {
+func (hb HTTPClient) VerifiableCredentials(ctx context.Context, credentialEndpoint string, accessToken string, credentialConfigID string, credentialIdentifier string, proofJwt string) (*openid4vci.CredentialResponse, error) {
 	credentialEndpointURL, err := url.Parse(credentialEndpoint)
 	if err != nil {
 		return nil, err
 	}
 
-	credentialRequest := CredentialRequest{
-		Proof: CredentialRequestProof{
-			ProofType: "jwt",
-			Jwt:       proofJwt,
+	credentialRequest := openid4vci.CredentialRequest{
+		CredentialConfigurationID: credentialConfigID,
+		CredentialIdentifier:      credentialIdentifier,
+		Proofs: &openid4vci.CredentialRequestProofs{
+			Jwt: []string{proofJwt},
 		},
 	}
 	jsonBody, _ := json.Marshal(credentialRequest)
@@ -357,15 +452,23 @@ func (hb HTTPClient) VerifiableCredentials(ctx context.Context, credentialEndpoi
 			log.Logger().WithError(err).Warn("Trouble closing reader")
 		}
 	}(response.Body)
-	if err = core.TestResponseCode(http.StatusOK, response); err != nil {
-		return nil, err
+	responseBody, err := io.ReadAll(response.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
 	}
-	var credential CredentialResponse
-	if err = json.NewDecoder(response.Body).Decode(&credential); err != nil {
+	if response.StatusCode < 200 || response.StatusCode > 299 {
+		var oidcError openid4vci.Error
+		if json.Unmarshal(responseBody, &oidcError) == nil && oidcError.Code != "" {
+			oidcError.StatusCode = response.StatusCode
+			return nil, oidcError
+		}
+		return nil, fmt.Errorf("credential request failed (status %d)", response.StatusCode)
+	}
+	var credentialResponse openid4vci.CredentialResponse
+	if err = json.Unmarshal(responseBody, &credentialResponse); err != nil {
 		return nil, fmt.Errorf("failed to decode response: %w", err)
 	}
-	return &credential, nil
-
+	return &credentialResponse, nil
 }
 func (hb HTTPClient) postFormExpectRedirect(ctx context.Context, form url.Values, redirectURL url.URL) (string, error) {
 	request, err := http.NewRequestWithContext(ctx, http.MethodPost, redirectURL.String(), strings.NewReader(form.Encode()))

auth/client/iam/interface.go

@@ -20,11 +20,20 @@ package iam
 
 import (
 	"context"
+	"net/url"
+
 	"github.com/nuts-foundation/go-did/vc"
 	"github.com/nuts-foundation/nuts-node/auth/oauth"
+	"github.com/nuts-foundation/nuts-node/vcr/openid4vci"
 	"github.com/nuts-foundation/nuts-node/vcr/pe"
 )
 
+// PARResponse holds the response from a Pushed Authorization Request (RFC 9126).
+type PARResponse struct {
+	RequestURI string `json:"request_uri"`
+	ExpiresIn  int    `json:"expires_in"`
+}
+
 // Client defines OpenID4VP client methods using the IAM OpenAPI Spec.
 type Client interface {
 	// AccessToken requests an access token at the oauth2 token endpoint.
@@ -52,8 +61,13 @@ type Client interface {
 	OpenIdCredentialIssuerMetadata(ctx context.Context, oauthIssuerURI string) (*oauth.OpenIDCredentialIssuerMetadata, error)
 	// OpenIDConfiguration returns the OpenID Configuration of the remote wallet.
 	OpenIDConfiguration(ctx context.Context, issuer string) (*oauth.OpenIDConfiguration, error)
+	// RequestNonce requests a fresh c_nonce from the issuer's Nonce Endpoint (v1.0 Section 7).
+	RequestNonce(ctx context.Context, nonceEndpoint string) (string, error)
 	// VerifiableCredentials requests Verifiable Credentials from the issuer at the given endpoint.
-	VerifiableCredentials(ctx context.Context, credentialEndpoint string, accessToken string, proofJWT string) (*CredentialResponse, error)
+	// Either credentialConfigID or credentialIdentifier must be non-empty (mutually exclusive per v1.0 Section 8.2).
+	VerifiableCredentials(ctx context.Context, credentialEndpoint string, accessToken string, credentialConfigID string, credentialIdentifier string, proofJWT string) (*openid4vci.CredentialResponse, error)
+	// PushedAuthorizationRequest sends a Pushed Authorization Request (RFC 9126) to the given endpoint.
+	PushedAuthorizationRequest(ctx context.Context, parEndpoint string, params url.Values) (*PARResponse, error)
 	// RequestObjectByGet retrieves the RequestObjectByGet from the authorization request's 'request_uri' endpoint using a GET method as defined in RFC9101/OpenID4VP.
 	// This method is used when there is no 'request_uri_method', or its value is 'get'.
 	RequestObjectByGet(ctx context.Context, requestURI string) (string, error)

auth/client/iam/openid4vp.go

@@ -43,6 +43,7 @@ import (
 	"github.com/nuts-foundation/nuts-node/crypto/dpop"
 	nutsHttp "github.com/nuts-foundation/nuts-node/http"
 	"github.com/nuts-foundation/nuts-node/vcr/holder"
+	"github.com/nuts-foundation/nuts-node/vcr/openid4vci"
 	"github.com/nuts-foundation/nuts-node/vcr/pe"
 	"github.com/nuts-foundation/nuts-node/vdr/resolver"
 )
@@ -355,11 +356,23 @@ func (c *OpenID4VPClient) OpenIdCredentialIssuerMetadata(ctx context.Context, oa
 	return rsp, nil
 }
 
-func (c *OpenID4VPClient) VerifiableCredentials(ctx context.Context, credentialEndpoint string, accessToken string, proofJWT string) (*CredentialResponse, error) {
+func (c *OpenID4VPClient) RequestNonce(ctx context.Context, nonceEndpoint string) (string, error) {
+	return c.httpClient.RequestNonce(ctx, nonceEndpoint)
+}
+
+func (c *OpenID4VPClient) PushedAuthorizationRequest(ctx context.Context, parEndpoint string, params url.Values) (*PARResponse, error) {
+	parsedURL, err := core.ParsePublicURL(parEndpoint, c.strictMode)
+	if err != nil {
+		return nil, fmt.Errorf("invalid PAR endpoint: %w", err)
+	}
+	return c.httpClient.PushedAuthorizationRequest(ctx, parsedURL.String(), params)
+}
+
+func (c *OpenID4VPClient) VerifiableCredentials(ctx context.Context, credentialEndpoint string, accessToken string, credentialConfigID string, credentialIdentifier string, proofJWT string) (*openid4vci.CredentialResponse, error) {
 	iamClient := c.httpClient
-	rsp, err := iamClient.VerifiableCredentials(ctx, credentialEndpoint, accessToken, proofJWT)
+	rsp, err := iamClient.VerifiableCredentials(ctx, credentialEndpoint, accessToken, credentialConfigID, credentialIdentifier, proofJWT)
 	if err != nil {
-		return nil, fmt.Errorf("remote server: failed to retrieve credentials: %w", err)
+		return nil, err
 	}
 	return rsp, nil
 }