Fugas de secretos en agentes de IA: escaneo vs contención
Fugas de secretos en agentes de IA por «No volver a preguntar»: escaneo vs contención, y salvaguardas que evitan credenciales en el repositorio.

Investigadores de seguridad acaban de encontrar contraseñas, tokens de API y credenciales de nube en más de mil archivos públicos de GitHub. No están en archivos .env descuidados, sino en la configuración de agentes de programación con IA. El responsable es un patrón silencioso de fugas de secretos en agentes de programación con IA: el desarrollador aprueba un comando como curl -H "Authorization: Bearer sk-...", hace clic en «No volver a preguntar» y el comando completo, con el token incluido, se guarda en un archivo de configuración local. Si subes ese archivo, el secreto queda público. Llevo años trabajando en seguridad de infraestructura y esta es una de las fugas más evitables que he visto. Además es nueva, porque el archivo que la provoca no existía hace dos años.
Los dos mecanismos de defensa a los que recurren los equipos son el escaneo de secretos (detectar la fuga y luego limpiar) y la contención (asegurarse de que el secreto nunca llegue al agente ni al repositorio). Ambos son necesarios. Ninguno basta por sí solo. Este artículo los compara cara a cara (cuándo gana cada uno y dónde falla) y termina con lo que yo desplegaría en un equipo que usa Claude Code, Cursor o cualquier agente con lista de permisos.
Antes que nada, una aclaración: esto no es un argumento contra las herramientas de programación agéntica. Las uso a diario y no volvería atrás. El aviso de permisos, cuando el agente pregunta «¿puedo ejecutar esto?», es uno de los mejores mecanismos de seguridad que incluyen estas herramientas. El problema está solo en lo que pasa después de que dices que sí: dónde se registra ese «sí» y qué contiene.
Cómo la lista de permisos se convierte en un almacén de secretos
Para entender el modo de fallo hay que fijarse en lo que realmente persiste «No volver a preguntar». Cuando una CLI agéntica pide ejecutar un comando, la implementación ingenua guarda la cadena completa del comando en la regla de permiso. No un patrón. No un hash. La cadena literal que aprobaste.
Así que aprobar aws s3 cp s3://bucket/backup.sql . --profile prod es inofensivo. Pero si aprueban psql postgresql://admin:hunter2@db.internal/myapp o curl -u deploy:APIKEY123 https://.../deploy, las credenciales quedan guardadas en .claude/settings.local.json o en la configuración equivalente. El archivo de configuración está pensado para quedarse en local (Claude Code incluso lo añade automáticamente a .gitignore cuando la herramienta lo crea), pero si el desarrollador lo creó a mano, lo forzó con add o su gitignore global no lo cubre, basta un git add . y un push para que termine en GitHub. Esa es exactamente la cadena detrás de los 1.122 archivos que encontraron los investigadores.
Fíjate en que muchos eslabones de esa cadena son razonables por separado. Aprobar un comando con una credencial incrustada es algo que los desarrolladores han hecho de forma interactiva durante décadas sin consecuencias: el comando se ejecuta, el historial de la shell lo guarda localmente y a nadie le preocupa. Hacer clic en «No volver a preguntar» es racional; la fatiga de los avisos es real, y el gran atractivo de estos agentes es que interrumpen menos. Incluso git add . es defendible si la herramienta te dijo que el archivo era local. El incidente no lo causa un acto descuidado, sino un sistema en el que cinco actos inofensivos se combinan en una credencial pública. Son los peores fallos de seguridad de arreglar, porque nadie se ve a sí mismo haciendo nada malo.
He visto este mismo error en la práctica antes de que existieran los agentes. Un responsable de equipo de una fintech para la que hice consultoría tenía un allowed_commands.sh para un bot auxiliar de CI: la misma idea, hecha a mano. Alguien aprobó una migración de base de datos puntual con el DSN escrito en línea. Seis meses después el repositorio se hizo open source, y el DSN estaba en el historial de git de un archivo que nadie pensó en auditar porque «no era configuración». Sí lo era; simplemente no lo parecía.
Esa es la idea central: las listas de permisos son archivos de configuración que capturan secretos operativos como efecto secundario. Nadie las revisa en busca de secretos porque nadie las considera portadoras de secretos. Tu política de gestión de secretos cubre .env, credentials.yml y, quizá, el estado de Terraform. Casi seguro no cubre .claude/settings.local.json ni las configuraciones de .cursor/. Escribimos sobre un punto ciego parecido en la auditoría de clientes de API como almacenes de credenciales: las herramientas que usas a diario acumulan secretos en lugares que tu política ni menciona.
Y la categoría crece. Cada herramienta agéntica lanzada en los últimos años tiene alguna variante: listas de permisos, directorios de confianza, aprobaciones recordadas, configuraciones de servidores MCP con tokens en línea. Cada una es una nueva ruta de archivo que tus políticas, gitignores y configuraciones de escáneres no mencionan. La próxima versión de este incidente será el mismo error en un archivo con otro nombre.
Escaneo de secretos vs contención: las dos defensas
Esta es la comparación que seguiré a lo largo del artículo:
- Primero la detección (escaneo de secretos): hooks de pre-commit, escáneres de repositorios como gitleaks y trufflehog, protección de push de GitHub o GitLab, y análisis periódicos del historial. Asume que los secretos se filtrarán; detéctalos rápido y rota las credenciales.
- Primero la contención (mantener los secretos fuera): los secretos solo entran en los comandos a través de variables de entorno, CLI de gestores de contraseñas o credenciales de vida corta; los agentes se ejecutan en sandboxes o máquinas virtuales efímeras; los archivos de configuración locales se ignoran globalmente. Se diseña para que no haya nada que filtrar.
La detección es una operación de limpieza; la contención es una propiedad del diseño. Fallan en direcciones opuestas: el escaneo tiene falsos negativos y siempre actúa a posteriori; la contención tiene un coste de adopción y choca con la fricción del desarrollador. Cuál gana depende de qué modo de fallo puedas tolerar.
También hay una asimetría en cómo se degradan con el tiempo. El escaneo se degrada de forma suave: un secreto que se le escapa es malo, pero los que sí detecta siguen cazándose y las reglas mejoran. La contención se degrada por excepciones. Cada vez que un desarrollador se salta la fricción («solo esta vez, pego el token directamente»), la propiedad se debilita, y no queda ningún registro de ese debilitamiento. Te enteras de que la contención falló igual que te enteras de que una puerta quedó abierta: cuando alguien la revisa. Por eso ambas defensas van juntas en lugar de ser rivales, pero también por qué las pondero de forma distinta. La siguiente sección explica por qué el escaneo, pese a ser la respuesta por defecto de la industria, es el más débil de las dos para este tipo de fuga.
Escaneo de secretos: fortalezas y límites duros
El escaneo de secretos gana cuando la fuga ya ha ocurrido o está a punto de ocurrir, lo cual, dada la naturaleza humana, pasa bastante a menudo. La protección de push de GitHub bloquea formatos de token conocidos en el momento del push. gitleaks en un hook de pre-commit detecta una cantidad sorprendente de cosas antes de que salgan del portátil. Si no haces nada más de este artículo, haz esto:
# .pre-commit-config.yaml
repos:
- repo: https://github.com/gitleaks/gitleaks
rev: v8.18.4
hooks:
- id: gitleaks
Diez minutos de configuración, y la clase de fuga concreta de esta historia (un token en un archivo de configuración subido) prácticamente desaparece, porque gitleaks no se fija en que el archivo sea un JSON de configuración. Analiza el contenido, no los nombres de archivo. Añade una regla regex para los prefijos de tus tokens internos si los tienes.
Hay una capa más de escaneo que vale la pena tener y que los equipos olvidan: escanear periódicamente tu propia máquina local en busca de secretos no confirmados. Los hooks a nivel de repositorio solo se activan al hacer commit o push. Un archivo de configuración que lleva tres meses en disco antes de que alguien ejecute git add . es una ventana de tres meses en la que el secreto está a un comando de hacerse público. Un trabajo programado (incluso un cron semanal que ejecute gitleaks sobre los dotfiles de tu directorio personal) reduce esa ventana a días. Es poco elegante, pero funciona.
Pero el escaneo tiene tres límites duros que la historia de Claude Code deja muy claros. Primero, los detectores basados en entropía no encuentran secretos de baja entropía. Una contraseña como Winter2024! en una cadena de conexión de psql no activa un control de entropía, y si no tiene un formato de proveedor conocido, ninguna regla la reconoce. Los investigadores encontraron muchas contraseñas en texto plano, no solo claves tipo AWS. Segundo, el escaneo es posterior, en la capa del push. La protección de push detiene el push, lo cual es genial, pero si no se activa, el secreto queda en el historial, y el historial es permanente. Rotar tras una fuga implica localizar cada sitio donde se usó la credencial, y nunca he visto que esa limpieza tarde menos de un día. Tercero, el escaneo crea una falsa sensación de completitud. Los equipos ven la marca verde y dejan de pensar en cómo fluyen los secretos. Como ya defendimos en nuestro artículo sobre escáneres de seguridad con IA, un escáner es una red de seguridad, no un sustituto de no caerse.
Sobre el segundo punto, conviene ser precisos respecto a lo que implica la «limpieza» cuando una credencial llega a un repositorio público, porque los equipos la subestiman sistemáticamente. La rotación es lo fácil: revocar el token, emitir uno nuevo y actualizar el almacén de secretos. Lo difícil es la arqueología: hay que encontrar y actualizar cada pipeline de despliegue, tarea cron, portátil de desarrollador e integración de terceros que usaba la credencial antigua, y si se pasa uno, habrá una caída en el peor momento posible. Luego está el problema espejo: si el repositorio es público, hay que asumir que el secreto fue recolectado en cuestión de minutos. Los bots que buscan credenciales vigilan el flujo de eventos de GitHub de forma continua. Cuando tu escáner avisa, lo más probable es que el secreto ya se haya clonado, indexado y quizá probado contra tus endpoints de producción. La detección te dio conciencia de la situación. No te dio seguridad.
Dicho esto, quiero ser justo con el escaneo, porque en estos debates se descarta demasiado rápido. En organizaciones grandes, con cientos de repositorios y miles de desarrolladores, el escaneo es la única capa que escala sin cambiar el comportamiento. No puedes formar a las personas para salir de una fuga a esa escala, pero sí puedes protegerte de la mayoría con protección de push. Si eres un equipo de plataforma y decides en qué invertir tu primera semana, la respuesta es el escaneo: es barato, centralizado y detecta los tokens de proveedor de alta entropía que causan más daño. Pero no lo confundas con la solución completa.

Contención: variables de entorno, sandboxes y credenciales de vida corta
La contención gana en todos los lugares donde el secreto se escribiría de otro modo, que es precisamente donde vive este incidente. Si la credencial nunca aparece como cadena literal en un comando, la lista de permisos no tiene nada peligroso que guardar. El comando aprobado pasa a ser curl -H "Authorization: Bearer $DEPLOY_TOKEN" ..., y el archivo de configuración contiene un nombre de variable inofensivo. Dos reglas cubren la mayor parte:
- Los secretos solo entran en los comandos mediante variables de entorno o indirección (
$TOKEN,$(op read ...), un archivo de configuración que el agente lee en tiempo de ejecución), nunca como valores literales. - Los directorios de configuración locales de los agentes (
.claude/,.cursor/,.aider*) van en tu gitignore global de la máquina (~/.config/git/ignore), no solo por repositorio, para que ningún proyecto pueda subirlos nunca.
# Global gitignore covers every repo on this machine
git config --global core.excludesFile ~/.config/git/ignore
cat >> ~/.config/git/ignore <<'EOF'
.claude/
.cursor/
.aider*
.env*
EOF
¿Por qué global y no por repositorio? Por dos razones. Primero, los gitignore por repositorio solo existen si alguien se acuerda de añadirlos a cada repositorio nuevo, y los repositorios nuevos se crean justo cuando nadie piensa en la higiene de seguridad. Segundo, un gitignore global es una política de la máquina, no del proyecto: no se puede eliminar por accidente en una pull request que «limpia el gitignore», algo que he visto ocurrir de verdad. La versión por repositorio protege un repositorio. La global protege al desarrollador, y el desarrollador es la unidad propensa a las fugas aquí.
La regla de las variables de entorno merece el mismo escrutinio, porque tiene un modo de fallo sutil: los perfiles de shell. Si el desarrollador «resuelve» el requisito de la variable exportando DEPLOY_TOKEN=sk-... en su .bashrc, solo has movido el secreto de un dotfile sin revisar a otro. La regla tiene que terminar en un backend de secretos real: 1Password CLI, direnv leyendo de un almacén cifrado, o un gestor de secretos en la nube con aws ssm o op inject al inicio de la sesión. El agente recibe la variable; el disco nunca recibe el valor. Es una indirección extra, y es la diferencia entre contención real y cosmética.
La versión fuerte de la contención es lo que llamaría sandboxing de verdad: ejecutar el agente en una máquina virtual o contenedor efímero por tarea, en una red aislada, con un proxy delante de las APIs externas. Una configuración de un practicante que admiro pone un proxy de API entre el agente y una clave SaaS de acceso total: las lecturas pasan, las escrituras requieren una confirmación en el teléfono. Eso es defensa en profundidad bien hecha: incluso un agente totalmente comprometido con --dangerously-skip-permissions solo puede tocar lo que el proxy permite. Cubrimos el compromiso general en contención frente a monitorización de agentes de IA; esta historia es un argumento a favor de la contención.
Las credenciales de vida corta son la otra mitad de la versión fuerte, y están infravaloradas porque reducen el radio de impacto incluso cuando fallan todas las demás capas. Una clave estática de AWS filtrada a GitHub es válida hasta que alguien se da cuenta. Una credencial emitida por OIDC con un TTL de una hora y filtrada a GitHub es una simple entrada en un registro. Si tu proveedor de nube admite federación de identidad de carga de trabajo (y todos los grandes lo hacen), las credenciales del agente deberían caducar más rápido de lo que tu proceso de respuesta a incidentes tarda en reunirse.
El coste real de la contención es la fricción. Las CLI de gestores de contraseñas implican pedir la huella dactilar a mitad de una tarea. Las máquinas virtuales efímeras suponen tiempo de preparación y latencia de arranque en cada ejecución. Los proxies con alcance limitado requieren que alguien los construya y mantenga. Para un desarrollador solo en un proyecto personal, el sandboxing completo es excesivo y la versión con gitignore global más variables de entorno es la decisión correcta. Para un equipo cuyos agentes tocan credenciales de producción, la fricción es el precio de no acabar siendo la próxima divulgación de una brecha.
La capa intermedia: arreglar la propia lista de permisos
Hay una tercera opción que dependen de los proveedores de herramientas, no de ti: no guardar el comando literal. Una regla de permiso que persiste curl -H "Authorization: Bearer *" como patrón, con los valores de los argumentos redactados, sirve igual de bien para hacer coincidencias y no contiene ningún secreto. El equipo de Claude Code ha dicho que está estudiando impedir precisamente esta clase de problema, y su dirección recomendada es un modo de permisos automático que no exige mantener listas de permitidos y denegados. Es el instinto correcto. Cada lista de permisos mantenida a mano es un incidente futuro con una fecha que aún no puedes ver.
Aclaro que la coincidencia de patrones no es gratis. Un glob como curl * coincide igual de bien con el comando de despliegue inofensivo que con el de exfiltración maliciosa, así que una redacción agresiva cambia el riesgo de fuga por el riesgo de aprobar demasiado. El diseño adecuado probablemente sea estructural y no textual: guardar qué binario y qué flags se aprobaron, nunca los valores de los argumentos. Así la coincidencia sigue siendo precisa (sí a curl con cabeceras, no a curl enviando datos a un dominio nuevo) sin almacenar nada en lo que pueda esconderse una credencial. Los proveedores llegarán ahí; el incentivo ya existe con más de mil archivos públicos como prueba.
Mientras los proveedores no lo lancen, puedes aproximarlo con higiene: ejecutar periódicamente un escáner sobre tus propios archivos de configuración locales. Un comando como gitleaks detect --no-git --source ~/.claude .claude audita exactamente los archivos de los que trata esta historia, antes de que estén cerca de un repositorio. Añádelo al script de configuración de tus dotfiles y no cuesta nada.
Mi recomendación: contención por defecto, escaneo como red
Si tuviera que elegir uno, elegiría la contención. Una fuga que nunca ocurre supera siempre a una fuga detectada rápido. El escaneo es lo que usas cuando la contención falla, y fallará, porque alguien pegará una cadena de conexión en un chat a la 1 de la madrugada, pero debe ser el manejador de excepciones, no la política.
Concretamente, para un equipo que va a desplegar herramientas de programación agéntica este trimestre, ordenadas por esfuerzo:
- Gitignore global para los directorios de configuración de los agentes en cada máquina de desarrollador: cinco minutos, y elimina por completo la fuga de archivos de configuración subidos.
- Regla: los secretos solo mediante variables de entorno o una CLI de gestor de contraseñas, nunca en línea dentro de los comandos. Ponla en el proceso de onboarding, no en una wiki que nadie lee.
- gitleaks como hook de pre-commit más protección de push en la forja: la red de seguridad para todo lo anterior.
- Credenciales de vida corta y con alcance limitado para todo lo que toque el agente (credenciales de nube emitidas por OIDC en lugar de claves estáticas), para que una fuga caduque en horas.
- Para agentes con acceso a producción: sandbox efímero más un proxy de API que limite lo que pueden hacer las credenciales del agente.
Fíjate en el orden. Los dos elementos más baratos son de contención, y eliminan toda la clase de incidentes en lugar de reducir su probabilidad. Los elementos de escaneo van en tercer lugar, no porque sean poco importantes, sino porque son la red bajo el trapecio: instalas la red después de haber revisado las cuerdas. Los puntos cuatro y cinco son donde dejas de defenderte de accidentes y empiezas a defenderte de compromisos, que es hacia donde se dirigen las herramientas agénticas lo planifiquemos o no.

Los dos primeros puntos por sí solos habrían evitado prácticamente todos los archivos del conjunto de datos de los investigadores. Esa es la parte frustrante de este incidente: no es un ataque sofisticado. Es un tipo de archivo nuevo que arrastra un error viejo, y la solución es la misma higiene que llevamos predicando desde el primer .env subido, aplicada a un directorio que ninguna política menciona todavía.
Actualiza la política. Los agentes no se van a ir a ningún sitio, y tampoco el botón «No volver a preguntar».


