
Una vulnerabilidad crítica de Ejecución Remota de Código (RCE) previa a la autenticación en Oracle E-Business Suite (versiones 12.2.3 - 12.2.14) permite a los atacantes obtener control total sobre los servidores vulnerables mediante solicitudes HTTP maliciosas, y ahora está siendo explotada activamente en el entorno real.
CVE-2025-61882 es un RCE crítico sin autenticación previa en Oracle E-Business Suite (EBS) explotado activamente en campañas de extorsión/robo de datos. Versiones afectadas: 12.2.3 → 12.2.14. Oracle publicó un aviso de emergencia con IOCs (IPs, comando de stager de shell, SHA-256). Parchee o proteja los sistemas expuestos inmediatamente, busque con las detecciones proporcionadas y use el script Python seguro a continuación para escanear registros. No ejecute PoCs públicos en producción — pruebe solo en un laboratorio aislado con autorización. 🛑🗿
Oracle EBS ejecuta funciones comerciales críticas (ERP, nómina, finanzas, RRHH). Un RCE sin autenticación previa en una instancia EBS expuesta a la web permite a un atacante ejecutar comandos arbitrarios en el servidor de aplicaciones, acceder potencialmente a datos sensibles, colocar webshells y exfiltrar archivos. Esta vulnerabilidad fue armada en el mundo real y vinculada a campañas de extorsión — es un incidente comercial real, no un CVE teórico. 🔥
/OA_HTML/ y endpoints relacionadosUiServlet y /OA_HTML/ para desencadenar RCE./bin/bash -i >& /dev/tcp/...).Oracle señala que estos IOCs son actividad observada en incidentes (no limitada a CVE-2025-61882). Trate cualquier coincidencia positiva como alta prioridad.
IPs
200.107.207.26 — Posible actividad GET/POST185.181.60.11 — Posible actividad GET/POSTPatrón de stager de shell
sh -c /bin/bash -i >& /dev/tcp// 0>&1 — comando observado de shell inverso TCP salienteHashes SHA-256 (artefactos de exploit / PoC)
76b6d36e04e367a2334c445b51e1ecce97e4c614e88dfb4f72b104ca0f31235d
(oracle_ebs_nday_exploit_poc_scattered_lapsus_retard_cl0p_hunters.zip)aa0d3859d6633b62bccfb69017d33a8979a3be1f3f0a5a4bf6960d6c73d41121
(.../exp.py)6fd538e4a8e3493dda6f9fcdc96e814bdd14f3e2ef8aa46f0143bff34b882c1b
(.../server.py)Versiones afectadas (repetido para énfasis)
TL;DR El Repositorio de GitHub contiene artefactos de detección pasiva para CVE-2025-61882 (RCE pre-auth de Oracle E-Business Suite). Úselos para buscar, clasificar y contener — no para explotar. 🛑🗿
Ya se añadió una breve Description.md (mini-README) dentro de la carpeta detections/ — revise ese archivo para el informe completo y el TL;DR. Este README de nivel superior solo resume el paquete de detección y su uso para que pueda tomarlo y ejecutarlo rápidamente.
detections/splunk/
oracle_cve61882_ioc_traffic.spl — Detecta tráfico hacia/desde IPs IOC proporcionadas por Oracle.oracle_cve61882_uiservlet_post.spl — Detecta POSTs sospechosos a UiServlet / /OA_HTML/ desde IPs externas.oracle_cve61882_reverse_shell.spl — Detecta creación de procesos tipo shell inverso en registros de endpoints.detections/elastic/
oracle_cve61882_uiservlet_post.kql — KQL para POSTs a UiServlet/OA_HTML.oracle_cve61882_filehash_detection.kql — KQL para coincidir con los SHA-256 maliciosos proporcionados por Oracle.detections/scripts/
ebs_safe_hunt.py — Analizador de registros Python seguro y sin conexión (sin llamadas de red, sin ejecución de exploits). Ejecútelo contra copias de sus registros de acceso.detections/Description.md
Revise detections/Description.md para contexto e IOCs. ✅
Coloque las consultas .spl de Splunk en su entorno Splunk (o impórtelas en búsquedas guardadas / alertas).
Pegue las consultas KQL en las reglas de detección de Kibana / Elastic.
Copie ebs_safe_hunt.py a un host que solo tenga acceso de lectura a registros archivados o redactados, luego ejecute:
python3 ebs_safe_hunt.py /path/to/access.log
Revise las salidas marcadas malicious_ips, servlet_posts, shell_stager y malicious_hash y escale según sea necesario. 🕵️♂️
Principio: combine la divulgación de versión o los hits de interfaz con indicadores de alta confianza (IPs maliciosas, POST a UiServlet/OA_HTML, cadenas de procesos de shell inverso, coincidencias de hash de archivo, grandes cargas salientes).
Ejemplos de Splunk Detectar tráfico hacia IOCs de 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
Detectar POSTs a UiServlet/OA_HTML desde IPs externas:
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 sus rangos internos
| stats count by clientip, uri, useragent, _time
| sort - count
Detectar creación de procesos de shell inverso (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
Ejemplos de Elastic / KQL POST sospechoso a 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")
Detección de hash de archivo:
event.type: "file" and file.hash.sha256 : ("76b6d36e04e3...", "aa0d3859d66...", "6fd538e4a8e3...")
Sigma (ideas de reglas portátiles)
UiServlet//OA_HTML/ desde IPs externas → alta prioridad/bin/bash -i >& /dev/tcp/ → críticoEste script analiza registros de acceso web en formato combinado y marca POSTs sospechosos a UiServlet/OA_HTML, solicitudes desde IPs maliciosas listadas por Oracle, patrones de stager de shell y ocurrencias de los hashes SHA-256 proporcionados. No realiza ninguna actividad de red ni ejecuta código de exploit.
#!/usr/bin/env python3
"""
ebs_safe_hunt.py — Analizador de registros seguro para indicadores de CVE-2025-61882.
Uso:
python3 ebs_safe_hunt.py /path/to/access.log
Notas:
- Analiza líneas de registro combinado de Apache/Nginx.
- Marca POSTs a UiServlet/OA_HTML, IPs maliciosas del aviso de Oracle,
patrones de stager de shell y hashes SHA256 observados.
- Seguro: sin red / sin ejecución de exploits.
"""
import sys
import re
from collections import Counter, defaultdict
# Expresión regular para formato de registro combinado común
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 proporcionados por Oracle
MALICIOUS_IPS = {"200.107.207.26", "185.181.60.11"}
MALICIOUS_HASHES = {
"76b6d36e04e367a2334c445b51e1ecce97e4c614e88dfb4f72b104ca0f31235d",
"aa0d3859d6633b62bccfb69017d33a8979a3be1f3f0a5a4bf6960d6c73d41121",
"6fd538e4a8e3493dda6f9fcdc96e814bdd14f3e2ef8aa46f0143bff34b882c1b",
}
SHELL_PATTERN = "/bin/bash -i" # buscamos esta subcadena (estilo shell inverso)
SUSPICIOUS_PATHS = ["UiServlet", "/OA_HTML/"]
# Opcional: lista de user-agents sospechosos utilizados a menudo por escáneres
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, aún verifique hashes o patrón de shell en líneas no estructuradas
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 maliciosas (Oracle)
if ip in MALICIOUS_IPS:
suspicious["malicious_ips"].append((line_no, ip, method, uri, ua))
# 2) POSTs a rutas EBS sospechosas
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 sospechosos (escáneres)
if any(k.lower() in ua.lower() for k in SUSPICIOUS_UAS):
suspicious["suspicious_ua"].append((line_no, ip, uri, ua))
# 4) Respuestas muy grandes (posible exfiltración) — ajuste el umbral para su entorno
try:
if size != "-" and int(size) > 5_000_000: # >5MB
suspicious["large_responses"].append((line_no, ip, uri, size))
except ValueError:
pass
# 5) Patrón de stager de shell o patrones /dev/tcp en la línea
if SHELL_PATTERN in line or "/dev/tcp/" in line:
suspicious["shell_stager"].append((line_no, ip, uri, line.strip()))
# 6) Hashes de archivos maliciosos conocidos presentes en los registros (si están disponibles)
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=== INFORME DE BÚSQUEDA EBS ===\n")
print("IPs de origen principales:")
for ip, c in r["ip_counts"].most_common(top):
print(f" {ip}: {c}")
print("\nURIs principales:")
for uri, c in r["uri_counts"].most_common(top):
print(f" {uri}: {c}")
print("\nUser-Agents principales:")
for ua, c in r["ua_counts"].most_common(top):
print(f" {ua}: {c}")
print("\nHallazgos sospechosos:")
if not r["suspicious"]:
print(" No se encontró ninguno.")
return
for k, items in r["suspicious"].items():
print(f"\n-- {k} ({len(items)} coincidencias) --")
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 /path/to/access.log")
sys.exit(1)
path = sys.argv[1]
result = analyze_log(path)
pretty_report(result)
Cómo usarlo: copie ebs_safe_hunt.py a un host que tenga acceso de lectura a registros archivados o copiados. Ejecute:
python3 ebs_safe_hunt.py /path/to/access.log
Revise los resultados marcados malicious_ips, servlet_posts, shell_stager y malicious_hash y escale adecuadamente. 🕵️♂️
200.107.207.26 y 185.181.60.11 y cualquier otra IP/dominio IOC proporcionado por el proveedor.Asunto: Crítico: CVE-2025-61882 — Oracle E-Business Suite — Se requiere acción inmediata
Qué: RCE crítico sin autenticación previa (CVE-2025-61882) en Oracle EBS (12.2.3–12.2.14). Explotado en campañas de robo de datos/extorsión.
Solicitudes inmediatas (próximas 24 horas):
Riesgo: Alto — posible compromiso completo del servidor de aplicaciones, exfiltración de datos, exposición regulatoria. Conclusión: parchee o proteja ahora. — 🗿
Tiene todo lo que necesita: la visión general, los IOCs directamente de Oracle, búsquedas prácticas y un script seguro para iniciar la clasificación. Parchee o proteja sus cajas EBS, lance las búsquedas de IOC a través de su SOC y aísle cualquier cosa que parezca sospechosa. Manténgase alerta, parchee rápido y ejercite ese músculo de respuesta a incidentes. 🗿🔥