
Uno strumento di modellazione delle minacce basato sull'intelligenza artificiale che sfrutta i modelli GPT di OpenAI per generare modelli di minaccia per una determinata applicazione basandosi sulla metodologia STRIDE.
STRIDE GPT è uno strumento di threat modelling basato sull'intelligenza artificiale che sfrutta i Large Language Models (LLM) per generare modelli di minaccia e alberi di attacco per una determinata applicazione, basandosi sulla metodologia STRIDE. Gli utenti forniscono dettagli sull'applicazione, come il tipo di applicazione, i metodi di autenticazione, e se l'applicazione è esposta su Internet o tratta dati sensibili. Il modello genera quindi il suo output in base alle informazioni fornite.
Se trovi utile STRIDE GPT, considera di supportare il progetto:

mitre_attack in SARIFembed.diagrams.net ospitato; per distribuzioni self-hosted o in ambienti air-gapped, puntalo al tuo draw.io tramite la variabile d'ambiente STRIDE_GPT_DRAWIO_URL/analyze del CLI emette un DFD a livello di sistema insieme ai suoi risultatiVuoi personalizzare STRIDE-GPT per la tua organizzazione? Dai un'occhiata alla nostra Guida all'Operatività completa per imparare come:
La guida include istruzioni passo-passo, esempi di codice e pattern di distribuzione per le organizzazioni che desiderano scalare il threat modelling basato sull'IA nei loro team.
Nel gennaio 2024 ho tenuto un talk su STRIDE GPT all'Open Security Summit. Durante il talk, ho discusso l'inizio del progetto, le sue funzionalità principali, gli aggiornamenti recenti e alcuni piani futuri. Puoi guardare la presentazione completa qui sotto:
Questo video è un'ottima risorsa per chiunque sia interessato a capire come funziona STRIDE GPT e come può essere utilizzato per migliorare il threat modelling.
--version (#161): stride-gpt --version ora stampa la versione installata ed esce; il banner della TUI interattiva mostra la versione in esecuzione, così puoi confermare a colpo d'occhio quale hai.uv.lock è ora l'unica fonte di verità per ogni dipendenza. I file requirements.txt duplicati sono stati ritirati; l'immagine Docker della UI e il workflow di scansione della sicurezza installano da uv.lock tramite uv export, quindi ciò che viene distribuito e ciò che viene scansionato non può più discostarsi da ciò che è bloccato. Nessun cambiamento per gli utenti pip install stride-gpt.STRIDE_GPT_DRAWIO_URL (predefinito a embed.diagrams.net), l'origine postMessage dell'iframe è limitata ad esso, e l'XML del diagramma non fidato viene analizzato con defusedxml.deepseek-v4-pro e deepseek-v4-flash. Le chiamate vengono instradate tramite l'integrazione nativa deepseek/ di LiteLLM (endpoint ospitato, nessun URL base personalizzato necessario); imposta la tua chiave tramite DEEPSEEK_API_KEY./analyze del CLI produce un DFD a livello di sistema dopo la sintesi, reso come blocco Mermaid nel report markdown, trasportato nel campo JSON data_flow_diagram e mostrato nella vista HTML tramite un runtime Mermaid caricato da CDN. La generazione del DFD è gestita in modo che un diagramma scadente non faccia mai fallire un buon report..git rimossi) prima dell'analisi, in modo che .../repo/ e .../repo.git non diano più 404 erroneamente.-o <path> a /analyze o /quick, vengono scritti dei file JSON fratelli accanto al report: <stem>.plan.json (l'AnalysisPlan), <stem>.findings.json (risultati dei sottosistemi, minacce trasversali e diagramma di flusso dati) e <stem>.run.json (un RunManifest che registra modelli, hash della configurazione, versione, tempistiche, quali carte di riferimento sono state effettivamente caricate e un run_summary che indica se l'esecuzione è stata completata o troncata da un limite di chiamate). I manifest escludono chiavi API ed endpoint e oscurano i percorsi del filesystem, quindi sono sicuri da committare o allegare a un ticket. Il flag -f governa solo l'artefatto del report; i fratelli sono sempre JSON.MITRE_ATTACK come stringa separata da virgole (es. "T1190, T1059, AML.T0053") invece della forma canonica di lista, gli ID delle tecniche vengono ora recuperati invece di essere scartati. In precedenza i report markdown/HTML mostravano la colonna "MITRE ATT&CK" ma lasciavano ogni cella vuota, e l'esportazione SARIF perdeva completamente gli ID. Tutti i renderer (markdown, pillole HTML, SARIF) e il controllo di visibilità delle colonne ora passano attraverso un unico normalizzatore, e la prosa in forma libera che non è un ID di tecnica viene filtrata in modo che la colonna non si riempia mai di falsi positivi.The api_key client option must be set quando nessuna chiave del provider cloud era presente nell'ambiente. LM Studio viene instradato tramite il prefisso openai/ di LiteLLM, e l'SDK OpenAI rifiuta di creare un client senza una chiave anche quando api_base punta a localhost, quindi il CLI ora passa un placeholder per i provider che non si autenticano. Di conseguenza, la scansione dell'ambiente come ultima risorsa del worker tier non si applica più a questi provider: una ANTHROPIC_API_KEY o OPENAI_API_KEY configurata veniva precedentemente inviata a qualsiasi host nominato da api_base, il che sia mascherava questo bug sia metteva una chiave reale sul cavo. Se usi LM Studio e hai una tale chiave impostata, questa non viene più trasmessa al tuo endpoint./analyze e /quick possono ora trasportare ID di tecniche avversarie standardizzate da MITRE ATT&CK Enterprise (v17.1) e MITRE ATLAS (2026.05). Due nuove carte di riferimento a divulgazione progressiva (mitre_enterprise, mitre_atlas) istruiscono l'agente a usare solo gli ID e i nomi catalogati, eliminando l'allucinazione degli ID. Le carte vengono rigenerate dai dati STIX/YAML upstream tramite scripts/refresh_mitre_cards.py anziché scritte dal modello a memoria. Le tecniche vengono visualizzate come una colonna MITRE ATT&CK nelle tabelle markdown, pillole cliccabili color cielo nell'HTML e array properties.mitre_attack in SARIF./analyze e /quick ora emettono un report HTML visualizzabile in browser autonomo insieme agli output markdown/JSON/SARIF, adatto per la condivisione con gli stakeholder.claude-opus-4-8, il nuovo modello di frontiera di Anthropic, insieme al già esistente Opus 4.7. Entrambi possono essere selezionati come modello architetto o worker.mrwadams/stridegpt-ui) è stata eliminata; l'interfaccia web Streamlit ora risiede solo in mrwadams/stridegpt. Gli utenti CLI dovrebbero pip install stride-gpt piuttosto che scaricare un container.mistralai inutilizzato (l'accesso a Mistral passa già attraverso LiteLLM). Aggiornata la base python:3.12-slim per l'immagine UI e rimosso curl, eliminando 21 avvisi CVE medi/alte nelle PR #113–#115.except nudi, codice morto) (#116).pip install stride-gpt, separata dalla legacy interfaccia web Streamlit. Due comandi principali: /analyze (analisi agentica autonoma del codebase con un planner, cicli di agente che usano strumenti per sottosistema e una fase di sintesi trasversale) e /quick (modello di minaccia singolo da una descrizione scritta dell'applicazione).genai (OWASP LLM Top 10), agentic (OWASP ASI Top 10) e insider_threat si auto-descrivono tramite frontmatter YAML; l'agente le scopre tramite list_references e ne carica i corpi tramite load_reference.stride_gpt/__init__.py in modo che gli avvisi di pre-caricamento di Bedrock/SageMaker non appaiano su nuove installazioni che mancano di botocore.Supporto per Applicazioni AI Agentiche: Aggiunto supporto completo per il threat modeling di sistemi AI agentici con integrazione OWASP Top 10 per Applicazioni Agentiche (ASI01-ASI10). Basta selezionare "Applicazione AI agentica" e descrivere il proprio sistema — il LLM rileva automaticamente i pattern architetturali e applica le categorie di minaccia pertinenti. Ogni rischio ASI è mappato alla categoria STRIDE appropriata per un'analisi delle minacce coerente.
Supporto per Applicazioni AI Generativa: Aggiunto supporto per il threat modeling di applicazioni GenAI con integrazione OWASP LLM Top 10 (LLM01-LLM10). Seleziona "Applicazione AI generativa" e descrivi il tuo sistema per ricevere un'analisi delle minacce specifica per LLM su misura. Le applicazioni AI agentiche includono sia le categorie di rischio LLM che ASI per una copertura completa.
Rilevamento di Pattern Architetturali Ispirato MAESTRO: Analisi delle minacce agentica migliorata con rilevamento automatico di pattern architetturali dalle descrizioni delle applicazioni, ispirato dal framework Cloud Security Alliance MAESTRO. Il LLM ora identifica e applica minacce specifiche per pattern per:
Analisi delle Minacce a Livelli Incrociati: I modelli di minaccia ora includono catene di attacco tra componenti che mostrano come la compromissione di un livello architetturale possa abilitare attacchi su altri (es. avvelenamento RAG → dirottamento degli obiettivi dell'agente → abuso dello strumento → esfiltrazione dei dati).
Suggerimenti di Miglioramento Migliorati: Per le applicazioni agentiche, i suggerimenti di miglioramento ora richiedono dettagli architetturali specifici come framework dell'agente, protocolli di comunicazione tra agenti, meccanismi di sandbox e implementazioni di circuit breaker.
Aggiornamenti ai Modelli OpenAI: Aggiornati ai modelli della serie GPT-5.2 (gpt-5.2, gpt-5.2-pro, gpt-5-mini, gpt-5-nano, gpt-5, gpt-4.1). Rimossi i modelli deprecati (gpt-4o, gpt-4o-mini, o3, o3-mini, o4-mini).
Modelli Anthropic Claude 4.5: Aggiornati alla serie Claude 4.5 (claude-sonnet-4-5, claude-haiku-4-5, claude-opus-4-5). Aggiunta la casella di controllo "Abilita Pensiero Esteso" per capacità di ragionamento avanzate su qualsiasi modello Claude. Aumentati i token massimi a 32k (standard) e 48k (modalità pensiero).
Anteprima Google Gemini 3: Aggiunti modelli di anteprima Gemini 3 (gemini-3-pro-preview, gemini-3-flash-preview) insieme ai modelli Gemini 2.5. Supporto della modalità di pensiero esteso per i modelli Gemini 3.
Aggiornamenti ai Modelli Mistral: Aggiornati agli ultimi modelli Mistral versionati, inclusi Mistral Large 3, Medium 3.1, Small 3.2, Ministral 3 (8B/14B) e Magistral 1.2 (Medium/Small).
Nuovo Logo del Progetto: Branding rinnovato con un design più pulito e minimalista di scudo + rete neurale.
Correzione di Bug: Risolto il problema per cui l'output del modello di minaccia scompariva dopo aver cliccato sul pulsante di download.
max_completion_tokens invece del deprecato max_tokens per GPT-5 e altri modelli di ragionamento OpenAI, garantendo la compatibilità con gli ultimi requisiti API di OpenAI.Punti salienti del rilascio:
Questa release ha aggiunto il supporto per i seguenti modelli:
GPT4o mini: Ho aggiunto il supporto per il modello GPT4o mini recentemente rilasciato da OpenAI. GPT4o mini è un modello piccolo ed economico che fornisce comunque risposte di alta qualità per le attività di threat modeling.
Gemini 1.5 Pro (stabile): Gli utenti possono ora scegliere tra la versione stabile o in anteprima del modello Gemini 1.5 Pro.
Punti salienti del rilascio:
Punti salienti del rilascio:
Punti salienti del rilascio:
Punti salienti del rilascio:
Punti salienti del rilascio:
Punti salienti del rilascio:
Punti salienti del rilascio:
Versione iniziale dell'applicazione.
pip install stride-gpt
Questo installa il comando `stride-gpt`. La CLI e l'interfaccia web di Streamlit sono ora prodotti distinti — `pip install stride-gpt` ti fornisce la CLI leggera senza l'ingombro di Streamlit. Per eseguire l'interfaccia web dal codice sorgente, vedi Opzione 2 qui sotto.
### Opzione 2: Dal codice sorgente
1. Clona il repository:
```bash
git clone https://github.com/mrwadams/stride-gpt.git
cd stride-gpt
```
2. Installa con [uv](https://docs.astral.sh/uv/) (consigliato — `uv.lock` è l'unica fonte di verità per le dipendenze): ```bash
# CLI plus the Streamlit web UI deps
uv sync
Oppure installa solo la CLI con pip: ```bash pip install -e .
3. (Opzionale) Configura le variabili d'ambiente: ```bash
cp .env.example .env
Modifica .env per aggiungere le tue chiavi API — oppure configurale in seguito eseguendo stride-gpt e utilizzando il comando /config nella REPL interattiva, o tramite l'interfaccia di Streamlit.
L'interfaccia web di Streamlit è disponibile come immagine Docker:```bash docker pull mrwadams/stridegpt:latest
Per la CLI, usa `pip install stride-gpt` — non esiste un'immagine CLI separata. Se hai bisogno di una CLI in sandbox, creane una tua partendo da un'immagine Python minima.
## Layout del repository
STRIDE-GPT è organizzato come un piccolo monorepo: una libreria Python condivisa, una o più app che la utilizzano.```
stride-gpt/
├── stride_gpt/ # shared library + Python CLI (core, agent loop, prompts, schemas, models)
├── apps/
│ └── web/ # Streamlit web UI
├── tests/ # pytest suite
└── pyproject.toml # single project file; web UI deps live in the `web` dependency-group
La directory apps/ è lo slot per frontend aggiuntivi distribuibili — ad esempio, un futuro CLI Node/TypeScript risiederebbe accanto a apps/web/. Il CLI Python stesso rimane in stride_gpt/cli.py perché è strettamente accoppiato alla libreria condivisa.
Analisi agentica del codebase — l'agente esplora autonomamente un codebase, pianifica la sua analisi e produce un modello di minaccia STRIDE:```bash
stride-gpt analyze .
stride-gpt analyze ./my-app --worker-model anthropic/claude-sonnet-4-6 -y
stride-gpt analyze . -o report.json -f json # also writes report.html alongside stride-gpt analyze . -o report.sarif -f sarif stride-gpt analyze . -o report.html -f html
> Ogni analisi salva automaticamente anche un file JSON e un HTML di accompagnamento in `~/.stride-gpt/reports/analyze/`, in modo che la vista visualizzabile nel browser sia sempre a un clic di distanza anche quando si esegue senza `-o`.
> **Nota sui costi:** L'analisi agentica è approfondita — l'agente effettua molte chiamate LLM e legge molti file durante l'esplorazione. Il consumo di token e i costi scalano con la dimensione del codebase e il modello scelto, e un'esecuzione completa su un repository di grandi dimensioni con un modello avanzato può essere costosa. Imposta limiti di spesa nel pannello del tuo fornitore prima di eseguire e considera modelli più rapidi/economici per le prime esecuzioni.
**Modalità rapida singola** — genera un modello di minacce da una descrizione testuale (come l'interfaccia Streamlit, ma nel terminale):```bash
# Read description from a file
stride-gpt quick -i app-description.txt
# Pipe from stdin
echo "A web API that processes payments..." | stride-gpt quick
Interactive REPL — avvia una sessione interattiva con completamento tramite tab e cronologia:```bash stride-gpt
All'interno della REPL, digita `/help` per vedere i comandi e i flag disponibili. La versione viene mostrata sotto il banner ASCII all'avvio. Vedi il [cheat sheet interattivo della REPL](#interactive-repl-cheat-sheet) qui sotto per il riferimento completo ai comandi e alle scorciatoie.
#### Cheat sheet interattivo della REPL
Avvia la REPL con `stride-gpt` (senza argomenti), poi usa questi comandi e scorciatoie.
**Comandi** — digita un comando con barra al prompt:
| Comando | Cosa fa |
|---------|---------|
| `/analyze [path]` | Analizza un codebase per minacce STRIDE (funziona anche con un semplice percorso di directory) |
| `/quick` | Modello di minaccia rapido da una descrizione testuale |
| `/reports` | Elenca i report di analisi precedenti (`/reports <n>` ne visualizza uno) |
| `/config` | Visualizza o modifica le impostazioni (modello, provider, chiavi API) |
| `/help` | Mostra i comandi, i flag e gli esempi disponibili |
| `/quit` | Esci (alias: `/exit`, `/q`) |
`/analyze`, `/quick` e `/reports` accettano flag: `-o`/`--output <path>`, `-f`/`--format <markdown\|json\|sarif\|html>`, `-y`/`--yes` e `-i`/`--input <path>` (`/quick`). Digita `/help` per l'elenco completo.
**Scorciatoie da tastiera:**
| Tasto | Azione |
|-------|--------|
| `Tab` | Completa i comandi con barra e i percorsi dei file |
| `↑` / `↓` | Scorri la cronologia dei comandi |
| `→` / `Fine` | Accetta il suggerimento storico in grigio |
| `Ctrl+L` | Pulisci lo schermo e lo scrollback |
| `Ctrl+C` / `Ctrl+D` | Esci dalla REPL |
**Controlla la versione installata:**```bash
stride-gpt --version # prints e.g. "stride-gpt 0.19.0" and exits
Flag comuni:
| Flag | Descrizione |
|---|---|
--version | Stampa la versione installata (stride-gpt <version>) ed esce |
-o, --output | Salva il report in un file |
-f, --format | Formato di output: markdown (predefinito), json, sarif, html |
-i, --input | Legge la descrizione dell'app da un file (solo quick) |
-y, --yes | Approva automaticamente il piano di analisi (solo analyze) |
--worker-model | Modello di livello predefinito che gestisce la maggior parte delle chiamate (es. anthropic/claude-sonnet-4-6). Usa la configurazione salvata se omesso. |
--architect-model | Modello più potente per la pianificazione/sintesi (es. openai/gpt-5.4). Usa la configurazione salvata se omesso. |
--no-architect | Salta il livello architect per questa esecuzione; il worker gestisce ogni chiamata. |
--app-type | Sovrascrive il tipo di app rilevato dal pianificatore (solo analyze): auto (predefinito), web, genai, agentic. |
--max-llm-calls | Limita il numero totale di chiamate LLM su entrambi i livelli (solo analyze; 0 = illimitato). |
--max-tool-calls | Limita il numero totale di esecuzioni di strumenti (solo analyze; 0 = illimitato). |
Ogni livello accetta anche --worker-api-key / --worker-api-base / --worker-max-tokens (e i corrispondenti --architect-*). Esegui stride-gpt analyze --help o stride-gpt quick --help per l'elenco completo.
Intermedi strutturati — quando si usa -o <path>, tre file JSON fratelli vengono scritti insieme al report in modo che l'esecuzione possa essere verificata o utilizzata da strumenti a valle:
| File | Contenuto |
|---|---|
<nome>.plan.json | Il AnalysisPlan prodotto dall'architetto — sottosistemi, aree di attenzione, tipo di app rilevato (solo analyze). |
<nome>.findings.json | Elenco SubsystemFinding per sottosistema, minacce trasversali e diagramma di flusso dei dati a livello di sistema (solo analyze). |
<nome>.run.json | Un RunManifest — modelli, hash di prompt + configurazione, riferimenti all'agente effettivamente caricato, Git SHA, versione, tempi. Emesso sia per analyze che per quick. |
Il flag di formato (-f) controlla solo l'artefatto del report; i fratelli sono sempre JSON. I percorsi dei file nel manifest e nei risultati sono oscurati (./… quando nella directory di lavoro, ~/… quando sotto $HOME) quindi un manifest è sicuro da condividere. L'archivio automatico in ~/.stride-gpt/reports/{analyze,quick}/ è invariato — i fratelli vengono emessi solo quando si passa -o.
Visualizza i report precedenti:```bash stride-gpt reports # List recent reports stride-gpt reports 1 # View report #1 stride-gpt reports 1 -o r.json -f json # Export a report
### Interfaccia Web Streamlit
L'interfaccia web è un'app separata dalla CLI. Avviala con:```bash
streamlit run apps/web/main.py
Apri l'URL fornito nel tuo browser e segui le istruzioni a schermo.
docker run -p 8501:8501 --env-file .env mrwadams/stridegpt
## Output di esempio
Ogni esecuzione di `stride-gpt analyze` e `stride-gpt quick` produce un report in markdown per impostazione predefinita (con visualizzazioni JSON, SARIF e HTML autonome disponibili tramite `-f`). Il markdown raggruppa le minacce per sottosistema in tabelle STRIDE, aggiunge una sezione trasversale per le minacce che attraversano più componenti e termina con un riepilogo dell'esecuzione. Le colonne opzionali (OWASP LLM/ASI, Categorie Insider, MITRE ATT&CK) appaiono solo quando un'esecuzione le popola.
Di seguito è riportato il markdown di un'esecuzione contro un'API di pagamenti fittizia, in modo da poter vedere la forma dell'output prima di eseguire lo strumento. Si tratta di un rendering reale dal motore di report, non di un mock-up.
<details>
<summary>Modello di minaccia markdown di esempio (clicca per espandere)</summary>````markdown
# STRIDE Threat Model: acme-payments-api
> Generated by STRIDE-GPT on 2026-07-16T09:42:00Z
## Overview
A Python FastAPI service that accepts card payments, stores customer profiles in PostgreSQL, and calls a third-party payment processor. Authentication is handled by JWT bearer tokens issued by an internal auth service; the API is internet-facing behind an API gateway.
## Data Flow Diagram
```mermaid
flowchart LR
Client[Client App] -->|HTTPS + JWT| Gateway[API Gateway]
Gateway --> API[Payments API]
API -->|SQL| DB[(PostgreSQL)]
API -->|HTTPS| Processor[Payment Processor]
app/auth/jwt.pyapp/auth/dependencies.py| Threat Type | Scenario | Potential Impact | MITRE ATT&CK |
|---|---|---|---|
| Spoofing | An attacker forges a JWT using a weak or leaked signing secret to impersonate another customer. | Full account takeover and unauthorized access to stored payment methods. | T1550.001 (Application Access Token) |
| Elevation of Privilege | A standard user calls an admin-only refund endpoint that only checks authentication, not role. | Unauthorized refunds and financial loss. | T1068 (Exploitation for Privilege Escalation) |
app/payments/routes.pyapp/db/models.py| Threat Type | Scenario | Potential Impact | MITRE ATT&CK |
|---|---|---|---|
| Information Disclosure | Full card numbers are logged in request debug logs when a payment fails. | PCI-DSS violation and exposure of cardholder data to anyone with log access. | T1552.001 (Credentials In Files) |
| Tampering | The payment amount is taken from a client-supplied field and not re-validated server-side against the order. | A user pays less than the order total by editing the request body. |
| Threat Type | Scenario | Potential Impact | MITRE ATT&CK | Affected Subsystems |
|---|---|---|---|---|
| Denial of Service | No rate limiting on the payment endpoint lets an attacker exhaust the processor quota and DB connections. | Legitimate payments fail during the attack; possible processor throttling. | T1499 (Endpoint Denial of Service) | Authentication & Authorization, Payments & Data Storage |
</details>
`stride-gpt quick` produce la stessa forma della tabella partendo da una descrizione scritta, ridotta a un singolo sottosistema **Application** invece di risultati per ogni sottosistema.
## Best Practices di Sicurezza
STRIDE GPT è progettato per un utilizzo locale e a singolo utente. Quando usi lo strumento:
### Proteggere le Tue Chiavi API
**Le tue chiavi API sono credenziali sensibili che possono generare addebiti sul tuo account.**
✅ **DA FARE:**
- Inserisci le chiavi API tramite interfaccia (rimangono nella sessione del browser)
- Usa il file .env per comodità sul tuo computer personale
- Imposta limiti di spesa nel pannello di controllo del provider LLM
- Controlla regolarmente l'utilizzo e i costi delle API
- Pulisci la sessione quando usi computer condivisi
❌ **DA EVITARE:**
- Non fare commit dei file .env nel sistema di controllo versione (già in .gitignore)
- Non condividere screenshot con chiavi API visibili
- Non eseguire STRIDE GPT su sistemi non fidati/compromessi
- Non condividere le tue chiavi API con altri
- Non ignorare addebiti API imprevisti
### Considerazioni sulla Privacy dei Dati
Quando generi modelli di minaccia, STRIDE GPT invia dati al provider LLM scelto:
- Dettagli dell'applicazione (tipo, metodi di autenticazione, architettura)
- Descrizioni dell'architettura di sistema
- Diagrammi/immagini di architettura caricati
- Modelli di minaccia e mitigazioni generati
**Cosa significa:**
- OpenAI, Anthropic, Google, ecc. potrebbero registrare questi dati secondo le loro politiche sulla privacy
- Considera l'uso di dettagli generici/fittizi per le dimostrazioni
- Rivedi le politiche di conservazione dei dati e privacy del tuo provider LLM
- Per sistemi sensibili, considera:
- Utilizzo di modelli locali (LM Studio)
- Utilizzo di provider con garanzie di privacy più rigorose
- Anonimizzazione delle descrizioni del sistema prima dell'inserimento
### Per Implementazioni di Team/Organizzazione
Se distribuisci STRIDE GPT per più utenti (non il caso d'uso predefinito):
- Aggiungi autenticazione/autorizzazione (non incluse di default)
- Usa un servizio di gestione dei segreti per le chiavi API
- Distribuisci dietro VPN o rete interna
- Consulta il documento [SECURITY.md](https://github.com/mrwadams/stride-gpt/blob/master/SECURITY.md) per ulteriori considerazioni
- Considera i requisiti di residenza dei dati e conformità
- Implementa controlli di accesso appropriati per i modelli di minaccia generati
### Sicurezza delle Dipendenze
Manteniamo le dipendenze aggiornate e monitoriamo le vulnerabilità:
- Le dipendenze vengono aggiornate regolarmente tramite Dependabot
- La scansione automatica di sicurezza viene eseguita ad ogni commit
- Gli avvisi di sicurezza sono tracciati nella scheda Sicurezza di GitHub
- Esegui `pip-audit` per verificare la presenza di vulnerabilità note localmente
Vedi [SECURITY.md](https://github.com/mrwadams/stride-gpt/blob/master/SECURITY.md) per informazioni complete sulla sicurezza, inclusi scansione automatica, segnalazione di vulnerabilità e pratiche di sviluppo sicuro.
### Segnalazione di Problemi di Sicurezza
Hai trovato un problema di sicurezza? Segnalalo in modo responsabile:
- Crea un avviso di sicurezza tramite la [segnalazione privata di vulnerabilità](https://github.com/mrwadams/stride-gpt/security/advisories/new) di GitHub
- Non pubblicare i problemi di sicurezza pubblicamente
- Accuseremo ricevuta entro 48 ore
- Le correzioni saranno prioritarie e rilasciate rapidamente
## Contribuire
I pull request sono benvenuti. Per modifiche sostanziali, apri prima un issue per discutere cosa vorresti cambiare.
## Licenza
[MIT](https://choosealicense.com/licenses/mit/)