En resumen
- 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
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.
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 llevacnf.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_urique dura 60 segundos y se abre una sola vez. Condpop_jkt, el código de autorización solo se canjea con la misma clave.

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.

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.

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.

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.

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.

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, noinvalid_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 mismorequest_uridevolvió 400. - El password grant es un atajo. La RFC 9700 dice que NO DEBE usarse.
Lo que saco en limpio sobre seguridad#
- Activa Require DPoP bound tokens en cada cliente. Sin él, quien tenga las credenciales del cliente aún puede pedir un bearer token simple.
- Pon
dpop_jkten la petición enviada para que el código de autorización también quede ligado a la clave. - Usa PAR con PKCE en los clientes de agentes, para que scopes y redirect URI nunca pasen por un navegador.
- 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
# 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" 0 de 8 pasos hechos
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
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
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
#!/usr/bin/env bash
# Realm, one user and one client for the DPoP and PAR lab. Lab only: throwaway secrets.
set -euo pipefail
KCADM="keycloak-$KC_VERSION/bin/kcadm.sh"
$KCADM config credentials --server "$KC_URL" --realm master --user "$KC_ADMIN_USER" --password "$KC_ADMIN_PASSWORD"
$KCADM create realms -s realm="$KC_REALM" -s enabled=true
$KCADM create users -r "$KC_REALM" -s username=alice -s enabled=true -s [email protected] -s emailVerified=true -s firstName=Alice -s lastName=Lab
$KCADM set-password -r "$KC_REALM" --username alice --new-password "$ALICE_PASSWORD"
# The agent client: confidential. Password grant is on only because this is a lab; the PAR step uses the code flow.
$KCADM create clients -r "$KC_REALM" -s clientId=agent -s publicClient=false -s secret="$AGENT_SECRET" \
-s directAccessGrantsEnabled=true -s standardFlowEnabled=true -s "redirectUris=[\"$REDIRECT_URI\"]"
echo "realm $KC_REALM ready" python3 -m venv .venv
.venv/bin/pip install -q PyJWT==2.15.1 cryptography==50.0.2 httpx==0.28.1
.venv/bin/pip list 2>/dev/null | grep -i -E "^(pyjwt|cryptography|httpx) " Salida esperada
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
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
{
"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
"""DPoP lab: get a DPoP-bound token from Keycloak, check cnf.jkt, call userinfo with and without a proof.
Tested with Keycloak 26.8.2, PyJWT 2.15.1, cryptography 50.0.2 and httpx 0.28.1. Lab-only secrets, read from the environment."""
import base64, hashlib, json, os, time, uuid
import httpx, jwt
from cryptography.hazmat.primitives.asymmetric import ec
TOKEN_URL = os.environ["TOKEN_URL"]
USERINFO = TOKEN_URL.replace("/token", "/userinfo")
def new_key():
key = ec.generate_private_key(ec.SECP256R1())
pub = json.loads(jwt.algorithms.ECAlgorithm.to_jwk(key.public_key()))
return key, {k: pub[k] for k in ("crv", "kty", "x", "y")}
def thumbprint(pub): # RFC 7638: SHA-256 over the required members in lexicographic order
return b64(hashlib.sha256(json.dumps(pub, separators=(",", ":"), sort_keys=True).encode()).digest())
def b64(raw):
return base64.urlsafe_b64encode(raw).rstrip(b"=").decode()
def proof(key, pub, htm, htu, ath=None, jti=None):
claims = {"jti": jti or str(uuid.uuid4()), "htm": htm, "htu": htu, "iat": int(time.time())}
if ath:
claims["ath"] = ath # hash of the access token, binds the proof to this token
return jwt.encode(claims, key, algorithm="ES256", headers={"typ": "dpop+jwt", "jwk": pub})
key, pub = new_key()
r = httpx.post(TOKEN_URL, headers={"DPoP": proof(key, pub, "POST", TOKEN_URL)}, data={
"grant_type": "password", "client_id": "agent", "client_secret": os.environ["AGENT_SECRET"],
"username": "alice", "password": os.environ["ALICE_PASSWORD"], "scope": "openid"})
body = r.json()
print("token_type:", body.get("token_type"), body.get("error_description", ""))
at = body["access_token"]
cnf = jwt.decode(at, options={"verify_signature": False}).get("cnf")
print("cnf.jkt equals our key's thumbprint:", cnf.get("jkt") == thumbprint(pub))
ath = b64(hashlib.sha256(at.encode()).digest())
def userinfo(label, headers):
print(f"{label}:", httpx.get(USERINFO, headers=headers).status_code)
userinfo("userinfo with a DPoP proof", {"Authorization": f"DPoP {at}", "DPoP": proof(key, pub, "GET", USERINFO, ath)})
userinfo("userinfo as plain Bearer (stolen token, no proof)", {"Authorization": f"Bearer {at}"})
other, other_pub = new_key()
userinfo("userinfo with a proof from a different key", {"Authorization": f"DPoP {at}", "DPoP": proof(other, other_pub, "GET", USERINFO, ath)})
reused = proof(key, pub, "GET", USERINFO, ath)
userinfo("userinfo, proof used once", {"Authorization": f"DPoP {at}", "DPoP": reused})
userinfo("userinfo, same proof replayed", {"Authorization": f"DPoP {at}", "DPoP": reused}) .venv/bin/python dpop_lab.py Salida esperada
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)
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
{
"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
# 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
{
"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
"""PAR + PKCE + DPoP authorization code flow against Keycloak, driven from a script (no browser).
Tested with Keycloak 26.8.2, PyJWT 2.15.1, cryptography 50.0.2 and httpx 0.28.1. Lab-only secrets, read from the environment."""
import base64, hashlib, json, os, re, secrets, time, uuid
from urllib.parse import urlparse, parse_qs, urlencode
import httpx, jwt
from cryptography.hazmat.primitives.asymmetric import ec
E = os.environ
TOKEN_URL, PAR_URL, AUTH_URL, REDIRECT = E["TOKEN_URL"], E["PAR_URL"], E["AUTH_URL"], E["REDIRECT_URI"]
def b64(raw): return base64.urlsafe_b64encode(raw).rstrip(b"=").decode()
def new_key():
key = ec.generate_private_key(ec.SECP256R1())
pub = json.loads(jwt.algorithms.ECAlgorithm.to_jwk(key.public_key()))
return key, {k: pub[k] for k in ("crv", "kty", "x", "y")}
def jkt(pub): return b64(hashlib.sha256(json.dumps(pub, separators=(",", ":"), sort_keys=True).encode()).digest())
def proof(key, pub, htm, htu):
claims = {"jti": str(uuid.uuid4()), "htm": htm, "htu": htu, "iat": int(time.time())}
return jwt.encode(claims, key, algorithm="ES256", headers={"typ": "dpop+jwt", "jwk": pub})
def flow(label, redeem_with_wrong_key=False):
key, pub = new_key()
verifier = b64(secrets.token_bytes(32))
challenge = b64(hashlib.sha256(verifier.encode()).digest())
# 1. Push the request over the back channel. dpop_jkt binds the authorization code to our key.
par = httpx.post(PAR_URL, auth=("agent", E["AGENT_SECRET"]), data={
"response_type": "code", "client_id": "agent", "redirect_uri": REDIRECT, "scope": "openid", "state": "lab",
"code_challenge": challenge, "code_challenge_method": "S256", "dpop_jkt": jkt(pub)})
par_body = par.json()
request_uri = par_body["request_uri"]
print(f"[{label}] PAR status {par.status_code}, expires_in {par_body['expires_in']}, request_uri is a urn:ietf:params:oauth:request_uri value: {request_uri.startswith('urn:ietf:params:oauth:request_uri:')}")
# 2. The browser only carries client_id and the request_uri. A tiny cookie jar stands in for the browser.
jar = {}
def browse(method, url, **kw):
r = httpx.request(method, url, cookies=jar, follow_redirects=False, **kw)
for line in r.headers.get_list("set-cookie"):
name, _, rest = line.partition("=")
jar[name] = rest.split(";")[0]
return r
page = browse("GET", AUTH_URL, params={"client_id": "agent", "request_uri": request_uri})
while page.status_code == 302:
page = browse("GET", page.headers["location"])
form = re.search(r'<form[^>]*id="kc-form-login"[^>]*action="([^"]+)"', page.text)
print(f"[{label}] authorization endpoint with the request_uri: {page.status_code}, login form found: {bool(form)}")
done = browse("POST", form.group(1).replace("&", "&"), data={"username": "alice", "password": E["ALICE_PASSWORD"]})
query = parse_qs(urlparse(done.headers["location"]).query)
code = query["code"][0]
print(f"[{label}] sign-in redirect: {done.status_code}, code returned: {bool(code)}, state returned: {query['state'][0]}")
again = browse("GET", AUTH_URL, params={"client_id": "agent", "request_uri": request_uri})
print(f"[{label}] same request_uri used a second time: {again.status_code}")
# 3. Redeem the code with a DPoP proof (ours, or a different key's).
use_key, use_pub = (new_key() if redeem_with_wrong_key else (key, pub))
tok = httpx.post(TOKEN_URL, headers={"DPoP": proof(use_key, use_pub, "POST", TOKEN_URL)}, data={
"grant_type": "authorization_code", "code": code, "redirect_uri": REDIRECT, "client_id": "agent",
"client_secret": E["AGENT_SECRET"], "code_verifier": verifier})
body = tok.json()
if tok.status_code == 200:
cnf = jwt.decode(body["access_token"], options={"verify_signature": False}).get("cnf", {})
print(f"[{label}] token endpoint: {tok.status_code}, token_type {body['token_type']}, cnf.jkt equals our key: {cnf.get('jkt') == jkt(pub)}")
else:
print(f"[{label}] token endpoint: {tok.status_code}, error {body.get('error')}")
def expiry():
key, pub = new_key()
par = httpx.post(PAR_URL, auth=("agent", E["AGENT_SECRET"]), data={
"response_type": "code", "client_id": "agent", "redirect_uri": REDIRECT, "scope": "openid", "state": "lab",
"code_challenge": b64(hashlib.sha256(b"unused-verifier").digest()), "code_challenge_method": "S256"})
time.sleep(par.json()["expires_in"] + 2)
late = httpx.get(AUTH_URL, params={"client_id": "agent", "request_uri": par.json()["request_uri"]}, follow_redirects=True)
print(f"[expiry] request_uri opened {par.json()['expires_in'] + 2} seconds after it was pushed: {late.status_code}")
flow("our key")
flow("other key", redeem_with_wrong_key=True)
expiry() .venv/bin/python par_flow.py Salida esperada
[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
# 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
000 Fuentes#
- Hudson Rock (InfoStealers), Inside the AI-Powered Marketplace Turning Infected Computers Into Searchable Profiles (15 Nov 2026)
- RFC 9449: OAuth 2.0 Demonstrating Proof of Possession (DPoP)
- RFC 9126: OAuth 2.0 Pushed Authorization Requests
- RFC 9700: Best Current Practice for OAuth 2.0 Security
- RFC 7636: Proof Key for Code Exchange by OAuth Public Clients
- Keycloak Server Administration Guide: DPoP bound tokens
- Keycloak release notes (DPoP supported in 26.4.0, authorization code binding to a DPoP key in 26.1.0)
- IETF 127 slides: Identity Assertion Authorization Grant (Parecki, McGuinness, Campbell)
Este artículo en Markdown · RSS · JSON feed
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