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

O 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 no arquivo .env é carregado na memória e pode acabar nos logs de conversa enviados aos 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 seu CLAUDE.md e acredita que está segura (não está)

CLAUDE.md é uma sugestão. 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: o 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 do 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 do Claude ler o .env diretamente. Existem três caminhos:

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

2. Captura de saída em tempo de execução. 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. O Claude captura toda a saída do comando. Seus segredos agora estão na conversa, mesmo que o Claude nunca tenha aberto o .env.

3. Ferramentas de grep e busca. O 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 o 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 a leitura direta 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 — seguro para ler, seguro para vazar
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 o Claude executar seus testes e capturar a saída, as únicas chaves visíveis serão fictícias.

O hook pre-commit que pega tudo

Mesmo com regras de negação, erros acontecem. Adicione um hook 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 — bloqueia commits contendo segredos
3
4PATTERNS=(
5  'sk-ant-'           # Chaves da API Anthropic
6  'sk-live-'          # Chaves live do Stripe
7  'sk_live_'          # Chaves live do Stripe (formato alternativo)
8  'ghp_'              # Tokens pessoais do GitHub
9  'gho_'              # Tokens OAuth do GitHub
10  'AKIA'              # Chaves de acesso AWS
11  'xox[bpors]-'       # Tokens do Slack
12  'SG\.'              # Chaves do SendGrid
13  'eyJ'               # JWTs
14  'BEGIN.*PRIVATE KEY' # Material de chave privada
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 "BLOQUEADO: Possível segredo encontrado correspondendo a '$pattern'"
22    echo "Remova o segredo e tente novamente."
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 "BLOQUEADO: Tentativa de commit de arquivo sensível: $file"
30    exit 1
31  fi
32done
33
34echo "Verificação de segurança pre-commit aprovada."
35exit 0

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

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

Isolamento por container (a opção nuclear)

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

bash

1# Monta /dev/null sobre .env para que o Claude não possa vê-lo
2docker run -v /dev/null:/app/.env:ro seu-container-de-dev

Da perspectiva do Claude, .env é um arquivo vazio. Seus segredos nunca entram no sistema de arquivos do container. Isso é exagero para a maioria dos projetos, mas essencial para trabalho com clientes que possuem 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 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 você 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🙏🏼