Mais de 10 Mil Imagens do Docker Hub Vazando Credenciais: O Que Você Precisa Saber

Olá HaWkers, uma descoberta preocupante está sacudindo a comunidade DevOps. Pesquisadores de segurança identificaram mais de 10 mil imagens públicas no Docker Hub que estão vazando credenciais, chaves de API, tokens de acesso e outras informações sensíveis.

Se você utiliza containers Docker em produção, este artigo é essencial para entender o problema e como se proteger. A questão vai além de uma simples falha técnica: ela expõe práticas inseguras que estão disseminadas em toda a indústria.

A Descoberta e Suas Dimensões

Pesquisadores da área de segurança conduziram uma análise massiva do Docker Hub, escaneando milhares de imagens públicas em busca de segredos expostos. O resultado foi alarmante.

Números Principais:

Mais de 10.000 imagens com credenciais expostas
Chaves AWS, tokens GitHub, senhas de bancos de dados
Certificados TLS privados e chaves SSH
Tokens de APIs de serviços em nuvem
Credenciais de serviços terceiros (Stripe, Twilio, SendGrid)

🚨 Alerta: Muitas dessas imagens são baixadas milhares de vezes por semana, significando que as credenciais expostas podem estar sendo utilizadas em ambientes de produção ao redor do mundo.

Como as Credenciais Acabam nas Imagens

Entender como isso acontece é crucial para prevenir o problema em suas próprias imagens. Existem várias formas comuns pelas quais segredos acabam expostos em containers.

Cenários Comuns de Vazamento

1. Variáveis de Ambiente no Build:

Desenvolvedores frequentemente passam credenciais como variáveis de ambiente durante o build, sem perceber que elas ficam registradas nas camadas da imagem.

# ERRADO - A credencial fica na imagem
FROM node:18
ENV DATABASE_URL=postgres://user:senha@host:5432/db
COPY . .
RUN npm install

2. Arquivos de Configuração Copiados:

Arquivos como .env, config.json ou credenciais de cloud providers são copiados acidentalmente para a imagem.

# ERRADO - Copia tudo, incluindo .env
FROM node:18
WORKDIR /app
COPY . .
RUN npm install

3. Histórico de Camadas:

Mesmo que você remova um arquivo em uma camada posterior, ele continua presente nas camadas anteriores da imagem.

# ERRADO - O arquivo ainda existe nas camadas
FROM node:18
COPY secrets.json /app/
RUN rm /app/secrets.json

Como Verificar Suas Próprias Imagens

Agora que você entende o problema, é hora de auditar suas imagens Docker. Existem ferramentas específicas para essa tarefa.

Ferramentas de Análise de Segredos

1. Trivy (Aqua Security):

# Escanear imagem local
trivy image --scanners secret minha-imagem:latest

# Escanear imagem do Docker Hub
trivy image --scanners secret usuario/imagem:tag

2. Docker Scout:

# Analisar vulnerabilidades e segredos
docker scout cves minha-imagem:latest
docker scout quickview minha-imagem:latest

3. Dockle:

# Verificar boas práticas
dockle minha-imagem:latest

Análise Manual de Camadas

Você também pode inspecionar as camadas manualmente para entender o que está em cada uma:

# Salvar imagem como tar
docker save minha-imagem:latest > imagem.tar

# Extrair e analisar
mkdir analise && tar -xf imagem.tar -C analise

# Verificar conteúdo das camadas
for layer in analise/*/layer.tar; do
  echo "=== $layer ==="
  tar -tf "$layer" | grep -E '\.(env|json|key|pem|conf)$'
done

Boas Práticas Para Evitar Vazamentos

Prevenir é sempre melhor que remediar. Aqui estão as melhores práticas para manter suas imagens Docker seguras.

1. Use Build Secrets (Docker BuildKit)

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

# Usar secret durante o build sem expor na imagem
RUN --mount=type=secret,id=npm_token \
    NPM_TOKEN=$(cat /run/secrets/npm_token) \
    npm install

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

2. Multi-Stage Builds

# Stage 1: Build com dependências
FROM node:18 AS builder
WORKDIR /app
COPY package*.json ./
# Credenciais só existem neste stage
ARG NPM_TOKEN
RUN npm install
COPY . .
RUN npm run build

# Stage 2: Imagem final limpa
FROM node:18-slim
WORKDIR /app
# Copia apenas os artefatos necessários
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
CMD ["node", "dist/index.js"]

3. Arquivo .dockerignore Robusto

# Ignorar arquivos sensíveis
.env
.env.*
*.pem
*.key
.aws/
.ssh/
credentials.json
secrets/
*.secret

# Ignorar arquivos de desenvolvimento
.git
node_modules
.vscode
*.log

4. Injeção de Secrets em Runtime

# docker-compose.yml
version: '3.8'
services:
  app:
    image: minha-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

O Impacto Para a Indústria

Esta descoberta levanta questões importantes sobre a segurança da cadeia de suprimentos de software.

Riscos Identificados

Acesso a Infraestrutura:

Chaves AWS permitem acesso a recursos cloud
Credenciais de banco de dados expõem dados sensíveis
Tokens de CI/CD permitem injeção de código malicioso

Movimentação Lateral:

Uma credencial vazada pode levar a outras
Acesso a repositórios privados
Comprometimento de pipelines inteiros

Impacto Financeiro:

Uso não autorizado de recursos cloud
Custos de resposta a incidentes
Potenciais multas regulatórias (LGPD, GDPR)

O Que as Empresas Estão Fazendo

Empresa	Ação Tomada
Docker	Implementando escaneamento automático
AWS	Alertas para chaves expostas publicamente
GitHub	Secret scanning em repositórios
Google Cloud	Detecção de credenciais em logs

Ferramentas de Prevenção em CI/CD

Para evitar que credenciais cheguem às imagens, implemente verificações no 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

O Que Fazer Se Suas Credenciais Foram Expostas

Se você descobrir que credenciais foram expostas em uma imagem Docker, aja imediatamente.

Passos de Resposta:

Rotacionar Credenciais: Gere novas credenciais imediatamente
Auditar Uso: Verifique logs de acesso para uso não autorizado
Remover Imagem: Delete a imagem do Docker Hub
Notificar: Informe equipes e stakeholders relevantes
Documentar: Registre o incidente para análise posterior

⚠️ Importante: Apenas remover a imagem não é suficiente. Se alguém já baixou a imagem, as credenciais continuam expostas. A rotação é obrigatória.

Conclusão

O vazamento de mais de 10 mil imagens Docker com credenciais expostas é um lembrete de que segurança precisa ser parte integral do processo de desenvolvimento, não uma reflexão tardia. A boa notícia é que as ferramentas e práticas para prevenir isso estão disponíveis e são relativamente simples de implementar.

Se você trabalha com containers, reserve um tempo para auditar suas imagens e implementar as práticas recomendadas neste artigo. A segurança do seu ambiente depende disso.

Se você se interessa por segurança em desenvolvimento, recomendo que dê uma olhada em outro artigo: Vulnerabilidade Crítica em React Server Components: O Que Você Precisa Saber Para Proteger Suas Aplicações onde você vai descobrir como proteger suas aplicações React contra vulnerabilidades recentes.