iamops.dev
Argo sur X Flux RSS
FRFrançais

Labs Approfondissement · 30 minutes

DPoP et PAR avec Keycloak : des jetons liés à l'émetteur pour les agents IA

J'ai testé DPoP et PAR sur Keycloak 26.8.2. Un jeton DPoP volé reçoit un 401, une preuve rejouée est refusée et une requête PAR expire après 60 secondes.

Deux captures du terminal de mon lab Keycloak : une pushed authorization request qui fonctionne une fois puis est refusée, et des appels avec un jeton lié par DPoP où un bearer simple, une preuve d'une autre clé et une preuve rejouée reçoivent chacun un 401.
En brefUn jeton bearer vaut pour quiconque le détient. Avec DPoP (RFC 9449),…
  • 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 8 étapes

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.

Aller aux étapes

Comment ça marche

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 porte cnf.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_uri valable 60 secondes et qui ne s’ouvre qu’une fois. Avec dpop_jkt, le code d’autorisation ne s’échange qu’avec la même clé.
Diagramme de séquence : un client obtient de Keycloak 26.8.2 un jeton lié par DPoP, userinfo renvoie 200 seulement avec une preuve fraîche de la même clé, une demande de jeton sans preuve est refusée lorsque Require DPoP est activé, et une pushed authorization request avec dpop_jkt ne s'échange qu'avec cette clé et est refusée si elle est réutilisée ou après 62 secondes.
Le flux. Les étapes 1 à 8 sont DPoP : le jeton lié fonctionne sur userinfo avec une preuve fraîche, et échoue en Bearer simple, avec une autre clé, avec une preuve rejouée, ou lorsqu'un jeton est demandé sans preuve. Les étapes 9 à 17 sont PAR : le request_uri dure 60 secondes, le code s'échange avec la clé indiquée dans dpop_jkt, et une autre clé, une seconde ouverture ou un usage après 62 secondes renvoient 400.

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.

Sortie de terminal d'une requête de jeton simple à Keycloak : token_type vaut Bearer et la claim cnf du jeton d'accès est null.
Point de départ. Un jeton normal a token_type Bearer et aucune claim cnf, il n'est donc lié à aucune clé.

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.

Sortie de terminal du script DPoP : token_type DPoP, cnf.jkt égal à l'empreinte de la clé, userinfo répond 200 avec une preuve et 401 en Bearer simple, avec la preuve d'une autre clé et avec une preuve rejouée.
Cinq appels avec un seul jeton. Seul l'appel avec une preuve neuve de la bonne clé renvoie 200. Le cas du jeton volé, celui de la mauvaise clé et le rejeu renvoient tous 401.

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.

Sortie de terminal : une fois le réglage du client activé, une requête de jeton sans preuve renvoie invalid_request avec la description DPoP proof is missing.
Refuser les jetons non liés. Avec le réglage activé, une requête de jeton sans preuve échoue avec invalid_request et la description « DPoP proof is missing ».

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.

Sortie de terminal d'une requête d'autorisation poussée qui renvoie un request_uri et expires_in 60, suivie de l'URL du navigateur qui ne porte que client_id et le request_uri encodé.
PAR. La requête va de serveur à serveur. L'URL du navigateur ne contient que client_id et le request_uri, qui expire en 60 secondes. L'identifiant de la requête est remplacé par un espace réservé.

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é.

Sortie de terminal du flux complet. Avec la clé d'origine, le point de jeton renvoie 200, token_type DPoP et un cnf.jkt identique. Avec une autre clé, il renvoie 400 invalid_request. Une seconde utilisation du request_uri et une utilisation après 62 secondes renvoient toutes deux 400.
Le flux complet. Le code s'échange avec la clé nommée dans dpop_jkt et échoue avec une autre. Un request_uri ne s'ouvre pas deux fois et il est refusé après 62 secondes.

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, pas invalid_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ême request_uri a 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é#

  1. Activez Require DPoP bound tokens par client. Sans cela, un appelant qui a les identifiants du client peut toujours demander un jeton bearer simple.
  2. Mettez dpop_jkt dans la requête poussée pour que le code d’autorisation soit lui aussi lié à la clé.
  3. Utilisez PAR avec PKCE pour les clients agents, pour que scopes et redirect URI ne passent jamais par un navigateur.
  4. 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

bash · env.sh
# 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"
É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
bash · start-keycloak.sh
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

résultat
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
bash · kc-dpop-lab.sh
#!/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"
bash · install-libraries.sh
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

résultat
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
bash · bearer.sh
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

résultat
{
  "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
python · dpop_lab.py
"""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})
bash · run-dpop-lab.sh
.venv/bin/python dpop_lab.py

Résultat attendu

résultat
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)
bash · require-dpop.sh
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

résultat
{
  "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
bash · push-request.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

résultat
{
  "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
python · par_flow.py
"""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("&amp;", "&"), 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()
bash · run-par-flow.sh
.venv/bin/python par_flow.py

Résultat attendu

résultat
[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
bash · cleanup.sh
# 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

résultat
000

Sources#

Discutez-en sur X ou LinkedIn

Suivre sur X

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

Articles et labs liés