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

- URL: https://iamops.dev/fr/dpop-par-keycloak-sender-constrained-tokens/
- Language: fr
- Author: Argo
- Published: 2026-11-15
- Category: Labs
- Depth: Approfondissement
- Time: 30 minutes
- Topics: DPoP, PAR, Keycloak, OAuth, agents IA

## En bref

- Un jeton bearer vaut pour quiconque le détient. Avec [DPoP](https://iamops.dev/fr/dpop-par-keycloak-sender-constrained-tokens/#ce-que-montre-ce-lab) ([RFC 9449](https://iamops.dev/fr/dpop-par-rar-explained/#dpop-lie-le-jeton-à-une-clé)), 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](https://iamops.dev/fr/dpop-par-keycloak-sender-constrained-tokens/#un-jeton-normal-puis-un-jeton-lié) 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](https://iamops.dev/fr/dpop-par-keycloak-sender-constrained-tokens/#un-jeton-normal-puis-un-jeton-lié).
- [PAR](https://iamops.dev/fr/dpop-par-keycloak-sender-constrained-tokens/#requêtes-dautorisation-poussées) ([RFC 9126](https://iamops.dev/fr/dpop-par-rar-explained/#par-garde-la-demande-hors-de-la-barre-dadresse)) déplace les paramètres d'autorisation vers un appel sur le canal arrière. Le [request_uri](https://iamops.dev/fr/dpop-par-keycloak-sender-constrained-tokens/#requêtes-dautorisation-poussées) 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](https://iamops.dev/fr/dpop-par-keycloak-sender-constrained-tokens/#faire-exiger-dpop-par-le-client) activé. J'ai testé ce réglage.
- [Non testés](https://iamops.dev/fr/dpop-par-keycloak-sender-constrained-tokens/#ce-que-je-nai-pas-testé) : [RAR](https://iamops.dev/fr/dpop-par-rar-explained/#rar-décrit-la-réservation-elle-même), un serveur de ressources qui valide lui-même les preuves, la liaison mTLS et la liaison du refresh token.

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](https://www.rfc-editor.org/rfc/rfc9700) 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](https://iamops.dev/fr/ietf-127-id-jag-workload-grants-transaction-tokens/).

J'ai écrit une courte [présentation de DPoP, PAR et RAR](https://iamops.dev/fr/dpop-par-rar-explained/). L'[outil DPoP](https://iamops.dev/fr/tools/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.](https://iamops.dev/media/dpop-par-keycloak-sender-constrained-tokens/00-flow.webp)

*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.](https://iamops.dev/media/dpop-par-keycloak-sender-constrained-tokens/02-bearer.webp)

*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.](https://iamops.dev/media/dpop-par-keycloak-sender-constrained-tokens/03-dpop.webp)

*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](https://www.keycloak.org/docs/latest/server_admin/#_dpop-bound-tokens). 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.](https://iamops.dev/media/dpop-par-keycloak-sender-constrained-tokens/04-require-dpop.webp)

*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](https://www.rfc-editor.org/rfc/rfc7636), 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é.](https://iamops.dev/media/dpop-par-keycloak-sender-constrained-tokens/05-par.webp)

*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.](https://iamops.dev/media/dpop-par-keycloak-sender-constrained-tokens/06-par-flow.webp)

*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** `env.sh` (bash)

```bash
# 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 1: Dé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

`start-keycloak.sh` (bash)

```bash
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**

```text
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 2: Cré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

`kc-dpop-lab.sh` (bash)

```bash
#!/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=alice@example.com -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"
```

`install-libraries.sh` (bash)

```bash
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**

```text
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 3: Obtenir 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

`bearer.sh` (bash)

```bash
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**

```text
{
  "token_type": "Bearer",
  "cnf": null
}
```

### Étape 4: Obtenir 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.py` (python)

```python
"""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})
```

`run-dpop-lab.sh` (bash)

```bash
.venv/bin/python dpop_lab.py
```

**Résultat attendu**

```text
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 5: Faire 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)

`require-dpop.sh` (bash)

```bash
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**

```text
{
  "error": "invalid_request",
  "error_description": "DPoP proof is missing"
}
```

### Étape 6: Pousser 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

`push-request.sh` (bash)

```bash
# 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**

```text
{
  "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 7: Exé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_flow.py` (python)

```python
"""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()
```

`run-par-flow.sh` (bash)

```bash
.venv/bin/python par_flow.py
```

**Résultat attendu**

```text
[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 8: Nettoyage

**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

`cleanup.sh` (bash)

```bash
# 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**

```text
000
```


## Sources

- [Hudson Rock (InfoStealers), Inside the AI-Powered Marketplace Turning Infected Computers Into Searchable Profiles (15 Nov 2026)](https://www.infostealers.com/article/inside-the-ai-powered-marketplace-turning-infected-computers-into-searchable-profiles/)
- [RFC 9449: OAuth 2.0 Demonstrating Proof of Possession (DPoP)](https://www.rfc-editor.org/rfc/rfc9449)
- [RFC 9126: OAuth 2.0 Pushed Authorization Requests](https://www.rfc-editor.org/rfc/rfc9126)
- [RFC 9700: Best Current Practice for OAuth 2.0 Security](https://www.rfc-editor.org/rfc/rfc9700)
- [RFC 7636: Proof Key for Code Exchange by OAuth Public Clients](https://www.rfc-editor.org/rfc/rfc7636)
- [Keycloak Server Administration Guide: DPoP bound tokens](https://www.keycloak.org/docs/latest/server_admin/#_dpop-bound-tokens)
- [Keycloak release notes (DPoP supported in 26.4.0, authorization code binding to a DPoP key in 26.1.0)](https://www.keycloak.org/docs/latest/release_notes/)
- [IETF 127 slides: Identity Assertion Authorization Grant (Parecki, McGuinness, Campbell)](https://datatracker.ietf.org/meeting/127/materials/slides-127-oauth-sessa-identity-assertion-jwt-authorization-grant-00)

Discuss: [X](https://x.com/iamopsdev/status/2124170507813601639) | [LinkedIn](https://www.linkedin.com/feed/update/urn:li:share:7529937238588252160)
