CopyEscape — PoC de CVE-2026-17106

Proof of Concept educativa de CopyEscape (CVE-2026-17106), vulnerabilidad de carrera TOCTOU en docker cp que permite a un contenedor malicioso escribir archivos arbitrarios en el host Docker. Inspirada en el trabajo original de masasron, quien descubrio y documento la vulnerabilidad en el blog "CopyEscape: Taking Over Docker Hosts with docker cp".

Resumen ejecutivo

CVE-2026-17106 es una vulnerabilidad de condicion de carrera (TOCTOU) en la extraccion del archivo tar que el daemon de Docker produce durante docker cp <contenedor>:<ruta> <destino>. Afecta a Docker CLI 29.6.1 y versiones anteriores; parcheada a partir de la 29.7.0. El bug reside en la CLI (extraccion del tar en el host), no en el daemon.

La cadena bautizada CopyEscape demuestra como, partiendo unicamente de un contenedor en ejecucion sin capacidades extra, un atacante puede:

Camuflar un directorio real /watched/file.txt/ como un archivo regular ante cualquier proceso que lo abra dentro del contenedor, mediante una biblioteca LD_PRELOAD que intercepta open, openat, openat2, fopen, stat, lstat, fstatat, statx y las variantes 64.
Mantener un archivo cebo aaa.txt de 16 MiB que fuerza al daemon a tardar lo suficiente en producir el tar para que el monitor gane la carrera.
Vigilar con inotify los accesos del daemon y, en la ventana de carrera, sustituir un subdirectorio escape/ por un symlink absoluto al target del host ( en macOS o en Linux) mediante dos atomicos con rollback.

El resultado es escritura arbitraria de archivos en el host con los permisos del proceso que ejecuta docker cp. La variante Linux sobrescribe /usr/bin/runc y consigue ejecucion de codigo como root en el host al siguiente docker run / exec.

Aviso legal

Este repositorio contiene material estrictamente educativo y defensivo.

Proposito: demostrar la cadena de explotacion con fines de formacion, auditoria propia y validacion de patches.
Uso autorizado: ejecutalo unicamente contra sistemas que te pertenezcan o sobre los que dispongas de autorizacion escrita explicita.
Prohibido: cualquier uso contra sistemas de terceros sin consentimiento. El autor del repositorio no se responsabiliza del uso indebido del material aqui incluido.
Responsabilidad: el operador es el unico responsable del cumplimiento de la legislacion aplicable (LOPD/RGPD en Espana, CFAA en EE. UU., etc.).
La variante Linux destruye el runc del host: usala unicamente en una VM desechable con copia de seguridad verificada.

La PoC se entrega con una variante macOS inocua (escribe ~/pwnd como marcador) cuya unica finalidad es servir como demostracion reproducible.

Arquitectura de la cadena

┌─────────────────────────────────────────────────────────────────────┐
│  1. LD_PRELOAD camufla /watched/file.txt como archivo regular       │
│     open/openat/openat2/fopen/stat/lstat/fstatat/statx → decoy       │
│     docker exec ... cat /watched/file.txt  →  "top-level file"       │
└──────────────────────────────────────────┬──────────────────────────┘
                                           │
                                           ▼
┌─────────────────────────────────────────────────────────────────────┐
│  2. Layout real dentro del contenedor                               │
│     /watched/file.txt/                                               │
│     ├── aaa.txt            (16 MiB de 'B', cebo lento)               │
│     ├── escape/            (directorio real inicial)                 │
│     ├── escape/<basename>  (payload: runc o pwnd)                    │
│     └── .swap-escape       (symlink → /Users/<usr> o /usr/bin)       │
└──────────────────────────────────────────┬──────────────────────────┘
                                           │
                                           ▼
┌─────────────────────────────────────────────────────────────────────┐
│  3. docker cp pide tar al daemon                                    │
│     daemon recorre /watched/file.txt/ y abre aaa.txt                │
│     inotify detecta IN_OPEN sobre aaa.txt                           │
└──────────────────────────────────────────┬──────────────────────────┘
                                           │
                                           ▼
┌─────────────────────────────────────────────────────────────────────┐
│  4. Monitor pivot: dos rename(2) atomicos con rollback              │
│     escape/ → .old-escape/   (backup)                                │
│     .swap-escape → escape/   (symlink al target del host)            │
└──────────────────────────────────────────┬──────────────────────────┘
                                           │
                                           ▼
┌─────────────────────────────────────────────────────────────────────┐
│  5. Tar resultante contiene:                                        │
│     escape → /Users/<usr>   (symlink absoluto)                       │
│     escape/<basename>        (entrada hija que atraviesa el symlink) │
└──────────────────────────────────────────┬──────────────────────────┘
                                           │
                                           ▼
┌─────────────────────────────────────────────────────────────────────┐
│  6. CLI vulnerable extrae symlink + hija                            │
│     crea escape → /Users/<usr> en el destino local                   │
│     extrae escape/<basename> A TRAVES del symlink                    │
│     escribe /Users/<usr>/<basename> en el host                       │
└──────────────────────────────────────────┬──────────────────────────┘
                                           │
                                           ▼
┌─────────────────────────────────────────────────────────────────────┐
│  macOS: ~/pwnd con "COPYESCAPE_MACOS_DEMO"  (demo inocua)           │
│  Linux: /usr/bin/runc sobrescrito          (RCE como root)          │
└─────────────────────────────────────────────────────────────────────┘

Requisitos

La PoC esta construida para ejecutarse en macOS con:

Docker Desktop 4.81+ en marcha (el daemon puede ser cualquier version; el bug esta en la CLI).
curl, tar, git y docker en PATH.
Conexion a internet para descargar la CLI vulnerable 29.6.1 (unos 18 MB) y la imagen base alpine:3.21.
HOME con la forma /Users/<usuario>.

No se necesita root para la variante macOS. La variante Linux requiere root y una VM desechable.

El runner run-poc.sh descarga automaticamente el binario de la CLI vulnerable 29.6.1 desde el sitio oficial de Docker (download.docker.com). No modifica la instalacion de Docker Desktop del sistema: usa el daemon actual pero invoca el binario descargado para la operacion docker cp.

Estructura del repositorio

POC CopyEscape (CVE-2026-17106)/
├── README.md                 ← Este archivo
├── LICENSE                   ← Licencia MIT
├── .gitignore
├── Dockerfile                ← Dockerfile unificado (macos | linux)
├── entrypoint.sh             ← Arranque del monitor sin LD_PRELOAD
├── monitor.c                 ← Monitor inotify unificado (una sola fuente)
├── watched_preload.c         ← LD_PRELOAD con cobertura ampliada
└── run-poc.sh                ← Runner robusto con reintentos

El directorio cli-vulnerable/ (CLI 29.6.1 descargada) se excluye del repositorio via .gitignore. El runner la descarga automaticamente si no esta presente.

Guia rapida de uso

1. Ejecutar la PoC (variante macOS, inocua)

cd poc-v2
./run-poc.sh

El runner:

Descarga la CLI vulnerable 29.6.1 si no esta presente.
Construye la imagen Docker copyescape-macos-pocv2:local.
Arranca el contenedor preparado con COPYESCAPE_HOST_HOME=$HOME.
Espera a que /watched/file.txt sea legible dentro del contenedor.
Ejecuta docker cp con la CLI vulnerable.
Verifica la creacion del marcador ~/pwnd.

2. Opciones del runner

./run-poc.sh 10         # 10 intentos (la carrera es probabilistica)
./run-poc.sh --cleanup  # 5 intentos y borra la imagen al final

3. Salida esperada

[run-poc] CLI vulnerable: 29.6.1
[run-poc] Intento 1/5 (contenedor copyescape-pocv2-NNNN-RRRR)
[run-poc]   /watched/file.txt lee: top-level file
[run-poc]   docker cp (CLI 29.6.1)...
[run-poc]   EXITO en intento 1: se creo /Users/<tu-usuario>/pwnd
  Contenido del marcador: COPYESCAPE_MACOS_DEMO
[run-poc]   Logs del monitor:
    [monitor] plataforma=macos target_dir=/Users/<tu-usuario> target_file=/Users/<tu-usuario>/pwnd quiet_ms=400 trigger=aaa.txt
    [monitor] pivoted /watched/file.txt/escape -> /Users/<tu-usuario>
[run-poc] Resumen: 1 exito en 1 intento(s).

4. Limpieza

rm -f -- "$HOME/pwnd"
rm -rf -- poc-v2/file.txt
docker image rm copyescape-macos-pocv2:local

Verificacion de la explotacion

Una vez completada la cadena, los siguientes elementos sirven de evidencia:

Comparativa con el original

Que queda del original

La idea y la estrategia son de masasron: la carrera TOCTOU contra el productor de tar, el camuflaje via LD_PRELOAD, el cebo de 16 MiB, el pivot con dos rename(2), y la estructura escape/ + .swap-escape. Sin ese diseno, esta reescritura no existiria. El esquema conceptual es identico.

Que se ha reescrito

Aproximadamente un 15-20 % son lineas que coinciden literalmente (utilidades cortas y constantes del layout). El resto es codigo nuevo.

Mitigacion

Actualizar la CLI de Docker a 29.7.0 o superior. La PoC deja de funcionar (verificado con 29.7.2).
No ejecutar docker cp desde un contenedor en el que no se confia, y nunca como root en Linux.
Deteccion simple: vigilar la creacion de symlinks absolutos dentro del destino de docker cp durante la extraccion, o bloquear en el daemon los tars que contienen entradas hijas bajo un symlink.
La raiz del bug es la misma clase de fallo que TarSlip / ZipSlip: la CLI no valida que las entradas siguientes no escapen via un symlink ya creado.

Creditos

Investigacion original y divulgacion: masasron — https://github.com/masasron/CopyEscape-CVE-2026-17106
PoC y empaquetado de este repositorio: trabajo propio con fines educativos, reescrito desde cero sobre la idea original.

Licencia

Distribuido bajo licencia MIT. Consulta el archivo LICENSE para mas detalles.

`~/pwnd`	Archivo con contenido `COPYESCAPE_MACOS_DEMO\n`
`poc-v2/file.txt/`	Directorio (no archivo) con `escape -> /Users/<tu-usuario>` (symlink) y `aaa.txt` (16 MiB)
`docker logs <contenedor>`	Linea `pivoted /watched/file.txt/escape -> /Users/<tu-usuario>`
CLI 29.7.2 (`docker cp` con CLI parcheada)	El marcador no se crea; la PoC falla

`watched_preload.c`	89	257	Reescrito: wrappers `openat2`, `fstatat`, `statx`, `stat64`, `lstat64`, `open64`, `fopen64`; constructor thread-safe; guard anti `dlsym == NULL`; `O_TMPFILE`
`monitor.c` (macos + linux)	259 + 233 = 492 (duplicados)	344 (unificado)	Reescrito y unificado con `-DCOPYESCAPE_TARGET_*`; rollback en `try_pivot`; `exit_quiet_ms` y trigger configurables; deteccion robusta
`entrypoint.sh`	3	5	`env -u LD_PRELOAD` en lugar de `unset`
`Dockerfile`	22	43	Unificado; digest pin; `--platform`; sin `-Werror`; `-static`; `LABEL`
`demo-macos.sh` → `run-poc.sh`	88	166	Reescrito: reintentos de carrera; logs en fallo; `--cleanup`; validacion delegada al binario

Más Populares

POC-CopyEscape-CVE-2026-17106