Jeff Bruchado
Volver al blog

Más de 10 Mil Imágenes de Docker Hub Filtran Credenciales y Claves de API: Lo Que Necesitas Saber

Hola HaWkers, un descubrimiento alarmante está sacudiendo la comunidad de desarrolladores: investigadores de seguridad encontraron más de 10 mil imágenes en Docker Hub exponiendo credenciales sensibles, incluyendo claves de API de servicios como OpenAI, AWS, HuggingFace y hasta credenciales de bancos.

Si trabajas con containers, esa noticia debería hacerte pausar y revisar tus prácticas de seguridad inmediatamente. Vamos a entender lo que aconteció, quién fue afectado y, más importante, cómo evitar que esto acontezca contigo.

Lo Que Fue Descubierto

Investigadores de la empresa de inteligencia de amenazas Flare escanearon imágenes de containers enviadas al Docker Hub en noviembre de 2025 y encontraron un escenario preocupante.

Números de la Filtración

Total de Exposiciones:

  • 10.456 imágenes exponiendo por lo menos una clave sensible
  • 42% de las imágenes comprometidas exponían 5 o más secretos
  • 101 empresas identificadas con credenciales filtradas
  • Incluyendo una empresa Fortune 500 y un gran banco nacional

Tipos de Secretos Expuestos:

  • 4.000 tokens de acceso para modelos de IA (OpenAI, HuggingFace, Anthropic, Gemini, Groq)
  • Credenciales de bases de datos de producción
  • Claves de acceso AWS
  • Tokens de GitHub
  • Credenciales de sistemas CI/CD
  • Claves de integraciones de pago

Cómo Esto Acontece

La exposición de secretos en imágenes Docker no es un bug del Docker Hub - es un error humano que acontece de varias formas:

1. Archivos .ENV Incluidos en la Imagen

El error más común es incluir archivos .env directamente en la imagen:

# ❌ ERRADO - ¡Nunca hagas esto!
FROM node:20-alpine
WORKDIR /app
COPY . .
# ¡El archivo .env con tus credenciales fue copiado!
RUN npm install
CMD ["npm", "start"]

El problema es que el COPY . . copia TODO, incluyendo tu archivo .env con credenciales.

2. Hardcoding de Credenciales

Otro error frecuente es poner credenciales directamente en el código:

# ❌ ERRADO - Credenciales hardcoded
import openai

openai.api_key = "sk-proj-abc123..."  # ¡Expuesto en la imagen!

def get_completion(prompt):
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

3. Credenciales en Archivos de Configuración

Archivos como config.json, settings.yaml o .npmrc frecuentemente contienen secretos:

{
  "database": {
    "host": "prod-db.empresa.com",
    "user": "admin",
    "password": "SuperSecreta123!"
  },
  "api_keys": {
    "stripe": "sk_live_abc123...",
    "sendgrid": "SG.xyz789..."
  }
}

Por Qué 75% de las Credenciales No Fueron Revocadas

Un dato alarmante de la investigación: incluso cuando desarrolladores percibieron el error y removieron la credencial de la imagen, 75% de las veces la clave no fue revocada.

El Problema de las Capas Docker

Eso acontece porque Docker usa un sistema de capas. Incluso si remueves un archivo en una capa posterior, él aún existe en las capas anteriores:

FROM node:20-alpine
WORKDIR /app
COPY . .
# Credencial copiada en la capa 3

RUN rm .env
# ¡Removido en la capa 4, pero aún existe en la capa 3!

Cómo Atacantes Explotan Esto

# Atacantes pueden inspeccionar todas las capas
docker save imagen:tag -o imagen.tar
tar -xf imagen.tar
# Cada carpeta es una capa - credenciales pueden estar en cualquier una

Cómo Proteger Tus Imágenes Docker

Veamos las mejores prácticas para evitar ese tipo de filtración:

1. Usa .dockerignore Religiosamente

Crea un archivo .dockerignore robusto:

# Archivos de ambiente
.env
.env.*
*.env

# Credenciales
.npmrc
.pypirc
credentials.json
service-account.json
*.pem
*.key
id_rsa*

# Configuraciones locales
config.local.*
settings.local.*

# Git
.git
.gitignore

# IDE
.vscode
.idea
*.swp

2. Usa Build Arguments Para Secretos de Build

Si necesitas secretos apenas durante el build:

FROM node:20-alpine
WORKDIR /app

# Argumento secreto no persiste en la imagen final
ARG NPM_TOKEN

# Usa el secreto y remueve en la misma capa
RUN echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > .npmrc && \
    npm install && \
    rm .npmrc

COPY . .
CMD ["npm", "start"]

Build con:

docker build --build-arg NPM_TOKEN=$NPM_TOKEN -t app .

3. Usa Docker Secrets (Preferido)

Para producción, usa Docker Secrets o un gestor externo:

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .

# Credenciales vendrán via Docker Secrets en runtime
CMD ["npm", "start"]

En docker-compose:

version: '3.8'
services:
  app:
    image: mi-app
    secrets:
      - db_password
      - api_key
    environment:
      - DB_PASSWORD_FILE=/run/secrets/db_password
      - API_KEY_FILE=/run/secrets/api_key

secrets:
  db_password:
    external: true
  api_key:
    external: true

4. Multi-Stage Builds

Usa builds multi-stage para garantizar que archivos de build no filtren:

# Stage 1: Build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
ARG NPM_TOKEN
RUN echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > .npmrc && \
    npm ci && \
    rm .npmrc
COPY . .
RUN npm run build

# Stage 2: Producción - imagen limpia
FROM node:20-alpine AS production
WORKDIR /app
# Copia APENAS lo necesario del builder
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY package*.json ./

USER node
CMD ["npm", "start"]

5. Escanea Tus Imágenes

Integra escaneo de secretos en tu CI/CD:

# GitHub Actions ejemplo
name: Security Scan

on: [push, pull_request]

jobs:
  scan-secrets:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Scan for secrets with Trivy
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: 'fs'
          scan-ref: '.'
          format: 'table'
          exit-code: '1'
          severity: 'HIGH,CRITICAL'

      - name: Build image
        run: docker build -t app:${{ github.sha }} .

      - name: Scan image
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: 'app:${{ github.sha }}'
          format: 'table'
          exit-code: '1'

Herramientas de Detección

Existen varias herramientas para detectar secretos filtrados:

Trivy (Recomendado)

# Escanear directorio
trivy fs --scanners secret .

# Escanear imagen
trivy image mi-imagen:tag

Gitleaks

# Escanear repositorio
gitleaks detect --source .

# Escanear en pre-commit
gitleaks protect --staged

TruffleHog

# Escanear repositorio git
trufflehog git file://. --only-verified

Lo Que Hacer Si Filtraste Credenciales

Si descubriste que tus credenciales fueron expuestas, sigue este checklist:

Acciones Inmediatas

  1. Revoca la credencial inmediatamente - no apenas remueva de la imagen
  2. Genera nuevas credenciales con permisos mínimos
  3. Audita logs para identificar uso no autorizado
  4. Notifica a tu equipo de seguridad

Acciones de Largo Plazo

  1. Implementa rotación automática de credenciales
  2. Adopta un vault (HashiCorp Vault, AWS Secrets Manager, etc.)
  3. Configura alertas para detección de filtraciones
  4. Entrena a tu equipo sobre prácticas seguras

Industrias Más Afectadas

La investigación identificó patrones interesantes sobre quién más filtra credenciales:

Por Sector:

  • Desarrollo de Software: mayor número de filtraciones
  • Marketing e Industrial: segundo lugar
  • IA y Sistemas Inteligentes: tercer lugar
  • Financiero y Bancario: más de 10 empresas afectadas

Origen de las Filtraciones:

  • Cuentas de "Shadow IT" (fuera del monitoreo corporativo)
  • Cuentas personales de desarrolladores
  • Cuentas de contractors y terceros

Conclusión

La filtración de más de 10 mil imágenes Docker con credenciales expuestas es un recordatorio importante: seguridad es responsabilidad de todos los desarrolladores, no apenas del equipo de seguridad.

La buena noticia es que prevenir ese tipo de filtración es relativamente simple con las prácticas correctas: usa .dockerignore, nunca hardcodees credenciales, utiliza secrets managers, y escanea tus imágenes regularmente.

Si aún no revisaste tus imágenes Docker y tu pipeline de CI/CD, ahora es la hora. Una credencial filtrada puede costar desde el acceso a APIs pagas hasta comprometer toda la infraestructura de tu empresa.

Para entender más sobre buenas prácticas de infraestructura moderna, te recomiendo conferir el artículo Edge Computing y Serverless en 2025 donde discutimos cómo las nuevas arquitecturas pueden ayudar a mejorar la seguridad.

¡Vamos a por ello! 🦅

Comentarios (0)

Este artículo aún no tiene comentarios 😢. ¡Sé el primero! 🚀🦅

Añadir comentarios