Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
Outils/GitHubGitHub/nstarke/egodeath
Static AnalysisCode AnalysisReverse EngineeringPapers & ResearchLearning & Education
GitHubnstarke/egodeath

egodeath

A JavaScript Obfuscator based on Cryptographic Indistinguishability Obfuscation techniques

Voir le dépôt
53544il y a 1 jourVérifié par Kitploit
Partager
Contenu non disponible dans la langue demandée. Affichage de la version anglaise.

egodeath

This project does not achieve indistinguishability obfuscation. You should not be using this to product to protect secrets. It exists to deter reverse engineering, not prevent it

Tests

images/screenshot.png A JavaScript obfuscator designed to make code extremely difficult to read and analyze for both humans and LLMs. Written in TypeScript. Implements techniques from peer-reviewed cryptographic obfuscation research.

Requirements

Node.js 24 is the default (see .nvmrc); Node.js 26 also works. The supported range is ^24.15.0 || ^26.0.0. Node.js 22 and earlier are not supported. engine-strict=true in .npmrc makes npm install reject an unsupported version up front rather than failing later with an opaque error.

nvm use   # picks up .nvmrc

Installation

npm install -g egodeath      # CLI
npm install egodeath         # library

Library usage

const { obfuscate, obfuscateMultiple } = require('egodeath');

const out = obfuscate(sourceCode, { targetTokens: 10000 });

From source

npm install
npm run build
node dist/cli.js input.js > output.js

CLI Usage

# Basic usage
npx egodeath input.js > output.js

# With target token budget (default: 2,000,000)
npx egodeath --target-tokens 500000 input.js > output.js

# Minimal obfuscation (small output)
npx egodeath --target-tokens 10000 input.js > output.js

# Maximum bloat (10M tokens)
npx egodeath --target-tokens 10000000 input.js > output.js

# Using environment variable
INPUT_FILE=input.js npx egodeath > output.js

# Help
npx egodeath --help

Options

OptionDefaultDescription
--target-tokens <n>2000000Target output size in tokens. Small inputs are bloated up to this limit. Large inputs produce less bloat to stay within budget.
--help, -hShow help message

npm scripts

npm run build              # Compile TypeScript to dist/
npm run start              # Run the obfuscator (reads input.js)
npm run test               # Run the test suite
npm run typecheck          # Type check application, tests, and tools
npm run obfuscate-package  # Run compatibility tests against npm packages

Programmatic API

const { obfuscate } = require('./dist/obfuscator');

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

// With options
const obfuscated = obfuscate(code, { targetTokens: 500000 });

Strict CSP / Manifest V3

Use the explicit opt-in CSP-safe profile when the output must run without string code generation (for example, a Manifest V3 popup or service worker):

const { obfuscate } = require('egodeath');
const ratio = 30;
const output = obfuscate(sourceCode, {
  targetTokens: Math.ceil(sourceCode.length * ratio / 4),
  cspSafe: true,
  stubConsole: false,
});
npx egodeath --csp-safe --no-console-stub --target-tokens 30000 input.js > output.js

cspSafe is also accepted by obfuscateMultiple. It is false by default, so existing callers keep the original profile. Ratio 30 is a budget heuristic: targetTokens * 4 / input.length, not an exact output-size multiplier or security level. Rounding the token count can make the ratio slightly larger than 30.

The profile keeps the same budget and compatible transforms:

  • Identifier and closed-object/class renaming, dummy parameters, and comment removal.
  • Control-flow flattening, dead code, opaque predicates, proxy dispatchers, context padding, comma merging, arithmetic noise, and tripwires.
  • Property, number, regex, template, and chained string-array encoding.
  • Anti-debug traps and timers use literal debugger statements instead of evaluating encoded debugger strings. Debugger traps are consequently easier to recognize; they can still pause execution when developer tools are attached.
  • Timing and function toString integrity probes remain. The eval-native probe is omitted, and the global-variable eval-encoding transform is skipped. Global identifiers therefore remain visible; their lexical lookup behavior is kept.

This mode changes generated helpers, not source semantics. Source-provided eval, Function constructors, or string timers remain incompatible with strict CSP. Do not treat this as a sanitizer or a promise that arbitrary inputs run in an extension. It does not change a manifest, add unsafe-eval, or lower the budget. Use stubConsole: false / --no-console-stub when sharing a runtime with libraries whose logging should remain available. Existing integrity/tripwire behavior and performance tradeoffs still apply.

Validation includes ratio-30 execution with Node VM string code generation disabled, delayed timer callbacks, lexical shadowing, ESM imports/live exports, batch and CLI entry points. A manual Chromium Manifest V3 smoke check of the generated profile also passed without unsafe-eval; applications should test their own final bundle because source callbacks serialized into another execution context must remain self-contained.

Transform Pipeline

The obfuscator applies 20 transforms across 4 phases. Each stage builds on the previous one.

Phase 1: Security & Anti-Analysis Pre-transforms

OrderTransformFileDescription
1Anti-Debug Trapstransforms/antiDebug.tsInjects eval("debugger") statements and 10-20 setInterval loops with prime-number intervals (5s-600s) that repeatedly trigger debugger breakpoints. Each instance uses unique encoded strings.
2Punctured Program Tripwirestransforms/tripwires.tsEmbeds hidden checks comparing parameter hashes against secret values. 5 hash patterns (bitwise fingerprint, modular arithmetic, charCodeAt, numeric hash, typeof+length). Triggers silent state corruption, busy loops, or throws on secret inputs. [Paper 4]
3LPN Noise Injectiontransforms/noiseInjection.tsAdds and cancels random noise through split paths in arithmetic computations. 6 patterns: add/sub, XOR, mul/div, split dual-variable, computed hash-chain, bit-rotate. Intermediate values are meaningless without tracing full cancellation. [Paper 7]

Phase 2: Structural Pre-transforms

OrderTransformFileDescription
4Control Flow Flatteningtransforms/controlFlowFlattening.tsConverts function bodies into while(true) { switch((_s * P) % M) { ... } } state machines with modular arithmetic dispatch — case values are encoded through (stateId * multiplier) % modulus using random prime parameters. [Paper 3]
5Opaque Predicatestransforms/opaquePredicates.tsInjects if conditions that always evaluate to true or false but are mathematically hard to prove (e.g., (x*x+x)%2===0). 15 predicate formulas across modular arithmetic, bitwise, and type-check categories.
6Proxy Functionstransforms/proxyFunctions.tsRoutes all function calls through two dispatchers: _fc(fn, ...args) for simple calls, _mc(obj, prop)(...args) for method calls, preserving method lookup before argument evaluation. Uses Function.prototype.apply captured in a local variable for resilience.
7Context Window Exhaustiontransforms/contextExhaustion.tsWraps expressions in deeply nested ternaries with opaque conditions, void-expression chains, and conditional void padding. Forces LLMs to waste context window tokens on noise.
8Comma Expression Mergingtransforms/commaExpressions.tsCollapses consecutive expression statements into single comma expressions: a(); b(); return c() becomes return a(), b(), c().

Phase 3: Identifier Passes

Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    732
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    506
  • 3

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    405
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    342
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    261
  • 6

    antifox

    antifox-ai/antifox

    Plateforme de test d'intrusion autonome multi-agents par IA qui exécute la reconnaissance, la découverte de la surface d'attaque, la validation de l'exploitation et la livraison de rapports étayés par des preuves.

    259

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →