En bref
- Le 11 novembre 2026, IndyKite et Obsidian ont décrit la même structure : l'agent ou son runtime propose un appel, et un point de décision séparé répond pour chaque appel.
- Je l'ai construite en local : une politique Rego dans OPA 1.22.4, six tests unitaires et un petit point d'accès AuthZEN Access Evaluation devant OPA. Un paiement de 90 $ contre une limite de 50 $ est revenu avec decision false et le motif over delegated limit.
- La politique refuse par défaut. Un outil inconnu, un scope manquant, un paiement au-delà de la limite et un paiement non confirmé ont été refusés, et j'ai cassé une règle exprès pour voir un test échouer.
- Quand j'ai arrêté OPA, mon shim n'a donné aucune réponse ; le point d'application doit donc traiter une décision absente comme un refus.
- Non testés : une vraie passerelle MCP comme point d'application, les tests de conformité AuthZEN, les API batch et de recherche et la journalisation des décisions.
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: OPA derrière AuthZEN : un point de décision pour les appels d'outils MCP Read the whole lab here (Markdown): https://iamops.dev/fr/opa-authzen-mcp-tool-call-policy.md What the lab needs before the first step: - Linux on amd64 (for macOS or arm64 take the matching file from the release page), curl, jq and Python 3.13 - Ports 8181 and 8282 free 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.
Le 11 novembre 2026, deux éditeurs ont publié la même idée de deux côtés. IndyKite a publié son Intent Agent, qui transforme un prompt en évaluations AuthZEN et, selon son guide développeur, ne décide rien : la décision reste au service AuthZEN. Obsidian a décrit un Runtime Policy Decision Engine où un MCP Security Proxy, un runtime d’agents ou une passerelle client met un appel d’outil en pause, demande une décision et applique la réponse.
Les deux partagent le travail de la même façon. Quelque chose qui tient la requête demande, et autre chose décide. Je voulais faire tourner ce partage sur ma propre machine avec uniquement des briques open source, alors je l’ai construit : un moteur de politiques (OPA) avec une politique pour les appels d’outils MCP, et un fin point d’accès AuthZEN devant.
J’ai écrit une courte présentation d’AuthZEN, OPA et Cedar.
Ce que construit le lab#
- Une politique Rego qui reçoit une requête au format AuthZEN (subject, action, resource, context) pour un
tools/callMCP et renvoie un booléen plus des motifs. - Six tests unitaires qui tournent hors ligne avec l’exécuteur de tests d’OPA.
- Un petit point d’accès Python qui répond à
POST /access/v1/evaluationet au document de métadonnées du PDP, et transmet la requête à OPA comme input. - Deux refus que je voulais voir : un paiement au-delà de la limite déléguée à l’agent, et ce qui se passe quand OPA n’est pas là.
L’argent est en centimes de dollar américain. L’agent peut payer jusqu’à 5000 centimes, soit 50 $.

Mise en place#
OPA 1.22.4 est un binaire statique unique de la page des versions. Le point d’accès est un fichier de moins de 40 lignes de Python 3.13 avec la seule bibliothèque standard. Il faut aussi curl et jq. Il n’y a ni Docker, ni base de données, ni compte. Le lab ouvre le port 8181 pour OPA et le 8282 pour le point d’accès, tous deux sur localhost.
La politique#
La requête est celle qu’un point d’application construirait à partir d’un tools/call MCP. Le subject est l’agent avec ses scopes et sa limite, la resource est l’outil, et le context porte le montant et si l’utilisateur a confirmé.
La politique a un catalogue d’outils qui dit quel scope chacun exige et s’il déplace de l’argent. decision vaut false tant qu’une règle ne la met pas à true. Les outils de lecture exigent leur scope. Un outil qui déplace de l’argent exige le scope, un montant au plus égal à la limite et une confirmation :
decision if {
input.subject.type == "agent"
input.action.name == "tools/call"
tool.scope in input.subject.properties.scopes
tool.moves_money
input.context.amount_cents <= input.subject.properties.limit_cents
input.context.user_confirmed
}Un second ensemble, reasons, explique les refus. Les fichiers complets figurent dans les étapes du lab plus bas.
D’abord les tests#
L’exécuteur opa test trouve les règles test_ dans les fichiers _test.rego. J’en ai écrit six : une lecture est autorisée, une écriture sans le scope est refusée, un paiement confirmé dans la limite est autorisé, un paiement au-delà de la limite est refusé avec le bon motif, un paiement non confirmé est refusé, et un outil inconnu est refusé. opa check --strict et opa fmt sont passés avant les tests.

Pour voir si les tests peuvent échouer, j’ai supprimé dans une copie la ligne user_confirmed de la deuxième règle. Cinq tests ont continué à passer et test_payment_needs_confirmation a échoué. C’est le test qui fait son travail.
Une requête, hors ligne#
opa eval prend la politique et un fichier de requête sans démarrer de serveur. La requête est l’agent support-bot avec les deux scopes et une limite de 5000 centimes, qui appelle send_payment pour 9000 centimes avec la confirmation de l’utilisateur.

Le point d’accès AuthZEN#
OPA tourne en serveur sur le port 8181, et le point d’accès sur le port 8282 se place devant. La spécification AuthZEN définit la requête comme subject, action, resource et context, et la réponse comme un decision booléen obligatoire avec un context facultatif. Elle laisse le contenu de ce context à l’implémentation. J’ai mis les motifs de refus sous reason_admin, la clé de son exemple non normatif. Le document de métadonnées se trouve à /.well-known/authzen-configuration.

Le point d’accès est un outil pédagogique. Il n’authentifie pas les appelants, ne valide pas l’entrée et n’a ni API batch ni API de recherche ; ce n’est donc pas un PDP conforme.
D’autres refus, et OPA qui disparaît#
J’ai envoyé trois autres requêtes avec une petite fonction shell nommée ask. Avec le seul scope de lecture, le paiement a été refusé pour scope manquant, et aussi pour la limite, car le montant valait encore 9000. Avec un montant de 4500 centimes et user_confirmed à false, il a été refusé pour confirmation manquante. Un outil nommé delete_account a été refusé comme inconnu.

Ensuite j’ai arrêté OPA et renvoyé la requête de 4500 centimes. Le shim a levé une exception et coupé la connexion, et curl a affiché 000. Il n’y avait aucun decision: false à appliquer. Une passerelle qui attend un true peut traiter cela comme un refus. Une passerelle qui ne bloque que sur un false explicite laisserait passer l’appel. Je n’ai pas testé de vraie passerelle ; c’est donc une raison de vérifier la vôtre, pas un constat sur un produit.
Pièges#
- Les outils inconnus n’ont pas besoin de règle. Quand l’outil n’est pas dans le catalogue,
toolest indéfini, donc chaque règledecisionest indéfinie et la valeur par défautfalses’applique. Un test le fixe. - Les motifs peuvent s’empiler.
reasonsest un ensemble, et la requête avec le seul scope de lecture en a renvoyé deux à la fois. - La politique fait confiance au context.
user_confirmedne vaut que ce que vaut le point d’application qui le renseigne. Un modèle ne doit jamais pouvoir le remplir. Le guide d’IndyKite dit quelque chose de proche pour le subject : il vient de l’identité vérifiée de l’appelant, jamais du texte du prompt. - Refuser par défaut est un choix. Le billet d’Obsidian dit que les appels d’outils qui ne correspondent à aucune politique passent. Les miens sont refusés. Aucun des deux n’est faux, mais décidez-le exprès.
Ce que je ferais de cela#
- Placer le point d’application dans la passerelle ou le proxy qui voit chaque
tools/call, pas dans l’agent. - Construire le subject à partir du jeton vérifié et de l’enregistrement de délégation, pas à partir de ce que le modèle a écrit.
- Garder la politique dans un dépôt avec ses tests et lancer
opa testen CI. - Faire refuser le point d’application en cas d’erreur, et le tester en arrêtant le point de décision.
Ce que je n’ai pas testé#
Je n’ai pas testé de vraie passerelle MCP comme point d’application. Je n’ai pas lancé de tests de conformité AuthZEN, l’API d’évaluations batch, les API de recherche ni un autre point de décision AuthZEN. Je n’ai pas testé les bundles OPA, les journaux de décisions ni les performances des politiques. Il n’y a pas d’enregistrement pour ce lab. Le lab n’utilise ni identifiants ni jetons.
Les images de terminal ont été générées à partir de la sortie enregistrée de l’exécution du 20 novembre 2026.
Refaire ce lab#
Ce lab demande Linux sur amd64, curl, jq et Python 3.13. Comptez environ 20 minutes. 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. No secrets are involved.
export OPA_VERSION="1.22.4"
export OPA_URL="http://localhost:8181"
export PDP_URL="http://localhost:8282" Étapes terminées : 0 sur 8
Étape 1Télécharger OPA
Objectif. Téléchargez le binaire statique unique d’OPA à une version figée et affichez sa version.
Prérequis
- Linux sur amd64 (pour macOS ou arm64, prenez le fichier correspondant sur la page des versions), curl, jq et Python 3.13
- Ports 8181 et 8282 libres
curl -sSL -o opa "https://github.com/open-policy-agent/opa/releases/download/v$OPA_VERSION/opa_linux_amd64_static"
chmod +x opa
./opa version | head -1 Résultat attendu
Version: 1.22.4 Étape 2Écrire la politique
Objectif. Créez la politique Rego : un catalogue d’outils, une valeur par défaut false, deux règles de décision et un ensemble de motifs de refus.
Prérequis
- Étape 1 faite, dans le même dossier
cat > mcp_tools.rego <<'EOF'
# Which MCP tools may an agent call? The input has the shape of an
# AuthZEN Access Evaluation request: subject, action, resource, context.
package mcp.tools
default decision := false
# Tool catalog: the scope each tool needs and whether it moves money.
catalog := {
"get_balance": {"scope": "payments.read", "moves_money": false},
"list_transactions": {"scope": "payments.read", "moves_money": false},
"send_payment": {"scope": "payments.write", "moves_money": true},
}
tool := catalog[input.resource.id]
decision if {
input.subject.type == "agent"
input.action.name == "tools/call"
tool.scope in input.subject.properties.scopes
not tool.moves_money
}
decision if {
input.subject.type == "agent"
input.action.name == "tools/call"
tool.scope in input.subject.properties.scopes
tool.moves_money
input.context.amount_cents <= input.subject.properties.limit_cents
input.context.user_confirmed
}
# Explain denials, the way a PDP would put reasons in the AuthZEN context.
reasons contains "unknown tool" if not catalog[input.resource.id]
reasons contains "missing scope" if {
tool
not tool.scope in input.subject.properties.scopes
}
reasons contains "over delegated limit" if {
tool.moves_money
input.context.amount_cents > input.subject.properties.limit_cents
}
reasons contains "user did not confirm" if {
tool.moves_money
not input.context.user_confirmed
}
EOF
head -3 mcp_tools.rego Résultat attendu
# Which MCP tools may an agent call? The input has the shape of an
# AuthZEN Access Evaluation request: subject, action, resource, context.
package mcp.tools Étape 3Écrire les tests et les exécuter
Objectif. Écrivez six tests unitaires, puis lancez le formateur, la vérification stricte et l’exécuteur de tests. Tout doit passer.
Prérequis
- Le fichier de politique de l’étape précédente
cat > mcp_tools_test.rego <<'EOF'
package mcp.tools_test
import data.mcp.tools
agent(scopes, limit) := {"type": "agent", "id": "support-bot", "properties": {"scopes": scopes, "limit_cents": limit}}
call(subject, tool, ctx) := {"subject": subject, "action": {"name": "tools/call"}, "resource": {"type": "mcp_tool", "id": tool}, "context": ctx}
test_read_allowed if {
tools.decision with input as call(agent(["payments.read"], 0), "get_balance", {})
}
test_write_needs_scope if {
not tools.decision with input as call(agent(["payments.read"], 50000), "send_payment", {"amount_cents": 100, "user_confirmed": true})
}
test_payment_within_limit_confirmed if {
tools.decision with input as call(agent(["payments.write"], 5000), "send_payment", {"amount_cents": 4500, "user_confirmed": true})
}
test_payment_over_limit_denied if {
r := tools.reasons with input as call(agent(["payments.write"], 5000), "send_payment", {"amount_cents": 9000, "user_confirmed": true})
"over delegated limit" in r
}
test_payment_needs_confirmation if {
not tools.decision with input as call(agent(["payments.write"], 5000), "send_payment", {"amount_cents": 4500, "user_confirmed": false})
}
test_unknown_tool_denied if {
not tools.decision with input as call(agent(["payments.write"], 5000), "delete_account", {})
}
EOF
./opa fmt --list --fail . && ./opa check --strict . && echo "fmt + strict check: OK"
./opa test . -v Résultat attendu
fmt + strict check: OK
mcp_tools_test.rego:30:
data.mcp.tools_test.test_unknown_tool_denied: PASS (970.514µs)
mcp_tools_test.rego:17:
data.mcp.tools_test.test_payment_within_limit_confirmed: PASS (984.282µs)
mcp_tools_test.rego:26:
data.mcp.tools_test.test_payment_needs_confirmation: PASS (1.131509ms)
mcp_tools_test.rego:21:
data.mcp.tools_test.test_payment_over_limit_denied: PASS (1.197352ms)
mcp_tools_test.rego:13:
data.mcp.tools_test.test_write_needs_scope: PASS (1.433506ms)
mcp_tools_test.rego:9:
data.mcp.tools_test.test_read_allowed: PASS (1.255784ms)
--------------------------------------------------------------------------------
PASS: 6/6 Étape 4Évaluer une requête hors ligne
Objectif. Écrivez une requête au format AuthZEN pour un paiement de 90 dollars avec une limite de 50 dollars et évaluez-la avec opa eval, sans serveur.
Prérequis
- Les montants sont en centimes : 9000 font 90 dollars et 5000 font 50 dollars
cat > request.json <<'EOF'
{
"subject": { "type": "agent", "id": "support-bot",
"properties": { "scopes": ["payments.read", "payments.write"], "limit_cents": 5000 } },
"action": { "name": "tools/call" },
"resource": { "type": "mcp_tool", "id": "send_payment" },
"context": { "amount_cents": 9000, "user_confirmed": true }
}
EOF
./opa eval -d mcp_tools.rego -i request.json 'data.mcp.tools.decision' --format pretty
./opa eval -d mcp_tools.rego -i request.json 'data.mcp.tools.reasons' --format pretty Résultat attendu
false
[
"over delegated limit"
] Étape 5Lancer OPA en serveur et ajouter le point AuthZEN
Objectif. Servez la politique depuis OPA sur le port 8181, vérifiez son API de décision, puis démarrez le petit point Python sur le port 8282 et lisez son document de métadonnées.
Prérequis
- Étapes 2 à 4 faites
- Le point d’accès est un outil pédagogique, pas un PDP AuthZEN conforme ; gardez-le sur localhost
./opa run --server --addr localhost:8181 mcp_tools.rego > opa-server.log 2>&1 &
sleep 2
curl -s $OPA_URL/health
curl -s $OPA_URL/v1/data/mcp/tools/decision -d '{"input":'"$(cat request.json)"'}' cat > authzen_pdp.py <<'EOF'
"""A minimal AuthZEN Access Evaluation endpoint in front of OPA.
Standard library only (Python 3.10+). OPA runs on :8181 with mcp_tools.rego loaded.
This is a teaching shim, not a conformant AuthZEN PDP."""
import json
import urllib.request
from http.server import BaseHTTPRequestHandler, HTTPServer
OPA = "http://localhost:8181/v1/data/mcp/tools"
class PDP(BaseHTTPRequestHandler):
def _send(self, code, body):
data = json.dumps(body).encode()
self.send_response(code)
self.send_header("content-type", "application/json")
self.end_headers()
self.wfile.write(data)
def do_GET(self):
if self.path == "/.well-known/authzen-configuration":
base = f"http://{self.headers['host']}"
return self._send(200, {"policy_decision_point": base,
"access_evaluation_endpoint": f"{base}/access/v1/evaluation"})
self._send(404, {})
def do_POST(self):
if self.path != "/access/v1/evaluation":
return self._send(404, {})
request = json.loads(self.rfile.read(int(self.headers["content-length"])))
opa_req = urllib.request.Request(OPA, data=json.dumps({"input": request}).encode(),
headers={"content-type": "application/json"})
result = json.load(urllib.request.urlopen(opa_req)).get("result", {})
body = {"decision": bool(result.get("decision"))}
if not body["decision"]:
body["context"] = {"reason_admin": {"403": ", ".join(sorted(result.get("reasons", [])))}}
self._send(200, body)
HTTPServer(("127.0.0.1", 8282), PDP).serve_forever()
EOF
python3 authzen_pdp.py > pdp.log 2>&1 &
sleep 1
curl -s $PDP_URL/.well-known/authzen-configuration | jq . Résultat attendu
{}
{"result":false}
{
"policy_decision_point": "http://localhost:8282",
"access_evaluation_endpoint": "http://localhost:8282/access/v1/evaluation"
} Étape 6Demander une décision : 90 dollars, puis 45
Objectif. Envoyez la requête au point d’évaluation AuthZEN. Il doit refuser avec un motif. Puis changez seulement le montant à 4500 centimes et redemandez.
Prérequis
- OPA et le point d’accès tournent
curl -s $PDP_URL/access/v1/evaluation -H 'content-type: application/json' -d @request.json | jq .
jq '.context.amount_cents=4500' request.json \
| curl -s $PDP_URL/access/v1/evaluation -H 'content-type: application/json' -d @- | jq . Résultat attendu
{
"decision": false,
"context": {
"reason_admin": {
"403": "over delegated limit"
}
}
}
{
"decision": true
} Étape 7Essayer d’autres refus, puis arrêter OPA
Objectif. Envoyez trois autres requêtes : un scope manquant, un paiement non confirmé et un outil inconnu. Arrêtez ensuite OPA et redemandez pour voir qu’aucune décision ne revient.
Prérequis
- Le point d’accès tourne
ask() { curl -s $PDP_URL/access/v1/evaluation -H 'content-type: application/json' -d @- | jq -c .; }
jq '.subject.properties.scopes=["payments.read"]' request.json | ask
jq '.context.user_confirmed=false | .context.amount_cents=4500' request.json | ask
jq '.resource.id="delete_account"' request.json | ask
# Now stop OPA and ask again: no decision comes back
pkill -f "opa run --server"
sleep 1
curl -s -o /dev/null -w "%{http_code}\n" -m 5 $PDP_URL/access/v1/evaluation -H 'content-type: application/json' -d @request.json Résultat attendu
{"decision":false,"context":{"reason_admin":{"403":"missing scope, over delegated limit"}}}
{"decision":false,"context":{"reason_admin":{"403":"user did not confirm"}}}
{"decision":false,"context":{"reason_admin":{"403":"unknown tool"}}}
000 Étape 8Nettoyage
Objectif. Arrêtez les deux processus et supprimez les fichiers créés par le lab.
Prérequis
- Rien d’autre n’utilise les ports 8181 et 8282
pkill -f "opa run --server" || true
pkill -f authzen_pdp.py || true
rm -f opa mcp_tools.rego mcp_tools_test.rego request.json authzen_pdp.py opa-server.log pdp.log
unset -f ask
# check: nothing listens on ports 8181 and 8282 any more
curl -s -o /dev/null -w "%{http_code}\n" "$OPA_URL/health"
curl -s -o /dev/null -w "%{http_code}\n" "$PDP_URL/" Résultat attendu
000
000 Sources#
- IndyKite, IndyKite open sources the Intent Agent (11 Nov 2026)
- IndyKite Developer Hub, Intent Agent: turn a prompt into AuthZEN evaluations
- Obsidian Security, Introducing the Runtime Policy Decision Engine
- Help Net Security, Obsidian expands AI agent security with runtime policy enforcement (11 Nov 2026)
- OpenID AuthZEN Authorization API 1.0 (Final)
- Open Policy Agent: Policy Testing
- Open Policy Agent: REST API
- Open Policy Agent: v1.22.4 release
- 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