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
llvm-jutsu — Ofuscação anti-LLM através da contagem de dedos | Kitploit
Ferramentas/GitHubGitHub/thebabush/llvm-jutsu
Análise EstáticaAnálise de CódigoEngenharia ReversaAnálise de BináriosSegurança de IAAtaque Adversário
GitHubthebabush/llvm-jutsu

llvm-jutsu

Ofuscação anti-LLM através da contagem de dedos

Ver Repositório
239145há 8 mesesRevisado pelo Kitploit

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

llvm-jutsu: ofuscação anti-LLM

Isto é um inteiro de 32 bits

0xDEADBEEF codificado como mãos

O Problema

Estamos em 2025. Você passou semanas criando a verificação de licença perfeita. Usou todos os truques do manual: predicados opacos, achatamento de fluxo de controle, expressões MBA. Você faz o deploy. Em poucas horas, alguém cola seu binário no Claude e pergunta "qual é a chave de licença?" e o modelo simplesmente... conta.

As máquinas venceram. Será?

A Arte Antiga do Kuji-in

Durante séculos, ninjas usaram selos de mão para canalizar chakra e executar jutsus. O que os pergaminhos não contam é que essas formações de mãos têm o poder de proteger segredos das máquinas.

O llvm-jutsu é um passe de ofuscação LLVM que substitui constantes inteiras por gestos de mão. Cada byte é codificado como uma mão de 8 dedos, onde as posições dos dedos representam bits. Dedo esticado = 1. Dedo dobrado = 0. A máquina vê a imagem, fica sem contexto e não consegue evitar se render à engenhosidade humana. O reversor humano semicerra os olhos para a tela, lê os dedos e obtém a resposta.

Restauramos o equilíbrio do universo.

Isso Realmente Funciona?

Sim.

Depoimentos

"Consigo ver quatro mãos, cada uma com cinco dedos" — ChatGPT, 2025

Baixar ferramenta
Depoimento do ChatGPT

Claude tentando decifrar isso

Falha do Claude

Perguntas Frequentes

P: Não posso simplesmente enviar essas imagens para o Mechanical Turk e pagar humanos para decodificá-las?

R: Sim. Essa é a ideia. Agora você está pagando humanos para fazer um trabalho que os LLMs costumavam fazer de graça. A economia dos reversores está de volta. Empregos estão sendo criados. O PIB está subindo. De nada.

P: Não posso apenas treinar um modelo para desofuscar isso?

R: Pode, com certeza. Colete dados de treinamento, rotule milhares de imagens de mãos, faça o ajuste fino de um modelo de visão, faça o deploy e mantenha-o. Quando terminar, você poderia simplesmente ter lido os dedos você mesmo.

P: Por que mãos? Por que não pés?

R: Uma palavra: Tarantino.

P: Isso não é apenas segurança por obscuridade?

R: Toda segurança é obscuridade.

P: Isso está pronto para produção?

R: 100%, use isso em produção.

Como Funciona

root@kitploit:~
Your Code                         Obfuscated
─────────                         ──────────

if (key == 0xDEADBEEF) {    →     if (compare_hand_png(key, embedded_png)) {
    grant_access();                   grant_access();
}                                 }

Em tempo de compilação, nós:

  1. Encontramos todas as instruções icmp eq/ne que comparam contra constantes inteiras
  2. Renderizamos a constante como um PNG de gesto de mão (4 mãos para i32, organizadas 2×2)
  3. Incorporamos o PNG como uma constante global
  4. Substituímos a comparação por uma chamada a compare_hand_png()

Em tempo de execução, o programa:

  1. Renderiza o valor em tempo de execução usando a mesma geometria de mãos
  2. Compara os dois PNGs
  3. Retorna correspondência/não correspondência

O ponto-chave: o PNG é a única representação da constante no binário. Não há 0xDEADBEEF para dar grep. Apenas vibes. E mãos.

Codificação Visual

Um inteiro de 32 bits se transforma em quatro mãos, cada uma representando um byte. Polegar = bit 7, dedos = bits 6 a 0. Esticado = 1, dobrado = 0.

root@kitploit:~
0xDEADBEEF

┌─────────┬─────────┐
│ byte 0  │ byte 1  │
│  0xEF   │  0xBE   │
├─────────┼─────────┤
│ byte 2  │ byte 3  │
│  0xAD   │  0xDE   │
└─────────┴─────────┘

Recursos Anti-LLM

Cada mão inclui transformações derivadas de hash que preservam a legibilidade humana enquanto maximizam a confusão do modelo:

  • Rotação (0 a 360°): As mãos giram com base no hash completo do i32. Modelos têm dificuldade com objetos rotacionados.
  • Deslocamento de matiz: As cores de preenchimento variam por mão. Mesmo padrão de dedos, cores diferentes.
  • Randomização da cor do contorno: As cores do contorno percorrem todo o espaço RGB.
  • Balanço dos dedos: Pequenos deslocamentos de ângulo e posição por dedo. Orgânico, não mecânico.
  • Dependências entre mãos: Todas as transformações derivam do valor completo de 32 bits, não de bytes individuais. Nada de dividir para conquistar.

A proporção áurea (φ ≈ 1.618) é usada extensivamente para garantir que mãos adjacentes nunca compartilhem transformações semelhantes. Os antigos sabiam o que estavam fazendo.

Compilação

root@kitploit:~
# You need LLVM 15+ and a functioning belief in the power of ninjutsu
make

# This produces:
#   llvm-jutsu.so    The LLVM pass
#   example.obfuscated    Your obfuscated binary

Uso

root@kitploit:~
# Compile your code to LLVM IR
clang -O0 -emit-llvm -S -o code.ll code.c

# Run the jutsu
opt -load-pass-plugin=./llvm-jutsu.so -passes=llvm-jutsu -o obfuscated.bc code.ll

# Link with the hand comparison runtime
llvm-link obfuscated.bc lodepng.bc hand_png_helper.bc -o linked.bc

# Compile to binary
clang -O2 linked.bc -lc++ -o protected

Limitações

  • Desempenho: Renderizar e comparar PNGs em tempo de execução não é rápido. Isto é proteção espiritual, não otimização de desempenho.
  • Tamanho do binário: Cada constante incorpora um PNG de ~30KB. Seu crackme de 50KB agora tem 50MB. Considere isso um recurso. Mais bytes, mais confusão.
  • Só lida com i32 eq/ne: 32 bits devem ser suficientes para qualquer um.
  • Determinismo de ponto flutuante: Podem ocorrer pequenas variações entre plataformas. A comparação difusa lida com isso, mas se você estiver rodando em um Pentium 4, que os deuses o ajudem.

A Filosofia

A engenharia reversa moderna se tornou uma conversa com uma IA. Envie o binário, faça perguntas, receba respostas. O humano é meramente um engenheiro de prompt, um intermediário entre IDA e GPT. Um sloperator.

O llvm-jutsu é um retorno à tradição. O reversor precisa olhar para as mãos. Ler os dedos. Sentir os bits. Não há atalho. Não existe "é só perguntar ao Claude". Há apenas você, a tela e oito dedos por byte.

Não somos anti-IA. Somos pró-humanos. Acreditamos que, se alguém vai quebrar seu software, que ao menos seja feito de carne.

Acredite.

Licença

MIT. Use para o bem, use para o mal, use para o que quiser. Lavamos as mãos diante da multidão.

Créditos

  • Lode Vandevenne pelo lodepng
  • Masashi Kishimoto por Naruto

"Quando as pessoas estão protegendo algo verdadeiramente especial para elas, elas podem se tornar tão fortes quanto podem ser." — Naruto Uzumaki