← retour aux outils back to tools

# 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