Kurz gesagt
- Ich habe das Lab mit OPA (Open Policy Agent) mit Permit.io im Gratis-Plan Community nachgebaut: Ein kleiner Enforcement Point macht aus jedem tools/call des MCP (Model Context Protocol) eine Anfrage über AuthZEN (den Autorisierungsstandard von OpenID) an den Permit Edge PDP (Policy Decision Point).
- Mit Rollen und einer Regel für ABAC (attributbasierte Zugriffskontrolle) hat der Edge PDP die Zahlung über 90 Dollar gegen ein Limit von 50 abgelehnt und 45 Dollar mit Bestätigung erlaubt. Zwei erlaubt, vier abgelehnt, wie bei OPA.
- Ohne Schlüssel im PEP (Policy Enforcement Point) oder mit gestopptem PDP blieb jeder Aufruf zu. Das Log sagt, ob eine Ablehnung von der Policy oder von einem Fehler kam.
- Der Cloud PDP wertet kein ABAC aus: Dieselbe Zahlung über 45 Dollar wurde dort abgelehnt. Wählen Sie den PDP nach dem Policy-Modell. Die Modelle stehen in meinem Explainer zu RBAC (rollenbasierte Zugriffskontrolle), ABAC und ReBAC (beziehungsbasierte Zugriffskontrolle).
- Vor dem Schlüssel antwortete der PDP mit 401, 403 oder 503 und nie mit einer Entscheidung. Der Abschnitt bleibt, weil er zeigt, wie ein falsch konfigurierter PDP aussieht.
Dieses Lab nachbauen
Dieses Lab habe ich so geschrieben, dass Sie es selbst nachbauen können. Jeder Schritt enthält die Befehle zum Kopieren und die Ausgabe, die ich bekommen habe, und Sie können ihn als erledigt abhaken. Die Haken bleiben nur in diesem Browser.
Kopiert einen fertigen Prompt für Claude Code, Cursor, Codex oder einen anderen Coding-Agenten. Nur für Testumgebungen.
Prompt anzeigen
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely. Lab: Permit.io hinter AuthZEN: entscheiden, welche MCP-Aufrufe ein Agent machen darf Read the whole lab here (Markdown): https://iamops.dev/de/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.
Anfang des Monats habe ich einen Entscheidungspunkt für MCP-Tool-Aufrufe mit OPA gebaut: Ein Agent schlägt einen tools/call vor, etwas vor dem MCP-Server fragt eine Policy-Engine, und die Engine antwortet über AuthZEN mit ja oder nein. Diesmal ist die Engine Permit.io.
Permit.io passt aus zwei Gründen gut zum Vergleich. Sein PDP spricht AuthZEN 1.0 ohne Zusatzaufwand, und im März hat das Team Permit MCP Gateway veröffentlicht, einen Proxy vor MCP-Servern, der jeden Tool-Aufruf gegen Permit prüft. Ihr Beitrag über die sechs Ebenen, die jedes MCP-Gateway durchsetzen muss, ist eine kurze, nützliche Liste dessen, was ein Gateway über das Routing hinaus leisten muss.
Ich habe nur genutzt, was der kostenlose Community-Plan enthält. Neue Konten starten mit einer 14-tägigen Pro-Testphase, aber dieses Lab braucht sie nicht: RBAC, ABAC, der Edge PDP und das Audit-Log sind alle im kostenlosen Plan.
Wie Permit MCP-Tool-Aufrufe modelliert#
Die Architektur-Dokumentation des Gateways beschreibt die Zuordnung. Jeder MCP-Server wird ein Permit-Ressourcentyp mit dem Server-Schlüssel. Jedes Tool wird eine Aktion auf diesem Ressourcentyp. Für einen Tool-Aufruf führt das Gateway ein permit.check() aus, mit dem Agenten als Benutzer, dem Tool-Namen als Aktion und dem Server als Ressource, dazu eine zweite Prüfung für die Person, wenn ein Admin den Server importiert hat. Beide müssen erlauben.
Darüber liegen Vertrauensstufen (niedrig für Lesen, mittel für Schreiben, hoch für Löschen) und eine Obergrenze: Der Agent bekommt nie mehr, als der Admin der Person gegeben hat. Permit baut diese Grenze als ReBAC-Regeln. Laut Dokumentation lehnt das Gateway die Anfrage ab, wenn der PDP nicht antwortet, mit dem JSON-RPC (entfernte Prozeduraufrufe in JavaScript Object Notation)-Fehler -32005. Eine normale Ablehnung ist -32004. Ich habe -32004 in meinem Enforcement Point übernommen.
Der PDP ist der Teil, den ich getestet habe. Permit bietet drei Arten. Der Cloud PDP läuft gehostet unter cloudpdp.api.permit.io und deckt RBAC und ReBAC ab. Der Edge PDP ist ein Open-Source-Container (permitio/pdp-v2), der OPA und den Client von OPAL (Open Policy Administration Layer) enthält und auch ABAC abdeckt. Nexus PDP ist ein neuerer Container mit Speicher auf der Festplatte. Alle drei bieten die AuthZEN-Endpunkte: Evaluation, Batch-Evaluationen, die drei Such-APIs und das Discovery-Dokument.

Vorbereitung#
Ich habe Podman 5.4.2 auf Debian 13 für das Edge-PDP-Image permitio/pdp-v2:0.9.17 verwendet, dazu Python 3.13, das Permit Python SDK (Software Development Kit) 3.0.1 (das Paket im Python Package Index heißt permit), curl und jq. Alles lauscht auf localhost: 7766 für den PDP und 8383 für den Enforcement Point. Docker funktioniert genauso: Ersetzen Sie podman durch docker.
Sie brauchen ein kostenloses Permit.io-Konto. Registrieren Sie sich auf app.permit.io, öffnen Sie die Development-Umgebung des Standardprojekts und kopieren Sie deren Schlüssel für die API (Programmierschnittstelle) unter Settings, API Keys. Das Lab liest den Schlüssel über eine verdeckte Eingabe in eine einzige Shell-Variable. Er landet nie in einer Datei, einem Log oder einem Screenshot, und der PDP-Container erhält ihn als PDP_API_KEY.
Das Szenario ist das aus dem OPA-Lab. Ein Agent namens support-bot darf Kontostand und Umsätze lesen und Zahlungen bis 5000 Cent, also 50 Dollar, senden, wenn der Benutzer bestätigt hat. read-bot darf nur lesen. Die Tools sind get_balance, list_transactions und send_payment auf einem MCP-Server, payments_mcp. delete_account gibt es nicht.
Die Policy#
setup_permit.py legt die Policy über die Permit-API an. So können Sie sie in jeder Umgebung neu aufbauen und mit cleanup_permit.py wieder entfernen:
- Ressourcentyp
payments_mcpmit den drei Tools als Aktionen und zwei Attributen,amount_centsunduser_confirmed. - Ein Benutzerattribut
limit_cents, für beide Agenten auf 5000 gesetzt. - Zwei Rollen anstelle der Scopes:
payments_readermit den zwei Lese-Tools (RBAC) undpayments_writerohne einfache Berechtigungen. - Ein ABAC-Resource-Set,
payment_within_limit:resource.amount_centskleiner oder gleichuser.limit_cents, per Referenz verglichen, undresource.user_confirmedgleich true.payments_writererhältsend_paymentnur auf diesem Set.





Der PDP hat die Policy innerhalb der 30 Sekunden geladen, die ich ihm gegeben habe, und /healthy meldete für beide Teile ok.
Der Enforcement Point#
pep.py nimmt einen JSON-RPC-tools/call entgegen, ermittelt den Agenten aus dem Sitzungs-Header und sendet Permit eine AuthZEN Access Evaluation. Die Form folgt der Gateway-Zuordnung: Subject ist der Agent, Aktion ist der Tool-Name, Ressource ist der MCP-Server. Betrag und Bestätigung kommen in resource.properties, weil laut Permit-Dokumentation der PDP dort tenant liest und die übrigen Schlüssel als Ressourcenattribute an die Policy weitergibt.
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)),
}},
}Wichtig sind die Zeilen nach dem Aufruf. Nur HTTP (Hypertext Transfer Protocol) 200 mit "decision": true erlaubt. Jeder HTTP-Fehler, ein Timeout, eine abgelehnte Verbindung oder eine Antwort ohne Boolean ist eine Ablehnung, und das Log sagt, welcher Fall es war.
Permit antwortet mit mehr als der Entscheidung. Das Feld context enthält die Begründung, samt der Rollen des Agenten und seinem limit_cents. pep.py behält die kurzen Begründungscodes für das eigene Log und sagt dem Agenten nur denied: policy. Ein Agent, der das Limit lesen kann, kann lernen, eine Zahlung darunter aufzuteilen.
Lauf 1: AuthZEN mit Schlüssel#
Zuerst habe ich die AuthZEN-Endpunkte direkt geprüft, mit dem Schlüssel im Bearer-Header: das Discovery-Dokument, eine Evaluation für get_balance, einen Batch mit vier Zahlungen in einer Anfrage und eine Subject-Suche, wer get_balance aufrufen darf.

Der Batch ist die Policy in vier Zeilen. 90 Dollar gegen das Limit von 50: false. 45 Dollar bestätigt: true, erlaubt durch die ABAC-Regel. 45 Dollar unbestätigt: false. Dieselben 45 Dollar von read-bot, als Subject des einzelnen Batch-Eintrags gesetzt: false. Die Subject-Suche fand beide Agenten, weil beide payments_reader haben. Die Aktionssuche lieferte in meinem Lauf für beide Agenten eine leere Liste. Ich habe den Grund nicht untersucht und verlasse mich hier deshalb nicht darauf.
Lauf 2: sechs Tool-Aufrufe durch den Enforcement Point#
Dann habe ich pep.py gestartet und die sechs Aufrufe aus dem OPA-Lab gesendet: eine Kontostandsabfrage, eine Zahlung über 90 Dollar, eine über 45 Dollar mit und ohne Bestätigung, eine Zahlung von read-bot und das unbekannte delete_account.

Die Ergebnisse entsprechen dem OPA-Lab. Zwei Aufrufe liefen: die Kontostandsabfrage, erlaubt durch die Rolle, und die bestätigte Zahlung über 45 Dollar, erlaubt durch die ABAC-Regel. Vier hat die Policy abgelehnt. Für delete_account sagte der PDP no_such_action: Das Tool ist keine Aktion auf payments_mcp, also kann keine Rolle es gewähren.
Jede Entscheidung kam auch im Permit-Audit-Log an. Ich habe sie über die Audit-Log-API gezählt: Benutzer, Aktion, Ressourcentyp und Entscheidung für jeden Aufruf dieses Laufs, einschließlich der Aufrufe an den Cloud PDP in Lauf 4.


Lauf 3: Fail closed mit aktiver Policy#
Eine funktionierende Policy schafft den Fehlerpfad nicht ab. Ich habe pep.py mit leerem Schlüssel gegen denselben gesunden PDP neu gestartet, danach den PDP-Container gestoppt und die Zahlung über 45 Dollar erneut gesendet.

Beide Male wurde die bestätigte Zahlung über 45 Dollar, die die Policy erlaubt, abgelehnt. Die Log-Zeile sagt warum: pdp error HTTP 403 und pdp unreachable, nicht decision false. Genau auf diesen Unterschied sollte ein Alarm achten.
Lauf 4: Der Cloud PDP wertet kein ABAC aus#
Der Cloud PDP akzeptierte denselben Schlüssel und denselben Batch und antwortete viermal false. Der Grund stand im Context: ABAC is not supported yet in the Cloud PDP. Mit pep.py auf den Cloud PDP gerichtet lief die Kontostandsabfrage weiter über die Rolle, aber die bestätigte Zahlung über 45 Dollar wurde abgelehnt.

Das bleibt zu, also die sichere Richtung, aber es sähe wie eine kaputte Policy aus, wenn man es nicht wüsste. Limits wie dieses brauchen den Edge PDP oder eine Policy, die nicht von ABAC abhängt.
Vor dem Schlüssel: was ein PDP ohne Schlüssel tut#
Bevor das Konto existierte, habe ich dasselbe Lab ohne Schlüssel ausgeführt. Ich behalte diese Ergebnisse, weil sie zeigen, wie ein falsch konfigurierter PDP aus Sicht des Enforcement Points aussieht.
Der Container startete ohne PDP_API_KEY und beendete sich nicht. Sein Watchdog startete den internen API-Server immer wieder neu, und /healthy meldete einen Fehler.

AuthZEN-Anfragen bekamen Statuscodes und nie eine Entscheidung: 401 ohne Header, 403 mit leerem Bearer-Token und 503 mit falschem Schlüssel. Der Container wollte auch für das Discovery-Dokument ein Token.

Alle sechs Tool-Aufrufe durch pep.py wurden abgelehnt, jeder mit pdp error HTTP 403. Das richtige Ergebnis aus dem falschen Grund. Für den Agenten sieht ein PDP, der seinen Schlüssel verloren hat, aus wie eine strenge Policy, also kann nur das Log beides unterscheiden.

Der Cloud PDP lieferte sein Discovery-Dokument ohne Token und antwortete 401 auf eine Evaluation ohne Token. Die Fehlertexte unterscheiden sich: JSON beim Cloud PDP, reiner Text beim Container.

Stolperfallen#
- Der Cloud PDP ignoriert ABAC. Er antwortet false mit
NOT_SUPPORTEDim Context. Für Attributregeln brauchen Sie den Edge PDP. Er sendet auch keine Header für CORS (Cross-Origin Resource Sharing), ein Browser kann seine Antworten also nicht lesen. Rufen Sie ihn von einem Server auf. - Der Entscheidungs-Context verrät viel. Rollen, Attribute und Regelnamen kommen mit jeder Antwort zurück. Loggen Sie die Codes, geben Sie sie nicht an den Agenten weiter.
- Ein fehlender Schlüssel ist keine Policy. Der Container läuft weiter und antwortet je nach Anfrage mit 401, 403 oder 503. Nur der PEP kann daraus eine sichere Ablehnung machen.
- Das Subject kommt aus der Sitzung.
pep.pyignoriert jeden Agentennamen in den Argumenten. Dasselbe gilt füruser_confirmed: In einem echten Gateway muss es aus einem Bestätigungsschritt kommen, den das Modell nicht fälschen kann. - Tool-Listen werden nicht gefiltert. Laut Permit-Gateway-Dokumentation liefert
tools/listalle Upstream-Tools, und die Durchsetzung passiert bei jedem Aufruf. Ein Agent kann ein Tool sehen, das er nicht nutzen darf. - Das Gateway nutzt den SDK-Check, nicht AuthZEN. AuthZEN ist der Weg, über den ein anderer PEP, wie meiner, mit demselben PDP spricht.
Was ich damit machen würde#
- Den Enforcement Point bei Fehlern zumachen und den Grund loggen lassen, dann in einem Test den PDP stoppen und die Log-Zeile prüfen.
- Alarmieren, wenn Ablehnungen von PDP-Fehlern statt von Policy-Entscheidungen kommen.
- Den PDP-Schlüssel auf der Serverseite halten, im Gateway oder in einem Sidecar, nie in einem Browser oder im Prompt eines Agenten.
- Den PDP-Typ nach dem Policy-Modell wählen: ABAC-Limits wie dieses brauchen den Edge PDP.
- Den Entscheidungs-Context entfernen, bevor etwas an den Agenten zurückgeht.
Was nicht ausgeführt wurde#
Dieses Lab nutzt einen eigenen kleinen Enforcement Point statt des gehosteten Permit MCP Gateway. Es verwendet nur Funktionen des kostenlosen Community-Plans.
Die Terminal-Bilder sind aus der gespeicherten Ausgabe vom 22. November 2026 erzeugt, die Konsolen-Screenshots stammen vom selben Tag. Der Schlüssel erscheint nie.
Dieses Lab nachbauen#
Für dieses Lab brauchen Sie ein kostenloses Permit.io-Konto, Linux mit Podman oder Docker, curl, jq und Python 3.10 oder neuer. Planen Sie etwa 25 Minuten ein. env.sh fragt den API-Schlüssel Ihrer Development-Umgebung verdeckt ab; halten Sie ihn aus Dateien, Chats und Screenshots heraus. Öffnen Sie jeden Schritt, kopieren Sie die Blöcke und vergleichen Sie die Ausgabe mit meiner.
Jeder Wert in spitzen Klammern ist ein Platzhalter für Ihre Testumgebung. Nichts auf dieser Seite ist eine echte Kennung oder ein echtes Geheimnis.
Variablen einmal setzen
# 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 von 7 Schritten erledigt
Schritt 1Die Policy in Ihre Permit-Umgebung laden
Ziel. Installieren Sie das Permit Python SDK in einer virtuellen Umgebung und führen Sie setup_permit.py aus, um Ressource, Rollen, ABAC-Resource-Set und zwei Agenten anzulegen.
Voraussetzungen
- Ein kostenloses Permit.io-Konto; der API-Schlüssel der Development-Umgebung, an der Eingabe von env.sh getippt
- Linux mit Podman 5 oder Docker, curl, jq und Python 3.10 oder neuer
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 Erwartete Ausgabe
policy created: payments_mcp, 2 roles, 1 resource set, 2 agents Schritt 2Den Permit Edge PDP mit Schlüssel starten
Ziel. Starten Sie das Edge-PDP-Image in der festen Version mit PDP_API_KEY aus der Shell-Variablen, warten Sie, bis es die Policy geladen hat, und lesen Sie den Health-Endpunkt.
Voraussetzungen
- Die Policy aus dem vorigen Schritt existiert
- Ports 7766 und 8383 frei
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}' Erwartete Ausgabe
<container-id>
permit-pdp docker.io/permitio/pdp-v2:0.9.17 Up 30 seconds
{"status":"ok","opa":"ok","horizon":"ok"} Schritt 3Den PDP über AuthZEN fragen
Ziel. Lesen Sie das Discovery-Dokument, senden Sie eine Evaluation, einen Batch mit vier Zahlungen und eine Subject-Suche, und vergleichen Sie die Entscheidungen.
Voraussetzungen
- Der PDP ist gesund
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' Erwartete Ausgabe
["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"}] Schritt 4Sechs Tool-Aufrufe durch den Enforcement Point schicken
Ziel. Schreiben Sie pep.py und calls.sh, starten Sie den Enforcement Point und senden Sie die sechs MCP-Aufrufe aus dem OPA-Lab.
Voraussetzungen
- Der PDP ist gesund
- Port 8383 frei
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 Erwartete Ausgabe
{"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) Schritt 5Den Schlüssel entfernen, dann den PDP stoppen
Ziel. Starten Sie den Enforcement Point mit leerem Schlüssel neu, stoppen Sie dann den PDP-Container, und senden Sie jedes Mal die erlaubte Zahlung über 45 Dollar.
Voraussetzungen
- pep.py und calls.sh aus dem vorigen Schritt
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 Erwartete Ausgabe
{"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 Schritt 6Denselben Batch an den Cloud PDP senden
Ziel. Senden Sie den Batch mit demselben Schlüssel an den Permit Cloud PDP, richten Sie dann den Enforcement Point darauf und senden Sie die ersten drei Aufrufe.
Voraussetzungen
- Ausgehendes HTTPS zu 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 Erwartete Ausgabe
{"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) Schritt 7Aufräumen
Ziel. Stoppen Sie den Enforcement Point, entfernen Sie den Container, löschen Sie die Policy aus Ihrer Permit-Umgebung und löschen Sie die Dateien.
Voraussetzungen
- Nichts anderes nutzt die Ports 7766 und 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 Erwartete Ausgabe
cleanup done
0
000
000 Quellen#
- 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
Dieser Beitrag als Markdown · RSS · JSON feed
Neue Beiträge per E-Mail
Eine E-Mail pro Woche mit neuen Beiträgen und Labs. Jederzeit abbestellbar.
Ihre Adresse wird bei Kit gespeichert, dem Dienst, der die E-Mails versendet. Details