Los secretos en Docker no desaparecen: la trampa del comando RUN rmNota · digest del 6 de noviembre
Diagrama infográfico explosionado de las capas de una imagen OCI de Docker que conserva un archivo secreto eliminado en la capa inferior bajo un marcador whiteout de OverlayFS.
Nota2 secciones≈ 4 min

Los secretos en Docker no desaparecen: la trampa del comando RUN rm

¿Cuántas veces has visto este patrón en repositorios ajenos o te has sorprendido con ganas de hacer lo mismo?: durante la compilación del contenedor hace falta descargar un paquete privado de un repositorio npm cerrado, bajar un binario por API o autenticarse en una base protegida. El desarrollador copia una clave SSH o un archivo con un token dentro de la imagen, lanza la compilación y, en la línea siguiente, escribe diligentemente RUN rm -f /root/.ssh/id_rsa o encadena comandos con ampersands.

La lógica parece cristalina: el archivo estaba, el archivo se borró. Arrancamos el contenedor con docker run, comprobamos el directorio con ls -la: todo limpio, no hay rastro del secreto. Ya podemos subir con tranquilidad la imagen final al registro público Docker Hub o al corporativo GitHub Packages.

Pero en realidad acabas de entregar a los atacantes tus claves de acceso de producción en bandeja de plata.

Anatomía de los archivos whiteout en OverlayFS

Para entender la magnitud de la catástrofe, hay que asomarse bajo el capó del sistema de archivos por capas de las imágenes OCI (Union File System, en la inmensa mayoría de los casos OverlayFS).

Una imagen de Docker no es un disco duro monolítico, sino una pila de capas inmutables (immutable), cada una de las cuales es físicamente un archivo tar normal con el delta de cambios del sistema de archivos. Las instrucciones COPY o ADD crean una capa donde queda empaquetada tu clave privada.

Cuando en la línea siguiente ejecutas RUN rm, el motor de OverlayFS no puede borrar físicamente los bytes de una capa inferior ya consolidada. En su lugar, escribe en una nueva capa superior un diminuto marcador de sistema: el llamado archivo whiteout con el prefijo .wh.<nombre_del_archivo>. Al ensamblar las capas en un único árbol del sistema de archivos virtual, el controlador ve ese marcador y simplemente oculta el archivo de la salida de los comandos del usuario.

En su investigación, el ingeniero Luka Klaric demostró de forma gráfica lo trivial que resulta extraer estos secretos «eliminados». Cualquier usuario que descargue la imagen hace lo siguiente:

# Guardamos la imagen en un archivo local y desempaquetamos las capas
docker save my-company-app:latest -o image.tar
tar -xf image.tar

# Buscamos nuestro archivo en los archivos tar de cada capa histórica
find . -name "layer.tar" -exec tar -tf {} \; | grep -E "id_rsa|token|secret"

Y el secreto sale a la luz en texto claro en fracciones de segundo. Herramientas populares de análisis de imágenes como dive o escáneres como Trivy destacan al instante estos archivos ocultos.

Compilación segura con Docker BuildKit Secrets

La única forma fiable de usar datos confidenciales durante la fase de compilación es impedir por completo que lleguen a las capas de la imagen. El backend de compilación moderno Docker BuildKit ofrece para ello un mecanismo nativo: la directiva de montaje de secretos --mount=type=secret.

El secreto se monta en un sistema de archivos temporal en memoria RAM (tmpfs) en la ruta /run/secrets/<id> únicamente durante la ejecución de un comando RUN concreto:

# syntax=docker/dockerfile:1
FROM alpine:3.20

RUN apk add --no-cache curl ca-certificates

# Montamos el token de acceso sin guardarlo en el historial de capas de la imagen
RUN --mount=type=secret,id=api_token,required=true \
    TOKEN=$(cat /run/secrets/api_token) && \
    curl -f -H "Authorization: Bearer $TOKEN" \
         -o /usr/local/bin/private-tool \
         https://internal.example.com/bin/private-tool && \
    chmod +x /usr/local/bin/private-tool

CMD ["/usr/local/bin/private-tool"]

Al invocar el comando docker build, el valor del secreto se pasa directamente desde una variable de entorno del host o desde un archivo local, sin dejar rastro en la caché de compilación:

# Paso del secreto desde una variable de entorno de la estación de trabajo o del runner de CI
export API_TOKEN="ghp_my_super_secret_deployment_token"
docker build --secret id=api_token,env=API_TOKEN -t my-company-app:latest .

Como resultado, en la imagen final no hay ni el archivo en sí, ni marcadores blancos de OverlayFS, ni mención alguna al token en el comando docker history. La memoria tmpfs se limpia al instante por el kernel en cuanto finaliza el comando RUN. Esta sencilla regla de compilación ahorra a las empresas cientos de horas investigando incidentes de filtración de accesos a infraestructura.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 3