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 la gente no tiene y desconoce.

Aquí tienes la configuración de seguridad completa 👇

Antes de sumergirnos, 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á a salvo (no es así)

CLAUDE.md es una sugerencia. Claude la sigue la mayor parte del tiempo, pero bajo presión (tareas complejas, contexto extenso, 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 fiable es una regla de denegación en settings.json. Las reglas de denegación se aplican a nivel de 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 se filtran tus secretos

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 la 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 haya abierto .env.

3. Herramientas de búsqueda (grep). Claude usa grep para buscar un nombre de función en tu código. 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

Añade estas a ~/.claude/settings.json para una protección global en todos tus 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. Añade 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 — bloquea commits que contienen secretos
3
4PATTERNS=(
5  'sk-ant-'           # Claves de API de Anthropic
6  'sk-live-'          # Claves live de Stripe
7  'sk_live_'          # Claves live de Stripe (formato alternativo)
8  'ghp_'              # Tokens personales de GitHub
9  'gho_'              # Tokens OAuth de GitHub
10  'AKIA'              # Claves de acceso de AWS
11  'xox[bpors]-'       # Tokens de Slack
12  'SG\.'              # Claves de SendGrid
13  'eyJ'               # JWTs
14  'BEGIN.*PRIVATE KEY' # Material de clave 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: Se encontró un posible secreto que coincide con '$pattern'"
22    echo "Elimina el secreto e inténtalo de nuevo."
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: Intento de commit de archivo sensible: $file"
30    exit 1
31  fi
32done
33
34echo "Verificación de seguridad de pre-commit superada."
35exit 0

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

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

Aislamiento por 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# Monta /dev/null sobre .env para que Claude no pueda verlo
2docker run -v /dev/null:/app/.env:ro tu-contenedor-de-desarrollo

Desde la perspectiva de Claude, .env es un archivo vacío. Tus secretos nunca entran en el sistema de archivos del contenedor. Esto es excesivo para la mayoría de los proyectos, pero esencial para el trabajo con clientes que tienen 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 escanee 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🙏🏼