La configuración de .env que evita que Claude Code filtre tus secretos (configuración completa incluida)

Claude Code lee tus archivos .env en el momento en que abre tu proyecto.

Tus claves de API, contraseñas de bases de datos, tokens de Stripe, todo lo que está en el archivo .env se carga en la memoria y puede terminar en los registros de conversación enviados a los servidores de Anthropic.

Lo único que realmente bloquea el acceso es una línea en settings.json, que la mayoría de las personas no tienen y no conocen.

Aquí está la configuración de seguridad completa 👇

Antes de profundizar, comparto notas diarias sobre IA y vibe coding en mi canal de Telegram: **https://t.me/zodchixquant**🧠

Por qué las reglas de CLAUDE.md no te protegen

La mayoría de la gente añade "nunca leas archivos .env" a su CLAUDE.md y asume que están seguros (no lo están)

CLAUDE.md es una sugerencia. Claude la sigue la mayor parte del tiempo, pero bajo presión (tareas complejas, contexto largo, instrucciones ambiguas) puede y de hecho ignora las reglas de asesoramiento.

Un issue de GitHub de abril de 2026 confirmó: Claude lee y replica el contenido de .env en la conversación incluso cuando CLAUDE.md lo prohíbe explícitamente.

La única protección confiable es una regla de denegación en settings.json. Las reglas de denegación se aplican a nivel del sistema antes de que Claude siquiera vea el archivo.

La diferencia entre "por favor no leas esto" y "físicamente no puedes leer esto".

Las 3 formas en que tus secretos se filtran

No se trata solo de que Claude lea .env directamente. Hay tres vías:

1. Lectura directa del archivo. Claude escanea tu proyecto, abre .env y el contenido pasa a formar parte del contexto de la conversación. Esta es la obvia y la más fácil de bloquear con reglas de denegación.

2. Captura de salida en tiempo de ejecución. Claude ejecuta tus pruebas o inicia tu aplicación. Una solicitud HTTP fallida registra el encabezado completo Authorization: Bearer sk-live-abc123... . Un tiempo de espera de base de datos vuelca la cadena de conexión con la contraseña. Claude captura toda la salida de los comandos. Tus secretos ahora están en la conversación, aunque Claude nunca abrió .env.

3. Herramientas de búsqueda (grep). Claude usa grep para buscar en tu código base el nombre de una función. La búsqueda encuentra un archivo de configuración que contiene credenciales. La salida de grep incluye las líneas coincidentes con tus secretos visibles.

La mayoría de la gente solo se protege contra la vía 1. Las vías 2 y 3 son donde ocurre el daño real.

Las reglas de denegación que realmente funcionan

Agrega estas a ~/.claude/settings.json para protección global en todos los proyectos:

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}

Esto bloquea que Claude lea o escriba cualquier archivo .env, claves PEM, claves SSH, configuraciones de AWS, archivos de credenciales y tokens de npm/PyPI. El comodín \\ significa que se aplica a todos los subdirectorios de tu proyecto.

Bloqueando filtraciones en tiempo de ejecución

Las reglas de denegación detienen las lecturas directas de archivos, pero no la salida en tiempo de ejecución. Para eso, usa archivos .env específicos para pruebas con valores ficticios:

1# .env.test — seguro de leer, seguro de filtrar
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

Apunta tu framework de pruebas a .env.test en lugar de .env. Ahora, cuando Claude ejecute tus pruebas y capture la salida, las únicas claves visibles serán ficticias.

El hook de pre-commit que lo atrapa todo

Incluso con reglas de denegación, ocurren errores. Agrega un hook de pre-commit de git que escanee en busca de secretos antes de que cualquier commit llegue a tu repositorio:

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

Hazlo ejecutable: chmod +x .git/hooks/pre-commit

Esto atrapa claves de API de Anthropic, claves de Stripe, tokens de GitHub, claves de AWS, tokens de Slack, claves de SendGrid, JWTs y material de claves privadas. Si alguno de estos aparece en un archivo preparado, el commit se bloquea.

Aislamiento en contenedor (la opción nuclear)

Para máxima seguridad, ejecuta Claude Code dentro de un contenedor donde los archivos .env literalmente no existan:

bash

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

Desde la perspectiva de Claude, .env es un archivo vacío. Tus secretos nunca entran al sistema de archivos del contenedor. Esto es excesivo para la mayoría de los proyectos, pero esencial para trabajos con clientes que usan credenciales de producción.

La configuración de seguridad completa (lista para copiar y pegar)

~/.claude/settings.json completo con todas las protecciones de seguridad:

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 es el settings.json de mi artículo anterior más todas las reglas de seguridad de este. Reglas de permiso para el flujo de trabajo diario, reglas de denegación para secretos y operaciones peligrosas. Un solo archivo, protección completa.

La lista de verificación

Antes de tu próxima sesión con Claude Code:

1. ¿Tienes reglas de denegación para archivos .env en settings.json?

1. ¿Tus pruebas usan .env.test con valores ficticios?

1. ¿Hay un hook de pre-commit que busque patrones de secretos?

1. ¿Las credenciales de producción están almacenadas en un vault, no en archivos de texto plano?

1. ¿Está .env en tu .gitignore?

1. ¿Los archivos .env están fuera del directorio de tu proyecto para mayor seguridad?

Si marcaste los 6, tus secretos están tan protegidos como es posible. Si marcaste 0, estás a un prompt ambiguo de Claude de que tus claves de API aparezcan en un registro de conversación en los servidores de Anthropic.

Comparto notas diarias sobre IA, finanzas y vibe coding en mi canal de Telegram: **https://t.me/zodchixquant**

Gracias por leer🙏🏼