REAgent est un agent IA autonome et open-source conçu pour automatiser et accélérer les tâches de reverse engineering (RE) sur des binaires Windows PE (Portable Executable), en se concentrant sur les workflows répétitifs et chronophages qui ralentissent les experts en cybersécurité. Contrairement aux outils existants comme DecompAI ou ReverserAI, qui se limitent souvent à l'assistance statique ou à des plugins pour des décompilateurs, REAgent adopte une approche "goal-driven" : il reçoit un objectif en langage naturel (ex. : "Trouve comment fabriquer une clé de licence valide pour cette application") et orchestre une analyse statique, dynamique et hybride pour atteindre cet objectif, tout en préservant la confidentialité via des modèles LLM locaux.

Le projet cible les experts en RE (reverseurs, analystes malware, pentesters) en automatisant les "boulots sales" : résolution d'ordinals inter-modules, neutralisation de protections anti-debug, nettoyage de code assembleur pour une lisibilité optimale, et interactions basiques avec l'UI de l'application. Il est conçu pour tourner sur du hardware grand public comme une RTX 3080, en utilisant des modèles quantisés (7B-14B) pour éviter les fuites de données vers des serveurs cloud. REAgent n'est pas un outil de cracking grand public, mais un POC de recherche pour l'analyse de sécurité, la forensics et l'éducation en cybersécurité.

Le reverse engineering manuel est puissant mais laborieux : suivre les appels par ordinal entre un EXE et plusieurs DLL peut prendre des heures, neutraliser des checks comme IsDebuggerPresent est routinier mais répétitif, et interagir avec une GUI pour déclencher des breakpoints dynamiques ajoute de la friction. REAgent vise à gagner du temps sur ces aspects mécaniques, laissant l'expert se concentrer sur l'analyse sémantique et les décisions critiques.

Inspiré par des projets comme Ghidra, x64dbg et des prototypes IA (ReverserAI, DecompAI), REAgent se distingue par :

• Autonomie locale : 100% offline, optimisé pour GPU NVIDIA (RTX 3080+).
• Gestion multi-fichiers avancée : Suivi automatique des imports/exports par ordinal, fusion de graphes d'appels cross-modules.
• Orchestration hybride : Boucle agent (plan → action → observation) combinant scripts symboliques et LLM pour le raisonnement.
• Modes flexibles : Entièrement autonome pour les cas simples, semi-assisté pour les scénarios complexes.
• Focus offensif/défensif : Automatisation de bypass pour l'analyse malware ou la recherche de vulnérabilités, dans un cadre éthique (recherche/POC uniquement).

• Détection et isolation de portions pertinentes : À partir d'un objectif (ex. : "licence"), scanne les binaires pour identifier strings, imports suspects (crypto, serial checks), et chemins CFG (Control Flow Graph) liés. Évite le "copier-coller massif" en chunkant intelligemment (fonctions/basic blocks) pour respecter la fenêtre de contexte LLM (typiquement 4k-8k tokens).
• Renommage sémantique : Utilise un LLM local pour proposer des noms lisibles aux variables/fonctions (ex. : sub_401000 → verifySerialKey), avec post-processing pour cohérence inter-fichiers.
• Support multi-fichiers : Charge EXE + DLLs, résout ordinals via tables d'exports (bases comme RetDec), et reconstruit un graphe unifié d'appels (qui appelle quoi, avec propagation des renommages).

• Pilotage de debuggers : Intègre x64dbg ou GDB en mode headless pour poser des breakpoints, exécuter des traces, et collecter des états (registres, stack, mémoire).
• Interactions GUI automatisées :
  • Mode structuré : Utilise pywinauto pour cibler contrôles par nom/role (ex. : cliquer "Register", saisir un serial test).
  • Fallback vision : Capture d'écran (Pillow/pyautogui) → analyse par LLM multimodal (ex. : LLaVA) → clic en coordonnées (X,Y) et saisie clavier.
• Boucle d'itération : L'agent planifie (LLM), agit (scripts), observe (traces/logs), et affine (ex. : si anti-debug détecté, patch et relance).

• Détection de patterns : Scans pour anti-debug courants (IsDebuggerPresent, NtQueryInformationProcess, PEB.BeingDebugged, checks timers comme RDTSC/GetTickCount) et anti-analyse (packers simples, string encryption, API hashing).
• Bypass automatisé :
  • Patch binaire : Modifie opcodes (ex. : JNE → JMP pour IsDebuggerPresent) et génère un EXE/DLL patché.
  • Patch en mémoire : Via loader ou hooks (ex. : forcer PEB à 0).
  • Dépackage basique : Breakpoint sur VirtualAlloc, dump OEP (Original Entry Point), et ré-analyse sur l'image dépackée.
  • Décryptage strings/hashes : Extrait routines (XOR/ROL), les exécute offline, et renomme APIs/chaînes.
• Relance fluide : Après patch, recharge le binaire modifié dans le décompilateur (Ghidra headless) et continue l'analyse.

• Mode Autonome : Exécute un plan complet jusqu'à un objectif (succès ou blocage). Produit un rapport : fonctions clés, hypothèses (ex. : "Clé valide = MD5(serial + user) == constante 0xABC"), graphes annotés.
• Mode Semi-Assisté : Si bloqué (ex. : itérations sans progrès), expose état (captures, candidats) et attend instructions (ex. : "Ignore cette DLL", "Clique sur bouton X"). Réutilise tout le contexte accumulé.

• Résolution d'ordinals/hashes : Mapping automatique vers noms d'APIs, avec clustering heuristique pour inconnus.
• Génération de rapports : Diagrammes (via Graphviz) des flux inter-modules, logs annotés, et suggestions de patches (ex. : NOP pour checks).
• Tests d'hypothèses : Génère serials tests, les injecte, et valide via traces dynamiques.

REAgent est modulaire, en Python 3.10+, avec une séparation claire entre :

• Backend RE : Ghidra/Binary Ninja/radare2 headless pour analyse statique (CFG, xrefs, exports).
• Orchestrateur Agent : Boucle LangChain-like (plan LLM → outils scripts → observation) pour autonomie.
• LLM Local : Ollama/llama.cpp pour modèles quantisés (ex. : DeepSeek-Coder 7B Q4 sur RTX 3080, ~10-20s/inférence).
• Outils Dynamiques : x64dbg API pour debug, pywinauto/pyautogui pour GUI.
• Stockage : Base SQLite pour mémoire (faits sur binaires, renommages persistants).

Flux typique :

1. Input : reagent analyze --target "licence" --files app.exe lib.dll
2. Statique : Parse PE, résout ordinals, ranke fonctions.
3. Plan LLM : "Poser BP sur verify_func, tester serial random".
4. Action : Lance x64dbg, interagit GUI si besoin, patch si anti-debug.
5. Observation : Analyse traces via LLM.
6. Output : Rapport Markdown + binaires patchés.

• Hardware : GPU NVIDIA (RTX 3080 recommandé, 10GB+ VRAM pour modèles 7B-14B).
• OS : Windows 10+ (cible PE), ou Linux pour dev.
• Dépendances :
  • Python 3.10+.
  • CUDA 11.8+ pour GPU (ou CPU fallback).
  • Outils RE : Ghidra (headless), x64dbg, radare2.
  • LLM : Ollama installé avec modèle (ex. : ollama pull deepseek-coder:7b-q4).

1. Clone le repo :

   git clone https://github.com/yourusername/reagent.git
   cd reagent
   

2. Environnement virtuel :

   python -m venv venv
   source venv/bin/activate  # Linux/Mac
   # ou venv\Scripts\activate  # Windows
   pip install -r requirements.txt
   

   (Inclut : langchain, ollama, pywinauto, pyautogui, pillow, graphviz, pefile, capstone.)

3. Configure LLM :

   • Édite config.yaml : Spécifie modèle (ex. : deepseek-coder), threads GPU (ex. : 30 layers sur 3080), seed pour reproductibilité.
   • Lance Ollama : ollama serve.

4. Installe outils RE :

   • Télécharge Ghidra, ajoute à PATH.
   • Installe x64dbg, configure API pour scripting.

5. Test :

   python main.py --help
   reagent init --model deepseek-coder
   

• Analyse autonome :

  reagent analyze --target "Trouve la logique de clé de licence" --files app.exe --mode autonomous --output report.md
  

  • Génère rapport avec graphes, patches, et hypothèses.

• Mode semi-assisté :

  reagent analyze --target "Vérifie serial" --files app.exe --mode assisted
  

  • Pause à blocages, prompt pour instructions (ex. : "Clique sur 'OK'").

• Bypass spécifique :

  reagent bypass --type anti-debug --files app.exe --method patch-binary
  

  • Détecte/neutralise IsDebuggerPresent, etc., et produit app_patched.exe.

• Nettoyage multi-fichiers :

  reagent clean --files app.exe lib1.dll lib2.dll --focus ordinals
  

  • Résout ordinals, renomme, exporte graphe unifié.

1. Lance : reagent analyze --target "Fabrique clé licence" --files myapp.exe crypto.dll
2. Agent : Scan statique → Détecte ordinal 42 dans crypto.dll (résolu en CryptVerifySignature).
3. Dynamique : Pose BP sur routine, automatise GUI (clic "Register", serial test).
4. Anti-debug : Détecte IsDebuggerPresent → Patch JNE en JMP → Relance sur version modifiée.
5. Rapport : "Clé = SHA1(user + date) mod 10000 == 0. Hypothèse validée par trace."

• config.yaml : Ajuste contexte LLM (max_tokens: 4096), seuils de confiance (ex. : >0.7 pour renommages auto), fallbacks GUI.
• Logs : Verbose via --verbose pour debug (traces x64dbg, inférences LLM).

• Limites techniques : Modèles locaux (7B) hallucinent sur code complexe ; pas pour binaires obfusqués avancés (VMProtect, etc.). GUI fallback (vision) flaky sur layouts dynamiques. Temps : 5-30min par analyse sur RTX 3080.
• Éthique/Légal : Conçu pour recherche/éducation (POC malware, forensics). Ne pas utiliser pour cracking illégal. Respecte DMCA/EULA ; documente tout usage.
• Performances : Testé sur PE x64 non-packés ; extension à ARM/Android en TODO.

• v0.1 (MVP) : Analyse statique + ordinals + bypass basique (IsDebuggerPresent).
• v0.2 : Intégration dynamique (x64dbg + pywinauto) + mode assisté.
• v0.3 : Support packers simples + LLM multimodal pour GUI.
• Futur : Fine-tuning modèles RE-spécifiques, support Linux ELF, intégration IDA/Ghidra plugins, CI/CD pour tests sur binaires synthétiques.

Contributions bienvenues ! Fork, PR pour :

• Nouveaux bypass (ex. : anti-VM).
• Modèles alternatifs (Mistral, Qwen).
• Tests sur binaires réels (anonymisés).

Guidelines : Suivre PEP8, ajouter tests (pytest), documenter prompts LLM.

MIT License. Voir LICENSE pour détails. Projet open-source pour la communauté cybersécurité.