Skip to Content

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.

Requiresfapi

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. Lesen Sie diese Anleitung zuerst.

Was sich ändert

Standard-ClientFAPI-2.0-Client
Client-AuthentifizierungClient-SecretPrivate Key JWT, mit PS256 signiert
Authorisierungs-RequestParameter in der Browser-URLZuerst übermittelt, Browser erhält eine request_uri
PKCEEmpfohlenErforderlich, S256
Access TokenBearerDPoP, an Ihren Schlüssel gebunden
Token-RequestsEin AufrufZwei 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.

  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.

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 für Node.js, 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.

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);
}
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},
    )
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();
}
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
});
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
}
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);
}
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.

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:

{
  "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.

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);
}
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},
    )
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();
}
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,
            },
        },
    });
}
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
}
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);
}
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.

# 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:

let res = await tokenRequest(dpopProof('POST', tokenUrl));
if (!res.ok) {
  const nonce = res.headers.get('dpop-nonce');
  res = await tokenRequest(dpopProof('POST', tokenUrl, nonce));
}
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))
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));
}
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()));
}
res, _ := tokenRequest(dpopProof("POST", tokenURL, ""))
if res.StatusCode != http.StatusOK {
	nonce := res.Header.Get("DPoP-Nonce")
	res, _ = tokenRequest(dpopProof("POST", tokenURL, nonce))
}
$res = tokenRequest(dpopProof($dpopKey, 'POST', $tokenUrl));
if ($res->getStatusCode() !== 200) {
    $nonce = $res->getHeaderLine('DPoP-Nonce');
    $res = tokenRequest(dpopProof($dpopKey, 'POST', $tokenUrl, $nonce));
}
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:

{
  "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:

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

Auf dieser Seite