Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
POC-CVE-2025-24813-Apache-Tomcat-Remote-Code-Execution — Este repositório contém um exploit automatizado desenvolvido para fins educacionais e de pesquisa em cibersegurança, destinado a demonstrar uma potencial vulnerabilidade de execução remota de código (RCE) no Apache Tomcat (CVE-2025-24813). | Kitploit
Ferramentas/GitHubGitHub/makavellik/poc-cve-2025-24813-apache-tomcat-remote-code-execution
Análise de VulnerabilidadesExploraçãoExploração de Aplicações WebBypass de WAFTestes de PenetraçãoAprendizado e EducaçãoDesenvolvimento de Payloads
GitHubmakavellik/poc-cve-2025-24813-apache-tomcat-remote-code-execution

POC-CVE-2025-24813-Apache-Tomcat-Remote-Code-Execution

Este repositório contém um exploit automatizado desenvolvido para fins educacionais e de pesquisa em cibersegurança, destinado a demonstrar uma potencial vulnerabilidade de execução remota de código (RCE) no Apache Tomcat (CVE-2025-24813).

Ver Repositório
27há 1 anoAinda não revisado

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

Python License MIT Active Stealth Mode Simbiosis


⚠️🚀 CVE-2025-24813 — Suíte de Exploração RCE Apache Tomcat

root@kitploit:~

⚡ Versão: 1.0 🛡️ CVE ID: CVE-2025-24813 (Apache Tomcat RCE) 🧬 Payloads: ysoserial / Java 🌐 Modo: Interativo + Stealth 🔬 Uso: Ético, Investigativo, Educativo


🌌 Visão Geral

Esta ferramenta foi projetada como uma suíte de exploração futurista focada em:

  • 🔍 Avaliar o Apache Tomcat contra a CVE-2025-24813
  • 🛠️ Automatizar o processo de prova de conceito (PoC)
  • 🧠 Executar payloads personalizados com evasão avançada
  • 🧬 Adaptar-se às defesas modernas (WAFs, detecção, tráfego simulado)

🧪 Projetada para profissionais de cibersegurança, pesquisadores, pentesters e red teams.


🧠 O que este script faz?

🛸 Funcionalidades Principais

✅ Interface interativa e intuitiva

✅ Payloads dinâmicos (ysoserial ou Java compilado)

✅ Headers camaleônicos anti-WAF

✅ Evasão automática + fragmentação de payloads

✅ Fingerprinting de execução no backend

✅ Logging detalhado por alvo

✅ Banner estilo cyberpunk dinâmico (🔮 glitch animation)

✅ Live feedback no console (com Rich & Colorama)


⚙️ Requisitos

Instale os requisitos necessários com:

root@kitploit:~
pip install -r requirements.txt

Dependências:

root@kitploit:~
requests
colorama
rich
validators

E certifique-se de ter:

  • ☕ Java e javac no PATH
  • 📦 ysoserial.jar se você usar o payload do tipo ysoserial

🧪 Modo de Uso

Execute o script:

root@kitploit:~
python3 POC-Exploit_CVE_2025_24813.py

E complete a configuração:

🧬 Selecione o tipo de payload 💣 Especifique o comando 🌐 Insira a URL do alvo 🔧 Ajuste a evasão e a configuração SSL

🎯 Exemplo Visual:

root@kitploit:~
🔗 [?] 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'

🌈 Arquitetura Visual do Script

root@kitploit:~
┌──────────────────────────────┐
│  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: Baseado na conhecida ferramenta ysoserial, serializa gadgets vulneráveis para executar comandos.
  • Java Custom: Compila um .java personalizado que executa o comando remoto a partir do servidor.

Gadgets comuns:

  • CommonsCollections6
  • Spring1
  • Jdk7u21

📁 Estrutura do Projeto

root@kitploit:~
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 Responsável e Ético

Esta ferramenta foi criada exclusivamente para fins legais e educativos.

✅ Permitido:

  • Auditorias de segurança com autorização
  • Laboratórios pessoais e ambientes de teste
  • Pesquisa acadêmica

🚫 Proibido:

  • Uso em sistemas de terceiros sem consentimento
  • Atividades ilegais ou não autorizadas
  • Distribuição com fins maliciosos

⚖️ Isenção de responsabilidade

Nem o autor nem os colaboradores se responsabilizam pelo uso indevido. Você é o responsável pela sua conduta.


🧠 Créditos

  • 👤 Autor: [ByMakaveli]
  • 🔬 Pesquisa: Baseada em técnicas modernas de evasão e exploração Java
  • 🧰 Ferramentas utilizadas: ysoserial, Java, Rich, Colorama, requests

🛰️ CVE Referenciado

📄 CVE-2025-24813: Apache Tomcat Remote Code Execution 🔗 Ver detalhes no CVE MITRE


📜 Licença

root@kitploit:~
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...

Consulte o arquivo LICENSE para mais informações.


💎 Inspiração Visual

Este README e script são projetados para uma experiência imersiva, visual e elegante, em sintonia com uma nova era de cibersegurança futurista e com propósito.

✨ Não apenas exploits... é uma sinfonia técnica de evasão e controle digital.



🔧 Dependências necessárias

1. Python

  • Versão recomendada: Python 3.8+

  • Bibliotecas Python que você deve instalar:

    root@kitploit:~
    pip install requests colorama
    

2. Java

O script usa duas formas de payloads:

  1. Ysoserial → ferramenta Java externa que gera payloads de desserialização.
  2. Compilação própria em Java → quando você seleciona a opção "java" em vez de "ysoserial".

Por isso, você precisa de:

  • Java JDK (não apenas JRE, porque o código é compilado). Verifique com:

    root@kitploit:~
    java -version
    javac -version
    

    Se ambos os comandos funcionarem, você está pronto.


3. Ysoserial

  • Baixe o .jar daqui 👉 https://github.com/frohoff/ysoserial

  • Salve-o no mesmo diretório do script ou informe o caminho completo quando solicitado. Exemplo:

    root@kitploit:~
    java -jar ysoserial.jar CommonsCollections6 "calc.exe" > test.ser
    

4. Sistema operacional

  • No Windows, o payload padrão (calc.exe) abrirá a calculadora.
  • No Linux/Mac, você pode alterar o comando, por exemplo, para gnome-calculator ou xcalc.

⚙️ Resumo de instalação

  1. Instalar Python 3.8+

  2. Instalar bibliotecas:

    root@kitploit:~
    pip install requests colorama etc
    
  3. Instalar Java JDK 8+

    root@kitploit:~
    java -version
    javac -version
    
  4. Baixar ysoserial.jar para a pasta do script.


👉 Com tudo isso, você já poderá executar o script em modo laboratório seguro (somente em ambientes controlados, para testes).


🛡️ README — Tutorial seguro passo a passo

Versão: 1.0 Propósito: Este guia explica como preparar um ambiente totalmente seguro para testar o script que você tem, sem afetar sistemas reais. Inclui um servidor de testes (mock), modo seguro (DRY_RUN / SAFE_TEST) e passos claros para executar a ferramenta em laboratório.


⚠️ Aviso legal e ético (LEIA ANTES DE COMEÇAR)

  • Somente execute em ambientes sob seu controle: máquinas virtuais locais, contêineres ou redes isoladas.
  • Não execute isso contra sistemas de terceiros sem autorização expressa por escrito.
  • Este guia não fornece etapas para explorar servidores reais. Ele foi pensado para testes defensivos e educacionais.

🔍 O que este tutorial contém

  1. Preparar o ambiente Python de forma isolada.
  2. Criar um servidor de testes (mock) que simula as respostas do serviço alvo.
  3. Preparar um payload dummy (inofensivo) para testes.
  4. Adicionar um modo seguro (SAFE_TEST) ao script para que ele não execute ferramentas externas nem realize ações perigosas.
  5. Execução passo a passo e verificação de resultados (logs).
  6. Testes automatizados e boas práticas.

🧾 Requisitos

  • Python 3.8+ instalado.
  • pip disponível.
  • Recomendado: virtualenv ou venv.

Instale as dependências:

root@kitploit:~
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 é usado apenas para o servidor de testes local (mock).


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

Crie um arquivo mock_server.py com este conteúdo. O servidor simula os endpoints que o script espera e retorna estados controlados (200, 409, 500) para que você possa validar a lógica do script sem tocar em servidores reais.

root@kitploit:~
# 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)

Como executá-lo:

root@kitploit:~
python mock_server.py
# El mock quedará escuchando en http://127.0.0.1:8000

📁 2) Preparar um payload dummy (inofensivo)

Para testes, você não precisa gerar payloads reais. Crie um arquivo simples que o script possa enviar:

root@kitploit:~
echo "DUMMY_PAYLOAD" > payload.ser

Este arquivo não contém código executável: serve apenas para validar a lógica de upload e ver as respostas do servidor mock.


⚙️ 3) Adicionar um modo seguro (SAFE_TEST) ao script original

Para evitar que o script invoque utilitários externos (Java/ysoserial) ou execute ações perigosas, adicione este bloco ao início do script principal (antes de qualquer geração/chamada a subprocess):

root@kitploit:~
import os
SAFE_TEST = os.environ.get('SAFE_TEST', '0') == '1'

Em seguida, modifique (ou envolva) as funções de geração/upload para se comportarem de forma segura quando SAFE_TEST for True.

Exemplo de alteração mínima para generate_ysoserial_payload e generate_java_payload:

root@kitploit:~
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 ---

E em upload_and_verify_payload, se SAFE_TEST for True, use o fluxo normal (o mock o aceitará), mas não execute comandos fora do script.

Como ativar SAFE_TEST:

  • Linux/macOS:

    root@kitploit:~
    export SAFE_TEST=1
    
  • Windows (PowerShell):

    root@kitploit:~
    $env:SAFE_TEST = "1"
    

▶️ 4) Execução passo a passo (modo seguro)

  1. Inicie seu ambiente virtual e certifique-se de ter as dependências instaladas (veja a seção Requisitos).

  2. Execute o mock_server.py:

    root@kitploit:~
    python mock_server.py
    
  3. Crie o payload dummy se não usar SAFE_TEST ou se ele não criar o payload por você:

    root@kitploit:~
    echo "DUMMY_PAYLOAD" > payload.ser
    
  4. Ative o modo seguro no terminal:

    root@kitploit:~
    export SAFE_TEST=1   # Linux/macOS
    # o en PowerShell: $env:SAFE_TEST = "1"
    
  5. Execute o script principal:

    root@kitploit:~
    python3 tu_script.py
    
  6. Responda aos prompts (você usará valores de laboratório):

    • Insira a URL do alvo: http://127.0.0.1:8000
    • Digite o comando a executar: deixe o padrão (não será executado em SAFE_TEST)
    • Tipo de payload: ysoserial (o script, com SAFE_TEST=1, criará um payload dummy em vez de invocar ferramentas externas)
    • Caminho para ysoserial.jar: (você pode deixar ysoserial.jar — não será usado no modo seguro)
    • Verificar SSL? no (seu mock usa HTTP)
  7. Observe a saída no console: você deve ver mensagens Server is writable via PUT, Payload uploaded with status 409 e Exploit succeeded! Server returned 500 after deserialization. — isso é apenas no mock e significa que o fluxo lógico do script funciona.

  8. Revise os logs em logs/ — o script salva entradas com marcas de tempo. Por exemplo, logs/127_0_0_1_8000.log (de acordo com o nome do alvo sanitizado).


🔎 5) O que verificar nos testes

  • Que a função check_writable_servlet detecte o PUT bem-sucedido no endpoint /check.txt.
  • Que, ao enviar payload.ser, o mock retorne 409 e que o script depois faça um GET com o cookie JSESSIONID.
  • Que o mock retorne 500 e o script o interprete como sucesso de verificação lógica.
  • Que os logs contenham todas as entradas esperadas e que os arquivos temporários (se houver) sejam removidos.

🧪 6) Testes unitários (recomendação)

  • Use pytest e requests-mock para simular respostas HTTP.

  • Crie testes para:

    • validate_url — entradas válidas/errôneas.
    • retry_request — simular exceções e novas tentativas.
    • detect_waf — simular cabeçalhos Server com e sem assinaturas.
    • upload_and_verify_payload — usar o mock do servidor para validar o fluxo.

Exemplo simples com requests-mock (esqueleto):

root@kitploit:~
# 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

❌ O que NÃO fazer

  • Não execute o script contra alvos externos não autorizados.
  • Não compartilhe payloads ou PoCs funcionais publicamente sem coordenação e divulgação responsável.
  • Não distribua ferramentas que possam automatizar ataques sem controles estritos.

Baixar ferramenta