1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

4 

5# Rileva problemi di sicurezza mentre Claude scrive il codice

6 

7> Installa il plugin security-guidance per far sì che Claude riveda le proprie modifiche al codice per individuare vulnerabilità e correggerle nella stessa sessione.

8 

9Il plugin di guida sulla sicurezza fa sì che Claude riveda le proprie modifiche al codice per individuare vulnerabilità comuni mentre lavora e corregga ciò che trova nella stessa sessione. Il plugin rileva problemi come injection, deserializzazione non sicura e API DOM non sicure prima che il codice raggiunga una pull request, riducendo quanto la revisione della sicurezza ricade sui revisori umani a valle.

10 

11Una volta installato, il plugin viene eseguito automaticamente. Non c'è nulla da invocare e nessun comando separato da ricordare.

12 

13Il plugin è il compagno in-session di [Code Review](/it/code-review), che viene eseguito sulle pull request. Questo plugin riduce ciò che raggiunge la PR. Code Review cattura ciò che fa. Per come il plugin si integra con la revisione su richiesta e la scansione CI, vedi [Come questo si adatta ad altri strumenti di sicurezza](#how-this-fits-with-other-security-tools).

14 

15<h2 id="prerequisites">

16 Prerequisiti

17</h2>

18 

19* Claude Code CLI versione 2.1.144 o successiva

20* Python 3.8 o successiva nel tuo `PATH`. Il plugin prova `python3`, `python` e `py -3` in questo ordine

21* Un repository git per la directory in cui lavori. Le revisioni di fine turno e commit fanno il diff rispetto allo stato git e saltano silenziosamente al di fuori di un repository. Il controllo del pattern per modifica funziona ovunque

22 

23Al primo avvio il plugin crea un ambiente virtuale sotto `~/.claude/security/` e installa Claude Agent SDK al suo interno, il che richiede `pip` e accesso alla rete. Se quell'installazione fallisce, la revisione del commit ricade a una revisione singola invece di quella agentica. Su Windows il passaggio dell'ambiente virtuale viene saltato, quindi la revisione del commit agentica viene eseguita solo se `claude-agent-sdk` è già importabile e altrimenti ricade allo stesso modo.

24 

25<h2 id="install-the-plugin">

26 Installa il plugin

27</h2>

28 

29In una sessione Claude Code, installa dal [marketplace ufficiale Anthropic](/it/discover-plugins#official-anthropic-marketplace):

30 

31```text theme={null}

32/plugin install security-guidance@claude-plugins-official

33```

34 

35L'installazione richiede un ambito. Scegli l'ambito utente per scrivere il plugin nelle tue impostazioni utente, in modo che si carichi in ogni nuova sessione locale che avvii su questa macchina. Se Claude Code segnala che il marketplace non è stato trovato, esegui prima `/plugin marketplace add anthropics/claude-plugins-official`, quindi riprova l'installazione.

36 

37Quindi attivalo nella sessione corrente con `/reload-plugins`, che applica le modifiche ai plugin in sospeso senza un riavvio:

38 

39```text theme={null}

40/reload-plugins

41```

42 

43<h3 id="enable-in-cloud-sessions-and-shared-repositories">

44 Abilita nelle sessioni cloud e nei repository condivisi

45</h3>

46 

47I plugin con ambito utente non vengono trasferiti a [Claude Code sul web](/it/claude-code-on-the-web), perché quelle sessioni vengono eseguite sull'infrastruttura Anthropic piuttosto che sulla tua macchina. Per abilitare il plugin lì, o per attivarlo per tutti coloro che clonano un repository, dichiaralo nelle impostazioni del progetto archiviate:

48 

49```json .claude/settings.json theme={null}

50{

51 "enabledPlugins": {

52 "security-guidance@claude-plugins-official": true

53 }

54}

55```

56 

57Gli amministratori possono abilitare il plugin a livello organizzativo impostando [`enabledPlugins`](/it/settings#plugin-settings) nelle [impostazioni gestite](/it/admin-setup).

58 

59<h2 id="what-the-plugin-checks">

60 Cosa controlla il plugin

61</h2>

62 

63Il plugin rivede il lavoro di Claude in tre punti, ognuno a una profondità diversa:

64 

65* [Su ogni modifica di file](#on-each-file-edit): una corrispondenza di pattern veloce per chiamate rischiose, senza chiamata al modello

66* [Alla fine di ogni turno](#at-the-end-of-each-turn): una revisione del modello in background di tutto ciò che quel turno ha modificato

67* [Su ogni commit o push che Claude fa](#on-each-commit-or-push-claude-makes): una revisione agentica più profonda che legge il codice circostante

68 

69Puoi estendere ogni livello [aggiungendo le tue regole](#add-your-own-rules). I controlli incorporati non possono essere rimossi individualmente, ma puoi [disabilitare ogni livello](#disable-or-uninstall) indipendentemente.

70 

71<h3 id="on-each-file-edit">

72 Su ogni modifica di file

73</h3>

74 

75Quando Claude scrive in un file, il plugin scansiona il nuovo contenuto per pattern noti rischiosi. Questa è una corrispondenza di pattern senza chiamata al modello, quindi non aggiunge alcun costo di utilizzo.

76 

77Categorie di pattern di esempio:

78 

79* Esecuzione di codice dinamico: `eval(`, `new Function`, `os.system`, `child_process.exec`

80* Deserializzazione non sicura: `pickle`

81* Injection DOM: `dangerouslySetInnerHTML`, `.innerHTML =`, `document.write`

82* File di workflow: modifiche sotto `.github/workflows/`, che possono concedere autorizzazioni a livello di repository

83 

84Il controllo viene eseguito dopo che la modifica è stata applicata e aggiunge l'avviso al contesto di Claude per il passaggio successivo. Ogni avviso si attiva una volta per pattern per file per sessione, quindi le corrispondenze ripetute nello stesso file non inondano la conversazione.

85 

86Puoi [aggiungere i tuoi pattern](#add-custom-per-edit-patterns) a questo livello con un file `security-patterns.yaml`.

87 

88<h3 id="at-the-end-of-each-turn">

89 Alla fine di ogni turno

90</h3>

91 

92Un turno è un round di risposta di Claude: invii un messaggio, Claude lavora e risponde, e il turno termina. Dopo ogni turno, il plugin calcola un git diff di tutto ciò che è cambiato nell'albero di lavoro durante il turno, incluse le modifiche dagli strumenti di modifica di Claude, dai comandi Bash e dai subagent, e lo invia a una revisione Claude separata focalizzata sulla sicurezza. La revisione viene eseguita in background, quindi la risposta di Claude non viene ritardata. Se la revisione trova problemi, Claude viene ripromptato con i risultati e li affronta come follow-up.

93 

94Questo cattura problemi che una corrispondenza di stringa non può, come:

95 

96* Bypass dell'autorizzazione

97* Riferimenti diretti a oggetti non sicuri

98* Injection

99* Server-side request forgery

100* Crittografia debole

101 

102Vedi sia il risultato che la risoluzione di Claude direttamente nella tua sessione. La revisione copre fino a 30 file modificati per turno e si attiva al massimo tre volte di seguito prima di cedere il controllo a te.

103 

104<h3 id="on-each-commit-or-push-claude-makes">

105 Su ogni commit o push che Claude fa

106</h3>

107 

108Quando Claude esegue `git commit` o `git push` attraverso il suo strumento Bash, il plugin esegue una revisione agentica più profonda della modifica in background. Questa revisione legge il codice circostante, inclusi i chiamanti, i sanitizer e i file correlati, per decidere se un risultato è reale prima di segnalarlo. Il contesto aggiuntivo mantiene bassi i falsi positivi su pattern che sembrano pericolosi in isolamento ma sono sicuri nel tuo codebase.

109 

110Questo livello si attiva solo su commit e push che Claude fa attraverso il suo strumento Bash. I commit che esegui dalla tua shell, incluso l'escape shell `!` all'interno di una sessione, non vengono revisionati. Le revisioni di commit e push sono limitate a 20 per ora mobile. Se i risultati della revisione del commit duplicano ciò che la revisione di fine turno ha già segnalato, Claude non viene ripromptato, quindi un commit pulito non produce output visibile da questo livello.

111 

112<h3 id="review-independence-and-limits">

113 Indipendenza e limiti della revisione

114</h3>

115 

116Il plugin non chiede alla stessa istanza di Claude che ha scritto il codice di valutare se stesso. Il controllo per modifica è una corrispondenza di stringa deterministica senza modello coinvolto. Le revisioni di fine turno e commit vengono eseguite come una chiamata Claude separata con un contesto fresco e un prompt focalizzato sulla sicurezza: il revisore inizia dal diff, non ha investimento nell'approccio originale ed è istruito solo a trovare problemi.

117 

118Nessuno dei livelli blocca le scritture o i commit. I risultati raggiungono Claude che scrive come istruzioni, Claude li affronta nella conversazione, e il modello di revisione può perdere problemi. Tratta il plugin come uno strato di difesa in profondità, non una soluzione di sicurezza completa. Vedi [Come questo si adatta ad altri strumenti di sicurezza](#how-this-fits-with-other-security-tools).

119 

120<h2 id="add-your-own-rules">

121 Aggiungi le tue regole

122</h2>

123 

124Il plugin ha due punti di estensione: un file di guida Markdown per le revisioni supportate dal modello e un file di pattern YAML o JSON per la corrispondenza di stringa per modifica. Entrambi sono additivi. Puoi aggiungere controlli ma non puoi disabilitare quelli incorporati da questi file.

125 

126<h3 id="add-guidance-for-the-model-backed-reviews">

127 Aggiungi guida per le revisioni supportate dal modello

128</h3>

129 

130Crea `.claude/claude-security-guidance.md` nel tuo progetto e descrivi il tuo modello di minaccia e la tua lista di controllo di revisione in linguaggio naturale. Le revisioni supportate dal modello lo caricano come contesto aggiuntivo insieme alla lista di controllo delle vulnerabilità incorporata.

131 

132Il seguente esempio è per un servizio web con route admin controllate da ruoli e una politica di logging dei dati dei clienti:

133 

134```markdown .claude/claude-security-guidance.md theme={null}

135# Security guidance for this repo

136 

137- Do not log `customer_id` or `account_number` at INFO level or above.

138- All routes under `/admin` must call `require_role("admin")` before any database read.

139- Use `crypto.timingSafeEqual` for token comparison instead of `===`.

140```

141 

142Queste regole sono guida per il revisore, non guardrail deterministici. Il plugin presenta le violazioni come risultati per Claude da correggere, ma non blocca le scritture o garantisce che ogni violazione sia catturata. La guida è solo additiva: una regola che dice di ignorare una classe di vulnerabilità non sopprime quei risultati. Per l'applicazione rigida, abbina il plugin con un [hook che blocca la modifica](/it/hooks-guide#block-edits-to-protected-files) o un controllo CI.

143 

144<h3 id="add-custom-per-edit-patterns">

145 Aggiungi pattern personalizzati per modifica

146</h3>

147 

148Crea `.claude/security-patterns.yaml` per aggiungere regole regex o substring al [controllo di pattern per modifica](#on-each-file-edit). Questi vengono eseguiti come corrispondenze di stringa deterministiche insieme ai pattern incorporati:

149 

150```yaml .claude/security-patterns.yaml theme={null}

151patterns:

152 - rule_name: internal_api_key

153 substrings: ["sk_live_", "AKIA"]

154 reminder: "Hardcoded API key prefix. Load credentials from the secret manager."

155 - rule_name: tenant_unfiltered_query

156 regex: "\\.objects\\.all\\(\\)"

157 paths: ["**/src/tenants/**"]

158 reminder: "Multi-tenant code must filter by org_id."

159```

160 

161| Campo | Tipo | Descrizione |

162| :-------------- | :----- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

163| `rule_name` | string | Identificatore mostrato nell'avviso |

164| `reminder` | string | Testo di avviso aggiunto al contesto di Claude, limitato a 1 KB |

165| `regex` | string | Regex Python abbinato al contenuto modificato |

166| `substrings` | list | Substring letterali; fornisci questo o `regex` |

167| `paths` | list | Pattern glob opzionali; la regola si applica solo ai file corrispondenti. I glob corrispondono al percorso file completo, quindi prefissa i pattern relativi al progetto con `**/` |

168| `exclude_paths` | list | Pattern glob opzionali da saltare; lo stesso matching di `paths` |

169 

170Il plugin legge anche `.claude/security-patterns.yml` e `.claude/security-patterns.json` con lo stesso schema. JSON funziona su qualsiasi installazione Python. Le forme YAML richiedono che PyYAML sia importabile, che il plugin non installa per te. Il plugin carica fino a 50 regole personalizzate e salta le regex che sembrano inclini al backtracking catastrofico.

171 

172<h3 id="rule-file-lookup-locations">

173 Posizioni di ricerca del file di regole

174</h3>

175 

176Il plugin cerca `claude-security-guidance.md` e `security-patterns.yaml` negli stessi percorsi, indipendentemente da come il plugin è stato abilitato:

177 

178| Ambito | Percorso | Note |

179| :-------------- | :------------------------------------------ | :-------------------------------------------- |

180| Utente | `~/.claude/claude-security-guidance.md` | Si applica a ogni progetto sulla tua macchina |

181| Progetto | `.claude/claude-security-guidance.md` | Archiviato con il repository |

182| Progetto locale | `.claude/claude-security-guidance.local.md` | Gitignored, per override personali |

183 

184Il plugin carica tutti i percorsi che esistono e li concatena, con un limite combinato di 8 KB per il file di guida. Gli amministratori possono distribuire regole a livello organizzativo spingendo il file con ambito utente a `~/.claude/` attraverso la gestione dei dispositivi. Gli stessi percorsi si applicano a `security-patterns.yaml`.

185 

186<h2 id="usage-cost">

187 Costo di utilizzo

188</h2>

189 

190Il [controllo di pattern per modifica](#on-each-file-edit) non effettua alcuna chiamata al modello e non aggiunge alcun costo. Le revisioni di [fine turno](#at-the-end-of-each-turn) e [commit](#on-each-commit-or-push-claude-makes) spendono ciascuna un utilizzo del modello aggiuntivo che conta verso il tuo [utilizzo](/it/costs) come qualsiasi altra richiesta Claude. La revisione del commit è agentica e può richiedere diversi turni di modello per commit, limitata a 20 revisioni per ora mobile. Aspettati approssimativamente una chiamata di revisione per turno che modifica i file e una revisione più profonda per commit, entrambe soggette ai limiti di cui sopra.

191 

192Entrambe le revisioni supportate dal modello utilizzano Claude Opus 4.7 per impostazione predefinita. Imposta `SECURITY_REVIEW_MODEL` per scegliere un modello diverso per la revisione di fine turno e `SG_AGENTIC_MODEL` per la revisione del commit.

193 

194Il plugin è disponibile su tutti i piani.

195 

196<h2 id="disable-or-uninstall">

197 Disabilita o disinstalla

198</h2>

199 

200Per disattivare i singoli livelli mantenendo il resto, imposta la variabile di ambiente corrispondente:

201 

202| Variabile | Effetto |

203| :------------------------------ | :------------------------------------------------------------------------------- |

204| `ENABLE_PATTERN_RULES=0` | Disabilita il [controllo di pattern per modifica](#on-each-file-edit) |

205| `ENABLE_STOP_REVIEW=0` | Disabilita la [revisione diff di fine turno](#at-the-end-of-each-turn) |

206| `ENABLE_COMMIT_REVIEW=0` | Disabilita la [revisione di commit e push](#on-each-commit-or-push-claude-makes) |

207| `ENABLE_CODE_SECURITY_REVIEW=0` | Disabilita tutte le revisioni supportate dal modello contemporaneamente |

208| `SECURITY_GUIDANCE_DISABLE=1` | Disabilita il plugin completamente senza disinstallarlo |

209 

210Per mettere in pausa il plugin nel tuo ambito utente:

211 

212```text theme={null}

213/plugin disable security-guidance@claude-plugins-official

214```

215 

216Per rimuoverlo dal tuo ambito utente:

217 

218```text theme={null}

219/plugin uninstall security-guidance@claude-plugins-official

220```

221 

222Se il plugin è stato abilitato attraverso il `.claude/settings.json` di un progetto, disabilitarlo da `/plugin` scrive un override al tuo `.claude/settings.local.json` piuttosto che modificare il file archiviato, quindi il plugin rimane disattivato per te mentre i tuoi compagni di squadra non sono interessati. Se è stato abilitato attraverso [impostazioni gestite](/it/admin-setup), solo un amministratore può disabilitarlo.

223 

224<h2 id="how-the-plugin-integrates-with-claude-code">

225 Come il plugin si integra con Claude Code

226</h2>

227 

228Il plugin è costruito interamente su [hooks](/it/hooks), il meccanismo per eseguire il tuo codice in punti specifici del loop di Claude. Registra:

229 

230| Evento Hook | Scopo |

231| :------------------------------------------------------------ | :------------------------------------------------------------------------------------- |

232| `SessionStart` | Bootstrap dell'ambiente Python del plugin |

233| `UserPromptSubmit` | Cattura la baseline dell'albero di lavoro su cui la revisione di fine turno fa il diff |

234| `PostToolUse` su `Edit`, `Write` e `NotebookEdit` | Corrispondenza di pattern per modifica |

235| `Stop` | Revisione diff di fine turno, eseguita in background |

236| `PostToolUse` su `Bash`, filtrato a `git commit` e `git push` | Revisione di commit e push, eseguita in background |

237 

238Se costruisci i tuoi hook, il [codice sorgente del plugin](https://github.com/anthropics/claude-plugins-official/tree/main/plugins/security-guidance) è un esempio funzionante di esecuzione di una chiamata di modello separata da un hook e alimentazione del risultato di nuovo alla sessione.

239 

240<h2 id="how-this-fits-with-other-security-tools">

241 Come questo si adatta ad altri strumenti di sicurezza

242</h2>

243 

244Il plugin è uno strato in un approccio di difesa in profondità. Cattura i problemi il più presto possibile, mentre il codice è ancora nell'editor, ma non è una garanzia e non sostituisce i controlli successivi. Uno stack tipico:

245 

246| Fase | Strumento | Cosa copre |

247| :-------------- | :------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------ |

248| In sessione | Plugin di guida sulla sicurezza | Vulnerabilità comuni nel codice che Claude scrive, corrette nella stessa sessione |

249| Su richiesta | [`/security-review`](/it/commands#all-commands) | Passaggio di sicurezza una tantum sul ramo corrente, eseguito quando lo chiedi |

250| Su pull request | [Code Review](/it/code-review), piani Team e Enterprise | Revisione multi-agent di correttezza e sicurezza con contesto completo del codebase |

251| In CI | I tuoi scanner di analisi statica e dipendenze esistenti | Regole specifiche del linguaggio, controlli della catena di approvvigionamento e applicazione delle politiche che il plugin non tenta |

252 

253Ogni fase successiva cattura ciò che quelle precedenti perdono. Il valore del plugin è ridurre il volume che le raggiunge, non eliminare la necessità di esse.

254 

255<h2 id="troubleshooting">

256 Risoluzione dei problemi

257</h2>

258 

259Il plugin scrive diagnostica di runtime in `~/.claude/security/log.txt`. Controlla lì per primo se le revisioni non vengono visualizzate.

260 

261Motivi comuni per cui un livello di revisione salta senza un messaggio nella conversazione:

262 

263* La directory non è un repository git: le revisioni di fine turno e commit richiedono lo stato git e saltano al di fuori di un repository

264* La sessione non ha autenticazione Anthropic: le revisioni supportate dal modello saltano e viene eseguito solo il controllo di pattern per modifica

265* Un file `security-patterns.yaml` è presente ma PyYAML non è importabile: il file viene ignorato. Usa `security-patterns.json` invece

266 

267<h2 id="related-resources">

268 Risorse correlate

269</h2>

270 

271Per approfondire i pezzi che questa pagina tocca:

272 

273* [Code Review](/it/code-review): configura la revisione multi-agent al momento della PR

274* [Automatizza i workflow con gli hook](/it/hooks-guide): costruisci i tuoi controlli negli stessi punti del ciclo di vita

275* [Scopri e installa plugin](/it/discover-plugins#official-anthropic-marketplace): sfoglia altri plugin ufficiali