gmh5225/jataayuSicurezza degli agenti AI basati su LLM — rilevamento delle injection in ingresso + protezione della privacy in uscita
Nel Ramayana, Jataayu era l'aquila che individuò Ravana mentre rapiva Sita. Non aspettò che un pattern corrispondesse. Vide la minaccia, valutò la situazione e agì — da solo, senza esitazione. Questo è Jataayu.
Il livello di autorizzazione runtime per agenti AI che utilizzano strumenti. Blocca l'azione, non la stringa.
Jataayu decide — in modo deterministico — se l'azione di un agente è autorizzata a essere eseguita, in base al danno dell'effetto × la provenienza dell'input × la tua policy di capability. Un agente che ha letto una pagina web controllata dall'attaccante può comunque riassumerla; semplicemente non può essere ingannato per eseguire il comando shell, leggere il segreto o fare POST dei tuoi dati che l'attaccante voleva. Attorno a questo nucleo aggiunge screening di difesa in profondità (injection in ingresso, privacy in uscita, canali di esfiltrazione, supply-chain delle skill) e tracce di audit riproducibili.
La maggior parte degli strumenti di sicurezza per agenti cerca di rilevare il testo dell'attacco. È una corsa agli armamenti persa in partenza: un attaccante adattivo riscrive semplicemente la stringa finché il classificatore non la manca. La tesi di Jataayu — quella su cui gli standard del 2026 (OWASP Agentic Top 10, NIST) sono convergiti — è che il confine durevole è l'azione, giudicata da dove proviene l'input influente:
v0.3.1 — alpha. Non ancora su PyPI. Installa da GitHub (vedi sotto). L'API potrebbe ancora cambiare prima della 1.0. Vedi CHANGELOG.md per ciò che è stato rilasciato in ogni versione e ARCHITECTURE.md per il design.
# Core (effect boundary + regex pre-filter, no LLM deps)
pip install git+https://github.com/saikrishnarallabandi/jataayu.git
# With cloud LLM backends (OpenAI + Anthropic) for the optional slow path
pip install "jataayu[llm] @ git+https://github.com/saikrishnarallabandi/jataayu.git"
# With Ollama (local, free slow path)
pip install "jataayu[ollama] @ git+https://github.com/saikrishnarallabandi/jataayu.git"
Richiede Python ≥ 3.10. L'unica dipendenza obbligatoria è requests; i backend LLM sono extra opzionali.
Decidi in base al danno dell'effetto × la provenienza dell'input, in modo deterministico (nessun LLM):
from jataayu import jataayu_authorize_action
decision = jataayu_authorize_action(
"shell.exec",
{"cmd": "rm -rf /tmp/cache"},
untrusted=True, # these params were influenced by untrusted inbound content
)
# {tool_name, effect_class: 'shell', provenance: 'untrusted',
# decision: 'allow'|'deny'|'needs_approval', reason, violations, commit_token}
if decision["decision"] == "deny":
raise SecurityError(decision["reason"])
Input derivato da fonti non attendibili verso un effetto shell / code-eval / secret-read viene negato; verso network / file-write / memory-write richiede approvazione umana; tutto il resto è consentito.
Per l'esecuzione applicata, usa l'API a oggetti PREVIEW → COMMIT — il commit_token vincola la richiesta
esatta, quindi modificare l'azione dopo l'autorizzazione viene rifiutato:
from jataayu import EffectBoundary, Value, Provenance
eb = EffectBoundary()
preview = eb.preview(
"file.write",
{"path": "notes.md", "text": text},
values=[Value(text, Provenance.TRUSTED, source="user")],
)
if preview.approved:
eb.commit(preview, {"path": "notes.md", "text": text}, lambda: write_file("notes.md", text))
# commit() raises CommitRejected if the preview wasn't ALLOW or the params changed
Il contenuto iniettato può anche essere consegnato all'agente come handle opaco con un riepilogo limitato, così un tentativo di esfiltrazione detiene solo un handle, non il segreto grezzo (confinamento al confine di lettura).
L'injection arriva sul primo messaggio, sui risultati dei tool e su qualunque cosa l'agente abbia richiamato dalla memoria. Stesso motore, superficie giusta — trattalo come una fonte di taint che alimenta il confine dell'effetto, non come la tua garanzia:
from jataayu import (
jataayu_check_inbound,
jataayu_check_tool_return,
jataayu_check_memory_write,
jataayu_check_memory_read,
)
result = jataayu_check_inbound(github_issue_body, surface="github-issue")
if result["status"] == "HIGH":
raise SecurityError(f"Blocked: {result['findings']}")
# Returns: {status: 'SAFE'|'LOW'|'MEDIUM'|'HIGH', findings, risk_score, threat_types, blocked}
# A tool result or a memory recall can carry an injection — check before the agent consumes it
r = jataayu_check_tool_return(api_response, tool_name="web.search")
if r["blocked"]:
raise SecurityError(r["findings"])
jataayu_check_memory_write(note) # before persisting
jataayu_check_memory_read(recalled) # before it re-enters context
Rimuovi PII/segreti prima di inviare a superfici condivise e — cosa più importante — blocca l'URL che trasporta dati / l'immagine auto-scaricata che fa trapelare contesto con zero click (la classe EchoLeak / AgentFlayer / Notion). Lo scanner PII non vede mai quel payload; la guardia egress sì:
from jataayu import jataayu_check_outbound, jataayu_check_egress
result = jataayu_check_outbound(
draft_reply, surface="discord-channel",
protected_names=["Alice", "Bob"], # names that must never leak
)
safe_text = result["redacted"] if result["status"] in ("WARN", "BLOCK") else draft_reply
r = jataayu_check_egress(
"Task complete! ",
surface="github-comment",
context_secrets=[api_key], # optional: confirm exfil if a known secret rides in the URL
)
if r["status"] == "BLOCK":
safe_text = r["redacted"] # offending URL neutralized, human text kept