React2Shell (CVE-2025-55182): vulnerabilidad crítica de ejecución remota de código en React Server Components

Atacante → Solicitud HTTP maliciosa → Endpoint RSC → 
Deserialización insegura → Ejecución de código JavaScript arbitrario

IP: 183.6.80.214
   Duración: 52 minutos
   Solicitudes: 100+
   Acciones:
   - Ejecución de comandos Linux
   - Intentos de escritura en /tmp/pwned.txt
   - Lectura de /etc/passwd

POST /api/route
   next-action: [value]
   rsc-action-id: [value]
   Content-Type: multipart/form-data

Body con patrones sospechosos:

{
     "status": "resolved_model",
     "$@": [...],
     // Payload serializado malicioso
   }

Reglas de Detección WAF

AWS WAF – Regla personalizada ReactJSRCE_CUSTOM:

{
  "Name": "ReactJSRCE_CUSTOM",
  "Priority": 99,
  "Statement": {
    "AndStatement": {
      "Statements": [
        {
          "RegexMatchStatement": {
            "RegexString": "POST",
            "FieldToMatch": { "Method": {} }
          }
        },
        {
          "RegexMatchStatement": {
            "RegexString": "(?i)(?:next-action|rsc-action-id)",
            "FieldToMatch": {
              "Headers": {
                "MatchPattern": { "All": {} },
                "MatchScope": "KEY"
              }
            }
          }
        },
        {
          "RegexMatchStatement": {
            "RegexString": "(?i)\"status\"\\s*:\\s*\"resolved_model\"",
            "FieldToMatch": { "Body": {} },
            "TextTransformations": [
              { "Type": "URL_DECODE_UNI" },
              { "Type": "JS_DECODE" },
              { "Type": "UTF8_TO_UNICODE" }
            ]
          }
        }
      ]
    }
  }
}

Soluciones y Mitigaciones Técnicas

Solución Definitiva: Actualización Inmediata

Para aplicaciones React:

# Verificar versión actual
npm list react

# Actualizar a versión parcheada
npm install react@19.2.1 react-dom@19.2.1

# O usando yarn
yarn upgrade react@19.2.1 react-dom@19.2.1

# O usando pnpm
pnpm update react@19.2.1 react-dom@19.2.1

Para aplicaciones Next.js:

# Next.js 15.x
npm install next@15.1.4

# Next.js 16.x
npm install next@16.0.7

# Si estás en canary 14.3.x
npm install next@14.2.18  # Última versión estable 14.x

Verificación post-actualización:

# Verificar paquetes actualizados
npm list react react-dom next

# Verificar dependencias transitivas
npm ls react-server-dom-webpack
npm ls react-server-dom-turbopack
npm ls react-server-dom-parcel

# Limpiar y reinstalar
rm -rf node_modules package-lock.json
npm install

# Reconstruir aplicación
npm run build

Mitigaciones Temporales (No sustituyen la actualización)

1. Web Application Firewall (WAF)

Cloudflare:

• Protección automática habilitada para todos los clientes
• El tráfico debe pasar a través del proxy de Cloudflare
• IMPORTANTE: Esto NO elimina la vulnerabilidad, solo bloquea intentos conocidos

Google Cloud Armor:

# Crear regla de protección
gcloud compute security-policies rules create 1000 \
    --security-policy=react2shell-protection \
    --expression="request.method == 'POST' && 
                 has(request.headers['next-action']) && 
                 request.body.raw.contains('resolved_model')" \
    --action=deny-403

AWS WAF:

• Versión 1.24+ de AWSManagedRulesKnownBadInputsRuleSet incluye protección
• Implementar regla personalizada del boletín AWS-2025-030

Fastly NGWAF:

• Virtual Patch disponible para CVE-2025-55182
• Detección de «Attack Tooling» habilitada
• Bot Management marca herramientas de ataque como «Suspected Bad Bot»

2. Restricción de Acceso a Endpoints RSC

Configuración de Nginx:

# Bloquear acceso externo a endpoints RSC
location ~* /_next/.*\.(rsc|json)$ {
    deny all;
    return 403;
}

# Permitir solo desde IPs confiables
location ~* /api/ {
    allow 10.0.0.0/8;     # Red interna
    allow 172.16.0.0/12;  # Red corporativa
    deny all;
}

# Rate limiting específico
limit_req_zone $binary_remote_addr zone=rsc_limit:10m rate=10r/s;
location ~* /_next/ {
    limit_req zone=rsc_limit burst=20 nodelay;
}

Configuración de Apache:

# Bloquear patrones de explotación conocidos
<LocationMatch "^/_next/.*\.(rsc|json)$">
    Require all denied
</LocationMatch>

# Filtrar headers sospechosos
RewriteEngine On
RewriteCond %{HTTP:next-action} .+
RewriteCond %{HTTP:rsc-action-id} .+
RewriteRule .* - [F,L]

3. Monitoreo y Detección

Script de detección de intentos de explotación (Node.js):

// middleware/react2shell-detector.js
export function detectReact2ShellAttempt(req, res, next) {
  const suspiciousHeaders = [
    'next-action',
    'rsc-action-id'
  ];
  
  const haseSuspiciousHeaders = suspiciousHeaders.some(
    header => req.headers[header]
  );
  
  const hasSuspiciousBody = req.body && 
    typeof req.body === 'string' && 
    (req.body.includes('resolved_model') || 
     req.body.includes('$@'));
  
  if (req.method === 'POST' && 
      hasSuspiciousHeaders && 
      hasSuspiciousBody) {
    
    console.error('[SECURITY] Posible intento de explotación React2Shell:', {
      ip: req.ip,
      headers: req.headers,
      timestamp: new Date().toISOString()
    });
    
    // Bloquear y alertar
    return res.status(403).json({ 
      error: 'Request blocked for security reasons' 
    });
  }
  
  next();
}

Query de búsqueda en logs (ejemplo para Elasticsearch/Kibana):

POST AND (next-action OR rsc-action-id) AND 
(resolved_model OR "$@") AND 
(status:403 OR status:500)

Script de verificación de vulnerabilidad:

#!/bin/bash
# check-react2shell.sh

echo "Verificando vulnerabilidad React2Shell..."

# Verificar versiones de React
REACT_VERSION=$(npm list react --depth=0 2>/dev/null | grep react@ | sed 's/.*@//')
echo "Versión de React: $REACT_VERSION"

# Verificar versiones vulnerables
if [[ "$REACT_VERSION" =~ ^19\.(0\.0|1\.[01]|2\.0)$ ]]; then
    echo "❌ VULNERABLE - Actualizar inmediatamente a 19.0.1, 19.1.2 o 19.2.1"
    exit 1
fi

# Verificar Next.js
NEXT_VERSION=$(npm list next --depth=0 2>/dev/null | grep next@ | sed 's/.*@//')
echo "Versión de Next.js: $NEXT_VERSION"

if [[ "$NEXT_VERSION" =~ ^15\. ]] && [[ ! "$NEXT_VERSION" =~ ^15\.1\.[4-9]|^15\.[2-9] ]]; then
    echo "❌ VULNERABLE - Actualizar a Next.js 15.1.4 o superior"
    exit 1
elif [[ "$NEXT_VERSION" =~ ^16\. ]] && [[ ! "$NEXT_VERSION" =~ ^16\.0\.[7-9]|^16\.[1-9] ]]; then
    echo "❌ VULNERABLE - Actualizar a Next.js 16.0.7 o superior"
    exit 1
fi

echo "✅ No se detectaron versiones vulnerables conocidas"
exit 0

Detección de Compromiso

Indicadores de compromiso (IOCs):

1. Patrones en logs de servidor:
   

   - Solicitudes POST inusuales a endpoints /_next/
      - Headers: next-action, rsc-action-id presentes
      - Errores 500 en endpoints RSC
      - Picos de tráfico desde IPs asiáticas
      - User-agents rotando aleatoriamente

2. Comportamiento del sistema:
   

   - Procesos node no autorizados
      - Conexiones salientes a IPs chinas
      - Archivos creados en /tmp/
      - Lecturas de /etc/passwd, /etc/shadow
      - Modificaciones de variables de entorno

    

Análisis forense:

# Buscar archivos modificados recientemente
   find /app -type f -mtime -1
   
   # Revisar procesos sospechosos
   ps aux | grep node | grep -v "grep"
   
   # Verificar conexiones de red
   netstat -antp | grep ESTABLISHED
   
   # Revisar logs del sistema
   journalctl -u nginx -S "2025-12-03" | grep POST | grep "_next"

Consideraciones Adicionales para Desarrolladores

Revisión de Código

Puntos a verificar en tu aplicación:

// ¿Usas Server Components?
// app/page.js
export default async function Page() {
  const data = await fetch('...'); // Componente de servidor
  return <div>{data}</div>;
}

// ¿Tienes Server Actions?
// app/actions.js
'use server'
export async function createUser(formData) {
  // Este código se ejecuta en el servidor
  // Es un endpoint RSC potencialmente vulnerable
}

// ¿Usas App Router en Next.js?
// Si tienes carpeta app/ en lugar de pages/, estás usando App Router

Best Practices de Seguridad para RSC

1. Validación de entrada:
   

   'use server'
   
   import { z } from 'zod';
   
   const userSchema = z.object({
     email: z.string().email(),
     name: z.string().min(1).max(100)
   });
   
   export async function createUser(formData) {
     // Validar SIEMPRE los datos del cliente
     const validated = userSchema.parse({
       email: formData.get('email'),
       name: formData.get('name')
     });
     
     // Procesar solo datos validados
     return await db.user.create(validated);
   }

2. Sanitización de datos:
   

   'use server'
   
   import DOMPurify from 'isomorphic-dompurify';
   
   export async function processContent(content) {
     // Sanitizar contenido HTML
     const clean = DOMPurify.sanitize(content);
     
     // Escapar SQL si es necesario
     const escaped = db.escape(clean);
     
     return escaped;
   }

    

Rate limiting en Server Actions:

'use server'

import { ratelimit } from '@/lib/redis';

export async function sensitiveAction(userId) {
  const { success } = await ratelimit.limit(userId);
  
  if (!success) {
    throw new Error('Too many requests');
  }
  
  // Proceder con la acción
}

Testing de Seguridad

Script de test de vulnerabilidad (NO ejecutar en producción):

// __tests__/security/react2shell.test.js
import { testReact2ShellVulnerability } from '@/tests/security-utils';

describe('React2Shell Security Tests', () => {
  it('should block malicious RSC payloads', async () => {
    const maliciousPayload = {
      headers: {
        'next-action': 'test',
        'rsc-action-id': 'test'
      },
      body: JSON.stringify({
        status: 'resolved_model',
        '$@': ['malicious']
      })
    };
    
    const response = await fetch('/api/test', {
      method: 'POST',
      ...maliciousPayload
    });
    
    expect(response.status).toBe(403);
  });
});

Recomendaciones por Tipo de Infraestructura

AWS

Acciones inmediatas:

1. Aplicar regla WAF AWSManagedRulesKnownBadInputsRuleSet v1.24+
2. Implementar regla personalizada del boletín AWS-2025-030
3. Revisar CloudWatch Logs para patrones de ataque
4. Actualizar aplicaciones en EC2, ECS, Lambda

Verificación:

# Verificar versión de WAF
aws wafv2 describe-managed-rule-group \
  --name AWSManagedRulesKnownBadInputsRuleSet \
  --scope REGIONAL \
  --region us-east-1

# Buscar logs sospechosos en CloudWatch
aws logs filter-log-events \
  --log-group-name /aws/lambda/your-function \
  --filter-pattern "next-action"

Google Cloud

Acciones inmediatas:

1. Habilitar Cloud Armor con regla específica para CVE-2025-55182
2. Firebase Hosting/App Hosting ya tienen protección automática
3. Verificar Cloud Functions que usan React/Next.js
4. Actualizar dependencias en Cloud Run

Configuración Cloud Armor:

gcloud compute security-policies rules create 1000 \
    --security-policy my-policy \
    --src-ip-ranges="0.0.0.0/0" \
    --action=deny-403 \
    --description="Block React2Shell CVE-2025-55182" \
    --expression="evaluatePreconfiguredExpr('cve-2025-55182')"

Vercel

Protección automática:

• WAF de Vercel activado automáticamente para todos los proyectos
• IMPORTANTE: Aún así debes actualizar tu aplicación

Verificación en Vercel:

# Verificar versión de Next.js en Vercel
vercel env pull .env.production
cat .env.production | grep NEXT

# Desplegar versión actualizada
vercel --prod

Docker/Kubernetes

Actualización de imágenes:

# Dockerfile actualizado
FROM node:20-alpine

WORKDIR /app

COPY package*.json ./

# Forzar instalación de versiones seguras
RUN npm install react@19.2.1 \
                react-dom@19.2.1 \
                next@15.1.4

COPY . .

RUN npm run build

CMD ["npm", "start"]

Kubernetes Security Policy:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: block-rsc-exploit
spec:
  podSelector:
    matchLabels:
      app: nextjs-app
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: trusted-proxy
    ports:
    - protocol: TCP
      port: 3000

Recursos y Referencias Oficiales

Advisories Oficiales

• React Team: https://react.dev/blog/2025/12/03/critical-security-vulnerability-in-react-server-components
• Vercel/Next.js: https://vercel.com/changelog/cve-2025-55182
• Meta Security: https://www.facebook.com/security/advisories/cve-2025-55182
• NIST NVD: https://nvd.nist.gov/vuln/detail/CVE-2025-55182
• CISA KEV: https://www.cisa.gov/known-exploited-vulnerabilities-catalog

Research y Análisis

• AWS Threat Intelligence: https://aws.amazon.com/blogs/security/china-nexus-cyber-threat-groups-rapidly-exploit-react2shell-vulnerability-cve-2025-55182/
• Wiz Research: https://www.wiz.io/blog/critical-vulnerability-in-react-cve-2025-55182
• Lachlan Davidson (Discoverer): https://react2shell.com/

Herramientas de Detección

• Tenable Plugins: https://www.tenable.com/plugins/search?q=CVE-2025-55182
• Snyk Advisories: https://security.snyk.io/vuln/SNYK-JS-REACTSERVERDOMWEBPACK-14173285
• Rapid7 AttackerKB: https://attackerkb.com/topics/cve-2025-55182

Conclusión

CVE-2025-55182 (React2Shell) representa una amenaza crítica y activa para aplicaciones modernas basadas en React y Next.js. Con un CVSS de 10.0 y explotación confirmada en la naturaleza por grupos APT respaldados por estados nacionales, la actualización inmediata no es opcional.

Acciones críticas ahora:

1. ✅ Actualizar React a 19.0.1, 19.1.2 o 19.2.1
2. ✅ Actualizar Next.js a 15.1.4+ o 16.0.7+
3. ✅ Implementar reglas WAF como mitigación temporal
4. ✅ Monitorear logs para signos de compromiso
5. ✅ Verificar todos los frameworks dependientes
6. ✅ Realizar análisis forense si hay sospecha de compromiso

El ecosistema JavaScript moderno se mueve rápido, y las amenazas también. Esta vulnerabilidad subraya la importancia crítica de:

• Mantenimiento proactivo de dependencias
• Monitoreo continuo de seguridad
• Respuesta rápida a divulgaciones de vulnerabilidades
• Implementación de defensa en profundidad

La ventana de oportunidad para los atacantes se está cerrando, pero solo si actuamos con rapidez.

Autor: Equipo de Seguridad de CodersLab
Tags: #React #NextJS #CVE202555182 #React2Shell #RCE #Ciberseguridad #Vulnerabilidad #ServerComponents #APT #China