iamops.dev
Argo en X Feed RSS
ESEspañol

Labs A fondo · 30 minutos

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.

Dos capturas del terminal de mi laboratorio de Keycloak: una pushed authorization request que funciona una vez y después se rechaza, y llamadas con un token ligado por DPoP en las que un bearer simple, una prueba de otra clave y una prueba repetida reciben un 401.
En resumenUn bearer token sirve a quien lo tenga. Con DPoP (RFC 9449) el token…
  • Un bearer token sirve a quien lo tenga. Con DPoP (RFC 9449) 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 coincide con mi clave. Enviado como Bearer simple, con la prueba de otra clave o con una prueba repetida, el mismo token recibió 401.
  • PAR (RFC 9126) mueve los parámetros de autorización a una llamada por el canal trasero. El request_uri 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. Probé ese ajuste.
  • No probados: RAR, un resource server que valide las pruebas por su cuenta, el binding mTLS y el binding del refresh token.
Repite este lab 8 pasos

Escribí este lab para que puedas repetirlo tú mismo. Cada paso tiene los comandos para copiar y la salida que obtuve yo, y puedes marcarlo como hecho. Las marcas se quedan solo en este navegador.

Ir a los pasos

Cómo funciona

Copia un prompt listo para Claude Code, Cursor, Codex o cualquier agente de código. Solo para entornos de prueba.

Mostrar el prompt
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely.

Lab: DPoP y PAR con Keycloak: tokens ligados al emisor para agentes de IA
Read the whole lab here (Markdown): https://iamops.dev/es/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.

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

Escribí una explicación breve de DPoP, PAR y RAR. La herramienta 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.
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.
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.
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. 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.
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, 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.
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.
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

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"
Paso 1Arranca 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
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

Salida esperada

salida
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 2Crea 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
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) "

Salida esperada

salida
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 3Obté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
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)}'

Salida esperada

salida
{
  "token_type": "Bearer",
  "cnf": null
}
Paso 4Obté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
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

Salida esperada

salida
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 5Haz 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)
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 .

Salida esperada

salida
{
  "error": "invalid_request",
  "error_description": "DPoP proof is missing"
}
Paso 6Enví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
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)"

Salida esperada

salida
{
  "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 7Ejecuta 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
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

Salida esperada

salida
[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 8Limpieza

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
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/"

Salida esperada

salida
000

Fuentes#

Coméntalo en X o LinkedIn

Seguir en X

Nuevos artículos por correo

Un correo a la semana con nuevos artículos y labs. Puedes darte de baja cuando quieras.

Tu dirección se guarda en Kit, el servicio que envía los correos. Detalles

Artículos y labs relacionados