In breve
- Ho rifatto il lab OPA (Open Policy Agent) con Permit.io sul piano gratuito Community: un piccolo punto di enforcement trasforma ogni tools/call MCP (Model Context Protocol) in una richiesta AuthZEN (lo standard di autorizzazione OpenID) per l’Edge PDP (punto di decisione delle policy) di Permit.
- Con ruoli e una regola ABAC (controllo degli accessi basato sugli attributi), l’Edge PDP ha negato il pagamento da 90 dollari con un limite di 50 e ha consentito quello da 45 confermato. Due consentite, quattro negate, come con OPA.
- Senza chiave nel PEP (punto di applicazione delle policy) o con il PDP fermo, ogni chiamata è stata chiusa. Il log dice se un rifiuto viene dalla policy o da un errore.
- Il Cloud PDP non valuta ABAC: lo stesso pagamento da 45 dollari lì è stato negato. Scegli il PDP in base al modello di policy. I modelli sono nel mio explainer su RBAC (controllo degli accessi basato sui ruoli), ABAC e ReBAC (controllo degli accessi basato sulle relazioni).
- Prima di avere la chiave il PDP rispondeva 401, 403 o 503 e mai con una decisione. La sezione resta, perché mostra com’è un PDP configurato male.
Ripeti questo lab
Ho scritto questo lab perché tu possa rifarlo per conto tuo. Ogni passo ha i comandi da copiare e l'output che ho ottenuto io, e puoi segnarlo come fatto. Le spunte restano solo nel tuo browser.
Copia un prompt già pronto per Claude Code, Cursor, Codex o un altro agente di codice. Solo per ambienti di test.
Mostra il 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 dietro AuthZEN: decidere quali chiamate MCP può fare un agente Read the whole lab here (Markdown): https://iamops.dev/it/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.
All’inizio del mese ho costruito un punto di decisione per le chiamate MCP con OPA: un agente propone una tools/call, qualcosa davanti al server MCP chiede a un motore di policy, e il motore risponde sì o no tramite AuthZEN. Questa volta il motore è Permit.io.
Permit.io si presta bene al confronto per due motivi. Il suo PDP parla AuthZEN 1.0 senza configurazione aggiuntiva, e a marzo il team ha rilasciato Permit MCP Gateway, un proxy davanti ai server MCP che controlla ogni chiamata su Permit. Il loro articolo sui sei livelli che ogni gateway MCP deve applicare è un elenco breve e utile di cosa deve fare un gateway oltre all’instradamento.
Ho usato solo ciò che include il piano gratuito Community. I nuovi account partono con una prova Pro di 14 giorni, ma a questo lab non serve: RBAC, ABAC, l’Edge PDP e l’audit log sono tutti nel piano gratuito.
Come Permit modella le chiamate MCP#
La documentazione di architettura del gateway descrive la mappatura. Ogni server MCP diventa un tipo di risorsa Permit, con la chiave del server. Ogni tool diventa un’azione su quel tipo di risorsa. Per una chiamata il gateway esegue un permit.check() con l’agente come utente, il nome del tool come azione e il server come risorsa, più un secondo controllo per la persona quando un admin ha importato il server. Entrambi devono consentire.
Sopra ci sono i livelli di fiducia (basso per le letture, medio per le scritture, alto per le cancellazioni) e un tetto: l’agente non ottiene mai più di quanto l’admin ha dato alla persona. Permit costruisce questo tetto con regole ReBAC. La documentazione dice anche che se il PDP non risponde, il gateway rifiuta la richiesta con l’errore JSON-RPC (chiamate di procedura remota in JavaScript Object Notation) -32005. Un rifiuto normale è -32004. Ho riusato -32004 nel mio punto di enforcement.
Il PDP è la parte che ho testato. Permit ne offre tre tipi. Il Cloud PDP è ospitato su cloudpdp.api.permit.io e copre RBAC e ReBAC. L’Edge PDP è un container open source (permitio/pdp-v2) che include OPA e il client OPAL (Open Policy Administration Layer) e copre anche ABAC. Nexus PDP è un container più recente con archivio su disco. Tutti e tre servono gli endpoint AuthZEN: valutazione, valutazioni batch, le tre API (interfaccia di programmazione) di ricerca e il documento di discovery.

Preparazione#
Ho usato Podman 5.4.2 su Debian 13 per eseguire l’immagine Edge PDP permitio/pdp-v2:0.9.17, Python 3.13, l’SDK (kit di sviluppo software) Python di Permit 3.0.1 (il pacchetto sul Python Package Index si chiama permit), curl e jq. Tutto ascolta su localhost: 7766 per il PDP e 8383 per il punto di enforcement. Docker funziona allo stesso modo: sostituisci podman con docker.
Serve un account Permit.io gratuito. Registrati su app.permit.io, apri l’ambiente Development del progetto predefinito e copia la sua chiave API da Settings, API Keys. Il lab legge la chiave da un prompt nascosto in una sola variabile di shell. Non finisce mai in un file, in un log o in uno screenshot, e il container PDP la riceve come PDP_API_KEY.
Lo scenario è quello del lab OPA. Un agente chiamato support-bot può leggere saldo e movimenti e può inviare pagamenti fino a 5000 centesimi, 50 dollari, quando l’utente ha confermato. read-bot può solo leggere. I tool sono get_balance, list_transactions e send_payment su un server MCP, payments_mcp. delete_account non esiste.
La policy#
setup_permit.py crea la policy tramite l’API di Permit, così puoi ricostruirla in qualsiasi ambiente e toglierla con cleanup_permit.py:
- Tipo di risorsa
payments_mcpcon i tre tool come azioni e due attributi,amount_centseuser_confirmed. - Un attributo utente
limit_cents, a 5000 per entrambi gli agenti. - Due ruoli al posto degli scope:
payments_readercon i due tool di lettura (RBAC), epayments_writersenza permessi semplici. - Un resource set ABAC,
payment_within_limit:resource.amount_centsminore o uguale auser.limit_cents, confrontati per riferimento, eresource.user_confirmeduguale a true.payments_writerottienesend_paymentsolo su quel set.





Il PDP ha scaricato la policy entro i 30 secondi che gli ho dato, e /healthy ha riportato ok per entrambe le sue parti.
Il punto di enforcement#
pep.py riceve una tools/call JSON-RPC, ricava l’agente dall’header di sessione e invia a Permit una Access Evaluation AuthZEN. La forma segue la mappatura del gateway: il soggetto è l’agente, l’azione è il nome del tool, la risorsa è il server MCP. Importo e conferma vanno in resource.properties, perché la documentazione Permit dice che il PDP legge tenant da lì e passa le altre chiavi alla policy come attributi della risorsa.
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)),
}},
}Le righe importanti sono quelle dopo la chiamata. Consente solo HTTP (Hypertext Transfer Protocol) 200 con "decision": true. Qualsiasi errore HTTP, un timeout, una connessione rifiutata o una risposta senza booleano è un rifiuto, e il log dice quale dei casi è stato.
Permit risponde con più della sola decisione. Il campo context contiene il ragionamento, compresi i ruoli dell’agente e il suo limit_cents. pep.py tiene i codici brevi del motivo per il proprio log e all’agente dice solo denied: policy. Un agente che può leggere il limite può imparare a spezzare un pagamento per restarci sotto.
Prova 1: AuthZEN con la chiave#
Per prima cosa ho controllato direttamente gli endpoint AuthZEN, con la chiave nell’header bearer: il documento di discovery, una valutazione per get_balance, un batch di quattro pagamenti in una sola richiesta e una ricerca dei soggetti che possono chiamare get_balance.

Il batch è la policy in quattro righe. 90 dollari con il limite di 50: false. 45 confermati: true, consentito dalla regola ABAC. 45 non confermati: false. Gli stessi 45 da parte di read-bot, indicato come soggetto della singola voce del batch: false. La ricerca dei soggetti ha trovato entrambi gli agenti, perché entrambi hanno payments_reader. La ricerca delle azioni nella mia prova ha restituito una lista vuota per entrambi gli agenti. Non ho approfondito il perché, quindi qui non ci faccio affidamento.
Prova 2: sei chiamate dal punto di enforcement#
Poi ho avviato pep.py e inviato le sei chiamate del lab OPA: una lettura del saldo, un pagamento da 90 dollari, uno da 45 con e senza conferma, un pagamento di read-bot e lo sconosciuto delete_account.

I risultati coincidono con il lab OPA. Due chiamate sono passate: la lettura del saldo, consentita dal ruolo, e il pagamento da 45 dollari confermato, consentito dalla regola ABAC. Quattro sono state negate dalla policy. Per delete_account il PDP ha detto no_such_action: il tool non è un’azione di payments_mcp, quindi nessun ruolo può concederlo.
Ogni decisione è arrivata anche nell’audit log di Permit. Le ho contate tramite l’API dell’audit log: utente, azione, tipo di risorsa e decisione per ogni chiamata di questa prova, comprese quelle del Cloud PDP nella prova 4.


Prova 3: fail closed con una policy attiva#
Una policy funzionante non elimina il percorso di errore. Ho riavviato pep.py con una chiave vuota contro lo stesso PDP sano, poi ho fermato il container PDP e reinviato il pagamento da 45 dollari.

Entrambe le volte il pagamento da 45 dollari confermato, che la policy consente, è stato rifiutato. La riga di log dice perché: pdp error HTTP 403 e pdp unreachable, non decision false. È questa differenza che un allarme deve guardare.
Prova 4: il Cloud PDP non valuta ABAC#
Il Cloud PDP ha accettato la stessa chiave e lo stesso batch e ha risposto false quattro volte. Il motivo era nel context: ABAC is not supported yet in the Cloud PDP. Con pep.py puntato sul Cloud PDP, la lettura del saldo è passata grazie al ruolo, ma il pagamento da 45 dollari confermato è stato rifiutato.

Si chiude in sicurezza, che è la direzione giusta, ma sembrerebbe una policy rotta se non lo sapessi. Limiti come questo richiedono l’Edge PDP, oppure una policy che non dipende da ABAC.
Prima della chiave: cosa fa un PDP senza chiave#
Prima che l’account esistesse ho eseguito lo stesso lab senza chiave. Tengo questi risultati perché mostrano com’è un PDP configurato male visto dal punto di enforcement.
Il container è partito senza PDP_API_KEY e non è uscito. Il suo watchdog continuava a riavviare il server API interno, e /healthy segnalava un errore.

Le richieste AuthZEN ricevevano codici di stato e mai una decisione: 401 senza header, 403 con un token bearer vuoto e 503 con una chiave sbagliata. Il container voleva un token anche per il documento di discovery.

Tutte e sei le chiamate passate da pep.py sono state negate, ognuna con pdp error HTTP 403. Il risultato giusto per il motivo sbagliato. Per l’agente un PDP che ha perso la chiave sembra uguale a una policy severa, quindi solo il log può distinguerli.

Il Cloud PDP serviva il documento di discovery senza token e rispondeva 401 a una valutazione senza token. I corpi di errore sono diversi: JSON sul Cloud PDP, testo semplice sul container.

Trappole#
- Il Cloud PDP ignora ABAC. Risponde false con
NOT_SUPPORTEDnel context. Per le regole sugli attributi usa l’Edge PDP. Non invia nemmeno header CORS (Cross-Origin Resource Sharing), quindi un browser non può leggerne le risposte: chiamatelo da un server. - Il context della decisione dice molto. Ruoli, attributi e nomi delle regole tornano con ogni risposta. Registra i codici, non inoltrarli all’agente.
- Una chiave mancante non è una policy. Il container resta attivo e risponde 401, 403 o 503 a seconda di cosa invii. Solo il PEP può trasformarlo in un rifiuto sicuro.
- Il soggetto viene dalla sessione.
pep.pyignora qualsiasi nome di agente negli argomenti. Lo stesso vale peruser_confirmed: in un gateway reale deve venire da un passo di conferma che il modello non può falsificare. - L’elenco dei tool non è filtrato. Secondo la documentazione del gateway Permit,
tools/listrestituisce tutti i tool a monte e il controllo avviene su ogni chiamata. Un agente può vedere un tool che non può usare. - Il gateway usa il check dell’SDK, non AuthZEN. AuthZEN è il modo in cui un altro PEP, come il mio, parla con lo stesso PDP.
Cosa farei con questo#
- Far chiudere il punto di enforcement in caso di errore e registrare il motivo, poi fermare il PDP in un test e controllare la riga di log.
- Mettere un allarme quando i rifiuti vengono da errori del PDP invece che da decisioni di policy.
- Tenere la chiave PDP lato server, nel gateway o in un sidecar, mai in un browser o nel prompt di un agente.
- Scegliere il tipo di PDP in base al modello di policy: limiti ABAC come questo richiedono l’Edge PDP.
- Togliere il context della decisione prima che qualcosa torni all’agente.
Cosa non ho provato#
Questo lab usa un proprio piccolo punto di enforcement al posto del Permit MCP Gateway ospitato. Usa solo funzioni del piano gratuito Community.
Le immagini di terminale sono generate dall’output salvato del 22 novembre 2026; gli screenshot della console sono dello stesso giorno. La chiave non compare mai.
Ripeti questo lab#
Per questo lab servono un account Permit.io gratuito, Linux con Podman o Docker, curl, jq e Python 3.10 o successivo. Conta circa 25 minuti. env.sh chiede la chiave API del tuo ambiente Development in un prompt nascosto; tienila fuori da file, chat e screenshot. Apri ogni passo, copia i blocchi e confronta l’output con il mio.
Ogni valore tra parentesi angolari è un segnaposto per il tuo ambiente di test. Nulla in questa pagina è un identificativo o un segreto reale.
Imposta le variabili una sola volta
# 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 di 7 passi fatti
Passo 1Carica la policy nel tuo ambiente Permit
Obiettivo. Installa l’SDK Python di Permit in un ambiente virtuale ed esegui setup_permit.py per creare risorsa, ruoli, resource set ABAC e due agenti.
Prerequisiti
- Un account Permit.io gratuito; la chiave API del suo ambiente Development digitata al prompt di env.sh
- Linux con Podman 5 o Docker, curl, jq e Python 3.10 o successivo
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 Output atteso
policy created: payments_mcp, 2 roles, 1 resource set, 2 agents Passo 2Avvia l’Edge PDP di Permit con la chiave
Obiettivo. Avvia l’immagine Edge PDP alla versione fissata con PDP_API_KEY dalla variabile di shell, attendi che scarichi la policy e leggi l’endpoint di health.
Prerequisiti
- La policy del passo precedente esiste
- Porte 7766 e 8383 libere
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}' Output atteso
<container-id>
permit-pdp docker.io/permitio/pdp-v2:0.9.17 Up 30 seconds
{"status":"ok","opa":"ok","horizon":"ok"} Passo 3Interroga il PDP via AuthZEN
Obiettivo. Leggi il documento di discovery, invia una valutazione, un batch di quattro pagamenti e una ricerca di soggetti, e confronta le decisioni.
Prerequisiti
- Il PDP è 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' Output atteso
["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"}] Passo 4Fai passare sei chiamate dal punto di enforcement
Obiettivo. Scrivi pep.py e calls.sh, avvia il punto di enforcement e invia le sei chiamate MCP del lab OPA.
Prerequisiti
- Il PDP è sano
- Porta 8383 libera
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 Output atteso
{"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) Passo 5Rompi la chiave, poi ferma il PDP
Obiettivo. Riavvia il punto di enforcement con una chiave vuota, poi ferma il container PDP, e invia ogni volta il pagamento da 45 dollari consentito.
Prerequisiti
- pep.py e calls.sh del passo precedente
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 Output atteso
{"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 Passo 6Invia lo stesso batch al Cloud PDP
Obiettivo. Invia il batch al Cloud PDP di Permit con la stessa chiave, poi punta il punto di enforcement su di esso e invia le prime tre chiamate.
Prerequisiti
- HTTPS in uscita verso 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 Output atteso
{"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) Passo 7Pulizia
Obiettivo. Ferma il punto di enforcement, rimuovi il container, elimina la policy dal tuo ambiente Permit e cancella i file.
Prerequisiti
- Nient’altro usa le porte 7766 e 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 Output atteso
cleanup done
0
000
000 Fonti#
- 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
Questo articolo in formato Markdown · RSS · JSON feed
Nuovi articoli via email
Una email a settimana con nuovi articoli e lab. Disiscrizione in qualsiasi momento.
Il tuo indirizzo è salvato su Kit, il servizio che invia le email. Dettagli