En resumen
- Rehice el lab de OPA (Open Policy Agent) con Permit.io en el plan gratuito Community: un pequeño punto de aplicación convierte cada tools/call MCP (Model Context Protocol) en una petición AuthZEN (el estándar de autorización de OpenID) para el Edge PDP (punto de decisión de políticas) de Permit.
- Con roles y una regla ABAC (control de acceso basado en atributos), el Edge PDP denegó el pago de 90 dólares frente a un límite de 50 y permitió 45 dólares con confirmación. Dos permitidas, cuatro denegadas, igual que con OPA.
- Sin clave en el PEP (punto de aplicación de políticas) o con el PDP parado, cada llamada se quedó cerrada. El log dice si una denegación viene de la política o de un error.
- El Cloud PDP no evalúa ABAC: allí el mismo pago de 45 dólares se denegó. Elige el PDP según el modelo de política. Los modelos están en mi explainer sobre RBAC (control de acceso basado en roles), ABAC y ReBAC (control de acceso basado en relaciones).
- Antes de tener la clave, el PDP respondía 401, 403 o 503 y nunca con una decisión. La sección se queda, porque muestra cómo se ve un PDP mal configurado.
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: Permit.io detrás de AuthZEN: decidir qué llamadas MCP puede hacer un agente Read the whole lab here (Markdown): https://iamops.dev/es/permit-authzen-mcp-tool-call-policy.md What the lab needs before the first step: - A free Permit.io account; the API key of its Development environment typed at the env.sh prompt - Linux with Podman 5 or Docker, curl, jq and Python 3.10 or newer 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.
A principios de mes construí un punto de decisión para llamadas a herramientas MCP con OPA: un agente propone un tools/call, algo delante del servidor MCP pregunta a un motor de políticas, y el motor responde sí o no mediante AuthZEN. Esta vez el motor es Permit.io.
Permit.io encaja bien en la comparación por dos motivos. Su PDP habla AuthZEN 1.0 sin configuración extra, y en marzo el equipo lanzó Permit MCP Gateway, un proxy delante de los servidores MCP que comprueba cada llamada contra Permit. Su artículo sobre las seis capas que todo gateway MCP debe aplicar es una lista breve y útil de lo que un gateway tiene que hacer aparte de enrutar.
Usé solo lo que incluye el plan gratuito Community. Las cuentas nuevas empiezan con una prueba Pro de 14 días, pero este lab no la necesita: RBAC, ABAC, el Edge PDP y el registro de auditoría están todos en el plan gratuito.
Cómo modela Permit las llamadas MCP#
La documentación de arquitectura del gateway describe la correspondencia. Cada servidor MCP se convierte en un tipo de recurso de Permit, con la clave del servidor. Cada herramienta se convierte en una acción sobre ese tipo de recurso. Para una llamada, el gateway ejecuta un permit.check() con el agente como usuario, el nombre de la herramienta como acción y el servidor como recurso, más una segunda comprobación para la persona cuando un admin importó el servidor. Las dos tienen que permitir.
Encima hay niveles de confianza (bajo para lecturas, medio para escrituras, alto para borrados) y un techo: el agente nunca obtiene más de lo que el admin dio a la persona. Permit construye ese techo con reglas ReBAC. La documentación también dice que si el PDP no responde, el gateway rechaza la petición con el error JSON-RPC (llamadas a procedimiento remoto en JavaScript Object Notation) -32005. Una denegación normal es -32004. Reutilicé -32004 en mi punto de aplicación.
El PDP es la parte que probé. Permit ofrece tres tipos. El Cloud PDP está alojado en cloudpdp.api.permit.io y cubre RBAC y ReBAC. El Edge PDP es un contenedor de código abierto (permitio/pdp-v2) que incluye OPA y el cliente OPAL (Open Policy Administration Layer) y cubre también ABAC. Nexus PDP es un contenedor más reciente con almacenamiento en disco. Los tres sirven los endpoints AuthZEN: evaluación, evaluaciones por lotes, las tres API (interfaz de programación) de búsqueda y el documento de descubrimiento.

Preparación#
Usé Podman 5.4.2 en Debian 13 para la imagen Edge PDP permitio/pdp-v2:0.9.17, Python 3.13, el SDK (kit de desarrollo de software) de Python de Permit 3.0.1 (el paquete en el Python Package Index se llama permit), curl y jq. Todo escucha en localhost: 7766 para el PDP y 8383 para el punto de aplicación. Docker funciona igual: cambia podman por docker.
Necesitas una cuenta gratuita de Permit.io. Regístrate en app.permit.io, abre el entorno Development del proyecto por defecto y copia su clave API en Settings, API Keys. El lab lee la clave desde un aviso oculto a una sola variable del shell. Nunca va a un archivo, un log o una captura, y el contenedor PDP la recibe como PDP_API_KEY.
El escenario es el del lab de OPA. Un agente llamado support-bot puede leer el saldo y los movimientos, y puede enviar pagos de hasta 5000 céntimos, 50 dólares, cuando el usuario ha confirmado. read-bot solo puede leer. Las herramientas son get_balance, list_transactions y send_payment en un servidor MCP, payments_mcp. delete_account no existe.
La política#
setup_permit.py crea la política mediante la API de Permit, así que puedes reconstruirla en cualquier entorno y quitarla con cleanup_permit.py:
- Tipo de recurso
payments_mcpcon las tres herramientas como acciones y dos atributos,amount_centsyuser_confirmed. - Un atributo de usuario
limit_cents, a 5000 para los dos agentes. - Dos roles en lugar de los scopes:
payments_readercon las dos herramientas de lectura (RBAC), ypayments_writersin permisos simples. - Un resource set ABAC,
payment_within_limit:resource.amount_centsmenor o igual queuser.limit_cents, comparados por referencia, yresource.user_confirmedigual a true.payments_writerobtienesend_paymentsolo sobre ese conjunto.





El PDP descargó la política dentro de los 30 segundos que le di, y /healthy indicó ok para sus dos partes.
El punto de aplicación#
pep.py recibe un tools/call JSON-RPC, obtiene el agente de la cabecera de sesión y envía a Permit una Access Evaluation AuthZEN. La forma sigue la correspondencia del gateway: el sujeto es el agente, la acción es el nombre de la herramienta, el recurso es el servidor MCP. El importe y la confirmación van en resource.properties, porque la documentación de Permit dice que el PDP lee tenant de ahí y pasa las demás claves a la política como atributos del recurso.
body = {
"subject": {"type": "user", "id": agent},
"action": {"name": tool},
"resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {
"tenant": "default",
"amount_cents": args.get("amount_cents", 0),
"user_confirmed": bool(args.get("user_confirmed", False)),
}},
}Las líneas importantes son las que siguen a la llamada. Solo HTTP (Hypertext Transfer Protocol) 200 con "decision": true permite. Cualquier error HTTP, un tiempo agotado, una conexión rechazada o una respuesta sin booleano es una denegación, y el log dice cuál fue.
Permit responde con algo más que la decisión. El campo context lleva el razonamiento, incluidos los roles del agente y su limit_cents. pep.py guarda los códigos cortos del motivo para su propio log y al agente solo le dice denied: policy. Un agente que puede leer el límite puede aprender a partir un pago para quedarse por debajo.
Prueba 1: AuthZEN con clave#
Primero comprobé los endpoints AuthZEN directamente, con la clave en la cabecera bearer: el documento de descubrimiento, una evaluación para get_balance, un lote de cuatro pagos en una sola petición y una búsqueda de los sujetos que pueden llamar a get_balance.

El lote es la política en cuatro líneas. 90 dólares frente al límite de 50: false. 45 dólares confirmados: true, permitido por la regla ABAC. 45 dólares sin confirmar: false. Los mismos 45 dólares por parte de read-bot, indicado como sujeto del elemento del lote: false. La búsqueda de sujetos encontró a los dos agentes, porque los dos tienen payments_reader. La búsqueda de acciones devolvió una lista vacía para los dos agentes en mi prueba. No investigué por qué, así que aquí no me apoyo en ella.
Prueba 2: seis llamadas por el punto de aplicación#
Después arranqué pep.py y envié las seis llamadas del lab de OPA: una lectura del saldo, un pago de 90 dólares, uno de 45 con y sin confirmación, un pago de read-bot y el desconocido delete_account.

Los resultados coinciden con el lab de OPA. Dos llamadas pasaron: la lectura del saldo, permitida por el rol, y el pago confirmado de 45 dólares, permitido por la regla ABAC. La política denegó cuatro. Para delete_account el PDP dijo no_such_action: la herramienta no es una acción de payments_mcp, así que ningún rol puede concederla.
Cada decisión llegó también al registro de auditoría de Permit. Las conté con la API del registro de auditoría: usuario, acción, tipo de recurso y decisión para cada llamada de esta prueba, incluidas las del Cloud PDP en la prueba 4.


Prueba 3: fail closed con una política activa#
Una política que funciona no elimina el camino de error. Reinicié pep.py con una clave vacía contra el mismo PDP sano, y luego paré el contenedor PDP y volví a enviar el pago de 45 dólares.

Las dos veces se rechazó el pago confirmado de 45 dólares, que la política permite. La línea del log dice por qué: pdp error HTTP 403 y pdp unreachable, no decision false. Esa diferencia es la que debe vigilar una alerta.
Prueba 4: el Cloud PDP no evalúa ABAC#
El Cloud PDP aceptó la misma clave y el mismo lote, y respondió false cuatro veces. El motivo estaba en el context: ABAC is not supported yet in the Cloud PDP. Con pep.py apuntando al Cloud PDP, la lectura del saldo siguió pasando por el rol, pero el pago confirmado de 45 dólares se rechazó.

Se queda cerrado, que es la dirección segura, pero parecería una política rota si no lo supieras. Límites como este necesitan el Edge PDP, o una política que no dependa de ABAC.
Antes de la clave: qué hace un PDP sin clave#
Antes de que existiera la cuenta ejecuté el mismo lab sin clave. Mantengo estos resultados porque muestran cómo se ve un PDP mal configurado desde el punto de aplicación.
El contenedor arrancó sin PDP_API_KEY y no terminó. Su watchdog reiniciaba una y otra vez el servidor API interno, y /healthy indicaba un error.

Las peticiones AuthZEN recibían códigos de estado y nunca una decisión: 401 sin cabecera, 403 con un token bearer vacío y 503 con una clave incorrecta. El contenedor también pedía un token para el documento de descubrimiento.

Las seis llamadas por pep.py se denegaron, cada una con pdp error HTTP 403. El resultado correcto por el motivo equivocado. Para el agente, un PDP que perdió su clave se ve igual que una política estricta, así que solo el log puede distinguirlos.

El Cloud PDP servía su documento de descubrimiento sin token y respondía 401 a una evaluación sin token. Los cuerpos de error son distintos: JSON en el Cloud PDP, texto plano en el contenedor.

Trampas#
- El Cloud PDP ignora ABAC. Responde false con
NOT_SUPPORTEDen el context. Para reglas de atributos usa el Edge PDP. Tampoco envía cabeceras CORS (Cross-Origin Resource Sharing), así que un navegador no puede leer sus respuestas: llámelo desde un servidor. - El context de la decisión cuenta mucho. Roles, atributos y nombres de reglas vuelven con cada respuesta. Registra los códigos, no se los pases al agente.
- Una clave que falta no es una política. El contenedor sigue en marcha y responde 401, 403 o 503 según lo que envíes. Solo el PEP puede convertir eso en una denegación segura.
- El sujeto viene de la sesión.
pep.pyignora cualquier nombre de agente en los argumentos. Lo mismo vale parauser_confirmed: en un gateway real debe venir de un paso de confirmación que el modelo no pueda falsificar. - Las listas de herramientas no se filtran. Según la documentación del gateway de Permit,
tools/listdevuelve todas las herramientas de origen y el control ocurre en cada llamada. Un agente puede ver una herramienta que no puede usar. - El gateway usa el check del SDK, no AuthZEN. AuthZEN es la forma en que otro PEP, como el mío, habla con el mismo PDP.
Qué haría con esto#
- Hacer que el punto de aplicación se cierre ante errores y registre el motivo, y luego parar el PDP en una prueba y comprobar la línea del log.
- Alertar cuando las denegaciones vengan de errores del PDP y no de decisiones de política.
- Mantener la clave del PDP del lado del servidor, en el gateway o en un sidecar, nunca en un navegador ni en el prompt de un agente.
- Elegir el tipo de PDP según el modelo de política: límites ABAC como este necesitan el Edge PDP.
- Quitar el context de la decisión antes de que algo vuelva al agente.
Qué no se probó#
Este lab usa su propio pequeño punto de aplicación en lugar del Permit MCP Gateway alojado. Solo usa funciones del plan gratuito Community.
Las imágenes de terminal se generaron a partir de la salida guardada del 22 de noviembre de 2026; las capturas de la consola son del mismo día. La clave nunca aparece.
Repite este lab#
Este lab necesita una cuenta gratuita de Permit.io, Linux con Podman o Docker, curl, jq y Python 3.10 o posterior. Cuenta con unos 25 minutos. env.sh pide la clave API de tu entorno Development en un aviso oculto; mantenla fuera de archivos, chats y capturas. 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.
export PDP_IMAGE="docker.io/permitio/pdp-v2:0.9.17"
export PDP_URL="http://localhost:7766"
# The API key of your Permit.io Development environment (Settings, API Keys). Type it at the prompt;
# it stays in this shell only. Never put it in a file you commit, a chat or a screenshot.
read -rsp "Permit API key: " PERMIT_API_KEY; echo; export PERMIT_API_KEY
# Headers for every AuthZEN call to the PDP.
AUTHZ=(-H "authorization: Bearer $PERMIT_API_KEY" -H "content-type: application/json") 0 de 7 pasos hechos
Paso 1Carga la política en tu entorno de Permit
Objetivo. Instala el SDK de Python de Permit en un entorno virtual y ejecuta setup_permit.py para crear el recurso, los roles, el resource set ABAC y dos agentes.
Requisitos
- Una cuenta gratuita de Permit.io; la clave API de su entorno Development escrita en el aviso de env.sh
- Linux con Podman 5 o Docker, curl, jq y Python 3.10 o posterior
cat > setup_permit.py <<'EOF'
"""Create the lab policy in a Permit.io environment (free Community plan).
Reads PERMIT_API_KEY from the environment. Run once; cleanup_permit.py removes it.
Model: one resource type per MCP server, one action per tool (the way Permit MCP Gateway maps servers and tools)."""
import asyncio, inspect, os
from permit import Permit
permit = Permit(token=os.environ["PERMIT_API_KEY"], pdp=os.environ.get("PDP_URL", "http://localhost:7766"))
api = permit.api
async def call(result):
return await result if inspect.isawaitable(result) else result
async def main():
# The MCP server "payments_mcp" and its three tools. Payment calls carry the amount and the confirmation.
await call(api.resources.create({
"key": "payments_mcp", "name": "Payments MCP server",
"actions": {"get_balance": {}, "list_transactions": {}, "send_payment": {}},
"attributes": {"amount_cents": {"type": "number"}, "user_confirmed": {"type": "bool"}},
}))
# The agent's delegated limit is a user attribute.
await call(api.resource_attributes.create("__user", {"key": "limit_cents", "type": "number"}))
# Scopes become roles. The reader can call the two read tools on every call.
await call(api.roles.create({"key": "payments_reader", "name": "payments.read",
"permissions": ["payments_mcp:get_balance", "payments_mcp:list_transactions"]}))
# The writer gets send_payment only on calls inside the limit and confirmed by the user.
await call(api.roles.create({"key": "payments_writer", "name": "payments.write"}))
await call(api.condition_sets.create({
"key": "payment_within_limit", "name": "Payment within limit and confirmed",
"type": "resourceset", "resource_id": "payments_mcp",
"conditions": {"allOf": [
{"resource.amount_cents": {"less-than-equals": {"ref": "user.limit_cents"}}},
{"resource.user_confirmed": {"equals": True}},
]},
}))
await call(api.condition_set_rules.create({
"user_set": "payments_writer", "is_role": True,
"permission": "payments_mcp:send_payment", "resource_set": "payment_within_limit",
}))
# Two agents: support-bot holds both scopes and a 5000-cent limit, read-bot only reads.
for key, roles in (("support-bot", ["payments_reader", "payments_writer"]), ("read-bot", ["payments_reader"])):
await call(api.users.sync({"key": key, "attributes": {"limit_cents": 5000}}))
for role in roles:
await call(api.users.assign_role({"user": key, "role": role, "tenant": "default"}))
print("policy created: payments_mcp, 2 roles, 1 resource set, 2 agents")
asyncio.run(main())
EOF python3 -m venv .venv && .venv/bin/pip install -q permit==3.0.1
.venv/bin/python setup_permit.py Salida esperada
policy created: payments_mcp, 2 roles, 1 resource set, 2 agents Paso 2Arranca el Edge PDP de Permit con la clave
Objetivo. Arranca la imagen Edge PDP con la versión fija y PDP_API_KEY desde la variable del shell, espera a que descargue la política y lee su endpoint de salud.
Requisitos
- La política del paso anterior existe
- Puertos 7766 y 8383 libres
podman pull -q $PDP_IMAGE > /dev/null
podman run -d --name permit-pdp -p 7766:7000 -e PDP_API_KEY=$PERMIT_API_KEY $PDP_IMAGE | cut -c1-12
sleep 30
podman ps --format "{{.Names}} {{.Image}} {{.Status}}"
curl -s $PDP_URL/healthy | jq -c '{status, opa: .components.opa.status, horizon: .components.horizon.status}' Salida esperada
<container-id>
permit-pdp docker.io/permitio/pdp-v2:0.9.17 Up 30 seconds
{"status":"ok","opa":"ok","horizon":"ok"} Paso 3Pregunta al PDP por AuthZEN
Objetivo. Lee el documento de descubrimiento, envía una evaluación, un lote de cuatro pagos y una búsqueda de sujetos, y compara las decisiones.
Requisitos
- El PDP está sano
cat > get_balance.json <<'EOF'
{"subject": {"type": "user", "id": "support-bot"},
"action": {"name": "get_balance"},
"resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {"tenant": "default"}}}
EOF
cat > batch.json <<'EOF'
{"subject": {"type": "user", "id": "support-bot"},
"action": {"name": "send_payment"},
"evaluations": [
{"resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {"tenant": "default", "amount_cents": 9000, "user_confirmed": true}}},
{"resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {"tenant": "default", "amount_cents": 4500, "user_confirmed": true}}},
{"resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {"tenant": "default", "amount_cents": 4500, "user_confirmed": false}}},
{"subject": {"type": "user", "id": "read-bot"}, "resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {"tenant": "default", "amount_cents": 4500, "user_confirmed": true}}}
]}
EOF
cat > search.json <<'EOF'
{"subject": {"type": "user"},
"action": {"name": "get_balance"},
"resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {"tenant": "default"}}}
EOF
curl -s $PDP_URL/.well-known/authzen-configuration "${AUTHZ[@]}" | jq -c '[keys[] | sub("_endpoint$"; "")]'
curl -s -X POST $PDP_URL/access/v1/evaluation "${AUTHZ[@]}" -d @get_balance.json \
| jq -c '{decision, roles: .context.rbac.allowing_roles}'
curl -s -X POST $PDP_URL/access/v1/evaluations "${AUTHZ[@]}" -d @batch.json \
| jq -c '.evaluations[] | {decision, rbac: .context.rbac.code, abac: .context.abac.code}'
curl -s -X POST $PDP_URL/access/v1/search/subject "${AUTHZ[@]}" -d @search.json | jq -c '.results' Salida esperada
["access_evaluation","access_evaluations","policy_decision_point","search_action","search_resource","search_subject"]
{"decision":true,"roles":["payments_reader"]}
{"decision":false,"rbac":"no_permission","abac":"no_matching_rules"}
{"decision":true,"rbac":null,"abac":"allow"}
{"decision":false,"rbac":"no_permission","abac":"no_matching_rules"}
{"decision":false,"rbac":"no_permission","abac":"no_matching_rules"}
[{"type":"user","id":"support-bot"},{"type":"user","id":"read-bot"}] Paso 4Pasa seis llamadas por el punto de aplicación
Objetivo. Escribe pep.py y calls.sh, arranca el punto de aplicación y envía las seis llamadas MCP del lab de OPA.
Requisitos
- El PDP está sano
- Puerto 8383 libre
cat > pep.py <<'EOF'
"""A tiny enforcement point in front of an MCP server, for the lab only.
It takes an MCP JSON-RPC tools/call, builds an AuthZEN Access Evaluation from what the
gateway knows (the session), not from what the model wrote, and asks the PDP.
Anything other than HTTP 200 with "decision": true is a deny. Standard library only."""
import json, os, urllib.request
from http.server import BaseHTTPRequestHandler, HTTPServer
PDP = os.environ.get("PDP_URL", "http://localhost:7766") + "/access/v1/evaluation"
KEY = os.environ.get("PERMIT_API_KEY", "")
# Stand-in for a verified session: in a real gateway this comes from the token and the delegation record.
SESSIONS = {"s-support": "support-bot", "s-read": "read-bot"}
def ask_pdp(agent, tool, args):
body = {
"subject": {"type": "user", "id": agent},
"action": {"name": tool},
"resource": {"type": "payments_mcp", "id": "payments_mcp", "properties": {
"tenant": "default",
"amount_cents": args.get("amount_cents", 0),
"user_confirmed": bool(args.get("user_confirmed", False)),
}},
}
req = urllib.request.Request(PDP, data=json.dumps(body).encode(), method="POST", headers={
"content-type": "application/json", "authorization": f"Bearer {KEY}"})
try:
with urllib.request.urlopen(req, timeout=3) as r:
answer = json.load(r)
except urllib.error.HTTPError as e:
return False, f"pdp error HTTP {e.code}, fail closed"
except Exception as e:
return False, f"pdp unreachable ({type(e).__name__}), fail closed"
if not isinstance(answer, dict):
return False, "pdp sent no decision, fail closed"
# Permit puts its reasoning in "context". Keep the codes for our log, never send them to the agent.
ctx = answer.get("context") or {}
codes = ", ".join(f"{k} {ctx[k]['code']}" for k in ("rbac", "abac", "rebac")
if isinstance(ctx.get(k), dict) and "code" in ctx[k])
return answer.get("decision") is True, f"decision {json.dumps(answer.get('decision'))} ({codes or 'no context'})"
class Gateway(BaseHTTPRequestHandler):
def log_message(self, *a):
pass
def do_POST(self):
msg = json.loads(self.rfile.read(int(self.headers["content-length"])))
agent = SESSIONS.get(self.headers.get("x-session", ""))
params = msg.get("params", {})
if msg.get("method") != "tools/call" or not agent:
allowed, why = False, "no session or not a tools/call"
else:
allowed, why = ask_pdp(agent, params.get("name", ""), params.get("arguments", {}))
print(f"{agent} {params.get('name')} -> {'ALLOW' if allowed else 'DENY'}: {why}", flush=True)
if allowed:
out = {"jsonrpc": "2.0", "id": msg.get("id"),
"result": {"content": [{"type": "text", "text": f"called {params['name']} (stub)"}]}}
else:
# The agent learns that it was denied and whether the PDP failed, not the policy details.
reason = "policy" if why.startswith("decision") else why
out = {"jsonrpc": "2.0", "id": msg.get("id"), "error": {"code": -32004, "message": f"denied: {reason}"}}
data = json.dumps(out).encode()
self.send_response(200)
self.send_header("content-type", "application/json")
self.end_headers()
self.wfile.write(data)
HTTPServer(("127.0.0.1", 8383), Gateway).serve_forever()
EOF cat > calls.sh <<'EOF'
# Six MCP tool calls through the enforcement point on :8383.
call() { # session tool arguments-json
curl -s localhost:8383/mcp -H 'content-type: application/json' -H "x-session: $1" \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"'"$2"'","arguments":'"$3"'}}'; echo; }
call s-support get_balance '{}'
call s-support send_payment '{"amount_cents":9000,"user_confirmed":true}'
call s-support send_payment '{"amount_cents":4500,"user_confirmed":true}'
call s-support send_payment '{"amount_cents":4500,"user_confirmed":false}'
call s-read send_payment '{"amount_cents":4500,"user_confirmed":true}'
call s-support delete_account '{}'
EOF
python3 pep.py > pep.log &
sleep 1
bash calls.sh
cat pep.log Salida esperada
{"jsonrpc": "2.0", "id": 1, "result": {"content": [{"type": "text", "text": "called get_balance (stub)"}]}}
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: policy"}}
{"jsonrpc": "2.0", "id": 1, "result": {"content": [{"type": "text", "text": "called send_payment (stub)"}]}}
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: policy"}}
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: policy"}}
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: policy"}}
support-bot get_balance -> ALLOW: decision true (rbac allow)
support-bot send_payment -> DENY: decision false (rbac no_permission, abac no_matching_rules)
support-bot send_payment -> ALLOW: decision true (abac allow)
support-bot send_payment -> DENY: decision false (rbac no_permission, abac no_matching_rules)
read-bot send_payment -> DENY: decision false (rbac no_permission, abac no_matching_rules)
support-bot delete_account -> DENY: decision false (rbac no_such_action, abac no_matching_rules) Paso 5Rompe la clave y luego para el PDP
Objetivo. Reinicia el punto de aplicación con una clave vacía, luego para el contenedor PDP, y envía cada vez el pago permitido de 45 dólares.
Requisitos
- pep.py y calls.sh del paso anterior
pkill -f "python3 pep.py"; sleep 1
env -u PERMIT_API_KEY python3 pep.py > pep.log &
sleep 1
bash calls.sh | sed -n 3p
pkill -f "python3 pep.py"; sleep 1
python3 pep.py >> pep.log &
podman stop permit-pdp > /dev/null && podman ps -a --format "{{.Names}} {{.Status}}"
sleep 1
bash calls.sh | sed -n 3p
cat pep.log | sed -n '3p;9p'
podman start permit-pdp > /dev/null Salida esperada
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: pdp error HTTP 403, fail closed"}}
permit-pdp Exited (0) Less than a second ago
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: pdp unreachable (URLError), fail closed"}}
support-bot send_payment -> DENY: pdp error HTTP 403, fail closed
support-bot send_payment -> DENY: pdp unreachable (URLError), fail closed Paso 6Envía el mismo lote al Cloud PDP
Objetivo. Envía el lote al Cloud PDP de Permit con la misma clave, luego apunta el punto de aplicación hacia él y envía las tres primeras llamadas.
Requisitos
- HTTPS saliente hacia cloudpdp.api.permit.io
curl -s -X POST https://cloudpdp.api.permit.io/access/v1/evaluations "${AUTHZ[@]}" -d @batch.json \
| jq -c '.evaluations[] | {decision, abac: .context.abac.reason}'
pkill -f "python3 pep.py"; sleep 1
PDP_URL=https://cloudpdp.api.permit.io python3 pep.py > pep.log &
sleep 1
bash calls.sh | head -3
cat pep.log | head -3 Salida esperada
{"decision":false,"abac":"ABAC is not supported yet in the Cloud PDP"}
{"decision":false,"abac":"ABAC is not supported yet in the Cloud PDP"}
{"decision":false,"abac":"ABAC is not supported yet in the Cloud PDP"}
{"decision":false,"abac":"ABAC is not supported yet in the Cloud PDP"}
{"jsonrpc": "2.0", "id": 1, "result": {"content": [{"type": "text", "text": "called get_balance (stub)"}]}}
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: policy"}}
{"jsonrpc": "2.0", "id": 1, "error": {"code": -32004, "message": "denied: policy"}}
support-bot get_balance -> ALLOW: decision true (abac ABAC_EARLY_EXIT, rebac EARLY_EXIT)
support-bot send_payment -> DENY: decision false (rbac NO_PERMISSION, abac NOT_SUPPORTED, rebac NO_PERMISSION)
support-bot send_payment -> DENY: decision false (rbac NO_PERMISSION, abac NOT_SUPPORTED, rebac NO_PERMISSION) Paso 7Limpieza
Objetivo. Para el punto de aplicación, borra el contenedor, elimina la política de tu entorno de Permit y borra los archivos.
Requisitos
- Nada más usa los puertos 7766 y 8383
cat > cleanup_permit.py <<'EOF'
"""Remove what setup_permit.py created. Reads PERMIT_API_KEY from the environment."""
import asyncio, inspect, os
from permit import Permit
api = Permit(token=os.environ["PERMIT_API_KEY"]).api
async def call(result):
return await result if inspect.isawaitable(result) else result
async def main():
for step in (lambda: api.users.delete("support-bot"), lambda: api.users.delete("read-bot"),
lambda: api.condition_sets.delete("payment_within_limit"),
lambda: api.roles.delete("payments_writer"), lambda: api.roles.delete("payments_reader"),
lambda: api.resource_attributes.delete("__user", "limit_cents"),
lambda: api.resources.delete("payments_mcp")):
try:
await call(step())
except Exception as e: # keep going, report what is left
print("cleanup:", type(e).__name__, str(e)[:120])
print("cleanup done")
asyncio.run(main())
EOF
pkill -f "python3 pep.py"
podman rm -f permit-pdp > /dev/null
.venv/bin/python cleanup_permit.py
rm -rf .venv setup_permit.py cleanup_permit.py pep.py calls.sh get_balance.json batch.json search.json pep.log
podman ps -a --format "{{.Names}}" | grep -c permit-pdp
curl -s -o /dev/null -w "%{http_code}\n" localhost:8383 ; curl -s -o /dev/null -w "%{http_code}\n" localhost:7766/healthy Salida esperada
cleanup done
0
000
000 Fuentes#
- Permit.io blog, Announcing Permit MCP Gateway (17 Mar 2026)
- Permit.io blog, The Six Layers Every MCP Gateway Must Enforce (8 Apr 2026)
- Permit.io blog, Least Privilege in AI Agents and Agentic Identity
- Permit.io docs, Permit MCP Gateway
- Permit.io docs, Permit MCP Gateway architecture
- Permit.io docs, PDP overview and AuthZEN compatibility
- Permit.io docs, ABAC design patterns (compare two attributes)
- Permit.io pricing (Community plan)
- permitio/PDP on GitHub
- OpenID AuthZEN Authorization API 1.0 (Final)
- Model Context Protocol specification: Tools
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