TL;DR
- A bearer token works for whoever holds it. With DPoP (RFC 9449) the token is bound to a key, and every request needs a fresh proof signed with that key.
- In Keycloak 26.8.2 I got a DPoP-bound token whose cnf.jkt matched my key. Sent as a plain Bearer token, with another key's proof or with a replayed proof, the same token got a 401.
- PAR (RFC 9126) moves the authorization parameters to a back-channel call. The request_uri lasted 60 seconds and opened once, and with dpop_jkt in the pushed request the code only redeemed with the same key.
- Keycloak only refuses tokens without a proof when the client has Require DPoP bound tokens switched on. I tested that setting.
- Not run: RAR, a resource server that validates proofs itself, mTLS binding and refresh token binding.
Repeat this lab
I wrote this lab so you can run it yourself. Each step has the commands to copy and the output I got, and you can tick it as done. Your ticks stay in this browser only.
Copies a ready-made prompt for Claude Code, Cursor, Codex or any coding agent. For test environments only.
Show prompt
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely. Lab: DPoP and PAR with Keycloak: sender-constrained tokens for AI agents Read the whole lab here (Markdown): https://iamops.dev/dpop-par-keycloak-sender-constrained-tokens.md What the lab needs before the first step: - Java 21 (for example Eclipse Temurin), curl, jq and unzip - Port 8080 free; keep this terminal open and use a second one for the next steps - Values I have to set myself (the lab uses placeholders): <ADMIN_PASSWORD>, <ALICE_PASSWORD>, <AGENT_CLIENT_SECRET> How I want you to work: 1. Read the lab from start to finish first (each step lists its own prerequisites). Then check that the prerequisites are in place and that the tool versions match what the lab expects. Tell me what is missing before you run anything. 2. Run one step at a time. Before each command, show it to me and say in a sentence what it does. 3. Ask me before anything that costs money, creates cloud resources, touches a real tenant or account, or deletes anything. Wait for my answer. 4. Use the placeholders from the lab. Never paste real secrets, tokens or production identities into a command, a file or this chat. If a value is needed, tell me where to set it myself. 5. After each step, compare the output with the expected output in the lab. If it does not match, stop and tell me what differs. Do not carry on or invent a fix without asking me. 6. At the end, report what passed, what failed and which cleanup you did. Then offer to tick the steps off for me. The lab page keeps ticks only in my browser, so if you cannot do that, list the steps I should tick. This lab is for test environments only. Do not run it against production, or against a tenant or account that holds real data or real users. You may answer in my language.
On 15 November 2026 Hudson Rock described a marketplace that sells infostealer logs with an AI-written profile of each victim. The seller of one listing claimed valid Anthropic Claude API session tokens. Hudson Rock says the screenshot does not establish the token type or whether it still works, so I treat that as a claim, not a fact. The general point holds either way: a bearer token in a stolen log works for whoever holds it.
RFC 9700 says authorization and resource servers SHOULD sender-constrain access tokens, with mTLS or DPoP. I wanted to see what that looks like on the wire, so I ran DPoP and pushed authorization requests (PAR) against a local Keycloak. The IETF 127 slides for ID-JAG add a DPoP-bound variant as well, which I cover in my notes on that meeting.
I wrote a short explainer of DPoP, PAR and RAR. The DPoP tool can build and check a proof.
What this lab shows#
- A normal token carries no
cnfclaim. A DPoP-bound token carriescnf.jkt, the thumbprint of my key. - The bound token works with a fresh proof from my key. It fails as a plain Bearer token, with a proof from another key, and when the same proof is sent twice.
- With one client setting, Keycloak refuses to issue a token at all when the request has no proof.
- A pushed authorization request returns a
request_urithat lives 60 seconds and opens once. Withdpop_jkt, the authorization code only redeems with the same key.

Setup#
Keycloak 26.8.2 ran from the zip distribution on Java 21 in development mode, from a fresh unzip. The scripts need Python 3.13, PyJWT 2.15.1, cryptography 50.0.2 and httpx 0.28.1. The realm has one user, one confidential client named agent and nothing else. The DPoP part uses the password grant because it is quick and for no other reason. The PAR part uses the authorization code flow with PKCE, driven by a script instead of a browser.
A normal token, then a bound one#
First the baseline: a plain token request. token_type is Bearer and there is no cnf claim, so anyone who copies this token can use it.

Then the same request with a DPoP proof. The proof is a small JWT with typ set to dpop+jwt, my public key in the jwk header, and the claims htm (HTTP method), htu (URL), iat and a unique jti. For calls to a resource it also carries ath, a hash of the access token. I signed it with a throwaway P-256 key.

The token’s cnf.jkt equals the RFC 7638 thumbprint of my key. That is the whole mechanism: the server compares the key in the proof with the key named in the token. Keycloak also refused a proof it had already seen, which is the jti replay check from RFC 9449.
Making the client require DPoP#
The baseline above shows a gap. If a client does not require DPoP, Keycloak still hands a plain bearer token to a caller that sends no proof. The client setting is Require DPoP bound tokens, described in the admin guide. Through kcadm.sh it is the attribute dpop.bound.access.tokens.

Everything after this step ran with that setting on.
Pushed authorization requests#
With PAR the client posts the authorization parameters to the PAR endpoint over an authenticated back channel and gets a request_uri back. The browser only carries client_id and that reference. The code_challenge value in the first image is the example from RFC 7636, which is public.

The second script runs the whole code flow. It pushes the request with dpop_jkt set to my key’s thumbprint, opens the authorization endpoint with the request_uri, signs in as the lab user, and redeems the code at the token endpoint with a DPoP proof. Then it does the same again but redeems with a different key.

Gotchas#
- Python’s cookie jar and
localhost. My first version of the flow script lost the Keycloak session cookie and got a 400 on the login page. I now carry the cookies by hand in the script. - The error for the wrong key. Redeeming a bound code with another key returned
invalid_request, notinvalid_grant. Test for the status, not for one code. - The first open consumes the
request_uri. The authorization endpoint answered with a redirect, and opening the samerequest_uriagain returned 400. - The password grant is a shortcut. RFC 9700 says it MUST NOT be used.
Security takeaways#
- Switch on Require DPoP bound tokens per client. Without it, a caller with the client credentials can still ask for a plain bearer token.
- Put
dpop_jktin the pushed request so the authorization code is bound to the key too. - Use PAR with PKCE for agent clients, so scopes and redirect URIs never travel through a browser.
- This is my opinion: where the key lives matters as much as the binding. A key stored next to the token in the same log gives an infostealer both halves.
What was not run#
RAR (authorization_details), a resource server of my own that checks htu, htm, ath, jti and cnf.jkt itself, mTLS binding, refresh token binding and public clients were not run. Keycloak’s own userinfo endpoint did the checking here. There is no recording and no console screenshot for this lab. The lab used throwaway accounts only.
Terminal images were rendered from the saved output of the run on 20 November 2026, with the request identifier replaced by a placeholder. The run used port 8180 because 8080 was taken, and the images show 8080.
Repeat this lab#
This lab needs Java 21, Python 3.13, curl, jq and unzip. Plan for about 30 minutes, plus a minute of waiting for the expiry check. Open each step, copy the blocks and compare the output with mine.
Every value in angle brackets is a placeholder for your own test environment. Nothing on this page is a real identifier or secret.
Set your variables once
# Paste into every terminal you use for this lab. Replace each <PLACEHOLDER> with a throwaway value of your own.
export KC_VERSION="26.8.2"
export KC_URL="http://localhost:8080"
export KC_REALM="agentlab"
export KC_ADMIN_USER="admin"
export KC_ADMIN_PASSWORD='<ADMIN_PASSWORD>'
export ALICE_PASSWORD='<ALICE_PASSWORD>'
export AGENT_SECRET='<AGENT_CLIENT_SECRET>'
export REDIRECT_URI="http://localhost:6274/oauth/callback"
export TOKEN_URL="$KC_URL/realms/$KC_REALM/protocol/openid-connect/token"
export PAR_URL="$KC_URL/realms/$KC_REALM/protocol/openid-connect/ext/par/request"
export AUTH_URL="$KC_URL/realms/$KC_REALM/protocol/openid-connect/auth" 0 of 8 steps done
Step 1Start Keycloak in development mode
Goal. Run a local authorization server you fully control, so you can see DPoP and PAR on the wire.
Prerequisites
- Java 21 (for example Eclipse Temurin), curl, jq and unzip
- Port 8080 free; keep this terminal open and use a second one for the next steps
curl -LO "https://github.com/keycloak/keycloak/releases/download/$KC_VERSION/keycloak-$KC_VERSION.zip"
unzip -q "keycloak-$KC_VERSION.zip"
export KC_BOOTSTRAP_ADMIN_USERNAME="$KC_ADMIN_USER" KC_BOOTSTRAP_ADMIN_PASSWORD="$KC_ADMIN_PASSWORD"
"keycloak-$KC_VERSION/bin/kc.sh" start-dev --http-port 8080 Expected output
Running the server in development mode. DO NOT use this configuration in production.
INFO [org.keycloak.services] (main) KC-SERVICES0077: Created temporary admin user with username admin
INFO [io.quarkus] (main) Keycloak 26.8.2 on JVM (powered by Quarkus 3.40.1.1) started in 8.418s. Listening on: http://localhost:8080
INFO [io.quarkus] (main) Profile dev activated. Step 2Create the realm, one user and one client; install the Python libraries
Goal. Create the agentlab realm with the user alice and a confidential client named agent, then pin the three Python libraries the scripts use.
Prerequisites
- Keycloak from the previous step is running and env.sh is loaded in this terminal
- Python 3.13 with the venv module
#!/usr/bin/env bash
# Realm, one user and one client for the DPoP and PAR lab. Lab only: throwaway secrets.
set -euo pipefail
KCADM="keycloak-$KC_VERSION/bin/kcadm.sh"
$KCADM config credentials --server "$KC_URL" --realm master --user "$KC_ADMIN_USER" --password "$KC_ADMIN_PASSWORD"
$KCADM create realms -s realm="$KC_REALM" -s enabled=true
$KCADM create users -r "$KC_REALM" -s username=alice -s enabled=true -s [email protected] -s emailVerified=true -s firstName=Alice -s lastName=Lab
$KCADM set-password -r "$KC_REALM" --username alice --new-password "$ALICE_PASSWORD"
# The agent client: confidential. Password grant is on only because this is a lab; the PAR step uses the code flow.
$KCADM create clients -r "$KC_REALM" -s clientId=agent -s publicClient=false -s secret="$AGENT_SECRET" \
-s directAccessGrantsEnabled=true -s standardFlowEnabled=true -s "redirectUris=[\"$REDIRECT_URI\"]"
echo "realm $KC_REALM ready" python3 -m venv .venv
.venv/bin/pip install -q PyJWT==2.15.1 cryptography==50.0.2 httpx==0.28.1
.venv/bin/pip list 2>/dev/null | grep -i -E "^(pyjwt|cryptography|httpx) " Expected output
Logging into http://localhost:8080 as user admin of realm master
Created new realm with id 'agentlab'
Created new user with id '<user-id>'
Created new client with id '<client-id>'
realm agentlab ready
cryptography 50.0.2
httpx 0.28.1
PyJWT 2.15.1 Step 3Get a plain token and look for cnf
Goal. See the baseline: a token_type of Bearer and no cnf claim, so the token is not tied to any key.
Prerequisites
- The realm and client from the previous step
curl -s -u agent:"$AGENT_SECRET" -d grant_type=password \
-d username=alice --data-urlencode "password=$ALICE_PASSWORD" -d scope=openid "$TOKEN_URL" \
| jq '{token_type, cnf: (.access_token | split(".")[1] | @base64d | fromjson | .cnf)}' Expected output
{
"token_type": "Bearer",
"cnf": null
} Step 4Get a DPoP-bound token and test it five ways
Goal. Generate a throwaway P-256 key, request a token with a DPoP proof, check cnf.jkt, then call userinfo with a proof, as a plain Bearer token, with another key, and with a replayed proof.
Prerequisites
- The venv from step 2; env.sh loaded
- The client does not require DPoP yet, so this step works as written
"""DPoP lab: get a DPoP-bound token from Keycloak, check cnf.jkt, call userinfo with and without a proof.
Tested with Keycloak 26.8.2, PyJWT 2.15.1, cryptography 50.0.2 and httpx 0.28.1. Lab-only secrets, read from the environment."""
import base64, hashlib, json, os, time, uuid
import httpx, jwt
from cryptography.hazmat.primitives.asymmetric import ec
TOKEN_URL = os.environ["TOKEN_URL"]
USERINFO = TOKEN_URL.replace("/token", "/userinfo")
def new_key():
key = ec.generate_private_key(ec.SECP256R1())
pub = json.loads(jwt.algorithms.ECAlgorithm.to_jwk(key.public_key()))
return key, {k: pub[k] for k in ("crv", "kty", "x", "y")}
def thumbprint(pub): # RFC 7638: SHA-256 over the required members in lexicographic order
return b64(hashlib.sha256(json.dumps(pub, separators=(",", ":"), sort_keys=True).encode()).digest())
def b64(raw):
return base64.urlsafe_b64encode(raw).rstrip(b"=").decode()
def proof(key, pub, htm, htu, ath=None, jti=None):
claims = {"jti": jti or str(uuid.uuid4()), "htm": htm, "htu": htu, "iat": int(time.time())}
if ath:
claims["ath"] = ath # hash of the access token, binds the proof to this token
return jwt.encode(claims, key, algorithm="ES256", headers={"typ": "dpop+jwt", "jwk": pub})
key, pub = new_key()
r = httpx.post(TOKEN_URL, headers={"DPoP": proof(key, pub, "POST", TOKEN_URL)}, data={
"grant_type": "password", "client_id": "agent", "client_secret": os.environ["AGENT_SECRET"],
"username": "alice", "password": os.environ["ALICE_PASSWORD"], "scope": "openid"})
body = r.json()
print("token_type:", body.get("token_type"), body.get("error_description", ""))
at = body["access_token"]
cnf = jwt.decode(at, options={"verify_signature": False}).get("cnf")
print("cnf.jkt equals our key's thumbprint:", cnf.get("jkt") == thumbprint(pub))
ath = b64(hashlib.sha256(at.encode()).digest())
def userinfo(label, headers):
print(f"{label}:", httpx.get(USERINFO, headers=headers).status_code)
userinfo("userinfo with a DPoP proof", {"Authorization": f"DPoP {at}", "DPoP": proof(key, pub, "GET", USERINFO, ath)})
userinfo("userinfo as plain Bearer (stolen token, no proof)", {"Authorization": f"Bearer {at}"})
other, other_pub = new_key()
userinfo("userinfo with a proof from a different key", {"Authorization": f"DPoP {at}", "DPoP": proof(other, other_pub, "GET", USERINFO, ath)})
reused = proof(key, pub, "GET", USERINFO, ath)
userinfo("userinfo, proof used once", {"Authorization": f"DPoP {at}", "DPoP": reused})
userinfo("userinfo, same proof replayed", {"Authorization": f"DPoP {at}", "DPoP": reused}) .venv/bin/python dpop_lab.py Expected output
token_type: DPoP
cnf.jkt equals our key's thumbprint: True
userinfo with a DPoP proof: 200
userinfo as plain Bearer (stolen token, no proof): 401
userinfo with a proof from a different key: 401
userinfo, proof used once: 200
userinfo, same proof replayed: 401 Step 5Make the client refuse tokens without a proof
Goal. Switch on Require DPoP bound tokens for the agent client and repeat the plain token request. Keycloak should now refuse it.
Prerequisites
- You are logged in to kcadm (step 2 did that)
KCADM="keycloak-$KC_VERSION/bin/kcadm.sh"
CID=$($KCADM get clients -r "$KC_REALM" -q clientId=agent --fields id --format csv --noquotes)
$KCADM update clients/$CID -r "$KC_REALM" -s 'attributes."dpop.bound.access.tokens"=true'
# The same plain request as before, now without a proof
curl -s -u agent:"$AGENT_SECRET" -d grant_type=password \
-d username=alice --data-urlencode "password=$ALICE_PASSWORD" -d scope=openid "$TOKEN_URL" | jq . Expected output
{
"error": "invalid_request",
"error_description": "DPoP proof is missing"
} Step 6Push an authorization request and build the browser URL
Goal. Post the authorization parameters to the PAR endpoint over the back channel. The reply is a request_uri that lives 60 seconds.
Prerequisites
- env.sh loaded; the client secret is the one you set in env.sh
# The code_challenge below is the public example value from RFC 7636
curl -s -u agent:"$AGENT_SECRET" -d response_type=code -d client_id=agent -d redirect_uri="$REDIRECT_URI" \
-d scope=openid -d code_challenge=E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM \
-d code_challenge_method=S256 "$PAR_URL" | tee par.json | jq .
export REQUEST_URI=$(jq -r .request_uri par.json)
echo "$AUTH_URL?client_id=agent&request_uri=$(printf %s "$REQUEST_URI" | jq -sRr @uri)" Expected output
{
"request_uri": "urn:ietf:params:oauth:request_uri:<request-id>",
"expires_in": 60
}
http://localhost:8080/realms/agentlab/protocol/openid-connect/auth?client_id=agent&request_uri=urn%3Aietf%3Aparams%3Aoauth%3Arequest_uri%3A<request-id> Step 7Run the whole code flow with our key and with another key
Goal. Push the request with dpop_jkt, sign in as alice from a script, redeem the code with the right and with a wrong key, try the request_uri twice, and wait for it to expire. The expiry check takes about a minute.
Prerequisites
- Step 5 done, so the client requires DPoP
- The venv from step 2
"""PAR + PKCE + DPoP authorization code flow against Keycloak, driven from a script (no browser).
Tested with Keycloak 26.8.2, PyJWT 2.15.1, cryptography 50.0.2 and httpx 0.28.1. Lab-only secrets, read from the environment."""
import base64, hashlib, json, os, re, secrets, time, uuid
from urllib.parse import urlparse, parse_qs, urlencode
import httpx, jwt
from cryptography.hazmat.primitives.asymmetric import ec
E = os.environ
TOKEN_URL, PAR_URL, AUTH_URL, REDIRECT = E["TOKEN_URL"], E["PAR_URL"], E["AUTH_URL"], E["REDIRECT_URI"]
def b64(raw): return base64.urlsafe_b64encode(raw).rstrip(b"=").decode()
def new_key():
key = ec.generate_private_key(ec.SECP256R1())
pub = json.loads(jwt.algorithms.ECAlgorithm.to_jwk(key.public_key()))
return key, {k: pub[k] for k in ("crv", "kty", "x", "y")}
def jkt(pub): return b64(hashlib.sha256(json.dumps(pub, separators=(",", ":"), sort_keys=True).encode()).digest())
def proof(key, pub, htm, htu):
claims = {"jti": str(uuid.uuid4()), "htm": htm, "htu": htu, "iat": int(time.time())}
return jwt.encode(claims, key, algorithm="ES256", headers={"typ": "dpop+jwt", "jwk": pub})
def flow(label, redeem_with_wrong_key=False):
key, pub = new_key()
verifier = b64(secrets.token_bytes(32))
challenge = b64(hashlib.sha256(verifier.encode()).digest())
# 1. Push the request over the back channel. dpop_jkt binds the authorization code to our key.
par = httpx.post(PAR_URL, auth=("agent", E["AGENT_SECRET"]), data={
"response_type": "code", "client_id": "agent", "redirect_uri": REDIRECT, "scope": "openid", "state": "lab",
"code_challenge": challenge, "code_challenge_method": "S256", "dpop_jkt": jkt(pub)})
par_body = par.json()
request_uri = par_body["request_uri"]
print(f"[{label}] PAR status {par.status_code}, expires_in {par_body['expires_in']}, request_uri is a urn:ietf:params:oauth:request_uri value: {request_uri.startswith('urn:ietf:params:oauth:request_uri:')}")
# 2. The browser only carries client_id and the request_uri. A tiny cookie jar stands in for the browser.
jar = {}
def browse(method, url, **kw):
r = httpx.request(method, url, cookies=jar, follow_redirects=False, **kw)
for line in r.headers.get_list("set-cookie"):
name, _, rest = line.partition("=")
jar[name] = rest.split(";")[0]
return r
page = browse("GET", AUTH_URL, params={"client_id": "agent", "request_uri": request_uri})
while page.status_code == 302:
page = browse("GET", page.headers["location"])
form = re.search(r'<form[^>]*id="kc-form-login"[^>]*action="([^"]+)"', page.text)
print(f"[{label}] authorization endpoint with the request_uri: {page.status_code}, login form found: {bool(form)}")
done = browse("POST", form.group(1).replace("&", "&"), data={"username": "alice", "password": E["ALICE_PASSWORD"]})
query = parse_qs(urlparse(done.headers["location"]).query)
code = query["code"][0]
print(f"[{label}] sign-in redirect: {done.status_code}, code returned: {bool(code)}, state returned: {query['state'][0]}")
again = browse("GET", AUTH_URL, params={"client_id": "agent", "request_uri": request_uri})
print(f"[{label}] same request_uri used a second time: {again.status_code}")
# 3. Redeem the code with a DPoP proof (ours, or a different key's).
use_key, use_pub = (new_key() if redeem_with_wrong_key else (key, pub))
tok = httpx.post(TOKEN_URL, headers={"DPoP": proof(use_key, use_pub, "POST", TOKEN_URL)}, data={
"grant_type": "authorization_code", "code": code, "redirect_uri": REDIRECT, "client_id": "agent",
"client_secret": E["AGENT_SECRET"], "code_verifier": verifier})
body = tok.json()
if tok.status_code == 200:
cnf = jwt.decode(body["access_token"], options={"verify_signature": False}).get("cnf", {})
print(f"[{label}] token endpoint: {tok.status_code}, token_type {body['token_type']}, cnf.jkt equals our key: {cnf.get('jkt') == jkt(pub)}")
else:
print(f"[{label}] token endpoint: {tok.status_code}, error {body.get('error')}")
def expiry():
key, pub = new_key()
par = httpx.post(PAR_URL, auth=("agent", E["AGENT_SECRET"]), data={
"response_type": "code", "client_id": "agent", "redirect_uri": REDIRECT, "scope": "openid", "state": "lab",
"code_challenge": b64(hashlib.sha256(b"unused-verifier").digest()), "code_challenge_method": "S256"})
time.sleep(par.json()["expires_in"] + 2)
late = httpx.get(AUTH_URL, params={"client_id": "agent", "request_uri": par.json()["request_uri"]}, follow_redirects=True)
print(f"[expiry] request_uri opened {par.json()['expires_in'] + 2} seconds after it was pushed: {late.status_code}")
flow("our key")
flow("other key", redeem_with_wrong_key=True)
expiry() .venv/bin/python par_flow.py Expected output
[our key] PAR status 201, expires_in 60, request_uri is a urn:ietf:params:oauth:request_uri value: True
[our key] authorization endpoint with the request_uri: 200, login form found: True
[our key] sign-in redirect: 302, code returned: True, state returned: lab
[our key] same request_uri used a second time: 400
[our key] token endpoint: 200, token_type DPoP, cnf.jkt equals our key: True
[other key] PAR status 201, expires_in 60, request_uri is a urn:ietf:params:oauth:request_uri value: True
[other key] authorization endpoint with the request_uri: 200, login form found: True
[other key] sign-in redirect: 302, code returned: True, state returned: lab
[other key] same request_uri used a second time: 400
[other key] token endpoint: 400, error invalid_request
[expiry] request_uri opened 62 seconds after it was pushed: 400 Step 8Clean up
Goal. Stop Keycloak and delete everything the lab created, including the downloaded distribution and the Python environment.
Prerequisites
- Nothing else uses port 8080 or the keycloak directory
# Stop Keycloak: press Ctrl+C in the first terminal, or:
pkill -f "$PWD/keycloak-$KC_VERSION" || true
sleep 5
rm -rf "keycloak-$KC_VERSION" "keycloak-$KC_VERSION.zip" .venv dpop_lab.py par_flow.py kc-dpop-lab.sh par.json
unset KC_ADMIN_PASSWORD ALICE_PASSWORD AGENT_SECRET REQUEST_URI CID
# check: nothing listens on port 8080 any more
curl -s -o /dev/null -w "%{http_code}\n" "$KC_URL/" Expected output
000 Sources#
- Hudson Rock (InfoStealers), Inside the AI-Powered Marketplace Turning Infected Computers Into Searchable Profiles (15 Nov 2026)
- RFC 9449: OAuth 2.0 Demonstrating Proof of Possession (DPoP)
- RFC 9126: OAuth 2.0 Pushed Authorization Requests
- RFC 9700: Best Current Practice for OAuth 2.0 Security
- RFC 7636: Proof Key for Code Exchange by OAuth Public Clients
- Keycloak Server Administration Guide: DPoP bound tokens
- Keycloak release notes (DPoP supported in 26.4.0, authorization code binding to a DPoP key in 26.1.0)
- IETF 127 slides: Identity Assertion Authorization Grant (Parecki, McGuinness, Campbell)
This post as Markdown · RSS · JSON feed
New posts by email
One email a week with new posts and labs. Unsubscribe anytime.
Your address is stored with Kit, which sends the emails. Details