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-2024-6387 — Exploit SSH pour CVE-2024-6387 : RCE dans le serveur OpenSSH, sur les systèmes Linux basés sur glibc | Kitploit
Outils/GitHubGitHub/symbolexe/cve-2024-6387
Analyse des VulnérabilitésExploitationTests d'IntrusionRed TeamingOutil d'Accès à DistanceDéveloppement de Charges Utiles
GitHubsymbolexe/cve-2024-6387

CVE-2024-6387

Exploit SSH pour CVE-2024-6387 : RCE dans le serveur OpenSSH, sur les systèmes Linux basés sur glibc

Voir le dépôt
364il y a 2 ansPas 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 →
Partager

CVE-2024-6387

Capture d'écran 2024-07-04 182931 CVE-2024-6387 est un exemple hypothétique, mais supposons qu'il s'agisse d'une vulnérabilité réelle dans l'implémentation du serveur OpenSSH. Cette vulnérabilité pourrait impliquer un dépassement de tampon ou une corruption mémoire permettant à des attaquants distants d'exécuter du code arbitraire sur le serveur. Voici une explication de haut niveau de la manière dont une telle vulnérabilité pourrait être exploitée :

  1. Heap Spraying : L'attaquant prépare le tas de manière à le rendre prévisible.
  2. Corruption mémoire : L'attaquant envoie des paquets spécialement conçus qui provoquent une corruption mémoire.
  3. Exécution de code arbitraire : L'attaquant place du shellcode (code malveillant) à un endroit connu et redirige l'exécution vers celui-ci.

Le code de l'exploit

Le code Python fourni est un exploit conçu pour tirer parti de CVE-2024-6387. Voici une analyse détaillée des étapes qu'il suit : Configuration de la connexion : Établit une connexion TCP vers le serveur SSH cible.

root@kitploit:~
def setup_connection(ip, port):
    # ...

Envoi et réception de paquets : Gère l'envoi et la réception de paquets vers/depuis le serveur SSH.

root@kitploit:~
def send_packet(sock, packet_type, data):
    # ...

: Initie la négociation SSH en envoyant et en recevant la chaîne de version SSH.

Échange de version SSH
root@kitploit:~
def send_ssh_version(sock):
    # ...
def receive_ssh_version(sock):
    # ...

Initialisation de l'échange de clés (KEX_INIT) : Envoie et reçoit le paquet d'initialisation de l'échange de clés.

root@kitploit:~
def send_kex_init(sock):
    # ...
def receive_kex_init(sock):
    # ...

Réalisation de la négociation SSH : Combine les étapes ci-dessus pour terminer la négociation SSH.

root@kitploit:~
def perform_ssh_handshake(sock):
    # ...

Préparation du tas : Envoie une série de paquets pour manipuler l'état du tas sur le serveur.

root@kitploit:~
def prepare_heap(sock):
    # ...

Structure de fichier factice : Crée des structures de fichier factices pour exploiter la vulnérabilité de corruption mémoire.

root@kitploit:~
def create_fake_file_structure(data, glibc_base):
    # ...

Mesure du temps d'analyse : Mesure le temps mis par le serveur pour analyser certains paquets, afin de synchroniser correctement l'exploit final.

root@kitploit:~
def time_final_packet(sock):
    # ...

Paquet de clé publique : Confectionne un paquet contenant la charge utile de l'exploit, y compris le shellcode.

root@kitploit:~
def create_public_key_packet(packet, size, glibc_base):
    # ...

Exploitation de la condition de concurrence : Tente d'exploiter la condition de concurrence en synchronisant correctement l'envoi du paquet final.

root@kitploit:~
def attempt_race_condition(sock, parsing_time, glibc_base):
    # ...

Fonction principale : Coordonne l'ensemble du processus d'exploitation, y compris plusieurs tentatives avec différentes bases glibc.

root@kitploit:~
def main():
    # ...

Workflow d'exploitation

  • Configuration de la connexion : L'exploit commence par configurer une connexion vers le serveur SSH.
  • Négociation et préparation du tas : L'exploit effectue la négociation SSH et envoie plusieurs paquets pour préparer le tas.
  • Mesure du timing : L'exploit mesure le temps de réponse du serveur à certains paquets pour évaluer le timing de l'exploit final.
  • Tentative d'exploit final : L'exploit confectionne et envoie un paquet final contenant le shellcode. Il tente d'envoyer ce paquet de manière à déclencher la vulnérabilité.

Considérations supplémentaires

  • Gestion robuste des erreurs : Le code fourni inclut une meilleure gestion des erreurs pour permettre au script de se remettre des problèmes réseau courants.
  • Modularité : Le code est modulaire, ce qui le rend plus facile à comprendre et à maintenir.
  • Timing et synchronisation : Exploiter une condition de concurrence nécessite souvent un timing précis, ce que le script tente de gérer en mesurant et en ajustant le timing des envois de paquets.

Résumé

CVE-2024-6387 représente une vulnérabilité sévère dans OpenSSH permettant l'exécution de code à distance. Le script Python fourni exploite cette vulnérabilité en manipulant le tas et en synchronisant l'envoi des paquets pour provoquer une corruption mémoire, exécutant finalement le shellcode de l'attaquant sur le serveur. Le script démontre des techniques classiques de développement d'exploit, notamment le heap spraying, la corruption mémoire et le timing précis pour les conditions de concurrence.

Télécharger l’outil