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
egodeath — Um ofuscador de JavaScript baseado em técnicas de ofuscação de indistinguibilidade criptográfica. | Kitploit
Ferramentas/GitHubGitHub/nstarke/egodeath
Análise EstáticaAnálise de CódigoEngenharia ReversaPapers e PesquisaAprendizado e Educação
GitHubnstarke/egodeath

egodeath

Um ofuscador de JavaScript baseado em técnicas de ofuscação de indistinguibilidade criptográfica.

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

egodeath

Este projeto não alcança ofuscação de indistinguibilidade. Você não deve usar este produto para proteger segredos. Ele existe para dificultar a engenharia reversa, não para impedi-la

Tests

images/screenshot.png Um ofuscador de JavaScript projetado para tornar o código extremamente difícil de ler e analisar tanto para humanos quanto para LLMs. Escrito em TypeScript. Implementa técnicas de pesquisa criptográfica de ofuscação revisada por pares.

Instalação

root@kitploit:~
npm install
npm run build

Uso via CLI

root@kitploit:~
# Uso básico
node dist/index.js input.js > output.js

# Com orçamento de tokens alvo (padrão: 2.000.000)
node dist/index.js --target-tokens 500000 input.js > output.js

# Ofuscação mínima (saída pequena)
node dist/index.js --target-tokens 10000 input.js > output.js

# Inchaço máximo (10M de tokens)
node dist/index.js --target-tokens 10000000 input.js > output.js

# Usando variável de ambiente
INPUT_FILE=input.js node dist/index.js > output.js

# Ajuda
node dist/index.js --help

Opções

OpçãoPadrãoDescrição
--target-tokens <n>2000000Tamanho alvo da saída em tokens. Entradas pequenas são inchadas até esse limite. Entradas grandes produzem menos inchaço para permanecer dentro do orçamento.
--help, -hExibe a mensagem de ajuda

Scripts npm

root@kitploit:~
npm run build              # Compila TypeScript para dist/
npm run start              # Executa o ofuscador (lê input.js)
npm run test               # Executa a suíte de testes
npm run obfuscate-package  # Executa testes de compatibilidade contra pacotes npm

API Programática

root@kitploit:~
const { obfuscate } = require('./dist/obfuscator');

const code = 'function add(a, b) { return a + b; }';
const obfuscated = obfuscate(code);

// Com opções
const obfuscated = obfuscate(code, { targetTokens: 500000 });

Pipeline de Transformações

O ofuscador aplica 20 transformações em 4 fases. Cada etapa se baseia na anterior.

Fase 1: Pré-transformações de Segurança e Anti-Análise

OrdemTransformaçãoArquivoDescrição
1Armadilhas Anti-Debugtransforms/antiDebug.tsInjeta instruções eval("debugger") e 10-20 loops de setInterval com intervalos de números primos (5s-600s) que disparam repetidamente breakpoints de depuração. Cada instância usa strings codificadas únicas.
2Armadilhas de Programa Perfuradotransforms/tripwires.tsEmbute verificações ocultas que comparam hashes de parâmetros com valores secretos. 5 padrões de hash (impressão digital bit a bit, aritmética modular, charCodeAt, hash numérico, typeof+length). Dispara corrupção silenciosa de estado, loops ocupados ou lança exceções em entradas secretas. [Paper 4]
3Injeção de Ruído LPNtransforms/noiseInjection.tsAdiciona e cancela ruído aleatório por meio de caminhos divididos em cálculos aritméticos. 6 padrões: add/sub, XOR, mul/div, divisão em variável dupla, cadeia de hash computada, rotação de bits. Valores intermediários são sem sentido sem rastrear a anulação completa. [Paper 7]

Fase 2: Pré-transformações Estruturais

OrdemTransformaçãoArquivoDescrição
4Achatamento de Fluxo de Controletransforms/controlFlowFlattening.tsConverte corpos de funções em máquinas de estado while(true) { switch((_s * P) % M) { ... } } com despacho de aritmética modular — os valores de caso são codificados por meio de (stateId * multiplier) % modulus usando parâmetros primos aleatórios. [Paper 3]
5Predicados Opacostransforms/opaquePredicates.tsInjeta condições if que sempre avaliam para verdadeiro ou falso, mas são matematicamente difíceis de provar (por exemplo, (x*x+x)%2===0). 15 fórmulas de predicado em categorias de aritmética modular, operações bit a bit e verificação de tipo.
6Funções Proxytransforms/proxyFunctions.tsRoteia todas as chamadas de função por meio de dois despachantes: _fc(fn, ...args) para chamadas simples, _mc(obj, prop, ...args) para chamadas de método. Usa Function.prototype.apply capturado em uma variável local para maior resiliência.
7Exaustão da Janela de Contextotransforms/contextExhaustion.tsEnvolve expressões em ternários profundamente aninhados com condições opacas, cadeias de expressões void e preenchimento condicional com void. Força LLMs a desperdiçar tokens da janela de contexto com ruído.
8Mesclagem de Expressões com Vírgulatransforms/commaExpressions.tsColapsa instruções de expressão consecutivas em expressões de vírgula únicas: a(); b(); return c() torna-se return a(), b(), c().

Fase 3: Passos de Identificadores

OrdemPassoArquivoDescrição
9Passo 1: Catalogaçãopasses/firstPass.tsPercorre a AST e cataloga cada identificador, construindo um mapa de globais que atribui a cada um um nome Unicode aleatório de 6 a 16 caracteres extraído de 16 intervalos de scripts (CJK, Hangul, Grego, Cirílico, Devanágari, Tailandês, Árabe, Katakana, etc.).
10Passo 2: Substituiçãopasses/secondPass.tsSubstitui todos os nomes de identificadores por seus equivalentes Unicode ofuscados. Codifica argumentos de require() como String.fromCharCode(...). Codifica fontes estáticas de import/export como literais de string com escape unicode. Substitui referências de superClass, expressões de template literal e padrões de desestruturação.
11Passo 3: Parâmetros Fantasmapasses/thirdPass.tsInjeta de 0 a 15 parâmetros aleatórios não utilizados em toda declaração e expressão de função. Ignora funções com parâmetros rest. Remove todos os comentários.

Fase 4: Pós-transformações

OrdemTransformaçãoArquivoDescrição
12Codificação de Variáveis Globaistransforms/globalVariableEncoding.tsSubstitui referências a globais (descobertas dinamicamente do pacote globalThis + window) por eval("Name<suffix>".replace(new RegExp("<suffix>$"), "")). Ambas as strings passam pelo array de strings.
13Codificação de Chaves de Propriedadetransforms/propertyKeyEncoding.tsConverte acesso por ponto em acesso computado com registros por escopo. O acesso entre escopos funciona porque todos os sufixos resolvem para o mesmo nome de propriedade em tempo de execução via .replace().
14Codificação de Númerostransforms/numberEncoding.ts11 estratégias de codificação: shift+add, identidade XOR, complemento, divisão, shifts aninhados, duplo NOT, modular, etc. Cada instância é gerada de forma única. Ignora chaves de propriedade e valores de casos de switch.
15Verificação de Integridade Própriatransforms/selfIntegrity.tsInjeta 2-4 verificações em tempo de execução: verificação de código nativo de eval, integridade de Function.prototype.toString, detecção de anomalias de temporização, validação de estrutura de código. Respostas anti-adulteração: espera ocupada, lançamento de exceção, corrupção silenciosa. [Paper 10]
16Extração de Array de Stringstransforms/stringArrayExtraction.tsColeta todas as strings em um único array com descriptografia XOR encadeada (a chave para a entrada N depende do conteúdo decodificado da entrada N-1) e padrões de erro esparsos dependentes da posição (cada caractere recebe uma chave XOR diferente, com erros esparsos inspirados em LPN em posições selecionadas). [Papers 2, 9]
17Stubs de Consoleobfuscator.tsDescobre dinamicamente todos os métodos de console e define cada um como uma função no-op.
18Minificação com Terserobfuscator.tsRemove espaços em branco/formatação via terser (, ). Recorre à remoção baseada em regex se o terser não conseguir analisar a saída.

Injeção de Código Morto

O código morto é injetado em vários pontos com duas estratégias de geração:

EstratégiaFonteDescrição
Baseada em modelostransforms/deadCodeInjection.ts9 tipos de modelo: acúmulo em loop, construção de arrays, manipulação de objetos, concatenação de strings, condicionais aninhadas, try/catch, contagem regressiva com while, switch computado, cadeias de operações bit a bit. Os modelos referenciam variáveis reais do escopo.
Baseada em mutaçãotransforms/deadCodeInjection.tsClona instruções REAIS e as muta: troca operadores dentro de grupos de equivalência, perturba constantes, renomeia identificadores. Produz código morto estruturalmente idêntico à AST que é indistinguível do código real apenas pela estrutura. [Paper 3]

Pontos de injeção de código morto:

  • Casos de switch mortos do CFF (~30% extra por função, escalados pelo orçamento)
  • Ramos else de predicados opacos
  • Blocos mortos independentes em funções sem CFF (controlados pelo orçamento)

Referências de Artigos de Pesquisa

Várias transformações são inspiradas em pesquisa criptográfica de ofuscação revisada por pares:

ArtigoAutoresTécnica Implementada
[Paper 1] On the (Im)possibility of Obfuscating ProgramsBarak, Goldreich, Impagliazzo, Rudich, Sahai, Vadhan, YangCasos de teste de funções inofuscáveis — ferramenta de verificação que testa se segredos sobrevivem à ofuscação
[Paper 2] Candidate iO and Functional Encryption for all CircuitsGarg, Gentry, Halevi, Raykova, Sahai, WatersDescriptografia encadeada de strings — randomização estilo Kilian em que a chave de cada entrada depende da string decodificada anterior
[Paper 3] iO from the Multilinear Subgroup Elimination AssumptionGentry, Lewko, Sahai, WatersCódigo morto baseado em mutação (estruturalmente idêntico ao código real); transições de estado com aritmética modular no CFF
[Paper 4] How to Use iO: Deniable Encryption, and MoreSahai, WatersArmadilhas de programa perfurado — verificações ocultas que disparam em entradas secretas
[Paper 7] iO from Well-Founded AssumptionsJain, Lin, SahaiInjeção de ruído inspirada em LPN em cálculos numéricos
[Paper 9] iO from Bilinear Maps and LPN VariantsRagavan, Vafa, VaikuntanathanCodificação XOR esparsa com padrões de erro dependentes da posição
[Paper 10] iO of Null Quantum Circuits and ApplicationsBartusek, MalavoltaTeste de circuito nulo para verificação de qualidade do código morto; verificação de integridade própria (modo duplo)

Ferramentas de Verificação

Duas ferramentas de verificação medem a qualidade da ofuscação, localizadas em src/verification/:

Teste de Circuito Nulo (verification/nullCircuitTest.ts)

Ofusca uma função real e uma função "nula" (mesma forma, não faz nada) e então compara 14 métricas estruturais para pontuar o quão distinguíveis elas são. Maior similaridade = melhor ofuscação.

root@kitploit:~
import { runNullCircuitTest } from './verification/nullCircuitTest';
const result = runNullCircuitTest(realCode, paramCount, stmtCount, threshold, targetTokens);
console.log('Similarity:', result.similarity); // 0.0-1.0

Testes de Funções Inofuscáveis (verification/unobfuscatableTests.ts)

7 casos de teste das provas de impossibilidade do Paper 1 que tentam extrair segredos de código ofuscado:

root@kitploit:~
import { runAllTests, printSummary } from './verification/unobfuscatableTests';
console.log(printSummary(runAllTests(10000)));

Testes: função de ponto (senha), números mágicos, strings canário, chaves embutidas, URLs, padrões de regex, assinaturas de fluxo de controle.

Orçamento de Tamanho da Saída

A opção --target-tokens controla o tamanho da saída por meio de um orçamento de inchaço que escala a injeção de código morto (a principal alavanca de volume). Transformações limitadas pelo orçamento:

Proporção do OrçamentoTransformações Ativadas
> 3Anti-debug, armadilhas, CFF, predicados opacos, mesclagem com vírgula
> 5Funções proxy, codificação de chaves de propriedade, injeção de ruído, integridade própria
> 8Exaustão da janela de contexto
> 10Codificação de variáveis globais

O multiplicador de código morto escala de 1x (proporção 30) a 150x (proporção 1500+), controlando o número e o tamanho dos casos de switch mortos e dos ramos de predicados opacos.

Estrutura do Projeto

root@kitploit:~
src/
  index.ts              Ponto de entrada da CLI
  obfuscator.ts         Orquestrador principal do pipeline (20 transformações)
  options.ts            Sistema de orçamento e opções
  types.ts              Definições de tipos da AST
  random.ts             Geração de nomes Unicode aleatórios (6-16 caracteres, 16 intervalos de scripts)
  ast.ts                Funções de fábrica de nós da AST
  keywords.ts           Descoberta dinâmica de palavras-chave (pacote globalThis + window)
  globals.ts            Gerenciamento de estado global (mapas com protótipo nulo)
  substitute.ts         Utilitários de substituição de identificadores
  declarations.d.ts     Declarações de tipos de módulos
  passes/
    firstPass.ts        Catalogação de identificadores
    secondPass.ts       Substituição de identificadores + codificação de strings
    thirdPass.ts        Injeção de parâmetros fantasma
  transforms/
    antiDebug.ts        Armadilhas eval("debugger") + loops de setInterval
    tripwires.ts        Verificações de entrada secreta de programa perfurado [Paper 4]
    noiseInjection.ts   Ruído aritmético inspirado em LPN [Paper 7]
    controlFlowFlattening.ts  Despacho com while/switch + aritmética modular [Paper 3]
    opaquePredicates.ts       15 predicados matemáticos sempre verdadeiros/falsos
    proxyFunctions.ts         Despachantes de achatamento de grafo de chamadas
    contextExhaustion.ts      Ruído com ternários/void para preenchimento de contexto de LLMs
    commaExpressions.ts       Mesclagem de instruções via operador vírgula
    globalVariableEncoding.ts eval+replace para globais
    propertyKeyEncoding.ts    Acesso computado a propriedades com registros por escopo
    numberEncoding.ts         11 estratégias de codificação bit a bit/aritmética
    selfIntegrity.ts          Verificações de tempo de execução anti-adulteração [Paper 10]
    stringArrayExtraction.ts  XOR encadeado + erros esparsos de posição [Papers 2, 9]
    deadCodeInjection.ts      Código morto baseado em modelos + mutação [Paper 3]
  verification/
    nullCircuitTest.ts        Pontuação de qualidade do código morto [Paper 10]
    unobfuscatableTests.ts    Casos de teste de extração de segredos [Paper 1]
  __tests__/                  300+ testes unitários em 21 suítes
tools/
  obfuscate-package.ts  Teste de compatibilidade de pacotes npm baseado em webpack
tests/
  input*.js             Arquivos originais de entrada de teste

Testes

root@kitploit:~
# Executa todos os testes
npm test

# Executa uma suíte de testes específica
npx jest controlFlowFlattening
npx jest tripwires
npx jest noiseInjection

# Testa com pacotes npm (clona repositórios, empacota com webpack, ofusca, executa testes)
npm run obfuscate-package                    # Todos os 10 pacotes
npm run obfuscate-package -- minimist semver # Pacotes específicos

Ferramenta de Teste de Compatibilidade

A ferramenta tools/obfuscate-package.ts testa o ofuscador contra pacotes npm reais:

  1. Clona o repositório git do pacote
  2. Instala todas as dependências (incluindo devDependencies para testes)
  3. Compila o pacote se ele tiver um script de build
  4. Usa webpack para empacotar o ponto de entrada principal da biblioteca em um único arquivo CommonJS
  5. Executa o ofuscador no arquivo empacotado
  6. Substitui o ponto de entrada principal da biblioteca pelo bundle ofuscado
  7. Executa a própria suíte de testes da biblioteca contra a versão ofuscada

Locais de saída

CaminhoConteúdo
dist/obfuscated/<package>/bundle.jsO bundle webpack ofuscado de cada pacote
dist/obfuscated/report.jsonRelatório JSON completo com tamanhos de bundle, status da ofuscação, saída dos testes

Licença

MIT - Copyright 2026 Nicholas Starke

Baixar ferramenta
mangle: false
compress: false