La configurazione .env per impedire a Claude Code di divulgare i tuoi segreti (configurazione completa inclusa)

Claude Code legge i tuoi file .env nel momento in cui apre il tuo progetto.

Le tue chiavi API, password del database, token Stripe, tutto ciò che è nel file .env viene caricato in memoria e può finire nei log delle conversazioni inviati ai server di Anthropic.

L'unica cosa che blocca realmente l'accesso è una riga in settings.json, che la maggior parte delle persone non ha e di cui non sa nulla.

Ecco la configurazione di sicurezza completa 👇

Prima di addentrarci, condivido note quotidiane su AI e vibe coding nel mio canale Telegram: **https://t.me/zodchixquant**🧠

Perché le regole di CLAUDE.md non ti proteggono

Molte persone aggiungono "non leggere mai i file .env" nel loro CLAUDE.md e pensano di essere al sicuro (non lo sono)

CLAUDE.md è un suggerimento. Claude lo segue la maggior parte delle volte, ma sotto pressione (compiti complessi, contesto lungo, istruzioni ambigue) può e ignora le regole consultive.

Un issue su GitHub dell'aprile 2026 ha confermato: Claude legge e riporta i contenuti di .env nella conversazione anche quando CLAUDE.md lo proibisce esplicitamente.

L'unica protezione affidabile è una regola di negazione in settings.json. Le regole di negazione sono applicate a livello di sistema prima ancora che Claude veda il file.

La differenza tra "per favore non leggere questo" e "non puoi fisicamente leggere questo".

I 3 modi in cui i tuoi segreti vengono esposti

Non si tratta solo di Claude che legge .env direttamente. Ci sono tre percorsi:

1. Lettura diretta del file. Claude scansiona il tuo progetto, apre .env e i contenuti diventano parte del contesto della conversazione. Questo è il più ovvio e il più facile da bloccare con regole di negazione.

2. Acquisizione dell'output in esecuzione. Claude esegue i tuoi test o avvia la tua app. Una richiesta HTTP fallita registra l'intera intestazione Authorization: Bearer sk-live-abc123... . Un timeout del database riversa la stringa di connessione con la password. Claude cattura tutto l'output dei comandi. I tuoi segreti sono ora nella conversazione, anche se Claude non ha mai aperto .env.

3. Strumenti di grep e ricerca. Claude usa grep per cercare un nome di funzione nel tuo codice. La ricerca incontra un file di configurazione contenente credenziali. L'output di grep include le righe corrispondenti con i tuoi segreti visibili.

La maggior parte delle persone si protegge solo dal percorso 1. I percorsi 2 e 3 sono dove avvengono i danni reali.

Le regole di negazione che funzionano davvero

Aggiungi queste a ~/.claude/settings.json per una protezione globale su ogni progetto:

json

1{
2  "permissions": {
3    "deny": [
4      "Read(**/.env*)",
5      "Read(**/.dev.vars*)",
6      "Read(**/*.pem)",
7      "Read(**/*.key)",
8      "Read(**/secrets/**)",
9      "Read(**/credentials/**)",
10      "Read(**/.aws/**)",
11      "Read(**/.ssh/**)",
12      "Read(**/config/database.yml)",
13      "Read(**/config/credentials.json)",
14      "Read(**/.npmrc)",
15      "Read(**/.pypirc)",
16      "Write(**/.env*)",
17      "Write(**/secrets/**)",
18      "Write(**/.ssh/**)"
19    ]
20  }
21}

Questo blocca Claude dalla lettura o scrittura di qualsiasi file .env, chiavi PEM, chiavi SSH, configurazioni AWS, file di credenziali e token npm/PyPI. Il wildcard \\ significa che si applica a ogni sottodirectory del tuo progetto.

Bloccare le fughe di dati in esecuzione

Le regole di negazione fermano la lettura diretta dei file ma non l'output in esecuzione. Per questo, usa file .env specifici per i test con valori fittizi:

text

1# .env.test — sicuro da leggere, sicuro da far trapelare
2STRIPE_SECRET_KEY=sk_test_not_a_real_key
3DATABASE_URL=postgres://test:test@localhost:5432/testdb
4OPENAI_API_KEY=sk-test-dummy-key-for-mocking
5AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
6AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

Punta il tuo framework di test a .env.test invece che a .env. Ora quando Claude esegue i tuoi test e cattura l'output, le uniche chiavi visibili sono fittizie.

L'hook pre-commit che cattura tutto

Anche con le regole di negazione, gli errori accadono. Aggiungi un hook git pre-commit che scansiona i segreti prima che qualsiasi commit raggiunga il tuo repository:

bash

1#!/bin/bash
2# .git/hooks/pre-commit — blocca i commit contenenti segreti
3
4PATTERNS=(
5  'sk-ant-'           # Chiavi API Anthropic
6  'sk-live-'          # Chiavi live Stripe
7  'sk_live_'          # Chiavi live Stripe (formato alternativo)
8  'ghp_'              # Token personali GitHub
9  'gho_'              # Token OAuth GitHub
10  'AKIA'              # Chiavi di accesso AWS
11  'xox[bpors]-'       # Token Slack
12  'SG\.'              # Chiavi SendGrid
13  'eyJ'               # JWT
14  'BEGIN.*PRIVATE KEY' # Materiale chiave privata
15)
16
17BLOCKED_FILES=('.env' 'credentials.json' 'id_rsa' '*.pem' '*.key')
18
19for pattern in "${PATTERNS[@]}"; do
20  if git diff --cached --diff-filter=ACM | grep -qE "$pattern"; then
21    echo "BLOCKED: Found potential secret matching '$pattern'"
22    echo "Remove the secret and try again."
23    exit 1
24  fi
25done
26
27for file in "${BLOCKED_FILES[@]}"; do
28  if git diff --cached --name-only | grep -q "$file"; then
29    echo "BLOCKED: Attempted to commit sensitive file: $file"
30    exit 1
31  fi
32done
33
34echo "Pre-commit security check passed."
35exit 0

Rendilo eseguibile: chmod +x .git/hooks/pre-commit

Questo cattura chiavi API Anthropic, chiavi Stripe, token GitHub, chiavi AWS, token Slack, chiavi SendGrid, JWT e materiale di chiave privata. Se uno di questi appare in un file staged, il commit viene bloccato.

Isolamento del contenitore (l'opzione nucleare)

Per la massima sicurezza, esegui Claude Code all'interno di un contenitore dove i file .env letteralmente non esistono:

bash

1# Monta /dev/null su .env in modo che Claude non possa vederlo
2docker run -v /dev/null:/app/.env:ro your-dev-container

Dal punto di vista di Claude, .env è un file vuoto. I tuoi segreti non entrano mai nel filesystem del contenitore. È eccessivo per la maggior parte dei progetti ma essenziale per lavori con clienti che hanno credenziali di produzione.

La configurazione di sicurezza completa (pronta per copia e incolla)

~/.claude/settings.json completo con tutte le protezioni di sicurezza:

json

1{
2  "permissions": {
3    "allow": [
4      "Read",
5      "Glob",
6      "Grep",
7      "LS",
8      "Edit",
9      "MultiEdit",
10      "Write(src/**)",
11      "Write(tests/**)",
12      "Bash(npm run *)",
13      "Bash(npm test *)",
14      "Bash(npx tsc *)",
15      "Bash(git status)",
16      "Bash(git diff *)",
17      "Bash(git log *)",
18      "Bash(git add *)",
19      "Bash(git commit *)"
20    ],
21    "deny": [
22      "Read(**/.env*)",
23      "Read(**/.dev.vars*)",
24      "Read(**/*.pem)",
25      "Read(**/*.key)",
26      "Read(**/secrets/**)",
27      "Read(**/credentials/**)",
28      "Read(**/.aws/**)",
29      "Read(**/.ssh/**)",
30      "Read(**/config/database.yml)",
31      "Read(**/config/credentials.json)",
32      "Read(**/.npmrc)",
33      "Read(**/.pypirc)",
34      "Write(**/.env*)",
35      "Write(**/secrets/**)",
36      "Write(**/.ssh/**)",
37      "Write(.github/workflows/*)",
38      "Bash(rm -rf *)",
39      "Bash(sudo *)",
40      "Bash(git push *)",
41      "Bash(npm publish *)",
42      "Bash(curl * | sh)",
43      "Bash(wget *)",
44      "Bash(chmod *)"
45    ],
46    "defaultMode": "acceptEdits"
47  }
48}

Questo è il settings.json del mio articolo precedente più tutte le regole di sicurezza di questo. Regole di permesso per il flusso di lavoro quotidiano, regole di negazione per segreti e operazioni pericolose. Un file, protezione completa.

La checklist

Prima della tua prossima sessione con Claude Code:

Hai regole di negazione per i file .env in settings.json?

I tuoi test usano .env.test con valori fittizi?

C'è un hook pre-commit che scansiona i pattern di segreti?

Le credenziali di produzione sono archiviate in un vault, non in file di testo semplice?

.env è nel tuo .gitignore?

I file .env sono fuori dalla directory del tuo progetto per maggiore sicurezza?

Se hai spuntato tutti e 6, i tuoi segreti sono protetti il più possibile. Se ne hai spuntati 0, sei a un prompt ambiguo di Claude di distanza dal vedere le tue chiavi API in un log di conversazione sui server di Anthropic.

Condivido note quotidiane su AI, finanza e vibe coding nel mio canale Telegram: **https://t.me/zodchixquant**

Grazie per aver letto🙏🏼