# Instalación (macOS/Linux)
brew install trufflesecurity/trufflehog/trufflehog

# Windows
curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -b /usr/local/bin

# Scan imagen Docker local
trufflehog docker --image=tu-imagen:tag --json --verify

# Scan namespace completo Docker Hub (público)
trufflehog docker --image=tuempresa/nombre-imagen:latest

# Output a archivo para análisis
trufflehog docker --image=mi-app:prod --json > scan-results.json

# Filtrar solo VERIFIED secrets (activos)
trufflehog docker --image=mi-app:prod --json --verify | jq '.[] | select(.verified == true)'

# Ejemplo output:
# {
#   "SourceMetadata": {"Container": "mi-app:prod", "file": "/app/.env", "layer": "sha256:abc123..."},
#   "SourceID": 16,
#   "SourceType": 16,
#   "SourceName": "trufflehog - filesystem",
#   "DetectorType": 673,
#   "DetectorName": "OpenAI",
#   "Verified": true,  # ⚠️ CRITICAL: Secret ES VÁLIDO
#   "Raw": "sk-proj-xxxxxxxxxxxxxxxxxxxx",
#   "Redacted": "sk-proj-xxxx...xxxx"
# }

# Instalación
brew install aquasecurity/trivy/trivy

# Scan imagen con secrets + vulnerabilities
trivy image --severity HIGH,CRITICAL \
--scanners vuln,secret \
mi-imagen:tag

# Output formato tabla legible
trivy image --scanners secret --format table mi-app:prod

# Output JSON para automation
trivy image --scanners secret --format json -o trivy-results.json mi-app:prod

# Scan solo secrets (skip CVE scan para velocidad)
trivy image --scanners secret mi-app:prod

# Ejemplo output:
# mi-app:prod (alpine 3.18)
# ===========================
# Total: 3 (UNKNOWN: 0, LOW: 0, MEDIUM: 0, HIGH: 2, CRITICAL: 1)
#
# Secrets
# ┌──────────────┬─────────────────┬──────────┬─────────────────────┐
# │ Category     │ Match           │ Severity │ Secret              │
# ├──────────────┼─────────────────┼──────────┼─────────────────────┤
# │ OpenAI Token │ sk-proj-xxxxxx  │ CRITICAL │ /app/.env:line 5    │
# │ AWS Keys     │ AKIA...         │ HIGH     │ /app/config.py:12   │
# └──────────────┴─────────────────┴──────────┴─────────────────────┘

FROM node:18-alpine
WORKDIR /app

# ⚠️ PELIGRO: Esto copia .env, .git/, y todo lo demás
COPY . .

RUN npm install
RUN npm run build

# ❌ Esto NO elimina .env del layer anterior
RUN rm .env

CMD ["npm", "start"]

# Resultado: .env está permanentemente en layer 2
# Cualquiera puede extraerlo con:
# docker history --no-trunc imagen:tag

# .dockerignore - Archivo en raíz del proyecto
.env
.env.*
*.env
.git
.gitignore
.vscode
.idea
node_modules
__pycache__
*.pyc
.pytest_cache
coverage
.coverage
*.log
*.key
*.pem
*.crt
secrets/
credentials/
config/local.json
docker-compose*.yml
README.md
.DS_Store

FROM node:18-alpine
WORKDIR /app

# ✅ SEGURO: Solo copiar archivos necesarios
COPY package*.json ./
RUN npm install --production

# ✅ Solo código fuente, NO archivos config
COPY src/ ./src/
COPY public/ ./public/

RUN npm run build

CMD ["npm", "start"]

# Secrets se inyectan en runtime vía Docker secrets o env vars
# NO están en la imagen

# Dockerfile inseguro
FROM python:3.11-slim

# ❌ Declarar ARG hace que sea visible en metadata
ARG OPENAI_API_KEY
ARG DATABASE_PASSWORD

ENV OPENAI_API_KEY=${OPENAI_API_KEY}
ENV DATABASE_PASSWORD=${DATABASE_PASSWORD}

COPY . /app
RUN pip install -r requirements.txt

CMD ["python", "app.py"]

# Build command (también inseguro)
docker build --build-arg OPENAI_API_KEY=sk-proj-xxx \
--build-arg DATABASE_PASSWORD=MySecretPass123 \
-t mi-app:latest .

# ⚠️ Extracción trivial del secret:
docker history --no-trunc mi-app:latest | grep OPENAI_API_KEY

# Output: ARG OPENAI_API_KEY=sk-proj-xxx (EXPUESTO)

# syntax=docker/dockerfile:1.4
FROM python:3.11-slim

WORKDIR /app
COPY requirements.txt .

# ✅ Secret mount: solo disponible durante RUN, NO persiste en image
RUN --mount=type=secret,id=openai_key \
    --mount=type=secret,id=db_password \
    pip install -r requirements.txt && \
    python setup.py --api-key=$(cat /run/secrets/openai_key) \
                    --db-password=$(cat /run/secrets/db_password)

COPY . .
CMD ["python", "app.py"]

# Build command SEGURO
export DOCKER_BUILDKIT=1

echo "sk-proj-xxx" > openai_key.txt
echo "MySecretPass123" > db_password.txt

docker build --secret id=openai_key,src=openai_key.txt \
             --secret id=db_password,src=db_password.txt \
             -t mi-app:latest .

# Cleanup local secret files
rm openai_key.txt db_password.txt

# ✅ Verificación: secrets NO están en la imagen
docker history --no-trunc mi-app:latest
# No muestra secrets

version: '3.8'

services:
    app:
        image: mi-app:latest
        secrets:
        - openai_api_key
        - database_password
        environment:
        # ✅ Solo path al secret, NO el valor
        OPENAI_API_KEY_FILE: /run/secrets/openai_api_key
        DATABASE_PASSWORD_FILE: /run/secrets/database_password

secrets:
    openai_api_key:
        file: ./secrets/openai_key.txt
    database_password:
        file: ./secrets/db_password.txt

# Application code lee desde archivo
# Python example:
import os

def get_secret(secret_name):
    secret_path = os.environ.get(f"{secret_name}_FILE")
    if secret_path and os.path.exists(secret_path):
        with open(secret_path, 'r') as f:
            return f.read().strip()
    return os.environ.get(secret_name)  # Fallback

openai_key = get_secret("OPENAI_API_KEY")

# docker-compose.dev.yml
services:
    app:
        environment:
        DATABASE_URL: postgresql://localhost:5432/dev_db
        OPENAI_API_KEY_FILE: /run/secrets/openai_dev
        # ✅ Development key con rate limits bajos

# docker-compose.prod.yml
services:
    app:
        environment:
        DATABASE_URL: postgresql://prod-db.internal:5432/prod_db
        OPENAI_API_KEY_FILE: /run/secrets/openai_prod
        # ✅ Production key con IP whitelisting

# ✅ Diferentes credentials, diferentes permisos

# Best practice: Vault paths
# Dev: vault/data/myapp/dev/openai-key
# Prod: vault/data/myapp/prod/openai-key

# ❌ INSEGURO: .env file copiado al Docker image
# Dockerfile que expone secrets
FROM python:3.11-slim
WORKDIR /app

# ⚠️ PELIGRO: COPY . . incluye archivos .env
COPY . .

RUN pip install -r requirements.txt
CMD ["python", "app.py"]

# Contenido de .env que queda permanente en layer
# OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxxxxxx
# ANTHROPIC_API_KEY=sk-ant-api03-xxxxxxxxxxxx
# DATABASE_URL=postgresql://user:password@prod-db:5432/maindb