En bref
- Un jeton bearer vaut pour quiconque le détient. Avec DPoP (RFC 9449), le jeton est lié à une clé et chaque requête exige une preuve neuve signée avec cette clé.
- Dans Keycloak 26.8.2, j'ai obtenu un jeton lié par DPoP dont le cnf.jkt correspond à ma clé. Envoyé en Bearer simple, avec la preuve d'une autre clé ou avec une preuve rejouée, le même jeton a reçu un 401.
- PAR (RFC 9126) déplace les paramètres d'autorisation vers un appel sur le canal arrière. Le request_uri a duré 60 secondes et ne s'est ouvert qu'une fois ; avec dpop_jkt dans la requête poussée, le code ne s'échange qu'avec la même clé.
- Keycloak ne refuse les jetons sans preuve que si le client a Require DPoP bound tokens activé. J'ai testé ce réglage.
- Non testés : RAR, un serveur de ressources qui valide lui-même les preuves, la liaison mTLS et la liaison du refresh token.
Refaire ce lab
J’ai écrit ce lab pour que vous puissiez le refaire vous-même. Chaque étape contient les commandes à copier et la sortie que j’ai obtenue, et vous pouvez la cocher une fois faite. Les coches restent uniquement dans ce navigateur.
Copie un prompt prêt à l’emploi pour Claude Code, Cursor, Codex ou tout autre agent de code. Pour les environnements de test uniquement.
Afficher le prompt
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely. Lab: DPoP et PAR avec Keycloak : des jetons liés à l'émetteur pour les agents IA Read the whole lab here (Markdown): https://iamops.dev/fr/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.
Le 15 novembre 2026, Hudson Rock a décrit une place de marché qui vend des logs d’infostealers avec un profil de chaque victime rédigé par une IA. Le vendeur d’une annonce affirmait détenir des jetons de session d’API Anthropic Claude valides. Hudson Rock écrit que la capture d’écran n’établit ni le type de jeton ni sa validité actuelle ; je le traite donc comme une affirmation, pas comme un fait. Le point général reste vrai : un jeton bearer dans un log volé fonctionne pour quiconque le possède.
La RFC 9700 dit que les serveurs d’autorisation et de ressources DEVRAIENT lier les jetons d’accès à l’émetteur, avec mTLS ou DPoP. Je voulais voir à quoi cela ressemble sur le réseau, alors j’ai testé DPoP et les requêtes d’autorisation poussées (PAR) sur un Keycloak local. Les diapositives IETF 127 sur ID-JAG ajoutent aussi une variante liée par DPoP, que je couvre dans mes notes sur cette réunion.
J’ai écrit une courte présentation de DPoP, PAR et RAR. L’outil DPoP peut construire et vérifier une preuve.
Ce que montre ce lab#
- Un jeton normal ne porte pas de claim
cnf. Un jeton lié par DPoP portecnf.jkt, l’empreinte de ma clé. - Le jeton lié fonctionne avec une preuve neuve de ma clé. Il échoue en Bearer simple, avec la preuve d’une autre clé et quand la même preuve est envoyée deux fois.
- Avec un seul réglage du client, Keycloak refuse d’émettre un jeton quand la requête n’a pas de preuve.
- Une requête d’autorisation poussée renvoie un
request_urivalable 60 secondes et qui ne s’ouvre qu’une fois. Avecdpop_jkt, le code d’autorisation ne s’échange qu’avec la même clé.

Mise en place#
Keycloak 26.8.2 tournait depuis la distribution zip avec Java 21 en mode développement, depuis une archive fraîchement décompressée. Les scripts demandent Python 3.13, PyJWT 2.15.1, cryptography 50.0.2 et httpx 0.28.1. Le realm a un utilisateur, un client confidentiel nommé agent et rien d’autre. La partie DPoP utilise le password grant parce qu’il est rapide, et pour aucune autre raison. La partie PAR utilise le flux authorization code avec PKCE, piloté par un script plutôt que par un navigateur.
Un jeton normal, puis un jeton lié#
D’abord le point de départ : une requête de jeton simple. token_type vaut Bearer et il n’y a pas de claim cnf ; quiconque copie ce jeton peut donc l’utiliser.

Puis la même requête avec une preuve DPoP. La preuve est un petit JWT avec typ égal à dpop+jwt, ma clé publique dans l’en-tête jwk et les claims htm (méthode HTTP), htu (URL), iat et un jti unique. Pour les appels à une ressource, elle porte aussi ath, un hachage du jeton d’accès. Je l’ai signée avec une clé P-256 jetable.

Le cnf.jkt du jeton est égal à l’empreinte RFC 7638 de ma clé. Tout le mécanisme est là : le serveur compare la clé de la preuve avec la clé nommée dans le jeton. Keycloak a aussi refusé une preuve déjà vue, soit la vérification de rejeu par jti de la RFC 9449.
Faire exiger DPoP par le client#
Le point de départ montre une faille. Si un client n’exige pas DPoP, Keycloak remet quand même un jeton bearer simple à un appelant qui n’envoie pas de preuve. Le réglage du client s’appelle Require DPoP bound tokens et il est décrit dans le guide d’administration. Avec kcadm.sh, c’est l’attribut dpop.bound.access.tokens.

Tout ce qui suit a tourné avec ce réglage activé.
Requêtes d’autorisation poussées#
Avec PAR, le client envoie les paramètres d’autorisation au point PAR par un canal arrière authentifié et reçoit un request_uri. Le navigateur ne porte que client_id et cette référence. La valeur de code_challenge dans la première image est l’exemple de la RFC 7636, qui est public.

Le second script exécute tout le flux. Il pousse la requête avec dpop_jkt égal à l’empreinte de ma clé, ouvre le point d’autorisation avec le request_uri, se connecte en tant qu’utilisateur du lab et échange le code au point de jeton avec une preuve DPoP. Puis il recommence, mais échange avec une autre clé.

Pièges#
- Le cookie jar de Python et
localhost. La première version de mon script a perdu le cookie de session Keycloak et reçu un 400 sur la page de connexion. Je transporte maintenant les cookies à la main dans le script. - L’erreur pour la mauvaise clé. Échanger un code lié avec une autre clé a renvoyé
invalid_request, pasinvalid_grant. Testez le statut, pas un seul code. - La première ouverture consomme le
request_uri. Le point d’autorisation a répondu par une redirection, et rouvrir le mêmerequest_uria renvoyé 400. - Le password grant est un raccourci. La RFC 9700 dit qu’il NE DOIT PAS être utilisé.
Ce que j’en retiens pour la sécurité#
- Activez Require DPoP bound tokens par client. Sans cela, un appelant qui a les identifiants du client peut toujours demander un jeton bearer simple.
- Mettez
dpop_jktdans la requête poussée pour que le code d’autorisation soit lui aussi lié à la clé. - Utilisez PAR avec PKCE pour les clients agents, pour que scopes et redirect URI ne passent jamais par un navigateur.
- C’est mon avis : l’endroit où vit la clé compte autant que la liaison. Une clé stockée à côté du jeton dans le même log donne à un infostealer les deux moitiés.
Ce que je n’ai pas testé#
Je n’ai pas testé RAR (authorization_details), un serveur de ressources à moi qui vérifie lui-même htu, htm, ath, jti et cnf.jkt, la liaison mTLS, la liaison du refresh token ni les clients publics. Ici, c’est le point userinfo de Keycloak qui a fait les vérifications. Il n’y a ni enregistrement ni capture de la console pour ce lab. Le lab n’a utilisé que des comptes jetables.
Les images de terminal ont été générées à partir de la sortie enregistrée de l’exécution du 20 novembre 2026, avec l’identifiant de la requête remplacé par un espace réservé. L’exécution a utilisé le port 8180 parce que 8080 était pris, et les images montrent 8080.
Refaire ce lab#
Ce lab demande Java 21, Python 3.13, curl, jq et unzip. Comptez environ 30 minutes, plus une minute d’attente pour le test d’expiration. Ouvrez chaque étape, copiez les blocs et comparez la sortie avec la mienne.
Chaque valeur entre chevrons est un espace réservé pour votre environnement de test. Rien sur cette page n’est un identifiant ou un secret réel.
Définissez vos variables une seule fois
# 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" Étapes terminées : 0 sur 8
Étape 1Démarrer Keycloak en mode développement
Objectif. Lancez un serveur d’autorisation local que vous maîtrisez entièrement, pour voir DPoP et PAR sur le réseau.
Prérequis
- Java 21 (par exemple Eclipse Temurin), curl, jq et unzip
- Port 8080 libre ; gardez ce terminal ouvert et utilisez-en un second pour les étapes suivantes
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 Résultat attendu
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. Étape 2Créer le realm, un utilisateur et un client ; installer les bibliothèques Python
Objectif. Créez le realm agentlab avec l’utilisateur alice et un client confidentiel nommé agent, puis installez les trois bibliothèques Python des scripts en versions figées.
Prérequis
- Keycloak de l’étape précédente tourne et env.sh est chargé dans ce terminal
- Python 3.13 avec le module venv
#!/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) " Résultat attendu
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 Étape 3Obtenir un jeton ordinaire et chercher cnf
Objectif. Voyez le point de départ : token_type Bearer et aucune claim cnf, donc le jeton n’est lié à aucune clé.
Prérequis
- Le realm et le client de l’étape précédente
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)}' Résultat attendu
{
"token_type": "Bearer",
"cnf": null
} Étape 4Obtenir un jeton lié par DPoP et le tester de cinq façons
Objectif. Générez une clé P-256 jetable, demandez un jeton avec une preuve DPoP, vérifiez cnf.jkt, puis appelez userinfo avec une preuve, en Bearer simple, avec une autre clé et avec une preuve rejouée.
Prérequis
- Le venv de l’étape 2 ; env.sh chargé
- Le client n’exige pas encore DPoP, cette étape fonctionne donc telle quelle
"""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 Résultat attendu
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 Étape 5Faire refuser au client les jetons sans preuve
Objectif. Activez Require DPoP bound tokens pour le client agent et répétez la requête simple. Keycloak devrait maintenant la refuser.
Prérequis
- Vous êtes connecté à kcadm (l’étape 2 l’a fait)
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 . Résultat attendu
{
"error": "invalid_request",
"error_description": "DPoP proof is missing"
} Étape 6Pousser une requête d’autorisation et construire l’URL du navigateur
Objectif. Envoyez les paramètres d’autorisation au point PAR par le canal arrière. La réponse est un request_uri valable 60 secondes.
Prérequis
- env.sh chargé ; le secret du client est celui défini dans 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)" Résultat attendu
{
"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> Étape 7Exécuter tout le flux avec notre clé puis avec une autre clé
Objectif. Poussez la requête avec dpop_jkt, connectez-vous en tant qu’alice depuis un script, échangez le code avec la bonne puis une mauvaise clé, essayez le request_uri deux fois et attendez son expiration. Le test d’expiration dure environ une minute.
Prérequis
- Étape 5 faite, le client exige donc DPoP
- Le venv de l’étape 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 Résultat attendu
[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 Étape 8Nettoyage
Objectif. Arrêtez Keycloak et supprimez tout ce que le lab a créé, y compris la distribution téléchargée et l’environnement Python.
Prérequis
- Rien d’autre n’utilise le port 8080 ni le répertoire keycloak
# 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/" Résultat attendu
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)
Cet article en Markdown · RSS · JSON feed
Les nouveaux articles par e-mail
Un e-mail par semaine avec les nouveaux articles et labs. Désinscription à tout moment.
Votre adresse est conservée chez Kit, le service qui envoie les e-mails. Détails