
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.
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. 🛑🗿
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. 🔥
/OA_HTML/ e endpoints relacionadosUiServlet e /OA_HTML/ para acionar RCE./bin/bash -i >& /dev/tcp/...).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/POST185.181.60.11 — Possível atividade GET/POSTPadrão de shell stager
sh -c /bin/bash -i >& /dev/tcp// 0>&1 — comando observado de reverse shell TCP de saídaHashes 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)
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.
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
Revise detections/Description.md para contexto e IOCs. ✅
Coloque as consultas .spl do Splunk no seu ambiente Splunk (ou importe-as em pesquisas salvas / alertas).
Cole as consultas KQL nas regras de detecção do Kibana / Elastic.
Copie ebs_safe_hunt.py para um host que somente tenha acesso de leitura a logs arquivados ou editados e execute:
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. 🕵️♂️
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:
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:
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):
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:
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:
event.type: "file" and file.hash.sha256 : ("76b6d36e04e3...", "aa0d3859d66...", "6fd538e4a8e3...")
Sigma (ideias de regras portáveis)
UiServlet//OA_HTML/ de IPs externos → alta prioridade/bin/bash -i >& /dev/tcp/ → críticoEste 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.
#!/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:
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. 🕵️♂️
200.107.207.26 e 185.181.60.11 e quaisquer outros IPs/domínios IOC fornecidos por fornecedores.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):
Risco: Alto — potencial comprometimento total do servidor de aplicação, exfiltração de dados, exposição regulatória. Resumo: aplique patch ou proteja agora. — 🗿
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. 🗿🔥