retour aux outils back to tools Ducklings

OllyDBG

Débogueur au niveau assembleur x86 32 bits pour binaires Windows, longtemps une référence pour l'analyse manuelle de malware et le développement d'exploits. 32-bit x86 assembler-level debugger for Windows binaries, long a staple for manual malware analysis and exploit development.

↗ http://www.ollydbg.de

Overview

OllyDBG is a user-mode Windows debugger that operates at the assembly level, combining a disassembler, register/stack/memory views, and dynamic analysis features (breakpoints, tracing, patching) in a single GUI. It remains popular for reverse engineering legacy 32-bit Windows malware and manually crafting exploits where step-by-step control over execution is needed, despite being largely superseded by x64dbg for modern work.

Common Usage

GUI-driven — typical workflow via menus and hotkeys:

File → Open           Load a target EXE/DLL for debugging
File → Attach          Attach to an already-running process
F2                     Toggle breakpoint at cursor
F7                     Step into
F8                     Step over
F9                     Run / continue
Ctrl+F9                Execute till return
Alt+M                  Memory map view
Alt+B                  Breakpoints window
Alt+C                  CPU window (disassembly/registers/stack)
Ctrl+G                 Go to address/expression

Common Workflows

1. Load the binary:            File → Open → target.exe
2. Find the entry point:       View → Executable modules → double-click module
3. Set a breakpoint on an API: Right-click disassembly → Search for → 
                                All intermodular calls → filter e.g. VirtualAlloc
4. Trace execution:            F7/F8 to step, watch registers/stack update live
5. Patch in memory:             Right-click instruction → Assemble, or
                                Binary → Edit on the hex pane
6. Dump patched process:        Use an OllyDump plugin to rebuild a PE from memory

Tips

OllyDBG 1.x only supports 32-bit binaries — for x64 targets use x64dbg instead.
Plugins (OllyDump, Hide Debugger, Command Line) extend it significantly and are commonly needed against packed/protected malware.
Anti-debug checks (IsDebuggerPresent, timing checks) are common in malware — pair with a plugin like ScyllaHide to defeat them.

Help / Man page

OllyDbg is a GUI application; there is no traditional CLI --help.

Command-line invocation:
  ollydbg.exe [target.exe] [arguments]
  ollydbg.exe -p <PID>        attach to running process

Key hotkeys:
  F2    Toggle breakpoint
  F3    Open new executable
  F4    Run to cursor
  F7    Step into
  F8    Step over
  F9    Run
  Ctrl+F2   Restart
  Ctrl+F9   Execute till return
  Alt+B     Breakpoints window
  Alt+M     Memory map
  Alt+C     CPU window
  Alt+E     Executable modules
  Ctrl+G    Go to address

Vue d’ensemble

OllyDBG est un débogueur Windows en mode utilisateur qui opère au niveau assembleur, combinant un désassembleur, des vues registres/pile/mémoire, et des fonctionnalités d’analyse dynamique (points d’arrêt, traçage, patch) dans une seule interface graphique. Il reste populaire pour le reverse engineering de malware Windows 32 bits legacy et la création manuelle d’exploits nécessitant un contrôle pas à pas de l’exécution, bien qu’il soit largement supplanté par x64dbg pour le travail moderne.

Utilisation courante

Piloté par l’interface graphique : flux de travail typique via menus et raccourcis clavier :

File → Open           Charger un EXE/DLL cible pour le débogage
File → Attach          S'attacher à un processus déjà en cours d'exécution
F2                     Basculer un point d'arrêt au curseur
F7                     Step into (entrer dans l'appel)
F8                     Step over (passer par-dessus l'appel)
F9                     Exécuter / continuer
Ctrl+F9                Exécuter jusqu'au retour
Alt+M                  Vue de la carte mémoire
Alt+B                  Fenêtre des points d'arrêt
Alt+C                  Fenêtre CPU (désassemblage/registres/pile)
Ctrl+G                 Aller à une adresse/expression

Flux de travail courants

1. Charger le binaire :             File → Open → target.exe
2. Trouver le point d'entrée :      View → Executable modules → double-clic sur le module
3. Poser un point d'arrêt sur une API : clic droit sur le désassemblage → Search for →
                                     All intermodular calls → filtrer par ex. VirtualAlloc
4. Tracer l'exécution :             F7/F8 pour avancer pas à pas, observer registres/pile en direct
5. Patcher en mémoire :              clic droit sur l'instruction → Assemble, ou
                                     Binary → Edit sur le panneau hexadécimal
6. Dumper le processus patché :      utiliser un plugin OllyDump pour reconstruire un PE depuis la mémoire

Conseils

OllyDBG 1.x ne supporte que les binaires 32 bits : pour les cibles x64 utiliser x64dbg à la place.
Les plugins (OllyDump, Hide Debugger, Command Line) l’étendent considérablement et sont souvent nécessaires face à des malwares packés/protégés.
Les vérifications anti-debug (IsDebuggerPresent, contrôles de timing) sont courantes dans les malwares : associer avec un plugin comme ScyllaHide pour les contourner.

Aide / Page de manuel

OllyDbg is a GUI application; there is no traditional CLI --help.

Command-line invocation:
  ollydbg.exe [target.exe] [arguments]
  ollydbg.exe -p <PID>        attach to running process

Key hotkeys:
  F2    Toggle breakpoint
  F3    Open new executable
  F4    Run to cursor
  F7    Step into
  F8    Step over
  F9    Run
  Ctrl+F2   Restart
  Ctrl+F9   Execute till return
  Alt+B     Breakpoints window
  Alt+M     Memory map
  Alt+C     CPU window
  Alt+E     Executable modules
  Ctrl+G    Go to address