A configuração de .env que impede o Claude Code de vazar seus segredos (Configuração completa inclusa)

Claude Code lê seus arquivos .env no momento em que abre seu projeto.

Suas chaves de API, senhas de banco de dados, tokens do Stripe — tudo que está no arquivo .env é carregado na memória e pode acabar nos logs de conversa enviados para os servidores da Anthropic.

A única coisa que realmente bloqueia o acesso é uma linha no settings.json, que a maioria das pessoas não tem e nem sabe que existe.

Aqui está a configuração de segurança completa 👇

Antes de mergulharmos, compartilho notas diárias sobre IA e vibe coding no meu canal do Telegram: **https://t.me/zodchixquant** 🧠

Por que as regras do CLAUDE.md não protegem você

A maioria das pessoas adiciona "nunca leia arquivos .env" ao CLAUDE.md e acha que está segura (não está).

CLAUDE.md é uma sugestão. Claude segue na maioria das vezes, mas sob pressão (tarefas complexas, contexto longo, instruções ambíguas) ele pode e ignora regras consultivas.

Uma issue no GitHub de abril de 2026 confirmou: Claude lê e ecoa o conteúdo do .env na conversa mesmo quando o CLAUDE.md proíbe explicitamente.

A única proteção confiável é uma regra de negação no settings.json. As regras de negação são aplicadas no nível do sistema antes mesmo de Claude ver o arquivo.

A diferença entre "por favor, não leia isso" e "você fisicamente não pode ler isso".

As 3 maneiras como seus segredos vazam

Não se trata apenas de Claude ler o .env diretamente. Existem três caminhos:

1. Leitura direta do arquivo. Claude escaneia seu projeto, abre o .env e o conteúdo se torna parte do contexto da conversa. Esse é o óbvio e o mais fácil de bloquear com regras de negação.

2. Captura de saída em tempo de execução. Claude executa seus testes ou inicia seu aplicativo. Uma requisição HTTP com falha registra o cabeçalho completo Authorization: Bearer sk-live-abc123.... Um timeout de banco de dados exibe a string de conexão com a senha. Claude captura toda a saída do comando. Seus segredos agora estão na conversa, mesmo que Claude nunca tenha aberto o .env.

3. Ferramentas de grep e busca. Claude usa grep para pesquisar em seu código por um nome de função. A busca encontra um arquivo de configuração contendo credenciais. A saída do grep inclui as linhas correspondentes com seus segredos visíveis.

A maioria das pessoas só se protege contra o caminho 1. Os caminhos 2 e 3 são onde o dano real acontece.

As regras de negação que realmente funcionam

Adicione estas ao ~/.claude/settings.json para proteção global em todos os projetos:

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}

Isso bloqueia Claude de ler ou escrever qualquer arquivo .env, chaves PEM, chaves SSH, configurações AWS, arquivos de credenciais e tokens npm/PyPI. O curinga \\ significa que se aplica a todos os subdiretórios do seu projeto.

Bloqueando vazamentos em tempo de execução

Regras de negação impedem leituras diretas de arquivos, mas não a saída em tempo de execução. Para isso, use arquivos .env específicos para teste com valores fictícios:

1# .env.test — safe to read, safe to leak
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

Aponte seu framework de teste para .env.test em vez de .env. Agora, quando Claude executar seus testes e capturar a saída, as únicas chaves visíveis serão fictícias.

O hook de pre-commit que pega tudo

Mesmo com regras de negação, erros acontecem. Adicione um hook de pre-commit do git que verifica segredos antes que qualquer commit chegue ao seu repositório:

bash

1#!/bin/bash
2# .git/hooks/pre-commit — blocks commits containing secrets
3
4PATTERNS=(
5  'sk-ant-'           # Anthropic API keys
6  'sk-live-'          # Stripe live keys
7  'sk_live_'          # Stripe live keys (alt format)
8  'ghp_'              # GitHub personal tokens
9  'gho_'              # GitHub OAuth tokens
10  'AKIA'              # AWS access keys
11  'xox[bpors]-'       # Slack tokens
12  'SG\.'              # SendGrid keys
13  'eyJ'               # JWTs
14  'BEGIN.*PRIVATE KEY' # Private key material
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

Torne-o executável: chmod +x .git/hooks/pre-commit

Isso captura chaves de API da Anthropic, chaves do Stripe, tokens do GitHub, chaves AWS, tokens do Slack, chaves SendGrid, JWTs e material de chave privada. Se algum deles aparecer em um arquivo preparado, o commit é bloqueado.

Isolamento em contêiner (a opção nuclear)

Para máxima segurança, execute o Claude Code dentro de um contêiner onde os arquivos .env literalmente não existem:

bash

1# Mount /dev/null over .env so Claude can't see it
2docker run -v /dev/null:/app/.env:ro your-dev-container

Da perspectiva do Claude, .env é um arquivo vazio. Seus segredos nunca entram no sistema de arquivos do contêiner. Isso é exagero para a maioria dos projetos, mas essencial para trabalhos com clientes que usam credenciais de produção.

A configuração de segurança completa (pronta para copiar e colar)

~/.claude/settings.json completo com todas as proteções de segurança:

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}

Este é o settings.json do meu artigo anterior mais todas as regras de segurança deste. Regras de permissão para o fluxo de trabalho diário, regras de negação para segredos e operações perigosas. Um arquivo, proteção completa.

A lista de verificação

Antes da sua próxima sessão com Claude Code:

1. Você tem regras de negação para arquivos .env no settings.json?

1. Seus testes usam .env.test com valores fictícios?

1. Existe um hook de pre-commit verificando padrões de segredos?

1. As credenciais de produção estão armazenadas em um cofre, não em arquivos de texto simples?

1. O .env está no seu .gitignore?

1. Os arquivos .env estão fora do diretório do seu projeto para segurança extra?

Se você marcou todos os 6, seus segredos estão tão protegidos quanto possível. Se marcou 0, você está a um prompt ambíguo do Claude de ter suas chaves de API aparecendo em um log de conversa nos servidores da Anthropic.

Compartilho notas diárias sobre IA, finanças e vibe coding no meu canal do Telegram: **https://t.me/zodchixquant**

Obrigado por ler 🙏🏼