Más de 10 Mil Imágenes de Docker Hub Filtrando Credenciales: Lo Que Necesitas Saber

Hola HaWkers, un descubrimiento preocupante está sacudiendo la comunidad DevOps. Investigadores de seguridad identificaron más de 10 mil imágenes públicas en Docker Hub que están filtrando credenciales, claves de API, tokens de acceso y otras informaciones sensibles.

Si utilizas containers Docker en producción, este artículo es esencial para entender el problema y cómo protegerte. La cuestión va más allá de una simple falla técnica: expone prácticas inseguras que están diseminadas en toda la industria.

El Descubrimiento y Sus Dimensiones

Investigadores del área de seguridad condujeron un análisis masivo del Docker Hub, escaneando miles de imágenes públicas en busca de secretos expuestos. El resultado fue alarmante.

Números Principales:

Más de 10.000 imágenes con credenciales expuestas
Claves AWS, tokens GitHub, contraseñas de bases de datos
Certificados TLS privados y claves SSH
Tokens de APIs de servicios en la nube
Credenciales de servicios terceros (Stripe, Twilio, SendGrid)

🚨 Alerta: Muchas de esas imágenes son descargadas miles de veces por semana, significando que las credenciales expuestas pueden estar siendo utilizadas en ambientes de producción alrededor del mundo.

Cómo las Credenciales Acaban en las Imágenes

Entender cómo esto acontece es crucial para prevenir el problema en tus propias imágenes. Existen varias formas comunes por las cuales secretos acaban expuestos en containers.

Escenarios Comunes de Filtración

1. Variables de Ambiente en el Build:

Desarrolladores frecuentemente pasan credenciales como variables de ambiente durante el build, sin percibir que quedan registradas en las capas de la imagen.

# INCORRECTO - La credencial queda en la imagen
FROM node:18
ENV DATABASE_URL=postgres://user:senha@host:5432/db
COPY . .
RUN npm install

2. Archivos de Configuración Copiados:

Archivos como .env, config.json o credenciales de cloud providers son copiados accidentalmente para la imagen.

# INCORRECTO - Copia todo, incluyendo .env
FROM node:18
WORKDIR /app
COPY . .
RUN npm install

3. Histórico de Capas:

Mismo que remuevas un archivo en una capa posterior, él continúa presente en las capas anteriores de la imagen.

# INCORRECTO - El archivo aún existe en las capas
FROM node:18
COPY secrets.json /app/
RUN rm /app/secrets.json

Cómo Verificar Tus Propias Imágenes

Ahora que entiendes el problema, es hora de auditar tus imágenes Docker. Existen herramientas específicas para esa tarea.

Herramientas de Análisis de Secretos

1. Trivy (Aqua Security):

# Escanear imagen local
trivy image --scanners secret mi-imagen:latest

# Escanear imagen del Docker Hub
trivy image --scanners secret usuario/imagen:tag

2. Docker Scout:

# Analizar vulnerabilidades y secretos
docker scout cves mi-imagen:latest
docker scout quickview mi-imagen:latest

3. Dockle:

# Verificar buenas prácticas
dockle mi-imagen:latest

Análisis Manual de Capas

También puedes inspeccionar las capas manualmente para entender lo que está en cada una:

# Salvar imagen como tar
docker save mi-imagen:latest > imagen.tar

# Extraer y analizar
mkdir analisis && tar -xf imagen.tar -C analisis

# Verificar contenido de las capas
for layer in analisis/*/layer.tar; do
  echo "=== $layer ==="
  tar -tf "$layer" | grep -E '\.(env|json|key|pem|conf)$'
done

Buenas Prácticas Para Evitar Filtraciones

Prevenir es siempre mejor que remediar. Aquí están las mejores prácticas para mantener tus imágenes Docker seguras.

1. Usa Build Secrets (Docker BuildKit)

# syntax=docker/dockerfile:1.4
FROM node:18

# Usar secret durante el build sin exponer en la imagen
RUN --mount=type=secret,id=npm_token \
    NPM_TOKEN=$(cat /run/secrets/npm_token) \
    npm install

# Build con secret
docker build --secret id=npm_token,src=./.npmrc -t app:latest .

2. Multi-Stage Builds

# Stage 1: Build con dependencias
FROM node:18 AS builder
WORKDIR /app
COPY package*.json ./
# Credenciales solo existen en este stage
ARG NPM_TOKEN
RUN npm install
COPY . .
RUN npm run build

# Stage 2: Imagen final limpia
FROM node:18-slim
WORKDIR /app
# Copia apenas los artefactos necesarios
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
CMD ["node", "dist/index.js"]

3. Archivo .dockerignore Robusto

# Ignorar archivos sensibles
.env
.env.*
*.pem
*.key
.aws/
.ssh/
credentials.json
secrets/
*.secret

# Ignorar archivos de desarrollo
.git
node_modules
.vscode
*.log

4. Inyección de Secrets en Runtime

# docker-compose.yml
version: '3.8'
services:
  app:
    image: mi-app:latest
    secrets:
      - db_password
      - api_key
    environment:
      - DB_PASSWORD_FILE=/run/secrets/db_password

secrets:
  db_password:
    file: ./secrets/db_password.txt
  api_key:
    external: true

El Impacto Para la Industria

Este descubrimiento levanta cuestiones importantes sobre la seguridad de la cadena de suministro de software.

Riesgos Identificados

Acceso a Infraestructura:

Claves AWS permiten acceso a recursos cloud
Credenciales de base de datos exponen datos sensibles
Tokens de CI/CD permiten inyección de código malicioso

Movimiento Lateral:

Una credencial filtrada puede llevar a otras
Acceso a repositorios privados
Comprometimiento de pipelines enteros

Impacto Financiero:

Uso no autorizado de recursos cloud
Costos de respuesta a incidentes
Potenciales multas regulatorias (LGPD, GDPR)

Lo Que las Empresas Están Haciendo

Empresa	Acción Tomada
Docker	Implementando escaneo automático
AWS	Alertas para claves expuestas públicamente
GitHub	Secret scanning en repositorios
Google Cloud	Detección de credenciales en logs

Herramientas de Prevención en CI/CD

Para evitar que credenciales lleguen a las imágenes, implementa verificaciones en el pipeline de CI/CD.

GitHub Actions

name: Security Scan
on: [push, pull_request]

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

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

      - name: Trivy Scan
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: 'app:${{ github.sha }}'
          format: 'sarif'
          output: 'trivy-results.sarif'
          scanners: 'vuln,secret'

      - name: Upload Results
        uses: github/codeql-action/upload-sarif@v2
        with:
          sarif_file: 'trivy-results.sarif'

Pre-commit Hooks

# .pre-commit-config.yaml
repos:
  - repo: https://github.com/gitleaks/gitleaks
    rev: v8.18.0
    hooks:
      - id: gitleaks

  - repo: https://github.com/trufflesecurity/trufflehog
    rev: v3.63.0
    hooks:
      - id: trufflehog

Lo Que Hacer Si Tus Credenciales Fueron Expuestas

Si descubres que credenciales fueron expuestas en una imagen Docker, actúa inmediatamente.

Pasos de Respuesta:

Rotar Credenciales: Genera nuevas credenciales inmediatamente
Auditar Uso: Verifica logs de acceso para uso no autorizado
Remover Imagen: Elimina la imagen del Docker Hub
Notificar: Informa equipos y stakeholders relevantes
Documentar: Registra el incidente para análisis posterior

⚠️ Importante: Apenas remover la imagen no es suficiente. Si alguien ya descargó la imagen, las credenciales continúan expuestas. La rotación es obligatoria.

Conclusión

La filtración de más de 10 mil imágenes Docker con credenciales expuestas es un recordatorio de que seguridad necesita ser parte integral del proceso de desarrollo, no una reflexión tardía. La buena noticia es que las herramientas y prácticas para prevenir esto están disponibles y son relativamente simples de implementar.

Si trabajas con containers, reserva un tiempo para auditar tus imágenes e implementar las prácticas recomendadas en este artículo. La seguridad de tu ambiente depende de eso.

Si te interesa seguridad en desarrollo, te recomiendo que des una mirada en otro artículo: Vulnerabilidad Crítica en React Server Components: Lo Que Necesitas Saber Para Proteger Tus Aplicaciones donde vas a descubrir cómo proteger tus aplicaciones React contra vulnerabilidades recientes.