keygraphhq/shannonShannon è un penetration tester AI autonomo in modalità white-box per applicazioni web e API. Analizza il tuo codice sorgente, identifica i vettori di attacco ed esegue exploit reali per dimostrare le vulnerabilità prima che raggiungano la produzione.
> [!NOTE]
> **[Verifica cyber per i modelli Anthropic e OpenAI](https://github.com/KeygraphHQ/shannon/discussions/483):** completa il programma di verifica cyber del tuo provider per prevenire malfunzionamenti e rifiuti del modello durante i carichi di lavoro cyber.
<div align="center">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="./assets/github-banner-dark.png">
<source media="(prefers-color-scheme: light)" srcset="./assets/github-banner-light.png">
<img src="https://raw.githubusercontent.com/keygraphhq/shannon/main/assets/github-banner-light.png" alt="Shannon, AI Pentester per Web App e API, di Keygraph" width="100%">
</picture>
<a href="https://trendshift.io/repositories/15604" target="_blank"><img src="https://trendshift.io/api/badge/repositories/15604" alt="KeygraphHQ%2Fshannon | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
### Shannon è un pentester AI autonomo per applicazioni web e API.
Analizza il tuo codice sorgente, identifica i percorsi di attacco ed esegue exploit reali per dimostrare le vulnerabilità prima che raggiungano la produzione. **Nessun exploit, nessun report.**
**Questo repository è Shannon: l'agente open-source completo, eseguito localmente dalla tua riga di comando.**
<p><strong>Avvia Shannon</strong></p>
```bash
npx @keygraph/shannon@latest
```
<sub>Il launcher interattivo ti guiderà attraverso la configurazione e il tuo primo pentest.</sub>
---
<a href="https://discord.gg/9ZqQPuhJB7"><picture><source media="(prefers-color-scheme: dark)" srcset="./assets/discord_button_dark.png"><source media="(prefers-color-scheme: light)" srcset="./assets/discord_button_light.png"><img src="https://raw.githubusercontent.com/keygraphhq/shannon/main/assets/discord_button_light.png" height="40" alt="Join Discord"></picture></a> <a href="https://keygraph.io/"><picture><source media="(prefers-color-scheme: dark)" srcset="./assets/keygraph_button_dark.png"><source media="(prefers-color-scheme: light)" srcset="./assets/keygraph_button_light.png"><img src="https://raw.githubusercontent.com/keygraphhq/shannon/main/assets/keygraph_button_light.png" height="40" alt="Visit Keygraph.io"></picture></a>
---
</div>
> [!TIP]
> **Agenti AI e LLM:** inizia da [llms.txt](https://github.com/keygraphhq/shannon/blob/main/llms.txt) per una mappa concisa di questo repository, oppure usa [llms-full.txt](https://github.com/keygraphhq/shannon/blob/main/llms-full.txt) per il README e la documentazione combinati in un unico file.
## Indice
- [Indice](#table-of-contents)
- [Cos'è Shannon?](#what-is-shannon)
- [Perché esiste Shannon](#why-shannon-exists)
- [Perché "Shannon"?](#why-shannon)
- [Non un sostituto dei pentester umani](#not-a-replacement-for-human-pentesters)
- [Shannon in azione](#shannon-in-action)
- [Avvio rapido](#quick-start)
- [Prerequisiti](#prerequisites)
- [Eseguire Shannon](#run-shannon)
- [Funzionalità principali](#key-capabilities)
- [Integrazioni CI/CD](#cicd-integrations)
- [GitHub Actions](#github-actions)
- [Edizioni](#editions)
- [Architettura](#architecture)
- [Documentazione](#documentation)
- [Sicurezza, ambito e limitazioni](#safety-scope-and-limitations)
- [Licenza](#license)
- [Ringraziamenti](#acknowledgements)
- [Informazioni su Keygraph](#about-keygraph)
- [Community e supporto](#community-and-support)
- [Domande frequenti](#common-questions)
- [Posso ospitare Shannon autonomamente?](#can-i-self-host-shannon)
- [Shannon supporta bring your own key (BYOK)?](#does-shannon-support-bring-your-own-key-byok)
- [Shannon produce output SARIF?](#does-shannon-output-sarif)
- [Quali provider AI supporta Shannon?](#which-ai-providers-does-shannon-support)
- [Posso eseguire Shannon su un modello locale o self-hosted?](#can-i-run-shannon-on-a-local-or-self-hosted-model)
- [Shannon sfrutta davvero le vulnerabilità o si limita a scansionare?](#does-shannon-actually-exploit-vulnerabilities-or-just-scan)
## Cos'è Shannon?
Shannon è un pentester AI autonomo sviluppato da [Keygraph](https://keygraph.io). Esegue test di sicurezza su applicazioni web e sulle relative API sottostanti combinando l'analisi del codice sorgente con lo sfruttamento in tempo reale.
Shannon analizza il codice sorgente della tua applicazione web per identificare potenziali vettori di attacco, quindi utilizza l'automazione del browser e strumenti da riga di comando per eseguire exploit reali contro l'applicazione in esecuzione e le sue API. Solo le vulnerabilità con una proof-of-concept funzionante vengono incluse nel report finale.
Shannon è l'agente. Questo repository è Shannon, il pentester open-source che esegui tu stesso. Lo stesso Shannon alimenta anche le edizioni commerciali di Keygraph, [Pro ed Enterprise](https://keygraph.io/pricing). Vedi [Edizioni](#editions) per un confronto tra Shannon, Pro, Enterprise e il Community Program.
<a id="why-shannon-exists"></a>
<details>
<summary><strong>Perché esiste Shannon</strong></summary>
Grazie a strumenti come Claude Code e Cursor, il tuo team rilascia codice senza sosta. Ma il tuo penetration test? Avviene una volta all'anno. Questo crea un enorme divario di sicurezza. Per gli altri 364 giorni, potresti rilasciare in produzione vulnerabilità senza saperlo.
Shannon colma questo divario fornendo penetration testing automatizzato e on-demand che può essere eseguito su ogni build o release.
</details>
<a id="why-shannon"></a>
<details>
<summary><strong>Perché "Shannon"?</strong></summary>
Prende il nome da Claude Shannon, il padre della teoria dell'informazione. Al suo nucleo, il pentesting è un problema di informazione: ogni sonda riduce l'incertezza sullo stato di un sistema. I migliori strumenti massimizzano il segnale ottenuto da ogni richiesta, trasformando quei bit di conoscenza in un percorso di exploit.
Inoltre, volevamo che potessi dire: "Ehi Claude, esegui Shannon" per trovare tutte le falle di sicurezza nella tua app vibe-coded.
</details>
<a id="not-a-replacement-for-human-pentesters"></a>
<details>
<summary><strong>Non un sostituto dei pentester umani</strong></summary>
Shannon è progettato per lavorare al fianco di pentester e red teamer esperti, non per sostituirli. I grandi pentester comprendono il business, concatenano gli attacchi in modi che nessuno aveva previsto e portano anni di giudizio che i modelli attuali non possono eguagliare.
Shannon risolve un problema diverso: c'è molto più software da testare di quanto i team di sicurezza abbiano tempo per coprire. I sistemi critici ricevono valutazioni periodiche da parte di esperti, mentre la lunga coda di app interne, API e servizi in rapida evoluzione raramente viene testata del tutto.
Shannon sposta il pentesting a sinistra nel ciclo di vita dello sviluppo software (SDLC). Usalo per eseguire test basati sullo sfruttamento contro ambienti di staging e release alla cadenza con cui vengono effettivamente distribuiti, e riserva il tempo degli esperti umani ai rischi che richiedono qualcuno che conosca l'organizzazione.
</details>
## Shannon in azione
Questi report provengono da scansioni Shannon OSS di Photoview 2.4.0, una delle applicazioni nel confronto di Doyensec tra Aikido e XBOW. Abbiamo eseguito Shannon contro la stessa versione dell'applicazione e valutato i suoi risultati separatamente. Leggi lo [studio Doyensec](https://doyensec.com/resources/ComparingAIApplicationSecurityTestingPlatforms_Doyensec.pdf) e il nostro [confronto successivo di Shannon](https://github.com/keygraphhq/shannon/blob/main/docs/shannon-xbow-aikido-benchmark.md) per la metodologia, i limiti, i costi e i risultati.
| Modello | Report | SARIF |
| ----------------- | ---------------------------------------------------------------------------- | --------------------------------------------------------------- |
| DeepSeek v4 Flash | [Visualizza report](https://github.com/keygraphhq/shannon/blob/main/benchmark/photoview-deepseek-v4-flash.pdf) | [SARIF](https://github.com/keygraphhq/shannon/blob/main/benchmark/photoview-deepseek-v4-flash.sarif) |
| Grok 4.6 | [Visualizza report](https://github.com/keygraphhq/shannon/blob/main/benchmark/photoview-grok-4-6.pdf) | [SARIF](https://github.com/keygraphhq/shannon/blob/main/benchmark/photoview-grok-4-6.sarif) |
| Claude Opus 5 | [Visualizza report](https://github.com/keygraphhq/shannon/blob/main/benchmark/photoview-opus-5.pdf) | [SARIF](https://github.com/keygraphhq/shannon/blob/main/benchmark/photoview-opus-5.sarif) |
## Avvio rapido
### Prerequisiti
- **Docker**: richiesto per il container worker.
- **Node.js 18+**: richiesto per il flusso di lavoro `npx` consigliato.
- **Credenziali del provider AI**: Shannon funziona su Anthropic, OpenAI, xAI, AWS Bedrock e [qualsiasi altro provider](https://github.com/keygraphhq/shannon/blob/main/docs/ai-providers.md#any-other-provider) nel catalogo dell'harness — ciascuno dei quali può essere indirizzato a un proxy o a un gateway LLM tramite un [base URL personalizzato](https://github.com/keygraphhq/shannon/blob/main/docs/ai-providers.md#custom-base-url), e un modello non presente nel catalogo può essere descritto con una [configurazione di modello personalizzata](https://github.com/keygraphhq/shannon/blob/main/docs/ai-providers.md#custom-model-configuration). Porti la tua chiave e Keygraph non intermedia mai il traffico verso il tuo modello. Shannon è indipendente dal provider. Vedi [Provider AI](https://github.com/keygraphhq/shannon/blob/main/docs/ai-providers.md#suggested-models) per gli ID dei modelli suggeriti.
- **Salvaguardie informatiche sbloccate con il tuo provider**: Anthropic e OpenAI applicano salvaguardie in tempo reale ai carichi di lavoro di sicurezza informatica, che possono interrompere una scansione a metà esecuzione. Completa le loro indicazioni per tester di sicurezza legittimi prima della prima esecuzione - vedi [Provider AI](https://github.com/keygraphhq/shannon/blob/main/docs/ai-providers.md#cyber-safeguards-do-this-before-your-first-scan) e l'[annuncio sulla verifica informatica](https://github.com/KeygraphHQ/shannon/discussions/483).
### Esegui Shannon
> [!WARNING]
> Shannon esegue attivamente exploit. Eseguilo solo contro applicazioni e ambienti di tua proprietà o per i quali hai un'autorizzazione scritta esplicita a testare. Non eseguire Shannon contro sistemi di produzione.
```bash
# Configure credentials with the interactive wizard.
npx @keygraph/shannon@latest setup
# Run a pentest against a source-available target.
npx @keygraph/shannon@latest start \
-u https://your-app.com \
-r /path/to/your/repo
```
Shannon scarica l'immagine del worker da Docker Hub, avvia l'infrastruttura locale richiesta, monta il repository di destinazione in sola lettura all'interno di un container worker effimero e scrive i risultati in un workspace locale.
Per build da sorgente, scansioni autenticate, configurazione specifica del provider e note sulla piattaforma, consulta la [Documentazione](#documentation).
> [!TIP]
> **Preferisci usare un abbonamento invece dei crediti API?**
>
> - **OpenAI Codex:** L'ultima versione di Shannon supporta gli abbonamenti ChatGPT Plus e Pro. Segui la [guida alla configurazione dell'abbonamento OpenAI Codex](https://github.com/keygraphhq/shannon/blob/main/docs/ai-providers.md#openai-codex-chatgpt-pluspro-subscription) per iniziare.
> - **xAI (Grok):** L'ultima versione di Shannon supporta gli abbonamenti xAI. Segui la [guida alla configurazione dell'abbonamento xAI](https://github.com/keygraphhq/shannon/blob/main/docs/ai-providers.md#xai-grok-subscription) per iniziare.
> - **Claude Code:** L'ultima versione di Shannon non supporta gli abbonamenti Claude Code. Segui la [guida alla configurazione dell'abbonamento Claude Code](https://github.com/keygraphhq/shannon/blob/main/docs/ai-providers.md#claude-code-subscription) per usare la versione `1.9.0`, che è l'ultima release basata su Claude Agent SDK.
## Capacità principali
- **Nessun exploit, nessun report**: segnala solo vulnerabilità confermate con una proof of concept riproducibile, riducendo il rumore speculativo degli scanner.
- **Analisi avanzata del codice**: mappa architettura, confini di fiducia, interfacce, flussi di dati e asset critici prima di inviare percorsi di attacco credibili agli agenti di pentesting live.
- **Esecuzione autonoma**: esegue ricognizione, analisi, sfruttamento e reporting con un singolo comando.
- **Esperienza terminale live**: semplifica la configurazione della scansione e mostra l'avanzamento e i risultati degli agenti senza esporre i log di orchestrazione.
- **Test autenticati**: supporta credenziali, flussi di login, TOTP, autenticazione via email, aree di focus e regole di ingaggio tramite configurazione.
- **Copertura orientata a OWASP**: verifica injection sfruttabili, XSS, SSRF, autenticazione compromessa e autorizzazione compromessa.
- **Workspace ripristinabili**: riprende scansioni interrotte senza ripetere il lavoro già completato.
- **Integrazioni CI/CD native**: funziona tramite la GitHub Action ufficiale o il componente GitLab CI/CD, conserva gli artefatti, pubblica i risultati e blocca le release in presenza di vulnerabilità dimostrate.
- **Report multiformato**: produce report PDF e Markdown ricchi di evidenze, oltre a JSON e SARIF 2.1.0. SARIF è abilitato per impostazione predefinita per le scansioni in modalità exploit.
- **Indipendente dal provider e BYOK**: supporta Anthropic, OpenAI, xAI, AWS Bedrock, API compatibili e gateway LLM, e modelli locali serviti tramite Ollama, vLLM o LM Studio.
- **Privato per progettazione**: funziona nella tua infrastruttura, archivia i risultati localmente e invia le richieste al modello direttamente all'endpoint scelto. Un endpoint locale mantiene i dati all'interno del tuo ambiente.
## Integrazioni CI/CD
Shannon può essere eseguito in modo continuo contro ambienti di staging e sviluppo distribuiti tramite le integrazioni ufficiali per [GitHub Actions](https://github.com/KeygraphHQ/shannon-action) e [GitLab CI/CD](https://gitlab.com/KeygraphHQ/shannon-ci).
Entrambe le integrazioni:
- analizzano il repository sorgente estratto mentre attaccano un target in esecuzione;
- conservano i report PDF, Markdown e SARIF come artefatti della pipeline;
- conservano i log di scansione e degli agenti per il debug, incluse le esecuzioni incomplete;
- supportano pentest su pull request, release e pianificati;
- distinguono una valutazione incompleta da una scansione completata senza risultati; e
- possono facoltativamente far fallire la pipeline quando Shannon sfrutta una vulnerabilità pari o superiore a una soglia di severità configurata.
Un'ipotesi derivante dall'analisi del codice non fa fallire la pipeline. I gate di severità contano solo i risultati con `status: exploited`.
### GitHub Actions
```yaml
name: Shannon Pentest
on:
workflow_dispatch:
permissions:
security-events: write
jobs:
pentest:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Run Shannon
uses: KeygraphHQ/shannon-action@v1
with:
url: https://staging.example.com
api-key: ${{ secrets.SHANNON_AI_API_KEY }}
fail-on-severity: high
upload-sarif: true
```
L'Action imposta `repo` per impostazione predefinita sull'area di lavoro GitHub estratta. Carica un artefatto contenente i report di valutazione della sicurezza e SARIF, più un artefatto di esecuzione separato contenente i log di scansione e dell'agente. Abilitando `upload-sarif` si pubblicano i risultati supportati nella scansione del codice di GitHub.
Requisiti:
- un repository privato;
- un runner con Docker e Docker Compose v2;
- accesso al target di staging o sviluppo in esecuzione; e
- una credenziale del provider del modello memorizzata come secret di GitHub Actions.
Vedi la [documentazione di Shannon GitHub Action](https://github.com/KeygraphHQ/shannon-action) e la [pagina su GitHub Marketplace](https://github.com/marketplace/actions/shannon-ai-pentester).
## Edizioni
| Edizione | Cos'è | Prezzo |
| --- | --- | --- |
| **Shannon** (open source) | Questo repository. Un pentester autonomo completo che esegui tu stesso, in locale o in CI/CD, contro un'applicazione di cui possiedi il codice sorgente. Adatto a sviluppatori individuali e piccoli team. | Open source con licenza AGPL-3.0. Paghi solo i tuoi costi del modello. |
| **Community Program** | Keygraph Pro senza costi, per organizzazioni no-profit 501(c)(3) con sede negli Stati Uniti e per startup in fase seed o pre-Serie A con 20 o meno sviluppatori attivi. | $0 di costi per i servizi cloud finché ne hai i requisiti. |
| **Pro** | L'edizione cloud-hosted di Keygraph, gestita da Keygraph, con tutti i moduli inclusi. | $50 per sviluppatore attivo al mese. |
| **Enterprise** | Tutto ciò che è incluso in Pro, self-hosted nel tuo ambiente o completamente air-gapped. | Personalizzato. |
Vedi [keygraph.io/pricing](https://keygraph.io/pricing) per i prezzi attuali e la tabella completa delle funzionalità.
**Pro**, **Enterprise** e il **Community Program** sono basati su una versione potenziata del motore Shannon di livello enterprise, e tutti e tre aggiungono:
- **Black-box pentesting**: testa l'applicazione in esecuzione dall'esterno, senza bisogno del codice sorgente.
- **Controlli sulle dipendenze (SCA) e sui secret**: SCA con reachability, e scansione dei secret che include la cronologia del repository.
- **Gestione dei risultati**: un record per vulnerabilità per repository attraverso scansioni e scanner, con cronologia degli stati, responsabili, SLA e dashboard.
- **Pull request di correzione e retest**: pull request di correzione revisionabili, con ogni correzione verificata tramite ri-analisi e replay dell'exploit, senza una nuova scansione completa.
- **Jira e controllo degli accessi**: sincronizzazione bidirezionale con Jira, SSO, RBAC e log di audit.
Nessun codice sorgente? Usa il [Blackbox Pentester](https://keygraph.io/agentic-blackbox-pentester).
[Confronta Shannon, Pro ed Enterprise in dettaglio →](https://github.com/keygraphhq/shannon/blob/main/docs/keygraph-platform.md)
## Architettura
Shannon combina l'analisi multi-fase del codice di sicurezza con la ricognizione e lo sfruttamento dal vivo:
```mermaid
flowchart TD
S["Source code"] --> EXISTING["Recon + vulnerability analysis"]
S --> SAST["Agentic security code analysis"]
EXISTING -- "Pentest candidates" --> REC["Finding reconciliation<br/>(merge + deduplicate)"]
SAST -- "SAST candidates" --> REC
REC -- "Reconciled exploitation queue" --> EXP["Exploitation agents"]
APP["Running application"] --> EXP
EXP -- "Exploit demonstrated" --> REPORT["Reporting<br/>PDF · Markdown · SARIF"]
EXP -- "No exploit demonstrated" --> DROP["Discard"]
REPORT --> CICD["CI/CD gate"]
```
Passaggio per passaggio:
1. **Ricognizione e analisi delle vulnerabilità** esplora l'applicazione in esecuzione, collega il comportamento a runtime al codice sorgente ed esegue agenti specializzati su Injection, XSS, SSRF, Autenticazione e Autorizzazione.
2. **Analisi agentica del codice di sicurezza** mappa l'architettura dell'applicazione, i confini di fiducia, le interfacce esposte, le dipendenze, i flussi di dati e gli asset ad alto rischio, quindi avvia indagini mirate su di essi.
3. **Riconciliazione dei risultati** unisce entrambi i flussi di candidati, elimina le duplicazioni sovrapposte e raggruppa ciò che rimane in una coda di sfruttamento.
4. **Agenti di sfruttamento** tentano attacchi reali di proof-of-concept contro l'applicazione in esecuzione.
5. **Validazione** scarta ogni candidato che Shannon non riesce a dimostrare.
6. **Reportistica** produce report in PDF e Markdown con le evidenze allegate, oltre a JSON strutturato e SARIF per i sistemi a valle.
Solo le vulnerabilità validate dal vivo diventano risultati del pentest di Shannon o contribuiscono ai gate di severità CI/CD.
Ogni scansione viene eseguita in un container Docker effimero con un workspace isolato e orchestrazione per singola invocazione.
## Documentazione
Usa queste guide per i dettagli operativi:
| Guida | Da usare per |
| --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Build dal sorgente e comandi CLI](https://github.com/keygraphhq/shannon/blob/main/docs/development.md) | Clonazione, build, comandi comuni, percorsi di output e sviluppo locale. |
| [Configurazione](https://github.com/keygraphhq/shannon/blob/main/docs/configuration.md) | Test autenticati, flussi di login, regole di ingaggio e filtri dei report. |
| [Provider AI](https://github.com/keygraphhq/shannon/blob/main/docs/ai-providers.md) | Selezione del modello, i provider supportati (Anthropic, OpenAI, xAI, AWS Bedrock e qualsiasi altro provider supportato da Pi) e gateway LLM personalizzati. |
| [Piattaforme e networking](https://github.com/keygraphhq/shannon/blob/main/docs/platforms.md) | Windows/WSL2, Linux, macOS, networking Docker, app locali e hostname personalizzati. |
| [Workspace e ripresa](https://github.com/keygraphhq/shannon/blob/main/docs/workspaces.md) | Denominazione dei workspace, ripresa delle scansioni interrotte e archiviazione dei workspace. |
| [Sicurezza e limitazioni](https://github.com/keygraphhq/shannon/blob/main/docs/safety.md) | Requisiti per l'uso autorizzato, indicazioni per ambienti non di produzione, effetti mutativi, costi e avvertenze sui modelli. |
| [Copertura e roadmap](https://github.com/keygraphhq/shannon/blob/main/docs/coverage-roadmap.md) | Copertura attuale delle vulnerabilità e lavoro pianificato. |
| [Pro ed Enterprise](https://github.com/keygraphhq/shannon/blob/main/docs/keygraph-platform.md) | Shannon confrontato con Pro, Enterprise e il Community Program: pentesting black-box, SCA e secrets, gestione dei risultati, pull request di correzione, retest, Jira e deployment. |
## Sicurezza, Ambito e Limitazioni
Shannon non è uno scanner passivo. I suoi agenti di sfruttamento possono creare utenti, inviare form, modificare lo stato dell'applicazione, attivare richieste in uscita e in altro modo influenzare il sistema target. Usa ambienti sandbox, di staging o di sviluppo locale con dati usa e getta.
Sei responsabile dell'uso legale ed etico di Shannon. Non puntare Shannon verso sistemi, repository o applicazioni che non possiedi o per cui non hai esplicita autorizzazione a testare.
Limitazioni importanti:
- Shannon è ottimizzato per il pentesting rapido e informato dal codice nello sviluppo quotidiano e nelle pipeline CI/CD. L'analisi SAST agentica esaustiva, una copertura più ampia degli scanner, la governance centralizzata e la gestione delle vulnerabilità lungo l'intero ciclo di vita sono fornite tramite Pro, Enterprise e il Community Program.
- I risultati richiedono comunque una revisione umana. I report generati da LLM possono contenere dettagli debolmente supportati o errati.
- Anthropic, OpenAI, xAI e AWS Bedrock sono provider integrati, e anche qualsiasi altro provider presente nel catalogo dell'harness funziona — ciascuno raggiungibile tramite un base URL personalizzato che lo indirizza verso un proxy o un LLM gateway. Le capacità dei modelli variano, e un modello che non segue in modo affidabile le istruzioni di Shannon o i vincoli sull'uso degli strumenti produrrà risultati più deboli.
- Un'esecuzione completa può richiedere circa da 1 a 1,5 ore e può comportare costi per le API LLM a seconda del prezzo del modello e della complessità dell'applicazione.
- Non scansionare codebase non attendibili o ostili. Gli strumenti basati su AI che leggono il codice sorgente possono essere esposti a prompt injection.
Leggi la guida completa [Sicurezza e limitazioni](https://github.com/keygraphhq/shannon/blob/main/docs/safety.md) prima di eseguire Shannon in un nuovo ambiente.
## Licenza
Shannon è distribuito con licenza [GNU Affero General Public License v3.0](https://github.com/keygraphhq/shannon/blob/main/LICENSE).
La licenza commerciale ed enterprise è disponibile per le organizzazioni che necessitano di termini di licenza diversi, supporto commerciale, ridistribuzione privata, uso come servizio gestito o opzioni di deployment più ampie, incluse Keygraph Pro ed Enterprise.
Per la licenza commerciale, contatta [[email protected]](mailto:[email protected]).
## Ringraziamenti
Grazie a [Pi](https://github.com/earendil-works/pi),
[Playwright CLI](https://github.com/microsoft/playwright-cli),
e [Mantis](https://github.com/google/mantis).
Consulta [THIRD_PARTY_NOTICES.md](https://github.com/keygraphhq/shannon/blob/main/THIRD_PARTY_NOTICES.md) per i dettagli su licenze e attribuzioni.
## Informazioni su Keygraph
**Keygraph** è l'azienda dietro Shannon. Sviluppa anche **Keygraph Pro** e **Keygraph Enterprise**, le edizioni commerciali che completano l'intero ciclo di vita dell'AppSec e utilizzano una build potenziata di Shannon come motore di pentesting.
## Community e supporto
Gli **orari di ricevimento della community** sono disponibili per assistenza pratica su bug, deployment e domande di configurazione.
- US/EU: giovedì, 10:00 PT
- Asia: giovedì, 14:00 IST
- [Prenota uno slot](https://cal.com/george-flores-keygraph/shannon-community-office-hours)
[Unisciti a Discord](https://discord.gg/cmctpMBXwE) per porre domande, condividere feedback e connetterti con altri utenti di Shannon.
Al momento, Keygraph non accetta contributi di codice esterni. Le issue sono benvenute per segnalazioni di bug e richieste di funzionalità:
- [Segnala bug](https://github.com/KeygraphHQ/shannon/issues)
- [Suggerisci funzionalità](https://github.com/KeygraphHQ/shannon/discussions)
Resta in contatto:
- [Sito web di Keygraph](https://keygraph.io)
- [Twitter/X: @KeygraphHQ](https://twitter.com/KeygraphHQ)
- [LinkedIn: Keygraph](https://linkedin.com/company/keygraph)
## Domande frequenti
### Posso ospitare Shannon autonomamente?
Sì. Shannon viene eseguito all'interno della tua infrastruttura in un container worker effimero. Monta il repository in sola lettura e scrive i risultati in un workspace locale.
Keygraph non riceve mai il tuo codice sorgente e non fa mai da proxy al traffico verso i modelli. Le richieste ai modelli vanno direttamente al provider o all'endpoint che configuri, e trasportano con sé il codice sorgente e il contesto dell'applicazione. Punta Shannon verso un endpoint ospitato localmente e anche quel traffico rimarrà all'interno del tuo ambiente.
### Shannon supporta il bring your own key (BYOK)?
Sì, sempre. Fornisci tu le credenziali LLM che Shannon utilizza per eseguire un pentest, in ogni deployment, open source e commerciale. Keygraph non fa mai da proxy al traffico verso i modelli.
### Shannon produce output SARIF?
Sì. Shannon genera SARIF 2.1.0, il formato standard OASIS per i risultati dell'analisi statica, insieme a JSON strutturato. Qualsiasi consumer SARIF può leggerlo: servizi di code scanning, piattaforme di gestione delle vulnerabilità, dashboard di sicurezza e pipeline CI/CD. Viene scritto per impostazione predefinita nelle scansioni in modalità exploit; imposta `report.sarif` su `"false"` nel tuo file di configurazione per disattivarlo.
### Quali provider AI supporta Shannon?
Anthropic, OpenAI, xAI e AWS Bedrock sono integrati e configurati direttamente tramite l'ID del provider. Oltre a questi, Shannon funziona con qualsiasi provider presente nel catalogo dell'harness Pi, denominato allo stesso modo `<provider>:<model-id>`. Qualsiasi provider può essere indirizzato verso un proxy o un LLM gateway tramite un base URL personalizzato, che sovrascrive solo l'endpoint e mantiene il dialetto API di quel provider. Un modello non presente nel catalogo, come uno servito da un router o gateway con il proprio ID, o un modello self-hosted, viene descritto in un file di [configurazione personalizzata del modello](https://github.com/keygraphhq/shannon/blob/main/docs/ai-providers.md#custom-model-configuration) e passato con `--models-config`. Shannon utilizza un'unica impostazione di modello unificata per l'intero pentest.
### Posso eseguire Shannon su un modello locale o self-hosted?
Shannon funziona con modelli locali serviti tramite Ollama, vLLM o LM Studio, che espongono un endpoint compatibile con OpenAI, così come con router come OpenRouter e LLM gateway come LiteLLM. Un modello non presente nel catalogo dell'harness, come la maggior parte dei modelli self-hosted, viene descritto in un file di [configurazione personalizzata del modello](https://github.com/keygraphhq/shannon/blob/main/docs/ai-providers.md#custom-model-configuration) passato con `--models-config`; router e gateway possono anche essere raggiunti tramite un base URL personalizzato. Le capacità variano, e un modello che non segue in modo affidabile le istruzioni di Shannon o i vincoli sull'uso degli strumenti produrrà pentest più deboli rispetto a un modello di frontiera, quindi segui questa strada solo se sai come si comporta il modello scelto. Vedi [Modelli locali e self-hosted](https://github.com/keygraphhq/shannon/blob/main/docs/ai-providers.md#local-and-self-hosted-models).
### Shannon sfrutta davvero le vulnerabilità o si limita a scansionare?
Shannon esegue exploit reali. Segnala una vulnerabilità solo quando ha prodotto un proof-of-concept funzionante, e scarta le ipotesi che non riesce a dimostrare. È un pentester, non uno scanner passivo.
**Realizzato da [Keygraph](https://keygraph.io)**