Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
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é.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
nfsu2-network-rce — NFS Underground 2 — Exécution de code à distance via le réseau (deux vecteurs RCE par débordement de tas, CVSS 9.8) | Kitploit
Outils/GitHubGitHub/icymodz420/nfsu2-network-rce
Analyse Dynamique (Sandboxing)Criminalistique MémoireAnalyse des VulnérabilitésExploitationRétro-ingénierieArticles et RechercheExploitation de Binaires
GitHubicymodz420/nfsu2-network-rce

nfsu2-network-rce

NFS Underground 2 — Exécution de code à distance via le réseau (deux vecteurs RCE par débordement de tas, CVSS 9.8)

Voir le dépôt
il y a 7 joursPas encore vérifié
Partager

NFS Underground 2 — Exécution de code à distance via le réseau

Deux vulnérabilités de débordement de tampon sur le tas dans le code réseau multijoueur de Need for Speed Underground 2 qui permettent une exécution de code à distance à partir de paquets réseau contrôlés par l'attaquant.

ProduitNeed for Speed Underground 2 (SPEED2.EXE)
VersionPC (Windows)
ÉditeurElectronic Arts
PlateformeWindows x86 (PE 32 bits)
GravitéCritique (CVSS 3.1 : 9.8 — AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H)
Vecteur d'attaqueRéseau (échange de clés TCP, session de jeu UDP)
ImpactExécution de code à distance — aucune interaction utilisateur au-delà du fait de rejoindre une partie
DateNovembre 2026

Scénario d'attaque

La victime lance le jeu et rejoint une session multijoueur — en réseau local ou en ligne. Un serveur malveillant (RCE-1) ou n'importe quel pair dans le même salon (RCE-2) envoie un unique paquet forgé. Le jeu de la victime déborde un tampon sur le tas avec des données contrôlées par l'attaquant, corrompt la table de pointeurs de fonction d'un objet réseau adjacent, et exécute du code arbitraire au tick de frame suivant. Aucun transfert de fichier, aucun chargement de sauvegarde, aucune interaction utilisateur au-delà de la connexion.

Pourquoi cela fonctionne

Le binaire ne dispose d'aucune mitigation d'exploitation moderne :

MitigationÉtat
ASLRAucune — base d'image fixe 0x00400000
Cookies de pile (/GS)Présents mais sans effet — le débordement cible le tas, pas la pile
DEPAucune — /NXCOMPAT non défini, le tas est exécutable
Validation des paquetsAucune — la longueur contrôlée par l'attaquant est transmise directement à recv()

Vulnérabilités

IDVecteurEmplacementDéclencheurCVSS 3.1
RCE-1Échange de clés TCPFUN_00759910Un serveur malveillant ou un MITM envoie une réponse de handshake forgée9.8 Critique
RCE-2Session de jeu UDPFUN_007510c0N'importe quel pair dans le même salon envoie un paquet surdimensionné8.1 Élevée

Les deux débordent des tampons alloués sur le tas avec des données contrôlées par l'attaquant, corrompent les tables de pointeurs de fonction (14 entrées) des objets réseau C++ adjacents, et permettent une exécution de code arbitraire via le mécanisme de dispatch de vtable du jeu lui-même.

La chaîne d'exploitation

Attacker sends crafted packet
    │
    ├── RCE-1: TCP key exchange, header bytes 0xFF 0xFF
    │         → FUN_00759910 parses length as 32,769 bytes
    │         → recv(32769) into 16,388-byte session buffer
    │
    └── RCE-2: UDP game session, length field 0x7FFF
              → FUN_007510c0 parses length as 32,769 bytes
              → recv(32769) into ~1,024-byte circular buffer slot
    │
    ▼
Heap overflow (16,381 or 30,000+ bytes past buffer)
    │
    ▼
Adjacent network object vtable overwritten
(14 function pointers: constructor, destructor, process_packet,
 send, close, listen, accept, configure, stats, read_buffer, ...)
    │
    ▼
Game dispatches through corrupted pointer on next tick
    │
    ▼
Arbitrary code execution

Le wrapper Recv n'a pas de vérification des limites

Tous les appels de réception réseau passent par FUN_0074a6d0 à 0x74a6d0 :

// Thin wrapper — passes caller's size directly to Winsock
if (param_5 == NULL)
    recv(*(param_1 + 0x18), param_2, param_3, 0);     // param_3 = attacker-controlled
else
    recvfrom(*(param_1 + 0x18), param_2, param_3, 0, param_5, param_6);

Aucun écrêtage, aucune vérification des limites. Quelle que soit la longueur calculée par l'appelant à partir des données réseau, elle est transmise directement à recv().

Chemin de déclenchement — Comment il se déclenche automatiquement

Le débordement se déclenche via la boucle de mise à jour réseau normale du jeu, appelée à chaque image :

Game main loop (FUN_004e6c30 / FUN_004e77a0 / FUN_004f2840)
    → FUN_00584f20 (network subsystem tick)
        → FUN_00740600 (network update)
            → FUN_0074e8e0 (packet processor)
                → FUN_00754490 (TCP state machine)
                    → FUN_00759910 — RCE-1 OVERFLOW
                → vtable dispatch: CALL [peer + 0x30]
                    → FUN_00751660 (read_buffer)
                        → FUN_007510c0 — RCE-2 OVERFLOW

Aucune navigation dans les menus, aucune pression de bouton — la propre boucle de rendu du jeu traite les paquets entrants et déclenche le débordement.

Corruption de vtable sur le tas

La fabrique d'objets réseau FUN_00751940 alloue 0x214 octets et installe 14 pointeurs de fonction :

DécalageEntréeCible d'origine
+0x00constructeurFUN_00751940
+0x04destructeurFUN_00751490
+0x08connectLAB_00752200
+0x0Cprocess_packetFUN_00757900
+0x10sendFUN_00751750
+0x14closeFUN_00751520
+0x18listenLAB_00751880
+0x1Cclose_aliasFUN_00751520
+0x20acceptLAB_00751500
+0x24configureLAB_00753ab0
+0x28timestampGetTickCount
+0x2CstatsFUN_00751560
+0x30read_bufferFUN_00751660
+0x34write_bufferLAB_00751700

Lorsque le débordement corrompt ces pointeurs, le propre code de répartition du jeu (CALL [object + offset]) redirige l'exécution vers l'adresse choisie par l'attaquant.

Preuve de concept — Six preuves, trois scripts

Chaque script prouve les deux vecteurs à un niveau différent de la chaîne d'exploitation :

#ScriptVecteurCe qu'il prouve
1network_rce_proof.jsRCE-1 (TCP)Débordement de tas de 16 381 octets au-delà de la limite du tampon
2network_rce_proof.jsRCE-2 (UDP)Débordement de plus de 30 000 octets au-delà de l'emplacement du tampon circulaire
3network_eip_control.jsRCE-1 (TCP)14/14 pointeurs de vtable corrompus en 0x41414141
4network_eip_control.jsRCE-2 (UDP)14/14 pointeurs de vtable corrompus en 0x41414141
5network_rce_ace.jsRCE-1 (TCP)MessageBoxA("RCE Succeeded") via la répartition par vtable corrompue
6network_rce_ace.jsRCE-2 (UDP)MessageBoxA("RCE Succeeded") via la répartition par vtable corrompue

Toutes les preuves s'exécutent dans l'espace d'adressage du jeu lui-même via Frida. Aucun trafic réseau n'est envoyé — chaque script alloue des tampons de tas correspondant aux structures réelles, reproduit la géométrie exacte du débordement et vérifie chaque octet corrompu.

Voir poc/README.md pour les étapes de reproduction détaillées et la sortie attendue.

Ce que chaque PoC prouve (et ce qu'il ne prouve pas)

Ce qui est prouvé :

  • Le chemin de réception vulnérable n'a aucune vérification des limites (analyse statique — décompilation Ghidra)
  • Le champ de longueur contrôlé par l'attaquant produit une taille de réception de 32 769 octets (analyse de longueur reproduite en processus)
  • Le débordement écrit au-delà du tampon dans les objets de tas adjacents (vérification mémoire)
  • Les 14 pointeurs de fonction de l'objet adjacent sont écrasés (vérification de la corruption)
  • La répartition via un pointeur corrompu exécute le code choisi par l'attaquant (MessageBoxA se déclenche)
  • Pas d'ASLR — toutes les adresses sont fixes et connues (base 0x400000)
  • Pas de DEP — la mémoire du tas est exécutable
Télécharger l’outil

Populaires

Voir tout →

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

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    708
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    500
  • 3

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    398
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    341
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    259
  • 6

    antifox

    antifox-ai/antifox

    Plateforme de test d'intrusion autonome multi-agents par IA qui exécute la reconnaissance, la découverte de la surface d'attaque, la validation de l'exploitation et la livraison de rapports étayés par des preuves.

    257

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →