# Financial-grade-API-Client (FAPI 2.0)

Einen Client an das FAPI 2.0 Security Profile anpassen: Private Key JWT, Pushed Authorization Requests und sender-gebundene Token per DPoP.

Requires: fapi

> **Hinweis:** Verfügbar mit dem Advanced- und Pro-Abonnement.

Wird eine Anwendung auf das **FAPI 2.0 Security Profile** umgestellt, ändert sich, was ihr Client senden muss. Ein Client, der vorher funktionierte, hört auf zu funktionieren: Das Profil ersetzt das Client-Secret durch eine signierte Assertion, verlangt, dass der Authorisierungs-Request zuerst über einen Back-Channel übermittelt wird, und stellt Access Token aus, die an einen Schlüssel des Clients gebunden sind.

Diese Anleitung behandelt nur die Unterschiede zum [Authorization-Code-Flow mit PKCE](https://dts-identity.com/de/docs/quickstarts/oidc-authorization-code.md). Lesen Sie diese Anleitung zuerst.

## Was sich ändert

| | Standard-Client | FAPI-2.0-Client |
|---|---|---|
| Client-Authentifizierung | Client-Secret | Private Key JWT, mit PS256 signiert |
| Authorisierungs-Request | Parameter in der Browser-URL | Zuerst übermittelt, Browser erhält eine `request_uri` |
| PKCE | Empfohlen | Erforderlich, S256 |
| Access Token | `Bearer` | `DPoP`, an Ihren Schlüssel gebunden |
| Token-Requests | Ein Aufruf | Zwei beim ersten Kontakt, wegen der DPoP-Nonce |

## Bevor Sie beginnen

1. **Erzeugen Sie ein Schlüsselpaar** für die Client-Authentifizierung. RSA (mindestens 2048 Bit) oder EC auf der Kurve P-256.
2. **Hinterlegen Sie den öffentlichen Schlüssel** an der Anwendung und schalten Sie sie dann auf das FAPI-2.0-Profil um. Die einzuhaltende Reihenfolge steht unter [Financial-grade API security](https://dts-identity.com/de/docs/integrations/applications.md#financial-grade-api-security).
3. **Erzeugen Sie ein zweites Schlüsselpaar** für die DPoP-Proofs. Halten Sie es getrennt vom Schlüssel der Client-Authentifizierung, damit jeder Schlüssel genau eine Aufgabe hat.
4. **Lesen Sie das Discovery-Dokument.** Es führt jetzt zusätzlich `pushed_authorization_request_endpoint`, und `dpop_signing_alg_values_supported` nennt die für Proofs zulässigen Algorithmen.

   ```
   https://<your-domain>/.well-known/openid-configuration
   ```

Stellt die von Ihrer Anwendung aufgerufene API JWT-Access-Token aus, setzen Sie auch deren Signing Algorithm auf PS256. Siehe [APIs](https://dts-identity.com/de/docs/integrations/apis.md#resource-indicators-and-tokens).

## 1. Eine Client Assertion erzeugen

Jeder Aufruf, der bisher das Client-Secret trug, trägt jetzt ein kurzlebiges JWT, signiert mit dem privaten Schlüssel Ihrer Client-Authentifizierung. Die Beispiele verwenden die JOSE-Bibliothek des jeweiligen Stacks: [`jose`](https://www.npmjs.com/package/jose) für Node.js, [`PyJWT`](https://pypi.org/project/PyJWT/) (mit dem `crypto`-Extra) für Python, Nimbus JOSE + JWT für Java, `Microsoft.IdentityModel.JsonWebTokens` für C#, `lestrrat-go/jwx` für Go, `web-token/jwt-framework` für PHP und `josekit` für Rust.

```js tab="Node.js" tab-group="lang"
import * as jose from 'jose';

const ISSUER = 'https://<your-domain>';
const CLIENT_ID = '<your-client-id>';

// Your client-authentication private key, plus the key id shown next to the
// registered key in the Admin Console.
const authKey = await jose.importPKCS8(process.env.CLIENT_AUTH_PRIVATE_KEY, 'PS256');
const KID = '<key-id-from-the-console>';

function clientAssertion() {
  return new jose.SignJWT({ jti: crypto.randomUUID() })
    .setProtectedHeader({ alg: 'PS256', kid: KID, typ: 'JWT' })
    .setIssuer(CLIENT_ID)
    .setSubject(CLIENT_ID)
    .setAudience(ISSUER)          // the issuer identifier, not the endpoint URL
    .setIssuedAt()
    .setExpirationTime('2m')
    .sign(authKey);
}
```

```python tab="Python" tab-group="lang"
import os
import time
import uuid

import jwt

ISSUER = "https://<your-domain>"
CLIENT_ID = "<your-client-id>"

# Your client-authentication private key, plus the key id shown next to the
# registered key in the Admin Console.
AUTH_KEY = os.environ["CLIENT_AUTH_PRIVATE_KEY"]
KID = "<key-id-from-the-console>"

def client_assertion():
    now = int(time.time())
    return jwt.encode(
        {
            "jti": str(uuid.uuid4()),
            "iss": CLIENT_ID,
            "sub": CLIENT_ID,
            "aud": ISSUER,  # the issuer identifier, not the endpoint URL
            "iat": now,
            "exp": now + 120,
        },
        AUTH_KEY,
        algorithm="PS256",
        headers={"kid": KID},
    )
```

```java tab="Java" tab-group="lang"
import com.nimbusds.jose.*;
import com.nimbusds.jose.crypto.RSASSASigner;
import com.nimbusds.jose.jwk.JWK;
import com.nimbusds.jwt.JWTClaimsSet;
import com.nimbusds.jwt.SignedJWT;
import java.time.Instant;
import java.util.Date;
import java.util.UUID;

static final String ISSUER = "https://<your-domain>";
static final String CLIENT_ID = "<your-client-id>";

// The key id shown next to the registered key in the Admin Console.
static final String KID = "<key-id-from-the-console>";

static String clientAssertion() throws Exception {
    // Your client-authentication private key
    var authKey = JWK.parseFromPEMEncodedObjects(System.getenv("CLIENT_AUTH_PRIVATE_KEY")).toRSAKey();
    var claims = new JWTClaimsSet.Builder()
        .jwtID(UUID.randomUUID().toString())
        .issuer(CLIENT_ID)
        .subject(CLIENT_ID)
        .audience(ISSUER) // the issuer identifier, not the endpoint URL
        .issueTime(new Date())
        .expirationTime(Date.from(Instant.now().plusSeconds(120)))
        .build();
    var jwt = new SignedJWT(
        new JWSHeader.Builder(JWSAlgorithm.PS256).keyID(KID).type(JOSEObjectType.JWT).build(),
        claims);
    jwt.sign(new RSASSASigner(authKey));
    return jwt.serialize();
}
```

```csharp tab="C#" tab-group="lang"
using System.Security.Cryptography;
using Microsoft.IdentityModel.JsonWebTokens;
using Microsoft.IdentityModel.Tokens;

const string Issuer = "https://<your-domain>";
const string ClientId = "<your-client-id>";

// Your client-authentication private key, plus the key id shown next to the
// registered key in the Admin Console.
var authRsa = RSA.Create();
authRsa.ImportFromPem(Environment.GetEnvironmentVariable("CLIENT_AUTH_PRIVATE_KEY"));
var authKey = new RsaSecurityKey(authRsa) { KeyId = "<key-id-from-the-console>" };

string ClientAssertion() => new JsonWebTokenHandler().CreateToken(new SecurityTokenDescriptor
{
    Issuer = ClientId,
    Audience = Issuer, // the issuer identifier, not the endpoint URL
    Claims = new Dictionary<string, object> { ["sub"] = ClientId, ["jti"] = Guid.NewGuid().ToString() },
    Expires = DateTime.UtcNow.AddMinutes(2),
    SigningCredentials = new SigningCredentials(authKey, SecurityAlgorithms.RsaSsaPssSha256), // PS256
});
```

```go tab="Go" tab-group="lang"
import (
	"os"
	"time"

	"github.com/google/uuid"
	"github.com/lestrrat-go/jwx/v2/jwa"
	"github.com/lestrrat-go/jwx/v2/jwk"
	"github.com/lestrrat-go/jwx/v2/jwt"
)

const issuer = "https://<your-domain>"
const clientID = "<your-client-id>"

// Your client-authentication private key, plus the key id shown next to the
// registered key in the Admin Console.
var authKey, _ = jwk.ParseKey([]byte(os.Getenv("CLIENT_AUTH_PRIVATE_KEY")), jwk.WithPEM(true))

const kid = "<key-id-from-the-console>"

func clientAssertion() []byte {
	authKey.Set(jwk.KeyIDKey, kid)
	token, _ := jwt.NewBuilder().
		JwtID(uuid.NewString()).
		Issuer(clientID).
		Subject(clientID).
		Audience([]string{issuer}). // the issuer identifier, not the endpoint URL
		IssuedAt(time.Now()).
		Expiration(time.Now().Add(2*time.Minute)).
		Build()
	signed, _ := jwt.Sign(token, jwt.WithKey(jwa.PS256, authKey))
	return signed
}
```

```php tab="PHP" tab-group="lang"
use Jose\Component\Core\AlgorithmManager;
use Jose\Component\KeyManagement\JWKFactory;
use Jose\Component\Signature\Algorithm\PS256;
use Jose\Component\Signature\JWSBuilder;
use Jose\Component\Signature\Serializer\CompactSerializer;

const ISSUER = 'https://<your-domain>';
const CLIENT_ID = '<your-client-id>';
const KID = '<key-id-from-the-console>';

// Your client-authentication private key, plus the key id shown next to the
// registered key in the Admin Console.
$authKey = JWKFactory::createFromKey(getenv('CLIENT_AUTH_PRIVATE_KEY'));

function clientAssertion($authKey): string {
    $jws = (new JWSBuilder(new AlgorithmManager([new PS256()])))
        ->create()
        ->withPayload(json_encode([
            'jti' => bin2hex(random_bytes(16)),
            'iss' => CLIENT_ID,
            'sub' => CLIENT_ID,
            'aud' => ISSUER, // the issuer identifier, not the endpoint URL
            'iat' => time(),
            'exp' => time() + 120,
        ]))
        ->addSignature($authKey, ['alg' => 'PS256', 'kid' => KID, 'typ' => 'JWT'])
        ->build();
    return (new CompactSerializer())->serialize($jws);
}
```

```rust tab="Rust" tab-group="lang"
use std::env;
use std::time::{Duration, SystemTime};

use josekit::jws::{JwsHeader, PS256};
use josekit::jwt::{self, JwtPayload};
use uuid::Uuid;

const ISSUER: &str = "https://<your-domain>";
const CLIENT_ID: &str = "<your-client-id>";

// The key id shown next to the registered key in the Admin Console.
const KID: &str = "<key-id-from-the-console>";

fn client_assertion() -> String {
    let mut header = JwsHeader::new();
    header.set_key_id(KID);
    header.set_token_type("JWT");

    let mut payload = JwtPayload::new();
    payload.set_jwt_id(Uuid::new_v4().to_string());
    payload.set_issuer(CLIENT_ID);
    payload.set_subject(CLIENT_ID);
    payload.set_audience(vec![ISSUER]); // the issuer identifier, not the endpoint URL
    payload.set_issued_at(&SystemTime::now());
    payload.set_expires_at(&(SystemTime::now() + Duration::from_secs(120)));

    // Your client-authentication private key
    let signer = PS256.signer_from_pem(env::var("CLIENT_AUTH_PRIVATE_KEY").unwrap()).unwrap();
    jwt::encode_with_signer(&payload, &header, &signer).unwrap()
}
```

Zwei Details entscheiden, ob das akzeptiert wird:

- **`aud` muss die Issuer-Kennung sein.** Ohne Profil wird auch die Endpunkt-URL akzeptiert, unter FAPI 2.0 nicht.
- **`alg` muss PS256 sein.** Das Profil legt den Signaturalgorithmus für die Assertions der Anwendung fest.

Senden Sie sie bei jedem Token- und Pushed-Authorization-Request als zwei Formularfelder:

```
client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer
client_assertion=<the JWT>
```

## 2. Den Authorisierungs-Request übermitteln

Statt die Parameter in die Browser-URL zu schreiben, senden Sie sie per POST an den Pushed-Authorization-Endpunkt. Die Antwort ist eine einmalig verwendbare Referenz.

```bash
curl -X POST https://<your-domain>/oauth/par \
  -d client_id=<your-client-id> \
  -d response_type=code \
  -d redirect_uri=https://app.example.com/callback \
  -d scope='openid profile' \
  -d code_challenge=<CODE_CHALLENGE> \
  -d code_challenge_method=S256 \
  -d client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer \
  -d client_assertion=<the JWT>
```

Ein erfolgreicher Aufruf antwortet mit `201` und:

```json
{
  "request_uri": "urn:ietf:params:oauth:request_uri:...",
  "expires_in": 60
}
```

- **`redirect_uri` muss immer mitgesendet werden**, auch wenn an der Anwendung genau eine registriert ist. Das Profil entfernt die Abkürzung, sie weglassen zu können.
- **PKCE ist hier verpflichtend**, mit `code_challenge_method=S256`. Ein übermittelter Request ohne Challenge wird abgelehnt.
- Die `request_uri` ist einmalig verwendbar und verfällt innerhalb einer Minute. Übermitteln Sie den Request, wenn der Benutzer unmittelbar weitergeleitet wird, nicht vorab.

## 3. Den Benutzer an den Authorisierungs-Endpunkt senden

Die Browser-URL trägt jetzt nur noch die Client-ID und die Referenz:

```
https://<your-domain>/authorize
  ?client_id=<your-client-id>
  &request_uri=urn%3Aietf%3Aparams%3Aoauth%3Arequest_uri%3A...
```

Die Plattform leitet den Benutzer mit `code`, `state` und einem `iss`-Parameter, der den Issuer nennt, an Ihre Redirect-URI zurück. **Prüfen Sie `iss` ebenso wie `state`**, bevor Sie fortfahren; das schützt davor, dass eine Antwort von einem anderen Issuer wiedereingespielt wird.

## 4. Einen DPoP-Proof erstellen

Ein DPoP-Proof ist ein JWT, signiert mit Ihrem privaten DPoP-Schlüssel, das den öffentlichen Schlüssel in seinem Header trägt. Es ist an genau einen Request gebunden: Methode und URL stehen darin.

```js tab="Node.js" tab-group="lang"
const dpopKey = await jose.importPKCS8(process.env.DPOP_PRIVATE_KEY, 'ES256');
const dpopPublicJwk = await jose.exportJWK(await jose.importSPKI(process.env.DPOP_PUBLIC_KEY, 'ES256'));

function dpopProof(method, url, nonce) {
  return new jose.SignJWT({ jti: crypto.randomUUID(), htm: method, htu: url, ...(nonce ? { nonce } : {}) })
    .setProtectedHeader({ alg: 'ES256', typ: 'dpop+jwt', jwk: dpopPublicJwk })
    .setIssuedAt()
    .sign(dpopKey);
}
```

```python tab="Python" tab-group="lang"
from cryptography.hazmat.primitives.serialization import load_pem_private_key
from jwt.algorithms import ECAlgorithm

dpop_key = load_pem_private_key(os.environ["DPOP_PRIVATE_KEY"].encode(), password=None)
dpop_public_jwk = ECAlgorithm.to_jwk(dpop_key.public_key(), as_dict=True)

def dpop_proof(method, url, nonce=None):
    claims = {"jti": str(uuid.uuid4()), "htm": method, "htu": url, "iat": int(time.time())}
    if nonce:
        claims["nonce"] = nonce
    return jwt.encode(
        claims, dpop_key,
        algorithm="ES256",
        headers={"typ": "dpop+jwt", "jwk": dpop_public_jwk},
    )
```

```java tab="Java" tab-group="lang"
import com.nimbusds.jose.crypto.ECDSASigner;

static String dpopProof(String method, String url, String nonce) throws Exception {
    var dpopKey = JWK.parseFromPEMEncodedObjects(System.getenv("DPOP_PRIVATE_KEY")).toECKey();

    var claims = new JWTClaimsSet.Builder()
        .jwtID(UUID.randomUUID().toString())
        .claim("htm", method)
        .claim("htu", url)
        .issueTime(new Date());
    if (nonce != null) claims.claim("nonce", nonce);

    var jwt = new SignedJWT(
        new JWSHeader.Builder(JWSAlgorithm.ES256)
            .type(new JOSEObjectType("dpop+jwt"))
            .jwk(dpopKey.toPublicJWK())
            .build(),
        claims.build());
    jwt.sign(new ECDSASigner(dpopKey));
    return jwt.serialize();
}
```

```csharp tab="C#" tab-group="lang"
var dpopEc = ECDsa.Create();
dpopEc.ImportFromPem(Environment.GetEnvironmentVariable("DPOP_PRIVATE_KEY"));
var dpopKey = new ECDsaSecurityKey(dpopEc);
var publicJwk = JsonWebKeyConverter.ConvertFromECDsaSecurityKey(
    new ECDsaSecurityKey(ECDsa.Create(dpopEc.ExportParameters(includePrivateParameters: false))));

string DpopProof(string method, string url, string? nonce = null)
{
    var claims = new Dictionary<string, object> { ["jti"] = Guid.NewGuid().ToString(), ["htm"] = method, ["htu"] = url };
    if (nonce is not null) claims["nonce"] = nonce;

    return new JsonWebTokenHandler().CreateToken(new SecurityTokenDescriptor
    {
        TokenType = "dpop+jwt",
        Claims = claims,
        SigningCredentials = new SigningCredentials(dpopKey, SecurityAlgorithms.EcdsaSha256), // ES256
        AdditionalHeaderClaims = new Dictionary<string, object>
        {
            ["jwk"] = new Dictionary<string, string>
            {
                ["kty"] = publicJwk.Kty, ["crv"] = publicJwk.Crv, ["x"] = publicJwk.X, ["y"] = publicJwk.Y,
            },
        },
    });
}
```

```go tab="Go" tab-group="lang"
import "github.com/lestrrat-go/jwx/v2/jws"

var dpopKey, _ = jwk.ParseKey([]byte(os.Getenv("DPOP_PRIVATE_KEY")), jwk.WithPEM(true))

func dpopProof(method, url, nonce string) []byte {
	dpopPublicJwk, _ := dpopKey.PublicKey()

	builder := jwt.NewBuilder().
		JwtID(uuid.NewString()).
		Claim("htm", method).
		Claim("htu", url).
		IssuedAt(time.Now())
	if nonce != "" {
		builder = builder.Claim("nonce", nonce)
	}
	token, _ := builder.Build()

	headers := jws.NewHeaders()
	headers.Set("typ", "dpop+jwt")
	headers.Set("jwk", dpopPublicJwk)
	signed, _ := jwt.Sign(token, jwt.WithKey(jwa.ES256, dpopKey, jws.WithProtectedHeaders(headers)))
	return signed
}
```

```php tab="PHP" tab-group="lang"
use Jose\Component\Signature\Algorithm\ES256;

$dpopKey = JWKFactory::createFromKey(getenv('DPOP_PRIVATE_KEY'));

function dpopProof($dpopKey, string $method, string $url, ?string $nonce = null): string {
    $claims = ['jti' => bin2hex(random_bytes(16)), 'htm' => $method, 'htu' => $url, 'iat' => time()];
    if ($nonce !== null) {
        $claims['nonce'] = $nonce;
    }
    $jws = (new JWSBuilder(new AlgorithmManager([new ES256()])))
        ->create()
        ->withPayload(json_encode($claims))
        ->addSignature($dpopKey, ['alg' => 'ES256', 'typ' => 'dpop+jwt', 'jwk' => $dpopKey->toPublic()])
        ->build();
    return (new CompactSerializer())->serialize($jws);
}
```

```rust tab="Rust" tab-group="lang"
use josekit::jws::ES256;

fn dpop_proof(method: &str, url: &str, nonce: Option<&str>) -> String {
    let pem = env::var("DPOP_PRIVATE_KEY").unwrap();
    let key_pair = ES256.key_pair_from_pem(&pem).unwrap();

    let mut header = JwsHeader::new();
    header.set_token_type("dpop+jwt");
    header.set_jwk(key_pair.to_jwk_public_key());

    let mut payload = JwtPayload::new();
    payload.set_jwt_id(Uuid::new_v4().to_string());
    payload.set_claim("htm", Some(method.into())).unwrap();
    payload.set_claim("htu", Some(url.into())).unwrap();
    payload.set_issued_at(&SystemTime::now());
    if let Some(nonce) = nonce {
        payload.set_claim("nonce", Some(nonce.into())).unwrap();
    }

    let signer = ES256.signer_from_pem(&pem).unwrap();
    jwt::encode_with_signer(&payload, &header, &signer).unwrap()
}
```

`htu` ist die Endpunkt-URL ohne Query und Fragment und muss der tatsächlich aufgerufenen URL entsprechen, inklusive Schema und Host.

## 5. Den Code eintauschen, zweimal

**Eine Server-Nonce ist erforderlich, daher scheitert der erste Token-Request immer.** Das ist erwartetes Verhalten und kein Fehler in Ihrer Einrichtung: Die Antwort liefert die Nonce für den nächsten Proof.

```bash
# First attempt: no nonce yet
curl -i -X POST https://<your-domain>/oauth/token \
  -H 'DPoP: <proof without nonce>' \
  -d grant_type=authorization_code \
  -d code=<one-time-code> \
  -d redirect_uri=https://app.example.com/callback \
  -d code_verifier=<CODE_VERIFIER> \
  -d client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer \
  -d client_assertion=<the JWT>
```

Die Antwort ist ein `400` mit `{"error":"use_dpop_nonce"}` und einem `DPoP-Nonce`-Response-Header. Lesen Sie diesen Header, erstellen Sie einen **neuen** Proof mit dem Wert als `nonce`-Claim und wiederholen Sie denselben Request:

```js tab="Node.js" tab-group="lang"
let res = await tokenRequest(dpopProof('POST', tokenUrl));
if (!res.ok) {
  const nonce = res.headers.get('dpop-nonce');
  res = await tokenRequest(dpopProof('POST', tokenUrl, nonce));
}
```

```python tab="Python" tab-group="lang"
res = token_request(dpop_proof("POST", token_url))
if not res.ok:
    nonce = res.headers.get("dpop-nonce")
    res = token_request(dpop_proof("POST", token_url, nonce))
```

```java tab="Java" tab-group="lang"
var res = tokenRequest(dpopProof("POST", tokenUrl, null));
if (res.statusCode() != 200) {
    var nonce = res.headers().firstValue("DPoP-Nonce").orElseThrow();
    res = tokenRequest(dpopProof("POST", tokenUrl, nonce));
}
```

```csharp tab="C#" tab-group="lang"
var res = await TokenRequest(DpopProof("POST", tokenUrl));
if (!res.IsSuccessStatusCode && res.Headers.TryGetValues("DPoP-Nonce", out var nonces))
{
    res = await TokenRequest(DpopProof("POST", tokenUrl, nonces.First()));
}
```

```go tab="Go" tab-group="lang"
res, _ := tokenRequest(dpopProof("POST", tokenURL, ""))
if res.StatusCode != http.StatusOK {
	nonce := res.Header.Get("DPoP-Nonce")
	res, _ = tokenRequest(dpopProof("POST", tokenURL, nonce))
}
```

```php tab="PHP" tab-group="lang"
$res = tokenRequest(dpopProof($dpopKey, 'POST', $tokenUrl));
if ($res->getStatusCode() !== 200) {
    $nonce = $res->getHeaderLine('DPoP-Nonce');
    $res = tokenRequest(dpopProof($dpopKey, 'POST', $tokenUrl, $nonce));
}
```

```rust tab="Rust" tab-group="lang"
let mut res = token_request(dpop_proof("POST", token_url, None)).await?;
if !res.status().is_success() {
    let nonce = res.headers().get("dpop-nonce").and_then(|v| v.to_str().ok()).map(String::from);
    res = token_request(dpop_proof("POST", token_url, nonce.as_deref())).await?;
}
```

Eine Nonce bleibt eine Weile gültig, halten Sie die letzte erhaltene also vor und beginnen Sie den nächsten Request damit. Behandeln Sie `use_dpop_nonce` jederzeit: Läuft eine Nonce ab, wiederholt sich derselbe Austausch.

Eine erfolgreiche Antwort unterscheidet sich in einem einzigen, wichtigen Punkt von einer gewöhnlichen:

```json
{
  "token_type": "DPoP",
  "access_token": "...",
  "id_token": "...",
  "expires_in": 3600
}
```

## 6. APIs mit dem Token aufrufen

`token_type` ist `DPoP`, nicht `Bearer`, und der Token ist an Ihren DPoP-Schlüssel gebunden. Jeder Aufruf einer Ressource benötigt sowohl den Token als auch einen frischen Proof für **diesen** Request:

```bash
curl https://api.example.com/orders \
  -H 'Authorization: DPoP <access_token>' \
  -H 'DPoP: <proof for GET https://api.example.com/orders>'
```

Den Token als `Authorization: Bearer` zu senden schlägt fehl. Eine Ressource, die die Bindung prüft, vergleicht den Schlüssel im Proof mit dem Confirmation-Claim im Token, sodass ein gestohlener Token ohne den privaten Schlüssel nutzlos ist.

## Fehlerbehebung

- **`use_dpop_nonce` bei jedem Request.** Dem Proof fehlt der `nonce`-Claim, oder Sie haben den vorherigen Proof erneut verwendet statt einen neuen zu signieren. Jeder Proof ist einmalig verwendbar.
- **`invalid_client`, obwohl dieselbe Einrichtung vor dem Profil funktionierte.** Entweder ist `aud` der Assertion die Endpunkt-URL statt der Issuer-Kennung, oder sie ist nicht mit PS256 signiert, oder die `kid` passt zu keinem hinterlegten Schlüssel.
- **`invalid_dpop_proof`.** Die `htu` entspricht nicht der aufgerufenen URL (häufige Ursache: ein Proxy, der den Host umschreibt), oder `htm` passt nicht zur Methode, oder die Uhr weicht um mehr als eine geringe Toleranz ab.
- **`invalid_request` am Authorisierungs-Endpunkt.** Die Anwendung verlangt einen übermittelten Request, Parameter können also nicht mehr in der Browser-URL gesendet werden. Übermitteln Sie sie zuerst und übergeben Sie die `request_uri`.
- **Die `request_uri` wird als unbekannt abgelehnt.** Sie wurde bereits verwendet oder ist verfallen. Übermitteln Sie einen neuen Request.
- **Die Ressource lehnt den Token ab.** Prüfen Sie, ob er mit dem Schema `DPoP` gesendet wird und ob die Ressource die Bindung prüft, statt einen Bearer Token zu erwarten.

## Siehe auch

- [Financial-grade API security](https://dts-identity.com/de/docs/integrations/applications.md#financial-grade-api-security) für die Einstellungen an der Anwendung und was das Profil erzwingt.
- [APIs](https://dts-identity.com/de/docs/integrations/apis.md#resource-indicators-and-tokens) für den Signaturalgorithmus der Access Token.
- [OpenID Connect (Authorization Code + PKCE)](https://dts-identity.com/de/docs/quickstarts/oidc-authorization-code.md) für den Basis-Flow.
