# DPoP y PAR con Keycloak: tokens ligados al emisor para agentes de IA

> Probé DPoP y PAR en Keycloak 26.8.2. Un token DPoP robado recibe 401, una prueba repetida se rechaza y una petición enviada con PAR caduca a los 60 segundos.

- URL: https://iamops.dev/es/dpop-par-keycloak-sender-constrained-tokens/
- Language: es
- Author: Argo
- Published: 2026-11-15
- Category: Labs
- Depth: A fondo
- Time: 30 minutos
- Topics: DPoP, PAR, Keycloak, OAuth, agentes de IA

## En resumen

- Un bearer token sirve a quien lo tenga. Con [DPoP](https://iamops.dev/es/dpop-par-keycloak-sender-constrained-tokens/#qué-muestra-este-lab) ([RFC 9449](https://iamops.dev/es/dpop-par-rar-explained/#dpop-ata-el-token-a-una-clave)) el token queda ligado a una clave y cada petición necesita una prueba nueva firmada con esa clave.
- En Keycloak 26.8.2 obtuve un token ligado con DPoP cuyo [cnf.jkt](https://iamops.dev/es/dpop-par-keycloak-sender-constrained-tokens/#un-token-normal-y-luego-uno-ligado) coincide con mi clave. Enviado como Bearer simple, con la prueba de otra clave o con una prueba repetida, el mismo token recibió [401](https://iamops.dev/es/dpop-par-keycloak-sender-constrained-tokens/#un-token-normal-y-luego-uno-ligado).
- [PAR](https://iamops.dev/es/dpop-par-keycloak-sender-constrained-tokens/#peticiones-de-autorización-enviadas) ([RFC 9126](https://iamops.dev/es/dpop-par-rar-explained/#par-mantiene-la-solicitud-fuera-de-la-barra-de-direcciones)) mueve los parámetros de autorización a una llamada por el canal trasero. El [request_uri](https://iamops.dev/es/dpop-par-keycloak-sender-constrained-tokens/#peticiones-de-autorización-enviadas) duró 60 segundos y se abrió una sola vez; con dpop_jkt en la petición enviada, el código solo se canjeó con la misma clave.
- Keycloak solo rechaza tokens sin prueba si el cliente tiene activado [Require DPoP bound tokens](https://iamops.dev/es/dpop-par-keycloak-sender-constrained-tokens/#hacer-que-el-cliente-exija-dpop). Probé ese ajuste.
- [No probados](https://iamops.dev/es/dpop-par-keycloak-sender-constrained-tokens/#lo-que-no-probé): [RAR](https://iamops.dev/es/dpop-par-rar-explained/#rar-describe-la-reserva-en-sí), un resource server que valide las pruebas por su cuenta, el binding mTLS y el binding del refresh token.

El 15 de noviembre de 2026 Hudson Rock describió un mercado que vende logs de infostealers con un perfil de cada víctima escrito por una IA. El vendedor de un anuncio afirmaba tener tokens de sesión de la API de Anthropic Claude válidos. Hudson Rock escribe que la captura no establece ni el tipo de token ni si sigue siendo válido, así que lo trato como una afirmación y no como un hecho. El punto general se mantiene: un bearer token en un log robado sirve a quien lo tenga.

La [RFC 9700](https://www.rfc-editor.org/rfc/rfc9700) dice que los servidores de autorización y de recursos DEBERÍAN ligar los access tokens al emisor, con mTLS o DPoP. Quería ver cómo se ve eso en la red, así que probé DPoP y las peticiones de autorización enviadas (PAR) contra un Keycloak local. Las diapositivas de IETF 127 sobre ID-JAG también añaden una variante ligada con DPoP, que cubro en mis [notas sobre esa reunión](https://iamops.dev/es/ietf-127-id-jag-workload-grants-transaction-tokens/).

Escribí una [explicación breve de DPoP, PAR y RAR](https://iamops.dev/es/dpop-par-rar-explained/). La [herramienta DPoP](https://iamops.dev/es/tools/dpop/) puede construir y comprobar una prueba.

## Qué muestra este lab

- Un token normal no lleva el claim `cnf`. Un token ligado con DPoP lleva `cnf.jkt`, la huella de mi clave.
- El token ligado funciona con una prueba nueva de mi clave. Falla como Bearer simple, con la prueba de otra clave y cuando se envía dos veces la misma prueba.
- Con un solo ajuste del cliente, Keycloak se niega a emitir un token si la petición no trae prueba.
- Una petición de autorización enviada con PAR devuelve un `request_uri` que dura 60 segundos y se abre una sola vez. Con `dpop_jkt`, el código de autorización solo se canjea con la misma clave.

![Diagrama de secuencia: un cliente obtiene de Keycloak 26.8.2 un token ligado con DPoP, userinfo devuelve 200 solo con una prueba nueva de la misma clave, una petición de token sin prueba se rechaza cuando Require DPoP está activo, y una pushed authorization request con dpop_jkt solo se canjea con esa clave y se rechaza si se reutiliza o después de 62 segundos.](https://iamops.dev/media/dpop-par-keycloak-sender-constrained-tokens/00-flow.webp)

*El flujo. Los pasos 1 a 8 son DPoP: el token ligado funciona en userinfo con una prueba nueva, y falla como Bearer simple, con otra clave, con una reutilización, o cuando se pide un token sin prueba. Los pasos 9 a 17 son PAR: el request_uri dura 60 segundos, el code se canjea con la clave de dpop_jkt, y otra clave, una segunda apertura o un uso después de 62 segundos devuelven 400.*

## Preparación

Keycloak 26.8.2 corrió desde la distribución zip con Java 21 en modo desarrollo, desde un unzip limpio. Los scripts necesitan Python 3.13, PyJWT 2.15.1, cryptography 50.0.2 y httpx 0.28.1. El realm tiene un usuario, un cliente confidencial llamado `agent` y nada más. La parte DPoP usa el password grant porque es rápido y por ninguna otra razón. La parte PAR usa el flujo authorization code con PKCE, dirigido por un script en lugar de un navegador.

## Un token normal y luego uno ligado

Primero el punto de partida: una petición de token simple. `token_type` es `Bearer` y no hay claim `cnf`, así que quien copie este token puede usarlo.

![Salida de terminal de una petición de token simple a Keycloak: token_type es Bearer y el claim cnf del access token es null.](https://iamops.dev/media/dpop-par-keycloak-sender-constrained-tokens/02-bearer.webp)

*Punto de partida. Un token normal tiene token_type Bearer y ningún claim cnf, así que no está atado a ninguna clave.*

Luego la misma petición con una prueba DPoP. La prueba es un JWT pequeño con `typ` igual a `dpop+jwt`, mi clave pública en la cabecera `jwk` y los claims `htm` (método HTTP), `htu` (URL), `iat` y un `jti` único. Para las llamadas a un recurso lleva también `ath`, un hash del access token. La firmé con una clave P-256 desechable.

![Salida de terminal del script DPoP: token_type DPoP, cnf.jkt igual a la huella de la clave, userinfo responde 200 con una prueba y 401 como Bearer simple, con la prueba de otra clave y con una prueba repetida.](https://iamops.dev/media/dpop-par-keycloak-sender-constrained-tokens/03-dpop.webp)

*Cinco llamadas con un token. Solo la llamada con una prueba nueva de la clave correcta devuelve 200. El caso del token robado, el de la clave equivocada y la repetición devuelven 401.*

El `cnf.jkt` del token es igual a la huella RFC 7638 de mi clave. Ese es todo el mecanismo: el servidor compara la clave de la prueba con la clave que nombra el token. Keycloak también rechazó una prueba ya vista, que es la comprobación de repetición por `jti` de la RFC 9449.

## Hacer que el cliente exija DPoP

El punto de partida muestra un hueco. Si un cliente no exige DPoP, Keycloak sigue entregando un bearer token simple a quien no envía prueba. El ajuste del cliente se llama **Require DPoP bound tokens** y está descrito en la [guía de administración](https://www.keycloak.org/docs/latest/server_admin/#_dpop-bound-tokens). Con `kcadm.sh` es el atributo `dpop.bound.access.tokens`.

![Salida de terminal: con el ajuste del cliente activado, una petición de token sin prueba devuelve invalid_request con la descripción DPoP proof is missing.](https://iamops.dev/media/dpop-par-keycloak-sender-constrained-tokens/04-require-dpop.webp)

*Rechazar tokens no ligados. Con el ajuste activado, una petición de token sin prueba falla con invalid_request y la descripción «DPoP proof is missing».*

Todo lo que sigue corrió con ese ajuste activado.

## Peticiones de autorización enviadas

Con PAR, el cliente envía los parámetros de autorización al endpoint PAR por un canal trasero autenticado y recibe un `request_uri`. El navegador solo lleva `client_id` y esa referencia. El valor de `code_challenge` en la primera imagen es el ejemplo de la [RFC 7636](https://www.rfc-editor.org/rfc/rfc7636), que es público.

![Salida de terminal de una petición de autorización enviada que devuelve un request_uri y expires_in 60, seguida de la URL del navegador que solo lleva client_id y el request_uri codificado.](https://iamops.dev/media/dpop-par-keycloak-sender-constrained-tokens/05-par.webp)

*PAR. La petición va de servidor a servidor. La URL del navegador solo contiene client_id y el request_uri, que caduca en 60 segundos. El identificador de la petición está sustituido por un marcador.*

El segundo script ejecuta todo el flujo. Envía la petición con `dpop_jkt` igual a la huella de mi clave, abre el endpoint de autorización con el `request_uri`, inicia sesión como el usuario del lab y canjea el código en el endpoint de tokens con una prueba DPoP. Después repite todo, pero canjea con otra clave.

![Salida de terminal del flujo completo. Con la clave original el endpoint de tokens devuelve 200, token_type DPoP y un cnf.jkt coincidente. Con otra clave devuelve 400 invalid_request. Un segundo uso del request_uri y un uso a los 62 segundos devuelven 400.](https://iamops.dev/media/dpop-par-keycloak-sender-constrained-tokens/06-par-flow.webp)

*El flujo completo. El código se canjea con la clave nombrada en dpop_jkt y falla con otra. Un request_uri no se puede abrir dos veces y se rechaza a los 62 segundos.*

## Trampas

- **El cookie jar de Python y `localhost`.** La primera versión de mi script perdió la cookie de sesión de Keycloak y recibió un 400 en la página de login. Ahora llevo las cookies a mano en el script.
- **El error de la clave equivocada.** Canjear un código ligado con otra clave devolvió `invalid_request`, no `invalid_grant`. Comprueba el estado, no un solo código.
- **La primera apertura consume el `request_uri`.** El endpoint de autorización respondió con una redirección, y abrir de nuevo el mismo `request_uri` devolvió 400.
- **El password grant es un atajo.** La RFC 9700 dice que NO DEBE usarse.

## Lo que saco en limpio sobre seguridad

1. Activa **Require DPoP bound tokens** en cada cliente. Sin él, quien tenga las credenciales del cliente aún puede pedir un bearer token simple.
2. Pon `dpop_jkt` en la petición enviada para que el código de autorización también quede ligado a la clave.
3. Usa PAR con PKCE en los clientes de agentes, para que scopes y redirect URI nunca pasen por un navegador.
4. Es mi opinión: dónde vive la clave importa tanto como el binding. Una clave guardada junto al token en el mismo log le da a un infostealer las dos mitades.

## Lo que no probé

No probé RAR (`authorization_details`), un resource server propio que compruebe por su cuenta `htu`, `htm`, `ath`, `jti` y `cnf.jkt`, el binding mTLS, el binding del refresh token ni los clientes públicos. Aquí las comprobaciones las hizo el endpoint userinfo de Keycloak. Este lab no tiene grabación ni captura de la consola. El lab usó solo cuentas desechables.

*Las imágenes de terminal se generaron a partir de la salida guardada de la ejecución del 20 de noviembre de 2026, con el identificador de la petición sustituido por un marcador. La ejecución usó el puerto 8180 porque el 8080 estaba ocupado, y las imágenes muestran 8080.*

## Repite este lab

Este lab necesita Java 21, Python 3.13, curl, jq y unzip. Cuenta con unos 30 minutos, más un minuto de espera para la comprobación de caducidad. Abre cada paso, copia los bloques y compara la salida con la mía.

Cada valor entre corchetes angulares es un marcador para tu entorno de prueba. Nada en esta página es un identificador o secreto real.

**Define tus variables una sola vez** `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"
```

### Paso 1: Arranca Keycloak en modo desarrollo

**Objetivo.** Arranca un servidor de autorización local que controlas por completo, para ver DPoP y PAR en la red.

**Requisitos**

- Java 21 (por ejemplo Eclipse Temurin), curl, jq y unzip
- Puerto 8080 libre; deja abierta esta terminal y usa una segunda para los pasos siguientes

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

**Salida esperada**

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

### Paso 2: Crea el realm, un usuario y un cliente; instala las librerías de Python

**Objetivo.** Crea el realm agentlab con el usuario alice y un cliente confidencial llamado agent, y luego instala con versión fija las tres librerías de Python de los scripts.

**Requisitos**

- Keycloak del paso anterior está en marcha y env.sh está cargado en esta terminal
- Python 3.13 con el módulo 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) "
```

**Salida esperada**

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

### Paso 3: Obtén un token normal y busca cnf

**Objetivo.** Mira el punto de partida: token_type Bearer y ningún claim cnf, así que el token no está atado a ninguna clave.

**Requisitos**

- El realm y el cliente del paso anterior

`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)}'
```

**Salida esperada**

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

### Paso 4: Obtén un token ligado con DPoP y pruébalo de cinco maneras

**Objetivo.** Genera una clave P-256 desechable, pide un token con una prueba DPoP, comprueba cnf.jkt y llama a userinfo con la prueba, como Bearer simple, con otra clave y con una prueba repetida.

**Requisitos**

- El venv del paso 2; env.sh cargado
- El cliente aún no exige DPoP, así que este paso funciona tal cual

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

**Salida esperada**

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

### Paso 5: Haz que el cliente rechace tokens sin prueba

**Objetivo.** Activa Require DPoP bound tokens para el cliente agent y repite la petición simple. Keycloak debería rechazarla ahora.

**Requisitos**

- Has iniciado sesión en kcadm (lo hizo el paso 2)

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

**Salida esperada**

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

### Paso 6: Envía una petición de autorización con PAR y construye la URL del navegador

**Objetivo.** Envía los parámetros de autorización al endpoint PAR por el canal trasero. La respuesta es un request_uri que dura 60 segundos.

**Requisitos**

- env.sh cargado; el secreto del cliente es el que pusiste en 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)"
```

**Salida esperada**

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

### Paso 7: Ejecuta todo el flujo con nuestra clave y con otra

**Objetivo.** Envía la petición con dpop_jkt, inicia sesión como alice desde un script, canjea el código con la clave correcta y con una incorrecta, prueba el request_uri dos veces y espera a que caduque. La comprobación de caducidad tarda cerca de un minuto.

**Requisitos**

- Paso 5 hecho, así que el cliente exige DPoP
- El venv del paso 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
```

**Salida esperada**

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

### Paso 8: Limpieza

**Objetivo.** Detén Keycloak y borra todo lo que creó el lab, incluida la distribución descargada y el entorno de Python.

**Requisitos**

- Nada más usa el puerto 8080 ni el directorio 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/"
```

**Salida esperada**

```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)
