En bref
- J’ai refait le lab OPA (Open Policy Agent) avec Permit.io sur le plan gratuit Community : un petit point d’application transforme chaque tools/call MCP (Model Context Protocol) en requête AuthZEN (le standard d’autorisation OpenID) pour l’Edge PDP (point de décision des politiques) de Permit.
- Avec des rôles et une règle ABAC (contrôle d’accès basé sur les attributs), l’Edge PDP a refusé le paiement de 90 dollars face à une limite de 50 et autorisé 45 dollars avec confirmation. Deux autorisés, quatre refusés, comme avec OPA.
- Sans clé dans le PEP (point d’application des politiques) ou avec le PDP arrêté, chaque appel est resté fermé. Le journal dit si un refus vient de la politique ou d’une erreur.
- Le Cloud PDP n’évalue pas ABAC : le même paiement de 45 dollars y a été refusé. Choisissez le PDP selon le modèle de politique. Les modèles sont dans mon explainer sur RBAC (contrôle d’accès basé sur les rôles), ABAC et ReBAC (contrôle d’accès basé sur les relations).
- Avant la clé, le PDP répondait 401, 403 ou 503 et jamais par une décision. Cette section reste, car elle montre à quoi ressemble un PDP mal configuré.
Refaire ce lab
J’ai écrit ce lab pour que vous puissiez le refaire vous-même. Chaque étape contient les commandes à copier et la sortie que j’ai obtenue, et vous pouvez la cocher une fois faite. Les coches restent uniquement dans ce navigateur.
Copie un prompt prêt à l’emploi pour Claude Code, Cursor, Codex ou tout autre agent de code. Pour les environnements de test uniquement.
Afficher le 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 derrière AuthZEN : décider quels appels MCP un agent peut faire Read the whole lab here (Markdown): https://iamops.dev/fr/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.
Au début du mois, j’ai construit un point de décision pour les appels d’outils MCP avec OPA : un agent propose un tools/call, quelque chose devant le serveur MCP interroge un moteur de politiques, et le moteur répond oui ou non via AuthZEN. Cette fois, le moteur est Permit.io.
Permit.io se prête bien à la comparaison pour deux raisons. Son PDP parle AuthZEN 1.0 sans effort, et en mars l’équipe a publié Permit MCP Gateway, un proxy placé devant les serveurs MCP qui vérifie chaque appel d’outil auprès de Permit. Leur article sur les six couches que tout gateway MCP doit appliquer est une liste courte et utile de ce qu’un gateway doit faire en plus du routage.
Je n’ai utilisé que ce que contient le plan gratuit Community. Les nouveaux comptes démarrent avec un essai Pro de 14 jours, mais ce lab n’en a pas besoin : RBAC, ABAC, l’Edge PDP et le journal d’audit sont tous dans le plan gratuit.
Comment Permit modélise les appels MCP#
La documentation d’architecture du gateway décrit la correspondance. Chaque serveur MCP devient un type de ressource Permit, avec la clé du serveur. Chaque outil devient une action sur ce type de ressource. Pour un appel, le gateway exécute un permit.check() avec l’agent comme utilisateur, le nom de l’outil comme action et le serveur comme ressource, plus une seconde vérification pour la personne quand un admin a importé le serveur. Les deux doivent autoriser.
Par-dessus viennent des niveaux de confiance (bas pour les lectures, moyen pour les écritures, haut pour les suppressions) et un plafond : l’agent n’obtient jamais plus que ce que l’admin a donné à la personne. Permit construit ce plafond avec des règles ReBAC. La documentation indique aussi que si le PDP ne répond pas, le gateway refuse la requête avec l’erreur JSON-RPC (appels de procédure à distance en JavaScript Object Notation) -32005. Un refus normal est -32004. J’ai repris -32004 dans mon point d’application.
Le PDP est la partie que j’ai testée. Permit en propose trois types. Le Cloud PDP est hébergé sur cloudpdp.api.permit.io et couvre RBAC et ReBAC. L’Edge PDP est un conteneur open source (permitio/pdp-v2) qui embarque OPA et le client OPAL (Open Policy Administration Layer) et couvre aussi ABAC. Nexus PDP est un conteneur plus récent avec un stockage sur disque. Les trois servent les endpoints AuthZEN : évaluation, évaluations par lot, les trois API (interface de programmation) de recherche et le document de découverte.

Mise en place#
J’ai utilisé Podman 5.4.2 sur Debian 13 pour l’image Edge PDP permitio/pdp-v2:0.9.17, Python 3.13, le SDK (kit de développement logiciel) Python de Permit 3.0.1 (le paquet sur le Python Package Index s’appelle permit), curl et jq. Tout écoute sur localhost : 7766 pour le PDP et 8383 pour le point d’application. Docker fonctionne de la même façon : remplacez podman par docker.
Il vous faut un compte Permit.io gratuit. Inscrivez-vous sur app.permit.io, ouvrez l’environnement Development du projet par défaut et copiez sa clé API dans Settings, API Keys. Le lab lit la clé depuis une invite masquée dans une seule variable du shell. Elle ne va jamais dans un fichier, un journal ou une capture d’écran, et le conteneur PDP la reçoit en tant que PDP_API_KEY.
Le scénario est celui du lab OPA. Un agent nommé support-bot peut lire le solde et les transactions, et envoyer des paiements jusqu’à 5000 centimes, soit 50 dollars, quand l’utilisateur a confirmé. read-bot peut seulement lire. Les outils sont get_balance, list_transactions et send_payment sur un serveur MCP, payments_mcp. delete_account n’existe pas.
La politique#
setup_permit.py crée la politique via l’API Permit, ce qui permet de la reconstruire dans n’importe quel environnement et de la supprimer avec cleanup_permit.py :
- Type de ressource
payments_mcpavec les trois outils comme actions, et deux attributs,amount_centsetuser_confirmed. - Un attribut utilisateur
limit_cents, fixé à 5000 pour les deux agents. - Deux rôles à la place des scopes :
payments_readeravec les deux outils de lecture (RBAC), etpayments_writersans permission simple. - Un resource set ABAC,
payment_within_limit:resource.amount_centsinférieur ou égal àuser.limit_cents, comparés par référence, etresource.user_confirmedégal à true.payments_writerobtientsend_paymentuniquement sur cet ensemble.





Le PDP a récupéré la politique dans les 30 secondes que je lui ai laissées, et /healthy a indiqué ok pour ses deux parties.
Le point d’application#
pep.py reçoit un tools/call JSON-RPC, retrouve l’agent à partir de l’en-tête de session et envoie à Permit une Access Evaluation AuthZEN. La forme suit la correspondance du gateway : le sujet est l’agent, l’action est le nom de l’outil, la ressource est le serveur MCP. Le montant et la confirmation vont dans resource.properties, car la documentation Permit indique que le PDP y lit tenant et transmet les autres clés à la politique comme attributs de ressource.
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)),
}},
}Les lignes importantes sont celles qui suivent l’appel. Seul un HTTP (Hypertext Transfer Protocol) 200 avec "decision": true autorise. Toute erreur HTTP, un délai dépassé, une connexion refusée ou une réponse sans booléen vaut refus, et le journal dit lequel.
Permit répond avec plus que la décision. Le champ context contient le raisonnement, y compris les rôles de l’agent et son limit_cents. pep.py garde les codes de raison courts pour son propre journal et ne dit à l’agent que denied: policy. Un agent qui peut lire la limite peut apprendre à découper un paiement pour rester en dessous.
Passage 1 : AuthZEN avec une clé#
J’ai d’abord vérifié les endpoints AuthZEN directement, avec la clé dans l’en-tête bearer : le document de découverte, une évaluation pour get_balance, un lot de quatre paiements en une seule requête, et une recherche des sujets qui peuvent appeler get_balance.

Le lot, c’est la politique en quatre lignes. 90 dollars face à la limite de 50 : false. 45 dollars confirmés : true, autorisé par la règle ABAC. 45 dollars non confirmés : false. Les mêmes 45 dollars par read-bot, indiqué comme sujet de l’élément du lot : false. La recherche de sujets a trouvé les deux agents, car tous deux ont payments_reader. La recherche d’actions a renvoyé une liste vide pour les deux agents lors de mon passage. Je n’ai pas cherché pourquoi, donc je ne m’appuie pas dessus ici.
Passage 2 : six appels par le point d’application#
J’ai ensuite démarré pep.py et envoyé les six appels du lab OPA : une lecture du solde, un paiement de 90 dollars, un de 45 dollars avec et sans confirmation, un paiement par read-bot, et l’inconnu delete_account.

Les résultats correspondent au lab OPA. Deux appels sont passés : la lecture du solde, autorisée par le rôle, et le paiement confirmé de 45 dollars, autorisé par la règle ABAC. Quatre ont été refusés par la politique. Pour delete_account, le PDP a répondu no_such_action : l’outil n’est pas une action de payments_mcp, donc aucun rôle ne peut l’accorder.
Chaque décision est aussi arrivée dans le journal d’audit de Permit. Je les ai comptées via l’API du journal d’audit : utilisateur, action, type de ressource et décision pour chaque appel de ce passage, y compris ceux du Cloud PDP au passage 4.


Passage 3 : fail closed avec une politique active#
Une politique qui fonctionne ne supprime pas le chemin d’erreur. J’ai relancé pep.py avec une clé vide face au même PDP en bonne santé, puis arrêté le conteneur PDP et renvoyé le paiement de 45 dollars.

Les deux fois, le paiement confirmé de 45 dollars, que la politique autorise, a été refusé. La ligne de journal dit pourquoi : pdp error HTTP 403 et pdp unreachable, pas decision false. C’est cette différence qu’une alerte doit surveiller.
Passage 4 : le Cloud PDP n’évalue pas ABAC#
Le Cloud PDP a accepté la même clé et le même lot, et a répondu false quatre fois. La raison était dans le context : ABAC is not supported yet in the Cloud PDP. Avec pep.py pointé vers le Cloud PDP, la lecture du solde passait toujours grâce au rôle, mais le paiement confirmé de 45 dollars a été refusé.

Cela reste fermé, ce qui est le sens sûr, mais on croirait à une politique cassée si on ne le savait pas. Les limites comme celle-ci demandent l’Edge PDP, ou une politique qui ne dépend pas d’ABAC.
Avant la clé : ce que fait un PDP sans clé#
Avant que le compte existe, j’ai exécuté le même lab sans clé. Je garde ces résultats, car ils montrent à quoi ressemble un PDP mal configuré vu du point d’application.
Le conteneur a démarré sans PDP_API_KEY et ne s’est pas arrêté. Son watchdog relançait sans cesse le serveur API interne, et /healthy signalait une erreur.

Les requêtes AuthZEN recevaient des codes de statut et jamais une décision : 401 sans en-tête, 403 avec un jeton bearer vide et 503 avec une mauvaise clé. Le conteneur exigeait aussi un jeton pour le document de découverte.

Les six appels passés par pep.py ont tous été refusés, chacun avec pdp error HTTP 403. Le bon résultat pour la mauvaise raison. Pour l’agent, un PDP qui a perdu sa clé ressemble à une politique stricte, donc seul le journal peut les distinguer.

Le Cloud PDP servait son document de découverte sans jeton et répondait 401 à une évaluation sans jeton. Les corps d’erreur diffèrent : JSON sur le Cloud PDP, texte brut sur le conteneur.

Pièges#
- Le Cloud PDP ignore ABAC. Il répond false avec
NOT_SUPPORTEDdans le context. Pour les règles d’attributs, utilisez l’Edge PDP. Il n’envoie pas non plus d’en-têtes CORS (Cross-Origin Resource Sharing) : un navigateur ne peut pas lire ses réponses, appelez-le depuis un serveur. - Le context de la décision en dit long. Rôles, attributs et noms de règles reviennent avec chaque réponse. Journalisez les codes, ne les transmettez pas à l’agent.
- Une clé manquante n’est pas une politique. Le conteneur reste actif et répond 401, 403 ou 503 selon ce que vous envoyez. Seul le PEP peut en faire un refus sûr.
- Le sujet vient de la session.
pep.pyignore tout nom d’agent dans les arguments. La même règle vaut pouruser_confirmed: dans un vrai gateway, il doit venir d’une étape de confirmation que le modèle ne peut pas falsifier. - Les listes d’outils ne sont pas filtrées. Selon la documentation du gateway Permit,
tools/listrenvoie tous les outils en amont et le contrôle se fait à chaque appel. Un agent peut voir un outil qu’il ne peut pas utiliser. - Le gateway utilise le check du SDK, pas AuthZEN. AuthZEN est la façon dont un autre PEP, comme le mien, parle au même PDP.
Ce que j’en ferais#
- Faire en sorte que le point d’application reste fermé en cas d’erreur et journalise pourquoi, puis arrêter le PDP dans un test et vérifier la ligne de journal.
- Alerter quand les refus viennent d’erreurs du PDP plutôt que de décisions de politique.
- Garder la clé du PDP côté serveur, dans le gateway ou un sidecar, jamais dans un navigateur ou dans le prompt d’un agent.
- Choisir le type de PDP selon le modèle de politique : des limites ABAC comme celle-ci demandent l’Edge PDP.
- Retirer le context de la décision avant que quoi que ce soit ne retourne à l’agent.
Ce qui n’a pas été testé#
Ce lab utilise son propre petit point d’application au lieu du Permit MCP Gateway hébergé. Il n’utilise que des fonctions du plan gratuit Community.
Les images de terminal sont générées à partir de la sortie enregistrée du 22 novembre 2026 ; les captures de la console datent du même jour. La clé n’apparaît jamais.
Refaire ce lab#
Ce lab demande un compte Permit.io gratuit, Linux avec Podman ou Docker, curl, jq et Python 3.10 ou plus récent. Comptez environ 25 minutes. env.sh demande la clé API de votre environnement Development dans une invite masquée ; gardez-la hors des fichiers, des chats et des captures. Ouvrez chaque étape, copiez les blocs et comparez la sortie avec la mienne.
Chaque valeur entre chevrons est un espace réservé pour votre environnement de test. Rien sur cette page n’est un identifiant ou un secret réel.
Définissez vos variables une seule fois
# 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") Étapes terminées : 0 sur 7
Étape 1Charger la politique dans votre environnement Permit
Objectif. Installez le SDK Python de Permit dans un environnement virtuel et lancez setup_permit.py pour créer la ressource, les rôles, le resource set ABAC et deux agents.
Prérequis
- Un compte Permit.io gratuit ; la clé API de son environnement Development saisie à l’invite de env.sh
- Linux avec Podman 5 ou Docker, curl, jq et Python 3.10 ou plus récent
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 Résultat attendu
policy created: payments_mcp, 2 roles, 1 resource set, 2 agents Étape 2Démarrer l’Edge PDP de Permit avec la clé
Objectif. Démarrez l’image Edge PDP à la version figée avec PDP_API_KEY tirée de la variable du shell, attendez qu’elle récupère la politique et lisez son endpoint de santé.
Prérequis
- La politique de l’étape précédente existe
- Ports 7766 et 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}' Résultat attendu
<container-id>
permit-pdp docker.io/permitio/pdp-v2:0.9.17 Up 30 seconds
{"status":"ok","opa":"ok","horizon":"ok"} Étape 3Interroger le PDP en AuthZEN
Objectif. Lisez le document de découverte, envoyez une évaluation, un lot de quatre paiements et une recherche de sujets, et comparez les décisions.
Prérequis
- Le PDP est en bonne santé
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' Résultat attendu
["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"}] Étape 4Faire passer six appels par le point d’application
Objectif. Écrivez pep.py et calls.sh, démarrez le point d’application et envoyez les six appels MCP du lab OPA.
Prérequis
- Le PDP est en bonne santé
- Port 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 Résultat attendu
{"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) Étape 5Casser la clé, puis arrêter le PDP
Objectif. Relancez le point d’application avec une clé vide, puis arrêtez le conteneur PDP, et envoyez chaque fois le paiement autorisé de 45 dollars.
Prérequis
- pep.py et calls.sh de l’étape précédente
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 Résultat attendu
{"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 Étape 6Envoyer le même lot au Cloud PDP
Objectif. Envoyez le lot au Cloud PDP de Permit avec la même clé, puis pointez le point d’application vers lui et envoyez les trois premiers appels.
Prérequis
- HTTPS sortant vers 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 Résultat attendu
{"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) Étape 7Nettoyage
Objectif. Arrêtez le point d’application, supprimez le conteneur, effacez la politique de votre environnement Permit et supprimez les fichiers.
Prérequis
- Rien d’autre n’utilise les ports 7766 et 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 Résultat attendu
cleanup done
0
000
000 Sources#
- 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
Cet article en Markdown · RSS · JSON feed
Les nouveaux articles par e-mail
Un e-mail par semaine avec les nouveaux articles et labs. Désinscription à tout moment.
Votre adresse est conservée chez Kit, le service qui envoie les e-mails. Détails