Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE-2025-61882-Oracle-E-Business-Suite-Pre-Auth-RCE-Exploit — Une faille critique d’exécution de code à distance (RCE) avant authentification dans Oracle E-Business Suite (versions 12.2.3 - 12.2.14) permet aux attaquants de prendre le contrôle total des serveurs vulnérables via des requêtes HTTP malveillantes — désormais activement exploitée dans la nature. | Kitploit
Outils/GitHubGitHub/adityabhatt3010/cve-2025-61882-oracle-e-business-suite-pre-auth-rce-exploit
Analyse des VulnérabilitésExploitationAnalyse ForensiqueSécurité WebRenseignement sur les MenacesRéponse aux IncidentsAnalyse de Journaux
GitHubadityabhatt3010/cve-2025-61882-oracle-e-business-suite-pre-auth-rce-exploit

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

Voir le dépôt
127il y a 11 moisPas encore vérifié

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →

À propos

Une faille critique d’exécution de code à distance (RCE) avant authentification dans Oracle E-Business Suite (versions 12.2.3 - 12.2.14) permet aux attaquants de prendre le contrôle total des serveurs vulnérables via des requêtes HTTP malveillantes — désormais activement exploitée dans la nature.

Partager

CVE-2025-61882 - Exploit RCE pré-authentification Oracle E-Business Suite

Une faille critique d'exécution de code à distance (RCE) avant authentification dans Oracle E-Business Suite (versions 12.2.3–12.2.14) permet aux attaquants de prendre le contrôle total des serveurs vulnérables via des requêtes HTTP malveillantes — désormais activement exploitée dans la nature.


TL;DR

CVE-2025-61882 est une RCE critique avant authentification dans Oracle E-Business Suite (EBS) activement exploitée dans des campagnes d'extorsion/vol de données. Versions concernées : 12.2.3 → 12.2.14. Oracle a publié une alerte d'urgence avec des IOC (IP, commande de stager shell, SHA-256). Corrigez ou protégez immédiatement les systèmes exposés, chassez avec les détections fournies, et utilisez le script Python sûr ci-dessous pour analyser les journaux. N'exécutez pas les PoC publics en production — testez uniquement dans un laboratoire isolé avec autorisation. 🛑🗿

Cover


Pourquoi c'est important

Oracle EBS gère des fonctions métier critiques (ERP, paie, finance, RH). Une RCE avant authentification sur une instance EBS exposée au web permet à un attaquant d'exécuter des commandes arbitraires sur le serveur applicatif, d'accéder potentiellement à des données sensibles, de déposer des webshells et d'exfiltrer des fichiers. Cette vulnérabilité a été exploitée dans la nature et liée à des campagnes d'extorsion — c'est un véritable incident métier, pas une CVE théorique. 🔥


Résumé technique (court)

  • Type : Exécution de code à distance (RCE) avant authentification
  • Produit : Oracle E-Business Suite (EBS)
  • Versions concernées : 12.2.3 → 12.2.14
  • Surface d'attaque : Composants exposés au web — UiServlet, flux /OA_HTML/, et points de terminaison associés
  • CVSS (approx.) : 9.8 — à traiter comme critique
  • Exploit : Requêtes HTTP forgées menant à l'exécution de commandes sur le serveur applicatif ; plusieurs schémas d'exploitation observés dans la nature

Chronologie (condensée)

  • Vulnérabilité découverte et exploitée en 2025.
  • Oracle a publié une alerte d'urgence et des correctifs peu après les rapports d'exploitation publique.
  • Plusieurs fournisseurs ont publié des recommandations de détection et des IOC.
  • Des PoC publics ont circulé — à manipuler avec une extrême prudence. ⚠️

Comportement observé des attaquants (TTP)

  • Scan des interfaces EBS et divulgation de versions.
  • Envoi de POST/requêtes forgés vers UiServlet et /OA_HTML/ pour déclencher la RCE.
  • Déploiement de stagers/webshells et ouverture de shells inversés (ex. : /bin/bash -i >& /dev/tcp/...).
  • Compression et exfiltration de fichiers sensibles, suivies de demandes d'extorsion et de fuite de données.
  • Utilisation d'infrastructures liées à des groupes d'extorsion connus.

IOC fournis par Oracle (à utiliser immédiatement)

Oracle précise que ces IOC représentent une activité observée lors d'incidents (non limitée à CVE-2025-61882). Traitez toute correspondance positive comme priorité élevée.

IP

  • 200.107.207.26 — Activité GET/POST potentielle
  • 185.181.60.11 — Activité GET/POST potentielle

Schéma de stager shell

  • sh -c /bin/bash -i >& /dev/tcp// 0>&1 — commande de type shell inversé TCP sortant observée

Hachages SHA-256 (artefacts d'exploit / PoC)

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

Versions concernées (répété pour insister)

  • Oracle E-Business Suite 12.2.3 — 12.2.14. 🔁

Règles de détection et de corrélation à priorité élevée (points de départ pratiques)

TL;DR Le dépôt GitHub contient des artefacts de détection passive pour CVE-2025-61882 (RCE avant authentification Oracle E-Business Suite). Utilisez-les pour chasser, trier et contenir — pas pour exploiter. 🛑🗿

Une brève Description.md (mini-README) a déjà été ajoutée dans le dossier detections/ — consultez ce fichier pour le compte-rendu complet et le TL;DR. Ce README de niveau supérieur ne résume que le pack de détection et son utilisation afin que vous puissiez saisir et exécuter rapidement les choses.

Contenu de ce pack

  • detections/splunk/

    • oracle_cve61882_ioc_traffic.spl — Détecte le trafic vers/depuis les IP IOC fournies par Oracle.
    • oracle_cve61882_uiservlet_post.spl — Détecte les POST suspects vers UiServlet / /OA_HTML/ depuis des IP externes.
    • oracle_cve61882_reverse_shell.spl — Détecte la création de processus de type shell inversé dans les journaux de points de terminaison.
  • detections/elastic/

    • oracle_cve61882_uiservlet_post.kql — KQL pour les POST UiServlet/OA_HTML.
    • oracle_cve61882_filehash_detection.kql — KQL pour correspondre aux SHA-256 malveillants fournis par Oracle.
  • detections/scripts/

    • ebs_safe_hunt.py — Analyseur de journaux Python sûr et hors ligne (aucun appel réseau, aucune exécution d'exploit). À exécuter sur des copies de vos journaux d'accès.
  • detections/Description.md

    • Le mini compte-rendu/TL;DR que vous avez ajouté — contient le contexte complet, les IOC, les versions concernées et les recommandations.

Démarrage rapide

  1. Consultez detections/Description.md pour le contexte et les IOC. ✅

  2. Placez les requêtes Splunk .spl dans votre environnement Splunk (ou importez-les dans des recherches enregistrées / alertes).

  3. Collez les requêtes KQL dans Kibana / les règles de détection Elastic.

  4. Copiez ebs_safe_hunt.py sur un hôte qui a uniquement un accès en lecture aux journaux archivés ou expurgés, puis exécutez :

    root@kitploit:~
    python3 ebs_safe_hunt.py /path/to/access.log
    

    Examinez les sorties signalées malicious_ips, servlet_posts, shell_stager et malicious_hash et escaladez si nécessaire. 🕵️‍♂️

Sécurité et règles d'engagement

  • Ces artefacts sont des outils de détection passive uniquement. N'exécutez pas de PoC publics contre la production ou des systèmes que vous ne possédez pas/que vous n'êtes pas autorisé à tester. ⚠️
  • Si la détection montre une compromission confirmée (correspondance de hachage de fichier, preuve de shell inversé ou webshell), isolez l'hôte et collectez les preuves numériques immédiatement.

Plongée dans les scripts :

Principe : combinez la divulgation de version ou les hits d'interface avec des indicateurs à haute confiance (IP malveillantes, POST vers UiServlet/OA_HTML, chaînes de processus de shell inversé, correspondances de hachage de fichiers, gros envois sortants).

Exemples Splunk Détecter le trafic vers les IOC 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

Détecter les POST UiServlet/OA_HTML depuis des IP externes :

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)  // adjust for your internal ranges
| stats count by clientip, uri, useragent, _time
| sort - count

Détecter la création de processus de shell inversé (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

Exemples Elastic / KQL POST suspect vers 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")

Détection de hachage de fichier :

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

Sigma (idées de règles portables)

  • Règle : POST vers UiServlet//OA_HTML/ depuis des IP externes → priorité élevée
  • Règle : Création de processus avec /bin/bash -i >& /dev/tcp/ → critique
  • Règle : Correspondance de hachage de fichier pour les trois SHA-256 → compromission confirmée

Script de détection sûr (Python) — à utiliser sur les journaux (aucun exploit, aucun appel réseau)

Ce script analyse les journaux d'accès web au format combiné et signale les POST UiServlet/OA_HTML suspects, les requêtes provenant des IP malveillantes listées par Oracle, les schémas de stager shell et les occurrences des hachages SHA-256 fournis. Il n'effectue aucune activité réseau et n'exécute aucun code d'exploit.

root@kitploit:~
#!/usr/bin/env python3
"""
ebs_safe_hunt.py — Safe log parser for CVE-2025-61882 indicators.

Usage:
    python3 ebs_safe_hunt.py /path/to/access.log

Notes:
 - Parses Apache/Nginx combined log lines.
 - Flags UiServlet/OA_HTML POSTs, malicious IPs from Oracle advisory,
   shell stager patterns, and observed SHA256 hashes.
 - Safe: no network / no exploit execution.
"""

import sys
import re
from collections import Counter, defaultdict

# Regex for common combined log format
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>[^"]*)"'
)

# Oracle-provided IOCs
MALICIOUS_IPS = {"200.107.207.26", "185.181.60.11"}
MALICIOUS_HASHES = {
    "76b6d36e04e367a2334c445b51e1ecce97e4c614e88dfb4f72b104ca0f31235d",
    "aa0d3859d6633b62bccfb69017d33a8979a3be1f3f0a5a4bf6960d6c73d41121",
    "6fd538e4a8e3493dda6f9fcdc96e814bdd14f3e2ef8aa46f0143bff34b882c1b",
}
SHELL_PATTERN = "/bin/bash -i"  # we search for this substring (reverse shell style)
SUSPICIOUS_PATHS = ["UiServlet", "/OA_HTML/"]

# Optional: list of suspicious user-agents often used by 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:
                # Optionally, still check for hashes or shell pattern in unstructured lines
                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) Malicious IPs (Oracle)
            if ip in MALICIOUS_IPS:
                suspicious["malicious_ips"].append((line_no, ip, method, uri, ua))

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

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

            # 4) Very large responses (possible exfil) — tune threshold for your environment
            try:
                if size != "-" and int(size) > 5_000_000:  # >5MB
                    suspicious["large_responses"].append((line_no, ip, uri, size))
            except ValueError:
                pass

            # 5) Shell stager pattern or /dev/tcp patterns in the line
            if SHELL_PATTERN in line or "/dev/tcp/" in line:
                suspicious["shell_stager"].append((line_no, ip, uri, line.strip()))

            # 6) Known malicious file hashes present in logs (if available)
            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=== EBS HUNT REPORT ===\n")
    print("Top source IPs:")
    for ip, c in r["ip_counts"].most_common(top):
        print(f"  {ip}: {c}")
    print("\nTop URIs:")
    for uri, c in r["uri_counts"].most_common(top):
        print(f"  {uri}: {c}")
    print("\nTop User-Agents:")
    for ua, c in r["ua_counts"].most_common(top):
        print(f"  {ua}: {c}")

    print("\nSuspicious findings:")
    if not r["suspicious"]:
        print("  None found.")
        return

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

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

Comment l'utiliser : copiez ebs_safe_hunt.py sur un hôte ayant un accès en lecture aux journaux archivés ou copiés. Exécutez :

root@kitploit:~
python3 ebs_safe_hunt.py /path/to/access.log

Examinez les résultats signalés malicious_ips, servlet_posts, shell_stager et malicious_hash et escaladez de manière appropriée. 🕵️‍♂️


Liste de contrôle immédiate d'atténuation et de confinement (pratique)

  • Correctif : Appliquez le correctif d'urgence d'Oracle conformément à l'alerte pour toute installation EBS 12.2.3–12.2.14. Suivez l'ordre prérequis CPU. ✅
  • Si vous ne pouvez pas corriger immédiatement : bloquez l'accès public à l'interface EBS (pare-feu, WAF, restriction au VPN/IP de confiance). 🔒
  • Bloquez les IOC au périmètre : bloquez 200.107.207.26 et 185.181.60.11 ainsi que toute autre IP/domaine IOC fourni par les fournisseurs.
  • Chassez : exécutez les chasses Splunk/Elastic ci-dessus et le script Python sûr sur les journaux.
  • EDR/AV : recherchez les trois hachages SHA-256 et les artefacts de webshell ; isolez les hôtes si trouvés.
  • Preuves numériques : capturez les images mémoire et disque des hôtes suspects ; conservez les journaux.
  • Identifiants : faites pivoter les identifiants de service/administrateur après le confinement.
  • Juridique/communications : préparez la notification d'incident si des données réglementées ont été exfiltrées.

Brief pour la direction (une page — copier/coller)

Objet : Critique : CVE-2025-61882 — Oracle E-Business Suite — Action immédiate requise

Quoi : RCE critique avant authentification (CVE-2025-61882) dans Oracle EBS (12.2.3–12.2.14). Exploitée dans des campagnes de vol de données/extorsion.

Demandes immédiates (prochaines 24 heures) :

  • Confirmez si des instances EBS 12.2.3–12.2.14 existent.
  • Si oui : appliquez le correctif d'urgence d'Oracle maintenant ou bloquez l'accès externe à ces instances.
  • Bloquez les IOC Oracle et intégrez les flux des fournisseurs dans la détection SOC.
  • SOC : exécutez les chasses priorisées (POST UiServlet/OA_HTML, IP malveillantes, schémas de shell inversé, correspondances de hachage de fichiers).
  • En cas de correspondance IOC : isolez l'hôte, collectez les preuves numériques, notifiez le service juridique.

Risque : Élevé — compromission potentielle complète du serveur applicatif, exfiltration de données, exposition réglementaire. En résumé : corrigez ou protégez maintenant. — 🗿


Notes finales et mises en garde

  • Des PoC publics existent et sont utilisables comme armes. Ne les exécutez pas sur la production ou des systèmes tiers sans autorisation écrite. Utilisez uniquement des laboratoires isolés. ⚠️
  • Les IOC d'Oracle représentent une activité observée lors d'incidents — certains indicateurs peuvent se rapporter à des attaques connexes. Enquêtez sur les correspondances avec contexte, mais escaladez toute correspondance positive.
  • La divulgation de version est bruyante — corrélez toujours les preuves de version avec des indicateurs d'exploitation à haute confiance avant de conclure à une compromission. 📌

Note d'adieu

Vous avez tout ce qu'il vous faut : la vue d'ensemble, les IOC directement d'Oracle, des chasses pratiques et un script sûr pour lancer le triage. Corrigez ou protégez vos boîtes EBS, lancez les chasses IOC dans votre SOC et isolez tout ce qui semble suspect. Restez vigilants, corrigez rapidement et exercez vos muscles de réponse aux incidents. 🗿🔥


Télécharger l’outil