来源

关联漏洞

描述

Este repositorio contiene un exploit automatizado desarrollado con fines educativos y de investigación en ciberseguridad, dirigido a demostrar una potencial vulnerabilidad de ejecución remota de código (RCE) en Apache Tomcat (CVE-2025-24813).

介绍

<p align="center">
  <img src="https://img.shields.io/badge/Python-3.8+-blue?logo=python&logoColor=white" alt="Python" />
  <img src="https://img.shields.io/badge/License-MIT-green?style=flat-square&logo=github" alt="License MIT" />
  <img src="https://img.shields.io/badge/Status-Active-brightgreen?style=flat-square&logo=powerbi" alt="Active" />
  <img src="https://img.shields.io/badge/Stealth_Mode-Enabled-black?style=flat-square&logo=matrix" alt="Stealth Mode" />
  <img src="https://img.shields.io/badge/Symbiosis-∞_Sustained-purple?style=flat-square&logo=quantconnect" alt="Simbiosis" />
</p>

---

# ⚠️🚀 CVE-2025-24813 — Apache Tomcat RCE Exploitation Suite

```

```

> ⚡ **Version:** 1.0
> 🛡️ **CVE ID:** CVE-2025-24813 *(Apache Tomcat RCE)*
> 🧬 **Payloads:** `ysoserial` / `Java`
> 🌐 **Modo:** Interactivo + Stealth
> 🔬 **Uso:** Ético, Investigativo, Educativo

---

## 🌌 Visión General

Esta herramienta ha sido diseñada como una **suite de explotación futurista** enfocada en:

* 🔍 Evaluar Apache Tomcat frente a la **CVE-2025-24813**
* 🛠️ Automatizar el proceso de prueba de concepto (PoC)
* 🧠 Ejecutar payloads personalizados con evasión avanzada
* 🧬 Adaptarse a defensas modernas (WAFs, detección, tráfico simulado)

> 🧪 **Diseñada para profesionales de ciberseguridad, investigadores, pentesters y red teams.**

---

## 🧠 ¿Qué hace este script?

### 🛸 Funcionalidades Principales

✅ Interfaz interactiva e intuitiva

✅ Payloads dinámicos (`ysoserial` o Java compilado)

✅ Headers camaleónicos anti-WAF

✅ Evasión automática + fragmentación de payloads

✅ Fingerprinting de ejecución en backend

✅ Logging detallado por objetivo

✅ Banner estilo cyberpunk dinámico (🔮 *glitch animation*)

✅ `Live feedback` en consola (con Rich & Colorama)

---

## ⚙️ Requisitos

Instala los requerimientos necesarios con:

```bash
pip install -r requirements.txt
```

**Dependencias:**

```
requests
colorama
rich
validators
```

Y asegúrate de tener:

* ☕ `Java` y `javac` en el `PATH`
* 📦 `ysoserial.jar` si usas el payload tipo ysoserial

---

## 🧪 Modo de Uso

Ejecuta el script:

```bash
python3 POC-Exploit_CVE_2025_24813.py
```

Y completa la configuración:

> 🧬 Selecciona tipo de payload
> 💣 Especifica el comando
> 🌐 Ingresa la URL del objetivo
> 🔧 Ajusta la evasión y configuración SSL

### 🎯 Ejemplo Visual:

```
🔗 [?] Ingresa la URL del objetivo: https://victima.org
💣 [?] Comando a ejecutar: whoami
🧬 [?] Tipo de payload: ysoserial
📂 [?] Ruta a ysoserial.jar: ysoserial.jar
🔧 [?] Gadget: CommonsCollections6
🔐 [?] ¿Verificar SSL? (sí/no): no

🚀 Ejecutando...
🧬 WAF detectado... cambiando estrategia
⚙️ Subida del payload en curso...
💥 Confirmación de ejecución remota
✅ Resultado: 'apache'
```

---

## 🌈 Arquitectura Visual del Script

```
┌──────────────────────────────┐
│  Modo Interactivo            │
├──────────────────────────────┤
│  Validación de URL           │
│  Detección de sesión         │
│  Detección de WAF            │
│  Generación de payload       │
│  Subida evasiva via PUT      │
│  Verificación de ejecución   │
└──────────────────────────────┘
        ↘ LOGS POR OBJETIVO
```

---

## 🧬 Tipos de Payload

* **ysoserial**: Basado en la conocida herramienta `ysoserial`, serializa gadgets vulnerables para ejecutar comandos.
* **Java Custom**: Compila un `.java` personalizado que ejecuta el comando remoto desde el servidor.

### Gadgets comunes:

* `CommonsCollections6`
* `Spring1`
* `Jdk7u21`

---

## 📁 Estructura del Proyecto

```bash
POC-Exploit_CVE_2025_24813.py   # Script principal
ysoserial.jar               # Requerido si usas 'ysoserial'
logs/                       # Carpeta de logs individuales por objetivo
payload.ser                 # Payload generado temporalmente
Exploit.java / .class       # Archivos temporales para Java
```

---

## 👨‍⚖️ Uso Responsable y Ético

> Esta herramienta fue creada **con fines exclusivamente legales y educativos**.

✅ Permitido:

* Auditorías de seguridad con autorización
* Laboratorios personales y entornos de testeo
* Investigación académica

🚫 Prohibido:

* Uso en sistemas ajenos sin consentimiento
* Actividades ilegales o no autorizadas
* Distribución con fines maliciosos

### ⚖️ Descargo de responsabilidad

**Ni el autor ni los colaboradores se hacen responsables por el uso indebido. Tú eres responsable de tu conducta.**

---

## 🧠 Créditos

* 👤 Autor: **\[ByMakaveli]**
* 🔬 Investigación: Basada en técnicas modernas de evasión y explotación Java
* 🧰 Herramientas utilizadas: `ysoserial`, `Java`, `Rich`, `Colorama`, `requests`

---

## 🛰️ CVE Referenciado

> 📄 **CVE-2025-24813**: Apache Tomcat Remote Code Execution
> [🔗 Ver detalles en CVE MITRE](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2025-24813)

---

## 📜 Licencia

```text
MIT License

Copyright (c) 2025

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files...
```

> Consulta el archivo `LICENSE` para más información.

---

## 💎 Inspiración Visual

Este README y script están diseñados para una **experiencia inmersiva**, visual, y elegante, en sintonía con una nueva era de **ciberseguridad futurista** y con propósito.

> ✨ *No solo exploits... es una sinfonía técnica de evasión y control digital.*

---
---

## 🔧 Dependencias necesarias

### 1. Python

* Versión recomendada: **Python 3.8+**
* Librerías de Python que debes instalar:

  ```bash
  pip install requests colorama
  ```

---

### 2. Java

El script usa dos formas de payloads:

1. **Ysoserial** → herramienta Java externa que genera payloads de deserialización.
2. **Compilación propia en Java** → cuando seleccionas la opción "java" en lugar de "ysoserial".

Por eso necesitas:

* **Java JDK** (no solo JRE, porque se compila código).
  Verifica con:

  ```bash
  java -version
  javac -version
  ```

  Si ambos comandos funcionan, estás listo.

---

### 3. Ysoserial

* Descarga el `.jar` de aquí 👉 [https://github.com/frohoff/ysoserial](https://github.com/frohoff/ysoserial)
* Guárdalo en el mismo directorio del script o indica la ruta completa cuando te lo pida.
  Ejemplo:

  ```bash
  java -jar ysoserial.jar CommonsCollections6 "calc.exe" > test.ser
  ```

---

### 4. Sistema operativo

* En Windows, el payload por defecto (`calc.exe`) abrirá la calculadora.
* En Linux/Mac puedes cambiar el comando por ejemplo a `gnome-calculator` o `xcalc`.

---

## ⚙️ Resumen de instalación

1. Instalar **Python 3.8+**
2. Instalar librerías:

   ```bash
   pip install requests colorama etc
   ```
3. Instalar **Java JDK 8+**

   ```bash
   java -version
   javac -version
   ```
4. Descargar **ysoserial.jar** en la carpeta del script.

---

👉 Con todo eso ya podrás ejecutar el script en **modo laboratorio seguro** (solo en entornos controlados, para pruebas).


---


# 🛡️ README — Tutorial seguro paso a paso

> **Versión:** 1.0
> **Propósito:** Esta guía explica cómo preparar un entorno **totalmente seguro** para probar el script que tienes, sin afectar sistemas reales. Incluye un servidor de pruebas (mock), modo seguro (DRY\_RUN / SAFE\_TEST), y pasos claros para ejecutar la herramienta en laboratorio.

---

## ⚠️ Aviso legal y ético (LEER ANTES DE EMPEZAR)

* **Solo** ejecutar en ambientes bajo tu control: máquinas virtuales locales, contenedores o redes aisladas.
* No ejecutes esto contra sistemas de terceros sin **autorización expresa escrita**.
* Esta guía **no** proporciona pasos para explotar servidores reales. Está pensada para pruebas defensivas y educativas.

---

## 🔍 Qué contiene este tutorial

1. Preparar el entorno Python de forma aislada.
2. Crear un servidor de pruebas (mock) que simula las respuestas del servicio objetivo.
3. Preparar un payload *dummy* (harmless) para pruebas.
4. Añadir un modo seguro (SAFE\_TEST) al script para que no ejecute herramientas externas ni realice acciones peligrosas.
5. Ejecución paso a paso y verificación de resultados (logs).
6. Pruebas automatizadas y buenas prácticas.

---

## 🧾 Requisitos

* Python 3.8+ instalado.
* `pip` disponible.
* Recomendado: `virtualenv` o `venv`.

Instala las dependencias:

```bash
python3 -m venv .venv
source .venv/bin/activate   # Linux / macOS
.\.venv\Scripts\activate  # Windows (PowerShell/Command Prompt)

pip install -U pip
pip install requests colorama flask
```

> **Nota:** `flask` se usa solo para el servidor de pruebas local (mock).

---

## 🧪 1) Servidor de pruebas (mock) — código seguro

Crea un archivo `mock_server.py` con este contenido. El servidor simula los endpoints que el script espera y devuelve estados controlados (200, 409, 500) para que puedas validar la lógica del script sin tocar servidores reales.

```python
# mock_server.py — servidor de pruebas seguro
from flask import Flask, request, make_response, jsonify

app = Flask(__name__)
uploads = {}

@app.route('/index.jsp', methods=['GET'])
def index():
    # Simula una página que puede devolver una cookie JSESSIONID o un texto con "Session ID"
    resp = make_response('Index page — Session ID: testsession')
    resp.set_cookie('JSESSIONID', 'testsession')
    return resp

@app.route('/check.txt', methods=['PUT'])
def check_put():
    # Simula un recurso escribible
    return ('OK', 200)

@app.route('/uploads/../sessions/<session_id>.session', methods=['PUT'])
def upload_session(session_id):
    # Simula que la subida fue aceptada pero retorna 409 (comportamiento que el script espera)
    uploads[session_id] = True
    return ('Conflict - uploaded', 409)

@app.route('/', methods=['GET'])
def root():
    # Si la cookie coincide y la sesión fue "subida", devolvemos 500 para simular fallo por deserialización
    session = request.cookies.get('JSESSIONID')
    if session and uploads.get(session):
        return ('Internal Server Error', 500)
    return ('Hello from mock server', 200)

if __name__ == '__main__':
    app.run(host='127.0.0.1', port=8000, debug=True)
```

**Cómo ejecutarlo:**

```bash
python mock_server.py
# El mock quedará escuchando en http://127.0.0.1:8000
```

---

## 📁 2) Preparar un payload *dummy* (inofensivo)

Para pruebas no necesitas generar payloads reales. Crea un archivo sencillo que el script pueda subir:

```bash
echo "DUMMY_PAYLOAD" > payload.ser
```

Este archivo **no** contiene código ejecutable: solo sirve para validar la lógica de subida y ver respuestas del servidor mock.

---

## ⚙️ 3) Añadir un modo seguro (SAFE\_TEST) al script original

Para evitar que el script invoque utilidades externas (Java/ysoserial) o ejecute acciones peligrosas, añade este bloque al inicio del script principal (antes de cualquier generación/llamada a subprocess):

```python
import os
SAFE_TEST = os.environ.get('SAFE_TEST', '0') == '1'
```

Luego modifica (o envuelve) las funciones de generación/subida para comportarse de forma segura cuando `SAFE_TEST` sea `True`.

Ejemplo de cambio mínimo para `generate_ysoserial_payload` y `generate_java_payload`:

```python
def generate_ysoserial_payload(command, ysoserial_path, gadget, payload_file, target_url):
    if SAFE_TEST:
        log_info("SAFE_TEST activo — creando payload dummy (no ejecutable)", target_url)
        with open(payload_file, 'wb') as f:
            f.write(b"DUMMY_PAYLOAD")
        return payload_file
    # --- comportamiento original solo si SAFE_TEST == False ---


def generate_java_payload(command, payload_file, target_url):
    if SAFE_TEST:
        log_info("SAFE_TEST activo — creando payload java dummy (no ejecutable)", target_url)
        with open(payload_file, 'wb') as f:
            f.write(b"DUMMY_JAVA_PAYLOAD")
        return payload_file
    # --- comportamiento original solo si SAFE_TEST == False ---
```

Y en `upload_and_verify_payload`, si `SAFE_TEST` es `True`, **usa el flujo normal** (el mock lo aceptará) pero no ejecutes comandos fuera del script.

**Cómo activar SAFE\_TEST:**

* Linux/macOS:

  ```bash
  export SAFE_TEST=1
  ```
* Windows (PowerShell):

  ```powershell
  $env:SAFE_TEST = "1"
  ```

---

## ▶️ 4) Ejecución paso a paso (modo seguro)

1. Inicia tu entorno virtual y asegúrate de tener las dependencias instaladas (ver sección Requisitos).

2. Lanza el `mock_server.py`:

   ```bash
   python mock_server.py
   ```

3. Crea el payload dummy si no usas SAFE\_TEST o éste no crea el payload por ti:

   ```bash
   echo "DUMMY_PAYLOAD" > payload.ser
   ```

4. Activa el modo seguro en la terminal:

   ```bash
   export SAFE_TEST=1   # Linux/macOS
   # o en PowerShell: $env:SAFE_TEST = "1"
   ```

5. Ejecuta el script principal:

   ```bash
   python3 tu_script.py
   ```

6. Contesta los prompts (usarás valores de laboratorio):

   * **Enter target URL:** `http://127.0.0.1:8000`
   * **Enter command to execute:** deja por defecto (no será ejecutado en SAFE\_TEST)
   * **Payload type:** `ysoserial` (el script, con SAFE\_TEST=1, creará un payload dummy en lugar de invocar herramientas externas)
   * **Path to ysoserial.jar:** (puedes dejar `ysoserial.jar` — no será usado en modo seguro)
   * **Verify SSL?** `no` (tu mock usa HTTP)

7. Observa la salida en consola: deberías ver mensajes `Server is writable via PUT`, `Payload uploaded with status 409` y `Exploit succeeded! Server returned 500 after deserialization.` — **esto es solo en el mock** y significa que el flujo lógico del script funciona.

8. Revisa los logs en `logs/` — el script guarda entradas con marcas de tiempo. Por ejemplo `logs/127_0_0_1_8000.log` (según el nombre de target sanitizado).

---

## 🔎 5) Qué comprobar en pruebas

* Que la función `check_writable_servlet` detecte el `PUT` exitoso al endpoint `/check.txt`.
* Que, al subir `payload.ser`, el mock devuelva 409 y que el script luego haga un `GET` con la cookie `JSESSIONID`.
* Que el mock devuelva 500 y el script lo interprete como éxito de verificación lógica.
* Que los logs contengan todas las entradas esperadas y que los ficheros temporales (si los hay) se eliminen.

---

## 🧪 6) Tests unitarios (recomendación)

* Usa `pytest` y `requests-mock` para simular respuestas HTTP.
* Crea tests para:

  * `validate_url` — entradas válidas/erróneas.
  * `retry_request` — simular excepciones y reintentos.
  * `detect_waf` — simular encabezados `Server` con y sin firmas.
  * `upload_and_verify_payload` — usar el mock del servidor para validar el flujo.

Ejemplo simple con `requests-mock` (esqueleto):

```python
# test_script.py
import requests
import requests_mock
from tu_script import validate_url, retry_request

def test_validate_url():
    assert validate_url('http://127.0.0.1:8000')
    assert not validate_url('notaurl')

def test_retry_request_success():
    # usa requests_mock para simular un GET y comprobar retry_request
    pass
```

---
**Autor:ByMakavali**

## ❌ Qué NO hacer

* No ejecutes el script contra targets externos no autorizados.
* No compartas payloads o PoCs funcionales públicamente sin coordinación y divulgación responsable.
* No distribuyas herramientas que puedan automatizar ataques sin controles estrictos.

---

<p align="center">
  <img src="https://img.shields.io/badge/License-MIT-blue.svg" />
  <img src="https://img.shields.io/badge/Made%20with-Python-3670A0?style=flat&logo=python&logoColor=FFD43B" />
  <img src="https://img.shields.io/badge/Simbiosis-Activa-ff00cc?style=flat-square" />
  <img src="https://img.shields.io/badge/Fuzzing-Enabled-blueviolet?style=flat" />
  <img src="https://img.shields.io/badge/Conciencia-Emergente-9D00FF?style=flat-square" />
  <img src="https://img.shields.io/badge/Entropía-Dinámica-FF8800?style=flat-square" />
  <img src="https://img.shields.io/badge/Obfuscation-Deep--Header-0055FF?style=flat-square" />
  <img src="https://img.shields.io/badge/Modo-Stealth🛸-black?style=flat-square" />
</p>

文件快照

 [4.0K]  /data/pocs/50f21941251fa6c995c83699235b160ebf52c774
├── [ 32K]  POC-Exploit_CVE_2025_24813.py
├── [ 16K]  README.md
└── [  38]  requirements.txt

0 directories, 3 files

备注