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
DirtyClone — DirtyClone - prova de conceito de escalada local de privilégios (LPE) que explora uma vulnerabilidade relacionada ao kernel/XFRM, descrita no código-fonte como CVE-2026-43503. | Kitploit
Ferramentas/GitHubGitHub/gl1tch0x1/dirtyclone
Escalada de PrivilégiosExploraçãoShellcodeCriptografiaDesenvolvimento de PayloadsExploração de Binários
GitHubgl1tch0x1/dirtyclone

DirtyClone

DirtyClone - prova de conceito de escalada local de privilégios (LPE) que explora uma vulnerabilidade relacionada ao kernel/XFRM, descrita no código-fonte como CVE-2026-43503.

Ver Repositório
21há 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

DirtyClone

DirtyClone é uma ferramenta de escalonamento local de privilégios, de diagnóstico e prova de conceito, escrita em C. Ela tem como alvo um caminho de exploração relacionado a kernel/XFRM descrito na fonte como CVE-2026-43503 e destina-se apenas a pesquisa de segurança autorizada em ambientes controlados.

Visão geral

Este repositório contém:

  • dirtyclone.c – a implementação completa da exploração
  • README.md – orientações de uso e ambiente

A implementação atual realiza as seguintes etapas de alto nível:

  • cria namespaces de usuário e de rede isolados,
  • configura a rede loopback e os estados/políticas XFRM/IPsec,
  • constrói uma carga útil ESP usando criptografia AES-CBC,
  • tenta a entrega por meio de um caminho UDP baseado em TEE e um fallback de IP bruto,
  • aguarda o cache de páginas do binário SUID alvo ser corrigido,
  • executa o binário alvo se o cache de páginas for modificado.

Aviso importante

Esta ferramenta destina-se apenas a testes de segurança autorizados. Executá-la em sistemas sem permissão explícita pode ser ilegal e pode comprometer a integridade do sistema.

Compilação

Instale primeiro o pacote de desenvolvimento OpenSSL necessário:

root@kitploit:~
# Debian/Ubuntu
sudo apt-get install libssl-dev

# Fedora
sudo dnf install openssl-devel

# Arch Linux
sudo pacman -S openssl

Em seguida, compile o binário:

root@kitploit:~
gcc -o dirtyclone dirtyclone.c -lcrypto -Wall -O2

Uso

Execute o programa com:

root@kitploit:~
./dirtyclone

Argumentos opcionais:

root@kitploit:~
./dirtyclone -q    # quiet mode
./dirtyclone -v    # verbose mode (default)
./dirtyclone -h    # show help

O que o programa faz

Em tempo de execução, o programa:

  1. exibe um banner e verifica se já está sendo executado como root;
  2. verifica os detalhes do kernel e da arquitetura e informa se o sistema parece estar dentro da faixa vulnerável;
  3. configura namespaces e rede loopback;
  4. configura estados/políticas XFRM e tenta adicionar uma regra netfilter TEE;
  5. mapeia o binário SUID alvo na memória e imprime um resumo de PoC dos bytes originais versus os esperados;
  6. envia um pacote ESP usando UDP+TEE ou um fallback de IP bruto;
  7. aguarda o cache de páginas refletir os bytes injetados e então tenta executar o binário alvo.

Como o DirtyClone funciona

A exploração é construída em torno de uma ideia simples: o programa prepara uma carga útil ESP/XFRM especialmente elaborada que faz o kernel descriptografar dados em uma região de memória apoiada pelo cache de páginas e, em seguida, verifica se os bytes no binário SUID alvo foram alterados.

Em termos práticos, o programa realiza as seguintes ações:

  • identifica um arquivo alvo, /usr/bin/su, e o mapeia na memória;
  • prepara uma pequena carga útil contendo bytes de shellcode e os metadados ESP necessários;
  • criptografa a carga útil com AES-CBC para que possa ser inserida no caminho XFRM/ESP;
  • envia o pacote através da pilha de rede local usando UDP assistido por TEE ou um fallback de IP bruto;
  • monitora a região mapeada para ver se os bytes esperados aparecem;
  • se os bytes aparecerem, assume que o caminho de exploração alterou o cache de páginas e executa o caminho alvo corrigido.

Este é um fluxo de prova de conceito, não uma estrutura genérica de escalonamento de privilégios. Ele destina-se a demonstrar o mecanismo de exploração e a ajudar a verificar se um kernel alvo ainda expõe o comportamento vulnerável.

Exemplo de implementação simulada

O exemplo simplificado a seguir mostra o mesmo conceito em alto nível:

root@kitploit:~
#include <stdio.h>
#include <string.h>

static int dummy_exploit(unsigned char *target_bytes) {
    unsigned char expected[] = {0x31, 0x0f, 0x05};
    memcpy(target_bytes, expected, sizeof(expected));
    return 0;
}

int main(void) {
    unsigned char target[16] = {0};
    dummy_exploit(target);
    printf("Patched bytes: %02x %02x %02x\n", target[0], target[1], target[2]);
    return 0;
}

O projeto real usa o mesmo princípio, mas empacota a carga útil como um pacote estilo ESP/XFRM e aciona o caminho do kernel através da pilha de rede em vez de uma simples cópia de memória.

Passo a passo da exploração

  1. Fase de configuração

    • o programa cria namespaces para isolar o ambiente do processo;
    • configura a rede loopback para que os pacotes permaneçam locais.
  2. Preparação do XFRM

    • a exploração adiciona estados e políticas XFRM que instruem o kernel sobre como processar o tráfego ESP;
    • também tenta instalar uma regra TEE para que o tráfego possa ser redirecionado pelo caminho planejado.
  3. Construção da carga útil

    • o código constrói uma pequena carga útil de texto simples contendo bytes no formato shellcode;
    • a carga útil é criptografada com AES-CBC usando uma chave de teste estática.
  4. Fase de entrega

    • o programa envia o pacote ESP elaborado via UDP ou IP bruto;
    • o kernel processa o pacote e, em um sistema vulnerável, grava os dados descriptografados de volta na região de cache de páginas do binário alvo.
  5. Verificação e execução

    • o código observa os bytes do arquivo alvo e verifica se eles correspondem aos bytes de shellcode esperados;
    • se corresponderem, tenta executar o binário alvo e entregar o controle ao caminho da carga útil injetada.

Detalhes técnicos

A implementação inclui:

  • lógica de repetição adaptativa enquanto aguarda alterações no cache de páginas,
  • rotinas de limpeza registradas via atexit e handlers de sinais,
  • execução segura de comandos baseada em fork/execvp,
  • criptografia AES-CBC usando as APIs EVP do OpenSSL,
  • shellcode ciente da arquitetura para x86_64 e AArch64,
  • lógica dupla de entrega para UDP assistido por TEE e transporte de IP bruto.

Pré-requisitos

O código-fonte espera um ambiente Linux com:

  • GCC ou Clang,
  • cabeçalhos e bibliotecas de desenvolvimento OpenSSL,
  • ip, iptables e modprobe disponíveis no sistema,
  • um binário alvo em /usr/bin/su,
  • um kernel que possa ser vulnerável ao caminho de exploração descrito.

Comportamento esperado

O programa destina-se a mostrar um resumo diagnóstico de PoC e então:

  • corrigir com sucesso o cache de páginas e executar o binário alvo, ou
  • falhar de forma limpa se o kernel estiver corrigido ou o caminho de exploração não estiver disponível.

Se a exploração não disparar, o programa imprime uma mensagem clara sugerindo que o kernel provavelmente está corrigido.

Segurança e ética

Use este projeto somente quando:

  • você for o proprietário do sistema alvo,
  • você tiver autorização explícita para testá-lo,
  • você estiver operando em um laboratório ou ambiente isolado.

Nunca execute este código em sistemas de produção ou em sistemas que você não tem permissão para avaliar.

Licença e autoria

O cabeçalho do código-fonte identifica o autor como MrAashish0x1 (gl1tch0x1). O repositório não inclui um arquivo de licença separado, portanto o código deve ser tratado como material de pesquisa, e não como software de produção.

Baixar ferramenta