Articoli approfonditi sulla tecnologia che plasma il futuro.

Fughe di segreti dagli agenti AI: scansione vs contenimento

Segreti esposti dagli agenti AI tramite le allowlist: scansione vs contenimento a confronto e le protezioni che bloccano le credenziali nel repo.

Un quadro di commutazione meccanico dove una leva etichettata per posizione instrada cavi luminosi, alcuni dei quali riversano luce fuori dal pannello
Le allowlist dei permessi danno l'impressione di avere il controllo, ma archiviano silenziosamente ogni comando che hai mai approvato, segreti compresi.

Alcuni ricercatori di sicurezza hanno appena trovato password, token API e credenziali cloud in più di mille file pubblici su GitHub — non nei soliti file .env disordinati, ma nelle impostazioni degli agenti di coding AI. Il colpevole è un pattern silenzioso legato alle fughe di segreti dagli agenti di coding AI: lo sviluppatore approva un comando come curl -H "Authorization: Bearer sk-...", clicca su “Non chiedere più” e l'intero comando, token incluso, finisce scritto in un file di impostazioni locale. Committi quel file e il segreto è pubblico. Lavoro da anni nella sicurezza delle infrastrutture e questa è una delle classi di leak più evitabili che abbia visto. È anche una classe davvero nuova, perché il file che la causa due anni fa non esisteva.

Le due difese a cui i team ricorrono sono la scansione dei segreti (rilevare la fuga, poi ripulire) e il contenimento (fare in modo che il segreto non tocchi mai l'agente o il repo). Sono entrambe necessarie. Nessuna basta da sola. Questo articolo le confronta una contro l'altra, quando vince ciascuna e dove fallisce ciascuna, e si chiude con ciò che farei davvero in un team che usa Claude Code, Cursor o qualsiasi agente con allowlist dei permessi.

Una premessa: questo non è un argomento contro gli strumenti di coding agentico. Li uso ogni giorno e non tornerei indietro. Il prompt dei permessi, quando l'agente chiede “posso eseguire questo?”, è davvero uno dei meccanismi di sicurezza migliori che questi strumenti offrono. Il problema riguarda esclusivamente cosa succede dopo che hai detto sì: dove viene registrato quel “sì” e cosa contiene.

Come l'allowlist diventa un archivio di segreti

Per capire la modalità di guasto, devi guardare cosa persiste davvero “Non chiedere più”. Quando una CLI agentica chiede di eseguire un comando, l'implementazione ingenua salva la stringa completa del comando nella regola dei permessi. Non un pattern. Non un hash. La stringa letterale che hai approvato.

Quindi quando uno sviluppatore approva aws s3 cp s3://bucket/backup.sql . --profile prod è innocuo. Ma se approva psql postgresql://admin:hunter2@db.internal/myapp oppure curl -u deploy:APIKEY123 https://.../deploy, le credenziali finiscono in .claude/settings.local.json o nel file di configurazione equivalente. Il file delle impostazioni è pensato per restare locale: Claude Code aggiunge persino automaticamente il file al gitignore quando è lo strumento a crearlo. Ma se lo sviluppatore ha creato il file a mano, o l'ha aggiunto forzatamente, oppure il suo gitignore globale non lo copre, basta un git add . e un push e finisce su GitHub. È esattamente la catena dietro i 1.122 file trovati dai ricercatori.

Nota quanti anelli di quella catena sono singolarmente ragionevoli. Approvare un comando con una credenziale inline è qualcosa che gli sviluppatori fanno interattivamente da decenni senza conseguenze: il comando viene eseguito, la cronologia della shell lo conserva in locale e nessuno se ne preoccupa. Cliccare “Non chiedere più” è razionale; la stanchezza da prompt è reale, e il vantaggio principale di questi agenti è proprio ridurre le interruzioni. Anche git add . è difendibile quando lo strumento ti ha detto che il file è locale. L'incidente non è causato da un solo gesto avventato. È causato da un sistema in cui cinque azioni innocue si combinano in una credenziale pubblica. Sono i peggiori tipi di fallimento di sicurezza da correggere, perché nessuno si vede fare qualcosa di sbagliato.

Ho visto questo stesso errore nel mondo reale anche prima che esistessero gli agenti. Un team lead di una fintech per cui ho fatto consulenza aveva un allowed_commands.sh per un bot di helper CI, la stessa idea fatta a mano. Qualcuno aveva approvato una migrazione del database una tantum con il DSN inline. Sei mesi dopo il repo è stato reso open source, e il DSN era nella cronologia git di un file che nessuno pensava di controllare perché “non era configurazione”. Il file era configurazione. Semplicemente non sembrava tale.

Ecco il nocciolo: le allowlist dei permessi sono file di configurazione che catturano segreti operativi come effetto collaterale. Nessuno le controlla per cercare segreti perché nessuno le considera portatrici di segreti. La tua policy di gestione dei segreti copre .env, credentials.yml, forse lo stato di Terraform. Quasi sicuramente non copre .claude/settings.local.json o le configurazioni in .cursor/. Avevamo scritto di un punto cieco simile in l'audit dei client API come vault di credenziali: gli strumenti che usi ogni giorno accumulano segreti in posti che la tua policy non nomina.

E la categoria sta crescendo. Ogni strumento agentico lanciato negli ultimi anni ha una sua variante: allowlist, directory fidate, approvazioni memorizzate, configurazioni dei server MCP con token inline. Ognuno di questi è un nuovo percorso di file che le tue policy, i tuoi gitignore e le configurazioni degli scanner non menzionano. La prossima versione di questo incidente sarà lo stesso errore in un file con un altro nome.

Scansione dei segreti vs contenimento: le due difese

Ecco il confronto che userò per il resto dell'articolo:

  • Prima il rilevamento (scansione dei segreti): hook pre-commit, scanner di repo come gitleaks e trufflehog, push protection di GitHub o GitLab, più scansioni periodiche della cronologia. Si presume che i segreti finiranno per trapelare; li si individua in fretta e si ruotano.
  • Prima il contenimento (tenere i segreti fuori): i segreti entrano nei comandi solo tramite variabili d'ambiente, CLI dei password manager o credenziali a breve durata; gli agenti girano in sandbox o VM effimere; i file di impostazioni locali sono nel gitignore globale. Si progetta in modo che non ci sia nulla da far trapelare.

Il rilevamento è un'operazione di pulizia. Il contenimento è una proprietà di progettazione. Falliscono in direzioni opposte: la scansione ha falsi negativi e agisce sempre a posteriori; il contenimento ha un costo di adozione e si scontra con l'attrito per gli sviluppatori. Quale vince dipende da quale tipo di fallimento puoi tollerare.

C'è anche un'asimmetria nel modo in cui degradano nel tempo. La scansione degrada con gradualità: un segreto mancato è grave, ma quelli che intercetta vengono comunque presi, e le regole migliorano. Il contenimento degrada per eccezioni. Ogni volta che uno sviluppatore aggira l'attrito, “solo questa volta, incollo direttamente il token”, la proprietà si indebolisce, e non esiste alcun log di questo indebolimento. Scopri che il contenimento è fallito allo stesso modo in cui scopri che una porta è rimasta aperta: quando qualcuno controlla. Per questo i due dovrebbero lavorare insieme anziché essere rivali, ma anche perché li peso in modo diverso. La sezione seguente spiega perché la scansione, pur essendo la risposta predefinita del settore, è la più debole dei due per questa specifica classe di leak.

Scansione dei segreti: punti di forza e limiti invalicabili

La scansione vince quando la fuga è già avvenuta o sta per avvenire, il che, data la natura umana, succede spesso. La push protection di GitHub blocca i formati di token noti al momento del push. gitleaks in un hook pre-commit intercetta una quantità sorprendente di problemi prima che lascino il laptop. Se di questo articolo fai solo una cosa, fai questa:

# .pre-commit-config.yaml
repos:
- repo: https://github.com/gitleaks/gitleaks
rev: v8.18.4
hooks:
- id: gitleaks

Dieci minuti di configurazione, e la classe specifica di leak di questa storia, un token in un file di impostazioni committato, in gran parte scompare, perché gitleaks non si preoccupa che il file sia un JSON di impostazioni. Scansiona il contenuto, non i nomi dei file. Aggiungi una regex per i prefissi dei tuoi token interni, se li hai.

C'è un altro livello di scansione che vale la pena avere e che i team dimenticano: scansionare periodicamente la tua macchina locale alla ricerca di segreti non committati. Gli hook a livello di repo si attivano solo al commit o al push. Un file di impostazioni che resta sul disco per tre mesi prima che qualcuno esegua git add . è una finestra di tre mesi in cui il segreto è a un comando dall'essere pubblico. Un job pianificato, anche un cron settimanale che lancia gitleaks sui dotfile della tua home, riduce quella finestra a pochi giorni. È poco elegante, ma funziona.

Ma la scansione ha tre limiti invalicabili che la storia di Claude Code mette bene in evidenza. Primo, i rilevatori basati sull'entropia non trovano i segreti a bassa entropia. Una password come Winter2024! in una stringa di connessione psql non fa scattare un controllo dell'entropia, e se non è un formato di provider noto, nessuna regola la riconosce. I ricercatori hanno trovato molte password in chiaro, non solo chiavi in stile AWS. Secondo, la scansione è a posteriori a livello di push. La push protection blocca il push, il che è ottimo, ma se non scatta il segreto è nella cronologia, e la cronologia è per sempre. Ruotare dopo una fuga significa cercare ogni punto in cui la credenziale è stata usata, e non ho mai visto questa pulizia richiedere meno di un giorno. Terzo, la scansione crea una falsa sensazione di completezza. I team vedono la spunta verde e smettono di pensare a come scorrono i segreti. Come abbiamo già sostenuto nel nostro articolo sugli scanner di sicurezza basati sull'AI, uno scanner è una rete di sicurezza, non un sostituto dell'evitare la caduta.

Sul secondo punto, vale la pena essere precisi su cosa comporti davvero la “pulizia” quando una credenziale finisce in un repo pubblico, perché i team la sottovalutano cronicamente. La rotazione è la parte facile: revochi il token, ne emetti uno nuovo, aggiorni lo store dei segreti. La parte difficile è l'archeologia: ogni pipeline di deploy, job cron, laptop di sviluppatore e integrazione di terze parti che usava la vecchia credenziale va trovato e aggiornato, e perderne uno significa un'interruzione nel momento peggiore. Poi c'è il problema speculare: se il repo è pubblico, devi presumere che il segreto sia stato raccolto nel giro di pochi minuti. I bot che raccolgono credenziali monitorano continuamente il flusso di eventi di GitHub. Quando il tuo scanner ti avvisa, il segreto è probabilmente già stato clonato, indicizzato e forse testato contro i tuoi endpoint di produzione. Il rilevamento ti ha dato consapevolezza. Non ti ha dato sicurezza.

Detto questo, voglio essere equo con la scansione, perché nei dibattiti viene liquidata troppo in fretta. Per le grandi organizzazioni con centinaia di repo e migliaia di sviluppatori, la scansione è l'unico livello che scala senza cambiare i comportamenti. Non puoi formare le persone per uscire da una fuga su quella scala, ma puoi proteggerti con la push protection da gran parte dei casi. Se sei un platform team e devi decidere dove spendere la prima settimana di lavoro, la risposta è la scansione: è economica, centralizzata e intercetta i token ad alta entropia dei provider, che fanno più danni. Solo non confonderla con la soluzione completa.

Una rete da pesca a maglie larghe tirata fuori dall'acqua scura, con la maggior parte dei pesci luminosi che sfuggono dagli spazi mentre solo pochi restano intrappolati
La scansione intercetta i segreti che riconosce: le password a bassa entropia e i formati nuovi passano attraverso le maglie.

Contenimento: variabili d'ambiente, sandbox e credenziali a breve durata

Il contenimento vince ovunque il segreto altrimenti verrebbe scritto da qualche parte, che è esattamente dove si colloca questo incidente. Se la credenziale non compare mai come stringa letterale in un comando, l'allowlist non ha nulla di pericoloso da memorizzare. Il comando approvato diventa curl -H "Authorization: Bearer $DEPLOY_TOKEN" ... e il file di impostazioni contiene solo il nome innocuo di una variabile. Due regole coprono la maggior parte dei casi:

  • I segreti entrano nei comandi solo tramite variabili d'ambiente o indirezioni ($TOKEN, $(op read ...), un file di configurazione che l'agente legge a runtime), mai come valori letterali.
  • Le directory di configurazione locali degli agenti (.claude/, .cursor/, .aider*) vanno nel gitignore globale della macchina (~/.config/git/ignore), non solo per singolo repo, così nessun progetto potrà mai committarle.
# Global gitignore covers every repo on this machine
git config --global core.excludesFile ~/.config/git/ignore
cat >> ~/.config/git/ignore <<'EOF'
.claude/
.cursor/
.aider*
.env*
EOF

Perché globale invece che per repo? Due motivi. Primo, i gitignore per repo esistono solo se qualcuno ricorda di aggiungerli a ogni nuovo repository, e i nuovi repository vengono creati proprio quando nessuno pensa all'igiene della sicurezza. Secondo, un gitignore globale è una policy di macchina, non di progetto: non può essere rimosso per sbaglio in una pull request che “ripulisce il gitignore”, cosa che ho visto succedere davvero. La versione per repo protegge un repo. Quella globale protegge uno sviluppatore, e lo sviluppatore è l'unità più soggetta a fughe in questo scenario.

La regola sulle variabili d'ambiente merita la stessa attenzione, perché ha un fallimento sottile: i profili della shell. Se lo sviluppatore “risolve” il requisito della variabile esportando DEPLOY_TOKEN=sk-... nel suo .bashrc, hai solo spostato il segreto da un dotfile non controllato a un altro. La regola deve terminare in un vero backend di segreti: la CLI di 1Password, direnv che legge da uno store cifrato, un gestore di segreti cloud con aws ssm o op inject all'inizio della sessione. L'agente riceve la variabile; il disco non riceve mai il valore. È un'indirezione in più, ed è la differenza tra contenimento e cosmesi.

La versione più forte del contenimento è quella che chiamerei sandboxing vero: eseguire l'agente in una VM o in un container effimero per ogni task, su una rete isolata, con un proxy davanti alle API esterne. Un setup pratico che apprezzo mette un proxy API tra l'agente e una chiave SaaS con privilegi totali: le letture passano, le scritture richiedono un tocco sul telefono. È difesa in profondità fatta bene. Anche un agente completamente compromesso con --dangerously-skip-permissions può toccare solo ciò che il proxy consente. Abbiamo trattato il compromesso più ampio in contenimento vs monitoraggio per gli agenti AI; questa storia è un argomento a favore del contenimento.

Le credenziali a breve durata sono l'altra metà della versione forte, e sono sottovalutate perché riducono il raggio d'impatto anche quando tutti gli altri livelli falliscono. Una chiave statica di accesso AWS finita su GitHub è valida finché qualcuno non se ne accorge. Una credenziale emessa via OIDC con TTL di un'ora finita su GitHub è una voce di log. Se il tuo cloud provider supporta la federazione delle identità dei workload, e tutti i principali lo fanno, le credenziali dell'agente dovrebbero scadere più in fretta di quanto il tuo processo di incident response riesca a riunirsi per una riunione.

Il costo reale del contenimento è l'attrito. Le CLI dei password manager significano richieste di impronta digitale a metà task. Le VM effimere significano tempo di configurazione e latenza di avvio a freddo a ogni esecuzione. I proxy con scope richiedono che qualcuno li costruisca e li mantenga. Per uno sviluppatore solo su un progetto personale, il sandboxing completo è eccessivo e la versione con gitignore globale più variabili d'ambiente è la scelta giusta. Per un team i cui agenti toccano credenziali di produzione, l'attrito è il prezzo per non diventare il prossimo annuncio di violazione.

Il livello intermedio: correggere l'allowlist stessa

C'è una terza opzione che è in mano ai vendor degli strumenti, non tua: non memorizzare il comando letterale. Una regola di permesso che salva curl -H "Authorization: Bearer *" come pattern, con i valori degli argomenti oscurati, è altrettanto utilizzabile per il matching e non contiene alcun segreto. Il team di Claude Code ha dichiarato di star valutando proprio come prevenire questa classe di problemi, e la direzione che consigliano è una modalità di permessi automatica che non richiede di mantenere liste di allow/deny. È l'istinto giusto. Ogni allowlist mantenuta a mano è un incidente futuro con un timestamp che non puoi ancora vedere.

Il pattern matching, va chiarito, non è un pasto gratis. Un glob come curl * corrisponde in egual misura al comando di deploy innocuo e a quello di esfiltrazione malevolo, quindi una redazione aggressiva scambia il rischio di fuga con il rischio di approvazioni troppo ampie. Il design giusto è probabilmente strutturale anziché testuale: persistere quale binario e quali flag sono stati approvati, mai i valori degli argomenti. Così il matching resta preciso (sì a curl con header, no a curl che invia dati a un nuovo dominio) senza memorizzare nulla in cui una credenziale possa nascondersi. I vendor ci arriveranno; l'incentivo ora è rappresentato da più di mille file pubblici come prova.

Finché i vendor non rilasceranno questa funzione, puoi approssimarla con l'igiene: esegui periodicamente uno scanner sui file di impostazioni locali. Un comando come gitleaks detect --no-git --source ~/.claude .claude controlla esattamente i file di cui parla questa storia, prima che finiscano vicino a un repo. Aggiungilo allo script di setup dei tuoi dotfile e non ti costa nulla.

La mia raccomandazione: contenimento come default, scansione come rete

Se fossi costretto a sceglierne uno, sceglierei il contenimento. Una fuga che non avviene mai batte una fuga rilevata in fretta, ogni volta. La scansione è ciò su cui fai affidamento quando il contenimento fallisce (e fallirà, perché qualcuno incollerà una stringa di connessione in una chat all'una di notte), ma dovrebbe essere il gestore delle eccezioni, non la policy.

Nello specifico, per un team che introduce strumenti di coding agentico questo trimestre, in ordine di sforzo:

  1. Gitignore globale per le directory di configurazione degli agenti su ogni macchina di sviluppo: cinque minuti, elimina del tutto la fuga dei file di impostazioni committati.
  2. Regola: i segreti solo tramite variabili d'ambiente o la CLI di un password manager, mai inline nei comandi. Mettila nell'onboarding, non in una wiki che nessuno legge.
  3. gitleaks come hook pre-commit più push protection sulla piattaforma: la rete di sicurezza per tutto quanto sopra.
  4. Credenziali a breve durata e con scope per tutto ciò che tocca l'agente (credenziali cloud emesse via OIDC invece di chiavi statiche), così una fuga scade in poche ore.
  5. Per gli agenti con accesso alla produzione: sandbox effimera più un proxy API che limita ciò che le credenziali dell'agente possono fare.

Nota l'ordine. I due elementi più economici sono di contenimento, ed eliminano l'intera classe di incidenti invece di ridurne la probabilità. Gli elementi di scansione arrivano al terzo posto, non al primo, non perché siano poco importanti, ma perché sono la rete sotto il trapezio, e la monti dopo aver controllato le corde. I punti quattro e cinque sono quelli in cui smetti di difenderti dagli incidenti e inizi a difenderti dalle compromissioni, che è dove stanno andando gli strumenti agentici, che lo si pianifichi o meno.

Il muro di una fortezza con un piccolo cancello, dietro cui si trova un secondo muro interno e un caveau chiuso a chiave al centro
Contenimento a strati: anche se il muro esterno cede, il caveau non custodisce nulla di statico che valga la pena rubare.

I primi due elementi da soli avrebbero prevenuto praticamente ogni file del dataset dei ricercatori. È la parte frustrante di questo incidente: non è un attacco sofisticato. È un nuovo tipo di file che porta con sé un vecchio errore, e la soluzione è la stessa igiene che predichiamo dal primo .env committato, applicata a una directory che nessuna policy menziona ancora.

Aggiorna la policy. Gli agenti non vanno da nessuna parte, e nemmeno il pulsante “Non chiedere più”.