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
netprobe-cve-2026-98432 — Sonde distante en boîte noire qui détecte CVE-2026-98432, une utilisation après libération de ireq_opt dans TCP IPv4 sous Linux, via l'écho différentiel des options SYN-ACK, ainsi qu'une vérification statique de vmlinux. | Kitploit
Outils/GitHubGitHub/xen0bit/netprobe-cve-2026-98432
Sniffing et Analyse de PaquetsScanners de VulnérabilitésAnalyse des VulnérabilitésExploitationFuzzingSécurité RéseauAnalyse de Binaires
GitHub
xen0bit/netprobe-cve-2026-98432

netprobe-cve-2026-98432

Sonde distante en boîte noire qui détecte CVE-2026-98432, une utilisation après libération de ireq_opt dans TCP IPv4 sous Linux, via l'écho différentiel des options SYN-ACK, ainsi qu'une vérification statique de vmlinux.

Voir le dépôt
18432il y a 20 joursPas encore vérifié

Populaires

Voir tout →

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

Pas encore de données de popularité.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

netprobe — CVE-2026-98432

Bonjour. CVE-2026-98432 est une utilisation après libération (Use-After-Free) exploitable à distance dans le noyau Linux. Certains rapports indiquent que des laboratoires d'IA l'ont exploitée en ~45 min via Multi-Path TCP (MPTCP). La vulnérabilité se situe en réalité dans la pile TCP IPv4 elle-même ; c'est simplement que MPTCP est le seul moyen, même de loin, pratique d'atteindre le chemin de code vulnérable. Même dans ce cas, ~45 min mérite un examen très approfondi et sceptique.

  • L'intervalle vulnérable est fixé par le code à environ la distance entre le chargement de ireq_opt et le premier déréférencement.
  • La libération survient 100 µs à quelques millisecondes plus tard (accept + close).
  • Il ne suffit pas qu'une interruption tombe dans la fenêtre ; le CPU doit rester éloigné du lecteur plus longtemps que la latence de libération.
  • Sur un noyau normal (!PREEMPT_RT), les softirqs ne sont pas planifiés du tout et même un déluge d'IRQ matérielles se terminerait en environ 10 ns, bien avant que la libération nécessaire ne provoque une utilisation après libération.
  • Le SYN dupliqué et l'ACK portent le même 4-tuple, donc RSS/RPS/sk_incoming_cpu les placent dans la même file de réception et les traitent sur le même CPU. Autrement dit : les softirqs sur un CPU sont sérialisés et, en raison de l'affinité de flux, il ne reste aucun lecteur avec lequel courir pour l'UAF.

Il existe certainement des noyaux Linux personnalisés qui utilisent MPTCP avec des options de pilotage par paquet qui rendent probablement cette vulnérabilité « atteignable » au sens le plus pur. En pratique, vous n'exécutez presque certainement pas une telle configuration de noyau, et vous n'êtes pas non plus assez malchanceux pour que quelqu'un soit suffisamment proche en latence et suffisamment persistant pour combler cet écart.

Le principal facteur qui rend l'exploitation même de loin pratique est constitué par les VM virtualisées/sur-souscrites, avec PREEMPT_RT, threadirqs, etc. — ce qui n'est pas quelque chose sur lequel un attaquant a le moindre contrôle ou la moindre influence, sauf s'il dispose d'un accès privilégié/authentifié supplémentaire. J'ai des amis dans le secteur qui connaissent probablement une astuce ou deux qui me feraient changer d'avis, mais je n'en connais aucune, l'IA est restée muette, et à tout le moins cette « astuce », si elle existe, n'est pas largement connue.

Vous devriez patcher vos serveurs, mais probablement sans paniquer. Tout le reste dans ce dépôt, y compris les lignes ci-dessous, est généré par IA, mais j'ai piloté la session et j'ai vérifié l'exactitude des artefacts.

Voici ce qui suit :

Une sonde distante en boîte noire qui démontre la présence de CVE-2026-98432 (utilisation après libération de ireq_opt / inet_opt dans le TCP IPv4 de Linux) avec des preuves au niveau des paquets — et non par correspondance de versions de noyau.

Elle s'arrête à l'utilisation après libération : elle prouve que le noyau a lu de la mémoire libérée et l'a signalé sur le réseau. Elle ne contourne pas KASLR, ne détourne pas le flux de contrôle et n'exécute pas de code.

Tests autorisés uniquement. La sonde de course peut déstabiliser une cible ; un noyau planté est un résultat plausible. Utilisez-la uniquement sur des hôtes que vous possédez ou pour lesquels vous disposez d'une autorisation écrite de test.


Nature du bug

Le correctif est e3f33b0a1d89d738e2b913dab519226eaf76e15b (ipv4: free inet_opt and ireq_opt after an RCU grace period), une modification de deux lignes passant de kfree() à kfree_rcu() dans inet_sock_destruct() et tcp_v4_reqsk_destructor().

  • tcp_v4_init_req() stocke les options IP renvoyées en écho du SYN (Record Route / Timestamp) dans ireq->ireq_opt.
  • tcp_v4_syn_recv_sock() transfère le pointeur vers le socket enfant au lieu de le copier.
  • Un SYN retransmis concurrent lit encore ireq->ireq_opt sous rcu_read_lock() et l'utilise dans ip_options_build().
  • Si l'enfant (ou le request socket) est libéré en premier, cette lecture est une utilisation après libération et le contenu de l'objet libéré est copié dans un SYN-ACK.

Ce dernier point constitue le détecteur : le noyau renvoie en écho les octets d'options obsolètes à l'expéditeur.

Correction du périmètre : l'enregistrement CVE concerne le TCP IPv4 générique. Seul le blog d'Anthropic le lie à un « listener TCP multipath » ; aucun texte CVE/NVD/Red Hat/Debian/Ubuntu ne mentionne MPTCP. La sonde teste d'abord le TCP simple.


État des preuves

Trois axes indépendants, du plus faible au plus fort :

VoletCe qu'il montreArtefact
Statique (épinglé au build-id)la forme du code du noyau en cours d'exécution : kfree simple aux deux destructeurs = vulnérable ; kvfree_call_rcu = corrigéverify-local, tableau ci-dessous
Oracle synthétiquele détecteur sur le réseau se déclenche lorsqu'un répondeur renvoie de la mémoire slab réutiliséescripts/validate_synthetic.sh → CONFIRMED VULNERABLE
Dynamique, au niveau du noyau (labo KVM)KASAN signale le slab-use-after-free réel dans ip_options_build, avec les piles du commit ; un noyau kfree_rcu avec un trafic identique reste propreevidence/guest-inst-vuln6-KASAN.log, evidence/guest-inst-patched2-CONTROL.log
Visible sur le réseau, noyau réel (labo non-KASAN)le SYN-ACK sur le réseau transportait le bloc d'options pulvérisé (42 04 be ef…) au lieu de l'horodatage renvoyé ; le contrôle kfree_rcu est resté propreevidence/race-stage1-wire-uaf.json, evidence/race-control-kfree_rcu.json

Le volet dynamique est un invité 7.0.14 conçu sur mesure (KASAN + un étirement de fenêtre par paramètre de démarrage) avec un aiguillage CPU par paquet : le SYN retransmis est traité sur un vCPU, l'ACK/transfert sur un second, et l'accept()+close() de la victime sur un troisième, de sorte que l'écrasement soit routinier plutôt qu'accidentel. Le noyau lui-même a signalé :

BUG: KASAN: slab-use-after-free in ip_options_build
Read of size 16 ... by task swapper/0 (cpu0, softirq)
  __asan_memcpy <- ip_options_build <- ip_build_and_send_pkt
  <- tcp_v4_send_synack <- tcp_rtx_synack <- tcp_check_req <- tcp_v4_rcv
Freed by task 1 (victim, cpu3):
  kfree <- inet_sock_destruct <- __sk_destruct <- inet_release <- __x64_sys_close
object: kmalloc-96, 16 bytes in (struct ip_options at the rcu_head offset)

plus 30 enregistrements READ-AFTER-FREE côté lecteur (lecture 71–322 µs après le free, optlen=40, ombre KASAN 0xfb). Le contrôle corrigé (kfree_rcu, vérifié dans le fichier objet) a exécuté la même course et la même rétention : 0 KASAN, 0 lecture-après-free. C'est là la vulnérabilité, pas une supposition de version.

Pourquoi une exécution distante propre n'est pas un correctif

Le lecteur n'est pas une longue boucle. tcp_v4_send_synack() charge ireq->ireq_opt et le passe à ip_build_and_send_pkt()/ip_options_build(), dont le memcpy constitue la lecture use-after-free ; le chargement et la lecture sont séparés de quelques instructions (de dizaines à des centaines de nanosecondes). Le côté free — destruction de l'enfant après l'accept()+close() de la victime — est bien plus tardif : le cycle de close mesuré seul est de 61–92 µs, et la latence ACK→destruction ajoute le réveil inter-CPU.

Ainsi, les deux événements ne sont pas simplement rarement simultanés ; ils sont séparés d'environ 90 µs par construction, et la lecture est terminée bien avant le free. L'expérience en timing naturel le quantifie : avec le même noyau instrumenté, sans étirement de fenêtre, environ 140k tentatives de course et un brassage concurrent de half-open,

stats: frees=180223 overlaps=0 raf=0        KASAN: 0
Télécharger l’outil