Skip to content
KitploitKITPLOIT
HerramientasBlog
Enviar
HerramientasBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

··Feeds·Contacto·Privacidad·© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
CVE-2025-61882-Oracle-E-Business-Suite-Pre-Auth-RCE-Exploit — 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. | Kitploit
Herramientas/GitHubGitHub/adityabhatt3010/cve-2025-61882-oracle-e-business-suite-pre-auth-rce-exploit
Análisis de VulnerabilidadesExplotaciónAnálisis ForenseSeguridad WebInteligencia de AmenazasRespuesta a IncidentesAnálisis de Registros
GitHubadityabhatt3010/cve-2025-61882-oracle-e-business-suite-pre-auth-rce-exploit

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

Ver Repositorio
12hace 10 mesesAún no revisado

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →

Acerca de

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.

Compartir

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

Una vulnerabilidad crítica de Ejecución Remota de Código (RCE) sin autenticación previa en Oracle E-Business Suite (versiones 12.2.3–12.2.14) permite a los atacantes obtener control total sobre servidores vulnerables mediante solicitudes HTTP maliciosas — ahora explotada activamente en el mundo real.


TL;DR

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. 🛑🗿

Cover



Por qué esto importa

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. 🔥


Resumen técnico (breve)

  • Tipo: Ejecución Remota de Código (RCE) sin autenticación previa
  • Producto: Oracle E-Business Suite (EBS)
  • Versiones afectadas: 12.2.3 → 12.2.14
  • Superficie de ataque: Componentes expuestos a la web — UiServlet, flujos /OA_HTML/ y endpoints relacionados
  • CVSS (aprox.): 9.8 — trátelo como crítico
  • Exploit: Solicitudes HTTP manipuladas que conducen a ejecución de comandos en el servidor de aplicaciones; se observaron múltiples patrones de exploit en el mundo real

Cronología (resumida)

  • Vulnerabilidad descubierta y explotada en 2025.
  • Oracle publicó un aviso de emergencia y parches poco después de los informes públicos de explotación.
  • Múltiples proveedores publicaron guías de detección e IOCs.
  • Circulan PoCs públicos — manéjelos con extrema precaución. ⚠️

Comportamiento observado del atacante (TTPs)

  • Escaneo de interfaces EBS y divulgación de versiones.
  • Envío de POSTs/solicitudes manipuladas a UiServlet y /OA_HTML/ para desencadenar RCE.
  • Implementación de stagers/webshells y generación de shells inversos (p. ej., /bin/bash -i >& /dev/tcp/...).
  • Compresión y exfiltración de archivos sensibles, seguido de demandas de extorsión y filtración de datos.
  • Uso de infraestructura vinculada a grupos de extorsión conocidos.

IOCs proporcionados por Oracle (úsalos inmediatamente)

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/POST
  • 185.181.60.11 — Posible actividad GET/POST

Patrón de stager de shell

  • sh -c /bin/bash -i >& /dev/tcp// 0>&1 — comando observado de shell inverso TCP saliente

Hashes 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)

  • Oracle E-Business Suite 12.2.3 — 12.2.14. 🔁

Reglas de detección y correlación de alta prioridad (iniciadores prácticos)

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.

Qué contiene este paquete

  • 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

    • El mini informe/TL;DR que añadió — contiene el contexto completo, IOCs, versiones afectadas y orientación.

Inicio rápido

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

  2. Coloque las consultas .spl de Splunk en su entorno Splunk (o impórtelas en búsquedas guardadas / alertas).

  3. Pegue las consultas KQL en las reglas de detección de Kibana / Elastic.

  4. Copie ebs_safe_hunt.py a un host que solo tenga acceso de lectura a registros archivados o redactados, luego ejecute:

    root@kitploit:~
    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. 🕵️‍♂️

Seguridad y reglas de compromiso

  • Estos artefactos son herramientas de detección pasiva únicamente. No ejecute PoCs públicos contra producción o sistemas que no posea/esté autorizado. ⚠️
  • Si la detección muestra compromiso confirmado (coincidencia de hash de archivo, evidencia de shell inverso o webshell), aísle el host y recopile evidencia forense inmediatamente.

Profundizando en los Scripts:

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:

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

Detectar POSTs a UiServlet/OA_HTML desde IPs externas:

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 sus rangos internos
| stats count by clientip, uri, useragent, _time
| sort - count

Detectar creación de procesos de shell inverso (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

Ejemplos de Elastic / KQL POST sospechoso a 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")

Detección de hash de archivo:

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

Sigma (ideas de reglas portátiles)

  • Regla: POST a UiServlet//OA_HTML/ desde IPs externas → alta prioridad
  • Regla: Creación de proceso con /bin/bash -i >& /dev/tcp/ → crítico
  • Regla: Coincidencia de hash de archivo para los tres SHA-256 → compromiso confirmado

Script de detección seguro (Python) — úselo contra registros (sin exploits, sin llamadas de red)

Este 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.

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

root@kitploit:~
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. 🕵️‍♂️


Lista de verificación de mitigación y contención inmediata (práctica)

  • Parche: Aplique el parche de emergencia de Oracle según el aviso para cualquier instalación EBS 12.2.3–12.2.14. Siga el orden de prerequisitos del CPU. ✅
  • Si no puede parchear inmediatamente: bloquee el acceso público a la interfaz EBS (firewall, WAF, restrinja a VPN/IPs de confianza). 🔒
  • Bloquee IOCs en el perímetro: bloquee 200.107.207.26 y 185.181.60.11 y cualquier otra IP/dominio IOC proporcionado por el proveedor.
  • Busque: ejecute las búsquedas de Splunk/Elastic anteriores y el script Python seguro en todos los registros.
  • EDR/AV: busque los tres hashes SHA-256 y artefactos de webshell; aísle los hosts si se encuentran.
  • Forense: capture imágenes de memoria y disco para los hosts sospechosos; conserve los registros.
  • Credenciales: rote las credenciales de servicio/administrador después de la contención.
  • Legal/comunicaciones: prepare la notificación de incidente si se exfiltraron datos regulados.

Resumen para liderazgo (una página — copiar/pegar)

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):

  • Confirme si existen instancias EBS 12.2.3–12.2.14.
  • Si es así: aplique el parche de emergencia de Oracle ahora o bloquee el acceso externo a esas instancias.
  • Bloquee los IOCs de Oracle e ingiera los feeds del proveedor en la detección del SOC.
  • SOC: ejecute las búsquedas priorizadas (POSTs a UiServlet/OA_HTML, IPs maliciosas, patrones de shell inverso, coincidencias de hash de archivo).
  • Si hay coincidencias de IOC: aísle el host, recopile evidencia forense, notifique a legal.

Riesgo: Alto — posible compromiso completo del servidor de aplicaciones, exfiltración de datos, exposición regulatoria. Conclusión: parchee o proteja ahora. — 🗿


Notas finales y precauciones

  • Existen PoCs públicos y son armables. No los ejecute en producción o sistemas de terceros sin autorización por escrito. Use solo laboratorios aislados. ⚠️
  • Los IOCs de Oracle representan actividad observada en incidentes — algunos indicadores pueden relacionarse con ataques conexos. Investigue las coincidencias con contexto, pero escale cualquier coincidencia positiva.
  • La divulgación de versión es ruidosa — siempre correlacione la evidencia de versión con indicadores de exploit de alta confianza antes de concluir compromiso. 📌

Nota de despedida

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. 🗿🔥


Descargar herramienta