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
CVE-2025-61882-Oracle-E-Business-Suite-Pre-Auth-RCE-Exploit — Uma falha crítica de Execução Remota de Código (RCE) pré-autenticação no Oracle E-Business Suite (versões 12.2.3 - 12.2.14) permite que atacantes obtenham controle total sobre servidores vulneráveis por meio de solicitações HTTP maliciosas — agora ativamente explorada na natureza. | Kitploit
Ferramentas/GitHubGitHub/adityabhatt3010/cve-2025-61882-oracle-e-business-suite-pre-auth-rce-exploit
Análise de VulnerabilidadesExploraçãoAnálise ForenseSegurança WebInteligência de AmeaçasResposta a IncidentesAnálise de Logs
GitHubadityabhatt3010/cve-2025-61882-oracle-e-business-suite-pre-auth-rce-exploit

CVE-2025-61882-Oracle-E-Business-Suite-Pre-Auth-RCE-Exploit

Ver Repositório
12há 10 mesesAinda 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 →

Sobre

Uma falha crítica de Execução Remota de Código (RCE) pré-autenticação no Oracle E-Business Suite (versões 12.2.3 - 12.2.14) permite que atacantes obtenham controle total sobre servidores vulneráveis por meio de solicitações HTTP maliciosas — agora ativamente explorada na natureza.

Compartilhar

CVE-2025-61882 - Exploração de RCE Pré-Autenticação no Oracle E-Business Suite

Uma falha crítica de Execução Remota de Código (RCE) pré-autenticação no Oracle E-Business Suite (versões 12.2.3–12.2.14) permite que atacantes obtenham controle total sobre servidores vulneráveis por meio de requisições HTTP maliciosas — agora explorada ativamente na natureza.


TL;DR

CVE-2025-61882 é uma RCE crítica, pré-autenticação no Oracle E-Business Suite (EBS) explorada ativamente em campanhas de extorsão/roubo de dados. Versões afetadas: 12.2.3 → 12.2.14. A Oracle publicou um alerta de emergência com IOCs (IPs, comando de shell-stager, SHA-256s). Aplique o patch ou proteja os sistemas expostos imediatamente, busque com as detecções fornecidas e use o script Python seguro abaixo para analisar logs. Não execute PoCs públicos em produção — teste apenas em laboratório isolado com autorização. 🛑🗿

Cover



Por que isso importa

O Oracle EBS executa funções críticas de negócio (ERP, folha de pagamento, finanças, RH). Uma RCE pré-autenticação em uma instância EBS exposta à web permite que um atacante execute comandos arbitrários no servidor de aplicação, potencialmente acesse dados sensíveis, instale webshells e exfiltre arquivos. Esta vulnerabilidade foi armamentizada na natureza e associada a campanhas de extorsão — é um incidente de negócio real, não um CVE teórico. 🔥


Resumo técnico (curto)

  • Tipo: Execução Remota de Código (RCE) pré-autenticação
  • Produto: Oracle E-Business Suite (EBS)
  • Versões afetadas: 12.2.3 → 12.2.14
  • Superfície de ataque: Componentes expostos à web — UiServlet, fluxos /OA_HTML/ e endpoints relacionados
  • CVSS (aproximado): 9.8 — trate como crítico
  • Exploração: Requisições HTTP elaboradas que levam à execução de comandos no servidor de aplicação; múltiplos padrões de exploração observados na natureza

Linha do tempo (condensada)

  • Vulnerabilidade descoberta e explorada em 2025.
  • A Oracle lançou um alerta de emergência e patches logo após relatos públicos de exploração.
  • Múltiplos fornecedores publicaram orientações de detecção e IOCs.
  • PoCs públicos circularam — manuseie com extrema cautela. ⚠️

Comportamento observado do atacante (TTPs)

  • Varredura de interfaces EBS e divulgação de versões.
  • Envio de POSTs/requisições elaboradas para UiServlet e /OA_HTML/ para acionar RCE.
  • Implantação de stagers/webshells e abertura de reverse shells (ex.: /bin/bash -i >& /dev/tcp/...).
  • Compactação e exfiltração de arquivos sensíveis, seguida de extorsão e demandas de vazamento de dados.
  • Uso de infraestrutura vinculada a grupos de extorsão conhecidos.

IOCs fornecidos pela Oracle (use imediatamente)

A Oracle observa que estes IOCs são atividade observada em incidentes (não limitados ao CVE-2025-61882). Trate qualquer correspondência positiva como alta prioridade.

IPs

  • 200.107.207.26 — Possível atividade GET/POST
  • 185.181.60.11 — Possível atividade GET/POST

Padrão de shell stager

  • sh -c /bin/bash -i >& /dev/tcp// 0>&1 — comando observado de reverse shell TCP de saída

Hashes SHA-256 (artefatos de exploração / PoC)

  • 76b6d36e04e367a2334c445b51e1ecce97e4c614e88dfb4f72b104ca0f31235d (oracle_ebs_nday_exploit_poc_scattered_lapsus_retard_cl0p_hunters.zip)
  • aa0d3859d6633b62bccfb69017d33a8979a3be1f3f0a5a4bf6960d6c73d41121 (.../exp.py)
  • 6fd538e4a8e3493dda6f9fcdc96e814bdd14f3e2ef8aa46f0143bff34b882c1b (.../server.py)

Versões afetadas (repetido para ênfase)

  • Oracle E-Business Suite 12.2.3 — 12.2.14. 🔁

Regras de detecção e correlação de alta prioridade (pontos de partida práticos)

TL;DR O Repositório GitHub contém artefatos de detecção passiva para CVE-2025-61882 (RCE pré-autenticação no Oracle E-Business Suite). Use-os para caçar, triar e conter — não para explorar. 🛑🗿

Uma breve Description.md (mini-README) já foi adicionada dentro da pasta detections/ — verifique esse arquivo para o writeup completo e TL;DR. Este README de nível superior apenas resume o pacote de detecção e o uso para que você possa pegar e executar rapidamente.

O que há neste pacote

  • detections/splunk/

    • oracle_cve61882_ioc_traffic.spl — Detecta tráfego de/para IPs IOC fornecidos pela Oracle.
    • oracle_cve61882_uiservlet_post.spl — Detecta POSTs suspeitos para UiServlet / /OA_HTML/ de IPs externos.
    • oracle_cve61882_reverse_shell.spl — Detecta criação de processos estilo reverse shell em logs de endpoints.
  • detections/elastic/

    • oracle_cve61882_uiservlet_post.kql — KQL para POSTs UiServlet/OA_HTML.
    • oracle_cve61882_filehash_detection.kql — KQL para corresponder aos SHA-256 maliciosos fornecidos pela Oracle.
  • detections/scripts/

    • ebs_safe_hunt.py — Analisador de logs Python seguro e offline (sem chamadas de rede, sem execução de exploração). Execute contra cópias dos seus logs de acesso.
  • detections/Description.md

    • O mini writeup/TL;DR que você adicionou — contém o contexto completo, IOCs, versões afetadas e orientações.

Início rápido

  1. Revise detections/Description.md para contexto e IOCs. ✅

  2. Coloque as consultas .spl do Splunk no seu ambiente Splunk (ou importe-as em pesquisas salvas / alertas).

  3. Cole as consultas KQL nas regras de detecção do Kibana / Elastic.

  4. Copie ebs_safe_hunt.py para um host que somente tenha acesso de leitura a logs arquivados ou editados e execute:

    root@kitploit:~
    python3 ebs_safe_hunt.py /caminho/para/access.log
    

    Revise as saídas sinalizadas malicious_ips, servlet_posts, shell_stager e malicious_hash e escale conforme necessário. 🕵️‍♂️

Segurança e regras de engajamento

  • Estes artefatos são ferramentas de detecção passivas apenas. Não execute PoCs públicos contra produção ou sistemas que você não possui/autoriza. ⚠️
  • Se a detecção mostrar comprometimento confirmado (correspondência de hash de arquivo, evidência de reverse shell ou webshell), isole o host e colete forense imediatamente.

Aprofundando nos Scripts:

Princípio: combine divulgação de versão ou hits de interface com indicadores de alta confiança (IPs maliciosos, POST para UiServlet/OA_HTML, strings de processos reverse shell, correspondências de hash de arquivo, uploads externos grandes).

Exemplos Splunk Detecte tráfego para IOCs da Oracle:

root@kitploit:~
index=web_logs OR index=proxy_logs
| where clientip IN ("200.107.207.26","185.181.60.11") OR dest_ip IN ("200.107.207.26","185.181.60.11")
| stats count by clientip, dest_ip, uri, method, useragent, _time
| sort - count

Detecte POSTs UiServlet/OA_HTML de IPs externos:

root@kitploit:~
index=web_logs sourcetype=access_combined
| where (uri LIKE "%UiServlet%" OR uri LIKE "%/OA_HTML/%") AND method="POST"
| where NOT cidrmatch("10.0.0.0/8", clientip)  // ajuste para seus intervalos internos
| stats count by clientip, uri, useragent, _time
| sort - count

Detecte criação de processos reverse shell (EDR):

root@kitploit:~
index=endpoint_events sourcetype=os_process
| where process_cmdline LIKE "%/bin/bash -i%/dev/tcp/%" OR process_cmdline LIKE "%/dev/tcp//%"
| table _time host user process_name process_cmdline parent_process

Exemplos Elastic / KQL POST suspeito UiServlet:

root@kitploit:~
http.request.method : "POST" and (http.request.uri : "*UiServlet*" or http.request.uri : "/OA_HTML/*") and not client.ip : ("10.0.0.0/8")

Detecção de hash de arquivo:

root@kitploit:~
event.type: "file" and file.hash.sha256 : ("76b6d36e04e3...", "aa0d3859d66...", "6fd538e4a8e3...")

Sigma (ideias de regras portáveis)

  • Regra: POST para UiServlet//OA_HTML/ de IPs externos → alta prioridade
  • Regra: Criação de processo com /bin/bash -i >& /dev/tcp/ → crítico
  • Regra: Correspondência de hash de arquivo para os três SHA-256s → comprometimento confirmado

Script de detecção seguro (Python) — use contra logs (sem explorações, sem chamadas de rede)

Este script analisa logs de acesso web em formato combinado e sinaliza POSTs suspeitos UiServlet/OA_HTML, requisições de IPs maliciosos listados pela Oracle, padrões de shell stager e ocorrências dos hashes SHA-256 fornecidos. Ele não realiza nenhuma atividade de rede nem executa código de exploração.

root@kitploit:~
#!/usr/bin/env python3
"""
ebs_safe_hunt.py — Analisador de logs seguro para indicadores do CVE-2025-61882.

Uso:
    python3 ebs_safe_hunt.py /caminho/para/access.log

Notas:
 - Analisa linhas de log combinado Apache/Nginx.
 - Sinaliza POSTs UiServlet/OA_HTML, IPs maliciosos do alerta da Oracle,
   padrões de shell stager e hashes SHA256 observados.
 - Seguro: sem rede / sem execução de exploração.
"""

import sys
import re
from collections import Counter, defaultdict

# Regex para formato de log combinado comum
LOG_PATTERN = re.compile(
    r'(?P<ip>\S+) \S+ \S+ \[(?P<time>.*?)\] "(?P<method>\S+) (?P<uri>\S+) \S+" (?P<status>\d{3}) (?P<size>\S+) "(?P<ref>[^"]*)" "(?P<ua>[^"]*)"'
)

# IOCs fornecidos pela Oracle
MALICIOUS_IPS = {"200.107.207.26", "185.181.60.11"}
MALICIOUS_HASHES = {
    "76b6d36e04e367a2334c445b51e1ecce97e4c614e88dfb4f72b104ca0f31235d",
    "aa0d3859d6633b62bccfb69017d33a8979a3be1f3f0a5a4bf6960d6c73d41121",
    "6fd538e4a8e3493dda6f9fcdc96e814bdd14f3e2ef8aa46f0143bff34b882c1b",
}
SHELL_PATTERN = "/bin/bash -i"  # procuramos por esta substring (estilo reverse shell)
SUSPICIOUS_PATHS = ["UiServlet", "/OA_HTML/"]

# Opcional: lista de user-agents suspeitos frequentemente usados por scanners
SUSPICIOUS_UAS = ["curl", "wget", "python-requests", "nikto", "sqlmap", "masscan", "Nmap"]

def analyze_log(path):
    ip_counts = Counter()
    uri_counts = Counter()
    ua_counts = Counter()
    suspicious = defaultdict(list)

    with open(path, "r", errors="replace") as fh:
        for line_no, line in enumerate(fh, 1):
            m = LOG_PATTERN.search(line)
            if not m:
                # Opcionalmente, ainda verifique hashes ou padrão de shell em linhas não estruturadas
                if any(h in line for h in MALICIOUS_HASHES):
                    suspicious["malicious_hash_lines"].append((line_no, line.strip()))
                if SHELL_PATTERN in line or "/dev/tcp/" in line:
                    suspicious["shell_pattern_lines"].append((line_no, line.strip()))
                continue

            ip = m.group("ip")
            method = m.group("method")
            uri = m.group("uri")
            ua = m.group("ua")
            size = m.group("size")

            ip_counts[ip] += 1
            uri_counts[uri] += 1
            ua_counts[ua] += 1

            # 1) IPs maliciosos (Oracle)
            if ip in MALICIOUS_IPS:
                suspicious["malicious_ips"].append((line_no, ip, method, uri, ua))

            # 2) POSTs para caminhos EBS suspeitos
            if method.upper() == "POST" and any(p in uri for p in SUSPICIOUS_PATHS):
                suspicious["servlet_posts"].append((line_no, ip, uri, ua))

            # 3) User-agents suspeitos (scanners)
            if any(k.lower() in ua.lower() for k in SUSPICIOUS_UAS):
                suspicious["suspicious_ua"].append((line_no, ip, uri, ua))

            # 4) Respostas muito grandes (possível exfiltração) — ajuste o limite para seu ambiente
            try:
                if size != "-" and int(size) > 5_000_000:  # >5MB
                    suspicious["large_responses"].append((line_no, ip, uri, size))
            except ValueError:
                pass

            # 5) Padrão de shell stager ou padrões /dev/tcp na linha
            if SHELL_PATTERN in line or "/dev/tcp/" in line:
                suspicious["shell_stager"].append((line_no, ip, uri, line.strip()))

            # 6) Hashes de arquivos maliciosos conhecidos presentes nos logs (se disponíveis)
            for h in MALICIOUS_HASHES:
                if h in line:
                    suspicious["malicious_hash"].append((line_no, ip, uri, h))

    return {
        "ip_counts": ip_counts,
        "uri_counts": uri_counts,
        "ua_counts": ua_counts,
        "suspicious": suspicious
    }

def pretty_report(r, top=10):
    print("\n=== RELATÓRIO DE BUSCA EBS ===\n")
    print("Principais IPs de origem:")
    for ip, c in r["ip_counts"].most_common(top):
        print(f"  {ip}: {c}")
    print("\nPrincipais URIs:")
    for uri, c in r["uri_counts"].most_common(top):
        print(f"  {uri}: {c}")
    print("\nPrincipais User-Agents:")
    for ua, c in r["ua_counts"].most_common(top):
        print(f"  {ua}: {c}")

    print("\nDescobertas suspeitas:")
    if not r["suspicious"]:
        print("  Nenhuma encontrada.")
        return

    for k, items in r["suspicious"].items():
        print(f"\n-- {k} ({len(items)} correspondências) --")
        for item in items[:100]:
            print("  " + " | ".join(map(str, item)))

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Uso: python3 ebs_safe_hunt.py /caminho/para/access.log")
        sys.exit(1)
    path = sys.argv[1]
    result = analyze_log(path)
    pretty_report(result)

Como usar: copie ebs_safe_hunt.py para um host que tenha acesso de leitura a logs arquivados ou copiados. Execute:

root@kitploit:~
python3 ebs_safe_hunt.py /caminho/para/access.log

Revise os resultados sinalizados malicious_ips, servlet_posts, shell_stager e malicious_hash e escale adequadamente. 🕵️‍♂️


Checklist imediato de mitigação e contenção (prático)

  • Patch: Aplique o patch de emergência da Oracle conforme o alerta para qualquer instalação EBS 12.2.3–12.2.14. Siga a ordem de pré-requisitos do CPU. ✅
  • Se não puder aplicar o patch imediatamente: bloqueie o acesso público à interface EBS (firewall, WAF, restrinja a VPN/IPs confiáveis). 🔒
  • Bloqueie IOCs no perímetro: bloqueie 200.107.207.26 e 185.181.60.11 e quaisquer outros IPs/domínios IOC fornecidos por fornecedores.
  • Busca: execute as buscas Splunk/Elastic acima e o script Python seguro em todos os logs.
  • EDR/AV: procure pelos três hashes SHA-256 e artefatos de webshell; isole hosts se encontrados.
  • Forense: capture imagens de memória e disco para hosts suspeitos; preserve logs.
  • Credenciais: rotacione credenciais de serviço/admin após a contenção.
  • Jurídico/comunicações: prepare notificação de incidente se dados regulados foram exfiltrados.

Briefing para liderança (uma página — copiar/colar)

Assunto: Crítico: CVE-2025-61882 — Oracle E-Business Suite — Ação imediata necessária

O quê: RCE crítica pré-autenticação (CVE-2025-61882) no Oracle EBS (12.2.3–12.2.14). Explorada em campanhas de roubo de dados/extorsão.

Pedidos imediatos (próximas 24 horas):

  • Confirme se existem instâncias EBS 12.2.3–12.2.14.
  • Se sim: aplique o patch de emergência da Oracle agora ou bloqueie o acesso externo a essas instâncias.
  • Bloqueie IOCs da Oracle e ingira feeds de fornecedores na detecção do SOC.
  • SOC: execute buscas priorizadas (POSTs UiServlet/OA_HTML, IPs maliciosos, padrões de reverse shell, correspondências de hash de arquivo).
  • Se houver hits de IOC: isole o host, colete forense, notifique o jurídico.

Risco: Alto — potencial comprometimento total do servidor de aplicação, exfiltração de dados, exposição regulatória. Resumo: aplique patch ou proteja agora. — 🗿


Notas finais e cuidados

  • PoCs públicos existem e são armamentizáveis. Não os execute em produção ou sistemas de terceiros sem autorização por escrito. Use apenas laboratórios isolados. ⚠️
  • Os IOCs da Oracle representam atividade observada em incidentes — alguns indicadores podem se relacionar a ataques correlatos. Investigue hits com contexto, mas escale qualquer correspondência positiva.
  • A divulgação de versão é ruidosa — sempre correlacione evidência de versão com indicadores de exploração de alta confiança antes de concluir comprometimento. 📌

Nota de despedida

Você tem tudo o que precisa: a visão geral, IOCs direto da Oracle, buscas práticas e um script seguro para iniciar a triagem. Aplique patch ou proteja seus servidores EBS, dispare as buscas de IOC pelo seu SOC e isole qualquer coisa que pareça suspeita. Fique atento, aplique patches rapidamente e exercite seus músculos de resposta a incidentes. 🗿🔥


Baixar ferramenta