Per le alternative Skill, curl e git-clone, oltre ai sistemi PEP 668 e alla configurazione del secret-cloaking, consulta la [guida completa all'installazione](https://github.com/prismorsec/prismor/blob/main/docs/installation.md).

---

## Capacità<a name="capabilities" />

![Architettura Prismor](https://assets.kitploit.com/production/public/readmes/13903/0e84c7211b3275de581182b7f69c44d8224142323b43220dd1234eee17616757.png)

- 🛡️ [Prismor](https://github.com/prismorsec/prismor/blob/main/docs/prismor-runtime.md) copre il motore delle policy, i log di sessione, l'audit di sicurezza e il riferimento CLI
- 📦 [Supply Chain](https://github.com/prismorsec/prismor/blob/main/docs/supply-chain.md) copre l'enforcement in fase di installazione, il matching degli IOC e il risk scoring
- 🛜 [Network Isolation](https://github.com/prismorsec/prismor/blob/main/docs/network-isolation.md) copre il controllo dell'egress guidato dalle policy, il rilevamento di IP grezzi e il blocco dei tunnel
- 🔍 [Skill Scanner](https://github.com/prismorsec/prismor/blob/main/docs/skill-scanner.md) copre la scansione del rischio di server MCP e skill sugli agent supportati
- 🚦 [MCP Guardrails](https://github.com/prismorsec/prismor/blob/main/docs/prismor-runtime.md#custom-guardrails-for-mcp-tools) ti permette di bloccare uno specifico server o tool MCP, oppure di richiedere l'approvazione umana prima che l'agent lo chiami, con una regola di policy che scrivi tu stesso
- 🛰️ [MCP Gateway](https://github.com/prismorsec/prismor/blob/main/docs/mcp-gateway.md) è un singolo connettore MCP che si pone davanti a ogni altro server MCP che utilizzi — ogni `tools/call` viene valutato dalle policy prima dell'inoltro e ogni risposta viene scansionata per injection prima che il modello la veda, così un risultato di tool avvelenato non diventa mai contesto. `prismor mcp-gateway install` sposta un `.mcp.json` esistente dietro di esso
- 🛤️ [LLM Proxy](https://github.com/prismorsec/prismor/blob/main/docs/llm-proxy.md) governa un agent che Prismor non può agganciare, attraverso l'unica cosa che ogni agent possiede: il suo traffico verso il modello. Puntalo a `prismor proxy` con `ANTHROPIC_BASE_URL`, `OPENAI_BASE_URL`, o `HttpOptions(base_url=...)` del Google Gen AI SDK e nient'altro dell'agent cambia. Ogni chiamata a tool che il modello *propone* — `tool_use` di Anthropic, `tool_calls` di OpenAI, `functionCall` di Gemini — viene rimodellata nello stesso evento che produce un hook `Bash` e giudicata dalla stessa regola, con le chiamate in streaming trattenute finché non possono essere giudicate
- [Claude Inference Hooks](https://github.com/prismorsec/prismor/blob/main/docs/inference-hook.md) rende Prismor il server di sicurezza AI dietro Claude Enterprise: Anthropic invia ogni prompt governato da claude.ai, Claude Code e Cowork a `prismor inference-hook serve`, che esegue la tua policy sul transcript e risponde allow/deny prima che il modello venga eseguito — richieste firmate (Standard Webhooks), fail-closed, shadow mode, nulla da installare sui dispositivi degli utenti. `prismor inference-hook test` invia frame campione firmati per verificare il cablaggio
- 🏷️ [Tool Tags](https://github.com/prismorsec/prismor/blob/main/docs/tool-tags.md) classificano i tool per capacità (read, write, network, exec) così una regola può dire "nulla che legga dati privati può anche raggiungere la rete" invece di nominare ogni tool uno per uno — i tool MCP si auto-dichiarano tramite `_meta`, e `prismor tags` elenca, testa e analizza le espressioni delle regole
- 🔐 [Sweep and Cloak](https://github.com/prismorsec/prismor/blob/main/docs/sweep-and-cloak.md) copre la prevenzione dei segreti ai confini dei tool, la configurazione pratica, le best practice, il threat model e la pulizia dei segreti trapelati
- 🦞 [OpenClaw Integration](https://github.com/prismorsec/prismor/blob/main/docs/openclaw.md) copre gli hook di runtime, la scansione delle prompt-injection e la configurazione a livello di progetto o utente per OpenClaw
- 🤖 [Hermes Agent Cloaking](https://github.com/prismorsec/prismor/blob/main/docs/hermes.md) copre il cloaking dei segreti specifico di Hermes con auto-discovery degli entry-point pip, installazione su filesystem e paste guard di pre_gateway_dispatch
- ☁️ [Hosted Agent VMs](https://github.com/prismorsec/prismor/blob/main/docs/cloud-agents.md) governa gli agent che girano su una macchina in cui non accedi mai (Claude Code on the web, Cursor cloud agents, Copilot coding agent, OpenHands Cloud, Codex cloud, Replicas): lo script di setup della piattaforma installa il binario, e `install-hooks --portable` scrive una configurazione degli hook che è sicura da committare
- 🧠 [Semantic Guard](https://github.com/prismorsec/prismor/blob/main/docs/semantic-guard.md): livello ibrido opt-in che aggiunge un controllo di intento assistito da LLM per i tentativi di prompt-injection parafrasati che le regole regex non riescono a intercettare
- 🪤 [Canary](https://github.com/prismorsec/prismor/blob/main/docs/canary.md) pianta file di credenziali honeytoken che fanno scattare un finding CRITICAL nel momento in cui un agent li legge, intercettando comportamenti di ricognizione
- 🪪 [IAM](https://github.com/prismorsec/prismor/blob/main/docs/iam.md) assegna a ogni agent un'identità nominata e un profilo di permessi a privilegio minimo quando più agent condividono un workspace
- 🧩 [Framework Agents](https://github.com/prismorsec/prismor/blob/main/docs/frameworks-overview.md) protegge gli agent in produzione (OpenAI Agents SDK, LangChain/LangGraph in Python e JS, CrewAI, browser-use, Pydantic AI, AutoGen Core, Agno, Semantic Kernel, Google ADK, BeeAI, Claude Agent SDK, Vercel AI SDK, Mastra) con una sola chiamata — avvolgi ogni richiesta in `use_subject("user:alice")` e un agent multi-tenant ottiene attribuzione per utente, profili IAM per utente e sospensione per utente
- 🎯 [Scoped Agent](https://github.com/prismorsec/prismor/blob/main/docs/scoped-agent.md) sintetizza regole minime e specifiche per il task a ogni sessione, così un pivot iniettato fuori dal task viene bloccato
- 🧬 [Learning](https://github.com/prismorsec/prismor/blob/main/docs/learning.md) analizza la cronologia delle sessioni per proporre nuove regole, segnalare falsi positivi e rilevare evasioni
- ⚖️ [Layered Policy & Exemptions](https://github.com/prismorsec/prismor/blob/main/docs/policy-layers-and-exemptions.md) copre observe/enforce per regola, il floor non sovrascrivibile e le esenzioni concesse dall'admin e limitate nel tempo attraverso i livelli org / progetto / repo
- 🔐 [Selezione esplicita dell'enforce e la finestra di unlock](https://github.com/prismorsec/prismor/blob/main/docs/cli-reference.md#choosing-what-blocks) — la configurazione dell'enforce parte senza nulla che blocca e sei tu a scegliere l'insieme; `prismor allow` crea eccezioni ristrette, e `prismor unlock` apre una finestra protetta da password e limitata nel tempo in cui un agent può modificare la policy (mai le regole di auto-protezione che difendono Prismor stesso)
- 📡 [Live Telemetry](https://github.com/prismorsec/prismor/blob/main/docs/live-telemetry.md) copre il collegamento opzionale al control-plane enterprise — enrollment dei dispositivi, policy remota firmata e telemetria redatta trasmessa a una dashboard org self-hosted
- 🔌 [Telemetry Sinks](https://github.com/prismorsec/prismor/blob/main/docs/telemetry-sinks.md) inoltrano ogni finding verso ciò che già utilizzi — un collector OpenTelemetry (log OTLP/HTTP), Splunk HEC, Datadog, syslog, un webhook o un file locale in JSON/CEF/OCSF — inviati prima della decisione di blocco e mai in grado di bloccare una chiamata a tool
- 📊 [Dashboard](https://github.com/prismorsec/prismor/blob/main/docs/dashboard.md) copre le dashboard da terminale e web locale oltre alla forensics delle sessioni, con `prismor tokens` che analizza dove sono effettivamente finiti il contesto e la spesa in token di una sessione
- 🩺 [Health and Recovery](https://github.com/prismorsec/prismor/blob/main/docs/cli-reference.md) — `prismor doctor` esegue un health-check di ogni sottosistema (hook, firma della policy, enrollment, telemetry sink, stato della catena), e `prismor pause` / `pause-hard` sospende *solo l'enforcement* per un umano durante un incidente mentre il logging in observe-mode continua a funzionare
- 🧾 [Signed Audit Trail](https://github.com/prismorsec/prismor/blob/main/docs/audit-trail.md) concatena con hash e firma con Ed25519 ogni azione dell'agent localmente, così `prismor trail verify` dimostra che la cronologia non è stata modificata, cancellata o riscritta
- 🔖 [Signed Telemetry Receipts](https://github.com/prismorsec/prismor/blob/main/docs/telemetry-receipts.md) è lo schema di trasmissione per i record che un dispositivo riporta — byte canonici, i due livelli di integrità e un verificatore di riferimento senza dipendenze, così un SIEM o un auditor può controllare una ricevuta senza Prismor
- 📑 [Attestation Bundle](https://github.com/prismorsec/prismor/blob/main/docs/attestation-bundle.md) impacchetta postura, inventario degli agent, host discovery, copertura dei controlli di framework (OWASP LLM/Agentic, NIST AI RMF, EU AI Act) e l'ancora del trail in un unico file firmato con Ed25519 che un auditor ri-verifica con `prismor attest verify`
- 🔦 [Host Discovery](https://github.com/prismorsec/prismor/blob/main/docs/attestation-bundle.md#host-discovery) scansiona la macchina con `prismor discover` e segnala qualsiasi agent AI in esecuzione senza gli hook di Prismor (shadow AI)
- ⏪ [Transcript Ingest](https://github.com/prismorsec/prismor/blob/main/docs/transcript-ingest.md) ricostruisce ciò che i tuoi agent hanno fatto *prima* che Prismor fosse installato — `prismor ingest --discover` riproduce i transcript di sessione su disco attraverso il motore delle policy live, così la dashboard è popolata dal primo giorno e puoi vedere esattamente cosa avrebbe bloccato l'attivazione di una regola in enforce, più `--coverage` per le sessioni che hanno girato senza monitoraggio
- 🗺️ [Agentic AI Architecture Review](https://github.com/prismorsec/prismor/blob/main/docs/agentic-architecture-review.md) è una checklist in fase di progettazione per sistemi multi-agent/che usano tool — ambito dei permessi, integrità della memoria, fiducia tra agent, collocazione della supervisione umana — ogni voce mappata a un ID di controllo reale e, dove esiste, alla regola Prismor che la supporta
- 🐳 [Docker and Containers](https://github.com/prismorsec/prismor/blob/main/docs/docker.md) copre l'hardening dei container, i prerequisiti e le limitazioni note

Mappa completa dei comandi per ogni capacità: [CLI Reference](https://github.com/prismorsec/prismor/blob/main/docs/cli-reference.md).

Queste capacità si mappano all'[OWASP Top 10 for LLM Applications](https://genai.owasp.org/llm-top-10/) - coprendo prompt injection (LLM01), divulgazione di informazioni sensibili (LLM02), supply chain (LLM03), gestione impropria dell'output (LLM05) e agency eccessiva (LLM06).

---

## Scenari e casi d'uso<a name="scenarios-and-use-cases" />

Workflow reali con i comandi e la configurazione che li fanno funzionare — onboarding di un team in observe mode, attribuzione IAM per utente per pipeline multi-agent e basate su framework, scoperta di shadow AI, approvazione step-up per operazioni ad alto rischio e generazione di un attestation bundle firmato per un audit di conformità. Vedi [USE_CASES.md](https://github.com/prismorsec/prismor/blob/main/USE_CASES.md).

---

## Configurazione<a name="configuration" />

### Riferimento dei comandi

Mappa completa dei comandi: [docs/cli-reference.md](https://github.com/prismorsec/prismor/blob/main/docs/cli-reference.md).

### Modalità di governance

`prismor setup` ti chiede di scegliere una postura invece di configurare a mano sei assi di policy. Ognuna viene compilata in `.prismor/policy.yaml` — enforcement, egress, accesso ai tool, regole sui tag, sandbox e confine dei dati insieme.

![Modalità di governance di Prismor](https://raw.githubusercontent.com/prismorsec/prismor/main/assets/prismor-modes.png)

| Modalità | Per | Copertura | Attrito |
|---|---|---|---|
| `dev-safe` | Lavoro su funzionalità di codice che non hai letto | 31% | 9% |
| `trusted-workspace` | Repo interni fidati, lavoro Docker locale | 34% | 9% |
| `regulated-airgap` | PII/PHI, SOC 2, EU AI Act — nessuna rete, nessuna shell | 100% | 90% |```bash
prismor mode list                            # compare the three
prismor mode explain dev-safe                # the trade, including what it does NOT stop
prismor mode apply dev-safe                  # compile it into this workspace
prismor mode apply regulated-airgap --observe   # what it would block, blocking nothing

### Un unico motore di policy, ogni superficie di applicazione

Lo Stage 1 ha più di una porta, e questo è intenzionale: nessun singolo punto di interposizione copre ogni agente. Gli hook sono i più ampi ma non ogni host li offre; MCP è l'unico punto in cui alcuni agenti possono essere intercettati del tutto; gli agenti dei framework di produzione girano dove non c'è un host da agganciare.

Quindi ogni superficie normalizza ciò che ha visto in un unico evento canonico e chiede allo stesso valutatore un verdetto. Una regola scritta una volta copre la stessa azione comunque essa arrivi.

| superficie | cosa governa | rifiuta | riscrive input | redige output |
|---|---|:--:|:--:|:--:|
| Hook degli agenti di coding | l'intera superficie di strumenti di un agente | sì | Claude/Qwen | no |
| Gateway MCP | ogni server MCP dietro un unico connettore | sì | sì | sì |
| Built-in rispecchiati | il Bash/Read/Write dell'agente stesso, su MCP | sì | sì | sì |
| Adattatori SDK dei framework | agenti in-process (13 framework) | sì | no | no |
| `prismor eval-server` | chiamanti non-Python, proxy esterni | sì | sì | sì |
| Canale inference-hook | webhook di turno di trascrizione ospitato | sì | no | no |

"Redigere output" è il motivo per cui esiste il mirror: un hook pre-azione può solo *rifiutare* una lettura di file, mentre una superficie che trasporta la risposta può restituire il file con la credenziale mascherata.

Questo è verificato anziché asserito — `tests/test_surface_conformance.py` riproduce un'azione attraverso il normalizzatore proprio di ciascuna superficie e fallisce se non concordano sul verdetto o sulla regola.

Vedi [il contratto di decisione](https://github.com/prismorsec/prismor/blob/main/docs/decision-contract.md) per la forma dell'evento e il vocabolario dei verdetti, e [superfici di governance](https://github.com/prismorsec/prismor/blob/main/docs/governance-surfaces.md) per quale superficie usare per agente.

---

## Capacità selezionate, illustrate<a name="selected-capabilities-walked-through" />

Tre moduli da [Capacità](#capabilities), con configurazione, output e risultati.

### Difesa ibrida semantica contro il prompt-injection<a name="hybrid-semantic-prompt-injection-defense" />

Le regole regex catturano le forme di injection note. La guardia semantica aggiunge uno strato consapevole dell'intento: un pre-filtro euristico gestisce i casi evidenti in <1 ms, e gli input incerti vengono escalati a un giudice LLM che detiene comunque il verdetto — conferma attacchi parafrasati che la regex aveva visto solo a metà e scagiona testo benigno che aveva attivato un segnale di rivendicazione di autorità. Testato su oltre 800 casi — **+30% di recall** senza falsi positivi aggiunti, incluse injection parafrasate e in-file che aggirano la regex.

![Risultati della guardia semantica](https://assets.kitploit.com/production/public/readmes/13903/a32297d3549c5ff60690c8dca14490f1d53a17a253d912bcb2187414dea3d018.png)

Il giudice gira su un login che già possiedi — nessuna API key necessaria. `prismor setup` lo chiede al suo passo **LLM judge**; in modalità script:```bash
prismor setup --non-interactive --judge claude   # Claude Code CLI, your Claude login
prismor setup --non-interactive --judge codex    # Codex CLI, your ChatGPT login
prismor setup --non-interactive --judge api --judge-model gpt-4o-mini   # any litellm model + key

# Clona il repository
git clone https://github.com/yourusername/kitploit-tool.git
cd kitploit-tool

# Esegui lo script di installazione
chmod +x install.sh
./install.sh

# Installa le dipendenze
pip install -r requirements.txt

# Rendi eseguibile lo script principale
chmod +x kitploit.py

# Copia la configurazione di esempio
cp config.example.yaml config.yaml

# Modifica la configurazione con i tuoi parametri
nano config.yaml

# Compila l'immagine Docker
docker build -t kitploit-tool .

# Esegui il container
docker run -it --rm \
  -v $(pwd)/config.yaml:/app/config.yaml \
  -v $(pwd)/output:/app/output \
  kitploit-tool

requests>=2.28.0
pyyaml>=6.0
click>=8.1.0
rich>=13.0.0

# Configurazione generale
general:
  verbose: false
  output_dir: "./output"
  log_level: "INFO"

# Configurazione di rete
network:
  timeout: 30
  retries: 3
  user_agent: "KitploitTool/1.0"

# Configurazione dei moduli
modules:
  scanner:
    enabled: true
    threads: 10
  analyzer:
    enabled: true
    depth: 3

export KITPLOIT_VERBOSE=true
export KITPLOIT_OUTPUT_DIR="/path/to/output"
export KITPLOIT_LOG_LEVEL="DEBUG"

| `-s` | `--server` | `SERVER` | `http://localhost:8080` | URL del server MCP |
| `-t` | `--token` | `TOKEN` | `null` | Token di autenticazione |
| `-c` | `--config` | `CONFIG` | `null` | File di configurazione |
| `-v` | `--verbose` | `VERBOSE` | `false` | Abilita output dettagliato |
| `-h` | `--help` | `HELP` | `false` | Mostra il messaggio di aiuto |

### Esempi di utilizzo

```bash
# Avvia il server MCP
mcp-server --server http://localhost:8080 --token your-token

# Abilita output dettagliato
mcp-server --verbose

# Usa un file di configurazione
mcp-server --config config.json

# Clona il repository
git clone https://github.com/example/mcp-server.git
cd mcp-server

# Installa le dipendenze
npm install

# Avvia in modalità sviluppo
npm run dev

# Esegui tutti i test
npm test

# Esegui i test con copertura
npm run test:coverage

# Esegui i test in modalità watch
npm run test:watch

# Crea la build di produzione
npm run build

# Avvia la build di produzione
npm start

Verdetti: `< 30` consenti · `30–59` avvisa · `≥ 60` blocca. La corrispondenza IOC blocca sempre. Crea alias per i tuoi package manager per controllare automaticamente ogni installazione.

`prismor supplychain harden` scrive le impostazioni di lockdown in `.npmrc` / `.yarnrc.yml` / `pip.conf` / `.cargo/config.toml` in modo che il package manager le applichi anche quando l'alias viene aggirato (CI, plugin IDE).```bash
prismor supplychain harden           # apply to current directory
prismor supplychain harden --dry-run

`--scope` ha come valore predefinito `project`. **Lo scope project e lo scope user modificano file diversi** — eseguire solo `--scope user` *non* tocca gli hook locali di un workspace, e viceversa:

| Agent | Scope project | Scope user |
|---|---|---|
| Claude Code | `<workspace>/.claude/settings.json` | `~/.claude/settings.json` |
| Cursor | `<workspace>/.cursor/hooks.json` | `~/.cursor/hooks.json` |
| Windsurf | `<workspace>/.windsurf/hooks.json` | `~/.codeium/windsurf/hooks.json` |
| OpenClaw | `<workspace>/.openclaw/plugins.json` | `~/.openclaw/config.json` |
| Hermes | `<workspace>/.hermes/plugins.json` | `~/.hermes/config.json` |
| Codex | `<workspace>/.codex/hooks.json` | `~/.codex/hooks.json` |
| Copilot | `<workspace>/.github/copilot/hooks.json` | `~/.copilot/hooks.json` |
| Grok Build | `<workspace>/.grok/hooks/prismor.json` | `~/.grok/hooks/prismor.json` |
| Kiro CLI | `<workspace>/.kiro/agents/kiro_default.json` | `~/.kiro/agents/kiro_default.json` |
| Crush | `<workspace>/crush.json` | `~/.config/crush/crush.json` |
| OpenHands | `<workspace>/.openhands/hooks.json` | `~/.openhands/hooks.json` |
| Qwen Code | `<workspace>/.qwen/settings.json` | `~/.qwen/settings.json` |
| Continue CLI | `<workspace>/.continue/settings.json` | `~/.continue/settings.json` |
| Goose | `<workspace>/.agents/plugins/prismor/hooks/hooks.json` | `~/.agents/plugins/prismor/hooks/hooks.json` |

Se esegui un solo scope, gli hook dell'altro (se installati) continuano a essere attivati. Esegui entrambi se vuoi che Prismor sia completamente fuori dai giochi per un agent.

Una sessione in esecuzione ha già caricato la sua configurazione degli hook — disinstallare a metà sessione non avrà effetto finché non avvii una nuova sessione.

Se `prismor uninstall-hooks` segnala successo ma gli hook vengono ancora attivati, probabilmente stai eseguendo un'installazione obsoleta — ad esempio una copia installata con `pipx` che è uno snapshot non aggiornato di un checkout di sviluppo. Controlla `which immunity` e, se punta a un venv `pipx`, reinstalla dalla sorgente corrente (`pipx install --force <path-or-package>`) prima di rieseguire la disinstallazione. Come ultima risorsa, modifica manualmente il file di configurazione degli hook.

### 2. Disattivazione soft: modalità observe + dry-run

Mantieni gli hook installati ma impedisci loro di bloccare:```bash
prismor install-hooks --agent all --scope project --mode observe
PRISMOR_LOCAL_DRY_RUN=1   # set in your shell/session env