Reverse Engineering Platforms: Ghidra, IDA, Binary Ninja, and Cutter
- What an RE Platform Does
- The Platforms at a Glance
- Installation and Licensing
- The Concepts You Need First
- Getting Started with Ghidra
- Getting Started with IDA
- Getting Started with Binary Ninja
- Getting Started with Cutter
- Side-by-Side: Common Operations
- A Suggested First-Binary Workflow
- Scripting and Automation
- Choosing a Tool
- Troubleshooting
- Further Reading
This page introduces four reverse engineering (RE) platforms. Ghidra (NSA) is the tool this course uses, and the one every assignment assumes. IDA (Hex-Rays), Binary Ninja (Vector 35), and Cutter (the Rizin-based GUI) are covered because you will meet all three in industry and in published write-ups, and because knowing what a tool does well is part of knowing when to reach for it. It assumes you are already comfortable reading x86 assembly and have worked through basic malware triage — extracting strings, checking imports, examining PE headers, and running file/hash/entropy checks. This page picks up where triage ends: you have an interesting binary, and now you need to understand what it actually does.
All four tools attempt to solve the same core problem — turn a binary back into something a human can reason about — and they share most of the same vocabulary. Once you know how to navigate one, the others feel familiar. The differences show up in cost, licensing, decompiler quality, debugger integration, and scripting ecosystems.
What an RE Platform Does
A reverse engineering platform is a workbench for static binary analysis. Every one of these tools does the following things, just with different names and hotkeys:
- Loader — parses the executable format (PE, ELF, Mach-O, raw binary, firmware image) and maps sections into a virtual address space the same way the OS loader would.
- Disassembler — converts machine code into assembly, identifies function boundaries, and recovers stack frames and parameter layouts.
- Cross-referencer — builds a bidirectional index of “who calls this function,” “who reads this string,” and “where does this jump come from.” This is the single most important feature for analysis work; you will use it constantly.
- Decompiler — translates assembly into C-like pseudocode. All four have a decompiler, though their quality, licensing, and availability differ.
- Database — stores your annotations (renames, comments, type information, structure definitions) so your analysis survives closing the program.
- Scripting / plugin interface — lets you automate repetitive tasks and build on top of the platform.
The workflow is the same everywhere: load → auto-analyze → navigate from known starting points (imports, strings, entry point) → rename and comment as you understand code → iterate until the behavior is clear.
The Platforms at a Glance
| Feature | Ghidra | IDA | Binary Ninja | Cutter |
|---|---|---|---|---|
| License / cost | Free and open source (Apache 2.0) | Commercial; IDA Free is heavily limited | Commercial (Vector 35); limited free tier, student-priced Non-Commercial | Free and open source (GPLv3) |
| Developer | US National Security Agency | Hex-Rays | Vector 35 | Rizin Organization |
| First released | 2019 (publicly released) | 1991 | 2016 | 2018 |
| Implementation | Java (requires JDK 21) | C++ native binary | C++ core with a Python API | Qt/C++ frontend over Rizin (C) |
| Primary view | Listing + Decompiler side by side | Graph view (toggle with Space) | Linear or graph, with an IL selector | Disassembly + Graph + Decompiler, freely arranged |
| Decompiler | Native, full-featured, recovers C++ classes | Hex-Rays — the commercial benchmark | HLIL, the top of the BNIL stack | Ghidra decompiler via rz-ghidra, plus jsdec |
| Debugger | Yes (less mature) | Yes (local and remote; gdb, WinDbg, Bochs) | Yes (built in) | Yes (via Rizin; gdb/lldb/windbg/native) |
| Architecture support | ~30 architectures including PPC, MIPS, SH-4, 6502, PIC | Broad; varies by license tier | 5 (Free) to 19+ (Ultimate) | Very broad (inherited from radare2’s esil engine) |
| Scripting | Java plugins, Jython, PyGhidra | IDC, IDAPython | Python API — not in the Free tier | Rizin commands, Python and C++ plugins |
| Headless automation | Yes, analyzeHeadless, no license needed |
Yes (idat) |
Commercial tier and above only | Yes, via Rizin |
| Project model | Project holds many binaries; shared multi-user repos | Single .idb / .i64 per binary |
Per-file .bndb database |
Rizin project files (.rzdb) |
The one-sentence summary: Ghidra is free, scriptable without a license, and scales to multi-binary projects, which is why this course uses it; IDA is the long-standing commercial reference with the most polished UI and the best signature database; Binary Ninja is the modern commercial challenger, with the cleanest API and its BNIL tower of intermediate languages; Cutter is the lightweight open-source option that lets you drop to a Rizin command line whenever the GUI gets in the way.
Installation and Licensing
Ghidra
Download a pre-built release from the Ghidra GitHub releases page. Requires JDK 21 (64-bit). Extract the archive and launch:
# Linux / macOS
./ghidraRun
# Windows
ghidraRun.bat
On REMnux, Ghidra is pre-installed; just type ghidra at the shell. There is no license to
request, no registration, and no per-student key — which is a large part of why the course
standardized on it.
IDA
IDA is commercial. IDA Free exists but is limited, and this course no longer provisions educational licenses. IDA is described here for comparison, since it remains the reference point most published malware write-ups are written against.
Binary Ninja
Binary Ninja is commercial, from Vector 35. The tiers differ in ways that matter for coursework:
- Free — browser-based demo aside, the free tier covers a handful of architectures and file formats, is non-commercial, and has no plugin or Python API and no headless mode.
- Non-Commercial (Personal) — student pricing available; adds architectures and lets you use the API from the GUI console, but still no headless automation.
- Commercial / Ultimate — adds headless automation and the full plugin API.
The API restriction is the one to note: scripted or batch analysis needs a Commercial license,
whereas Ghidra’s analyzeHeadless is free. Current release is 6.0 (“Krypton”, 2026); check the
purchase page for pricing, which changed with 6.0.
Cutter
Download from the Cutter releases page. Platform packages:
- macOS:
.dmg - Windows:
.zip(portable) or.msi - Linux:
.AppImage
chmod +x Cutter-v*-x86_64.AppImage
./Cutter-v*-x86_64.AppImage
Cutter bundles Rizin; no separate installation required. REMnux ships with Cutter as well.
The Concepts You Need First
Before walking through each tool, here are the concepts that show up in all four. Learn them once and the platform-specific terminology follows.
Loaders and Base Addresses
When a platform loads a binary, it parses the container format and lays the sections out in virtual memory exactly as the OS loader would. This is why the addresses you see (0x00401000, 0x10001757) match what you’d see at runtime in a debugger. Malware frequently appends shellcode or encrypted blobs after the normal PE sections; the loader won’t include these by default. All four platforms offer a “raw binary” or “manual load” option to force every byte into the analysis view.
Auto-Analysis
After loading, each tool runs an analysis pass that starts at the entry point, follows control flow through call/jmp/jcc instructions, marks function boundaries, recovers stack frames, and identifies strings and data. This takes anywhere from a few seconds (small EXEs) to several minutes (statically linked binaries). Let auto-analysis finish before you start working — navigating into unanalyzed regions will confuse you.
Disassembly Views: Linear vs. Graph
- Linear (text) view — instructions shown sequentially by address, the way they sit in the file. Good for seeing data interspersed with code, inspecting jump tables, or scanning long basic blocks.
- Graph view — each function rendered as a flowchart of basic blocks connected by control-flow edges. Good for understanding conditionals, loops, and switch structures at a glance.
In all of them, edge color conveys branch semantics (taken/not-taken/unconditional). Upward-pointing edges are loops.
Decompilers
A decompiler lifts assembly into C-like pseudocode. This is not the original source — variable names are synthesized, control-flow may be restructured, and types are guessed from usage — but it is dramatically easier to read than assembly for most functions. The four tools handle decompilation differently:
- Ghidra has a native decompiler widely considered the strongest free option; it recovers C++ classes and handles unusual calling conventions well.
- IDA uses the Hex-Rays decompiler, the commercial benchmark, licensed per architecture family.
- Binary Ninja exposes a stack of intermediate languages (BNIL): LLIL lifts each machine instruction, MLIL removes architecture-specific detail, and HLIL is the decompiler output. Being able to drop one layer at a time is genuinely useful on obfuscated code.
- Cutter can use jsdec (built in, approximate) or delegate to the Ghidra decompiler via the
rz-ghidraplugin (same engine as Ghidra proper).
Workflow tip: read the decompiler output first to form a hypothesis, then drop to assembly to verify the details. Don’t trust the decompiler blindly — optimized or obfuscated code produces misleading pseudocode.
Cross-References (XRefs)
Every tool tracks two categories:
- Code xrefs — who calls this function, who jumps here
- Data xrefs — who reads this string, who writes this global
Cross-references are how you move through a binary productively. You find an interesting API call in Imports → follow its xrefs to see every caller → rename the caller based on what it’s doing → follow its xrefs, and so on.
Renaming and Commenting
Auto-generated names like FUN_00401000, sub_401000, fcn.00401000, var_8, and arg_4 tell you nothing. As soon as you understand what a function or variable does, rename it. All of them propagate the new name to every reference. Add comments for the why (non-obvious constraints, observed behavior, references to external documentation) rather than the what (which the code already says).
The Database / Project
Your analysis is saved in a per-binary database:
- Ghidra: inside the project directory, a
.gprfile plus storage - IDA:
.idb(32-bit) or.i64(64-bit) - Binary Ninja: a
.bndbdatabase beside the original file - Cutter:
.rzdbRizin project file
Save often. None of these tools have a crash recovery model as reliable as modern IDEs, and large malware samples can provoke interesting bugs.
Getting Started with Ghidra
Creating a Project
Ghidra organizes work into projects, which hold one or more binaries plus your annotations. On first launch, create a project via File → New Project → Non-Shared Project, pick a directory, and name it. Projects persist across sessions; you can import many binaries into the same project and cross-reference between them (useful for malware families with multiple components).
Importing and Analyzing
Drag a binary into the project window, or use File → Import File. Ghidra auto-detects the format and opens an import dialog; the defaults are almost always correct. Once imported, double-click the binary to open it in the CodeBrowser, then say Yes to the auto-analyze prompt. The default analysis options are reasonable; for malware, leave Decompiler Parameter ID and Stack enabled.
The CodeBrowser
The CodeBrowser is Ghidra’s main analysis environment. The default layout shows:
- Listing (center) — the disassembly, similar to IDA’s text mode. Ghidra does not have a separate “graph mode” by default; graphs open in a separate window.
- Decompiler (right) — live C-like pseudocode for the current function. Click anywhere in the decompiler and the listing cursor follows; click in the listing and the decompiler highlights the matching line. This bidirectional linking is Ghidra’s signature feature.
- Symbol Tree (left) — organized view of Imports, Exports, Functions, Labels, Classes, and Namespaces. Expand Imports first when analyzing malware.
- Data Type Manager (lower left) — all known types; drag a struct onto a variable to apply it.
- Program Tree (upper left, tab) — view by section (
.text,.data, etc.) - Console (bottom) — script output and messages.
Opening the Function Graph (Window → Function Graph, or the icon in the toolbar) gives you a graph view equivalent to IDA’s graph mode.
Navigation
| Action | Shortcut |
|---|---|
| Go to address or symbol | G |
| Back / forward in history | Alt+Left / Alt+Right |
| Show references to cursor | Ctrl+Shift+F (or right-click → References → Show References To) |
| Show references from cursor | Ctrl+Shift+E |
| Open Function Graph | Window → Function Graph |
| Open Decompiler if closed | Window → Decompiler |
| Find next function | Ctrl+Shift+F in Functions window |
Annotation
| Action | Shortcut |
|---|---|
| Rename label / function | L |
| Add comment | ; (opens comment dialog with all five types) |
| Cycle byte size (byte → word → dword → qword) | B |
| Cycle string type | “ |
| Cycle float type | F |
| Define function at cursor | F (in listing when on undefined bytes) |
| Disassemble | D |
| Undo | Ctrl+Z |
Ghidra’s comment system offers five distinct types (EOL, Plate, Pre, Post, Repeatable), all reachable from the single ; dialog. Use plate comments to mark section headers (“— Decryption routine —”) and EOL comments for inline notes.
Decompiler Workflow
The decompiler is where you spend most of your time in Ghidra. Key operations:
- Rename variable — right-click in decompiler → Rename Variable (or press L). Propagates everywhere.
- Retype variable — right-click → Retype Variable. Change
undefined4toint, or apply a struct pointer. - Edit function signature — right-click the function name at the top → Edit Function Signature. Fix parameter counts and types here first; correct types propagate through all callers.
- Highlight — click a variable; every use in the current function highlights. Click an if-condition; the corresponding compare-and-branch highlights in the listing.
Multi-Binary Projects
Ghidra’s killer feature for malware work is multi-binary projects. Import a dropper, its second-stage payload, and any dropped DLLs into the same project. You can cross-reference symbols across binaries and use Version Tracking (Tools → Version Tracking) to compare variants of the same family.
Getting Started with IDA
Loading a File
Drag the binary onto IDA or use File → Open. IDA’s loader dialog asks you to confirm the file format, processor, and loading options. Accepting defaults works for almost all PE/ELF malware; the two options worth knowing are:
- Binary File — forces IDA to treat the input as raw bytes (no PE parsing). Use this when analyzing shellcode dumps or firmware.
- Manual Load — lets you load each PE section including the PE header itself, which malware sometimes abuses to hide code.
Let auto-analysis complete before doing anything else (the progress bar at the bottom).
The Interface
The main window is the disassembly view, which opens in graph mode by default. Press Space to toggle between graph and text (linear) modes.
Subviews you will use constantly, found under View → Open Subviews:
- Functions — all recognized functions; L flag marks library functions identified by FLIRT (skip these)
- Imports — every API the binary calls; usually the first thing to check
- Exports — only relevant for DLLs
- Strings — ASCII and Unicode strings longer than 5 characters by default
- Names — every named location (functions, labels, globals)
- Structures — define or import struct layouts to improve readability
At the bottom of the toolbar is the navigation band, a color-coded map of the binary’s address space. Dark blue is user-written code — focus your analysis there.
Navigation
| Action | Shortcut |
|---|---|
| Jump to address or name | G |
| Jump to file offset | Jump → Jump to File Offset |
| Toggle graph / text mode | Space |
| Open pseudocode (decompile current function) | F5 (opens in new tab) or Tab (toggles) |
| Back / forward in history | Esc / Ctrl+Enter |
| Follow link (jump target, string, etc.) | double-click or Enter |
| Xrefs to the item under cursor | X |
| Xrefs from the current address | Ctrl+J |
Annotation
| Action | Shortcut |
|---|---|
| Rename | N |
| Local comment | : |
| Repeatable comment (shows at xrefs) | ; |
| Define as code | C |
| Define as data | D |
| Define as string | A |
| Undefine | U |
| Create function | P |
| Standard symbolic constant | M |
The M shortcut is especially useful when you see push 80000000h — pressing M lets you replace the literal with GENERIC_READ, instantly revealing that the nearby call is CreateFile.
Decompiler
Press F5 on any function to open the Pseudocode view in a new tab. Renames and type edits in the pseudocode propagate to the disassembly view and vice versa. Right-click a variable → Set lvar type to apply a C type; this often cleans up casts and reveals structure access.
Getting Started with Binary Ninja
Loading a File
Open the file and that is it — analysis starts automatically and runs incrementally, so there
is no modal “analyze now?” prompt and no progress bar to wait out before you can start reading.
Your annotations are written to a .bndb database beside the original file.
The Interface
The main view toggles between linear and graph with Space, as in IDA and Cutter. Sidebar panels cover the usual pivots — Symbols, Types, Strings, Cross References, Variables, Memory Map, Mini-Graph, Console, and Logs.
What distinguishes Binary Ninja is the IL selector. Rather than a single decompiler pane, the view itself can be switched between layers of the BNIL stack:
| Layer | What you get |
|---|---|
| Disassembly | Native instructions |
| LLIL (Low Level IL) | Each machine instruction lifted into architecture-independent operations |
| MLIL (Medium Level IL) | Architecture detail removed; variables and parameters recovered |
| HLIL (High Level IL) | The decompiler output — structured, with expressions folded |
| Pseudo C | HLIL rendered as C-like syntax |
Press i to cycle disassembly → LLIL → MLIL → HLIL, and F5 or Tab to toggle
Pseudo C against disassembly.
Being able to step down one layer at a time is the practical reason to reach for Binary Ninja. When HLIL shows something that looks wrong, MLIL often shows you why without dropping all the way to raw assembly — a middle ground the other three tools do not really offer.
Navigation and Annotation
| Action | Shortcut |
|---|---|
| Go to address | g |
| Toggle linear / graph | Space |
| Cycle IL views | i |
| Toggle Pseudo C | F5 or Tab |
| Cross-references to cursor | x |
| Rename symbol or variable | n |
| Add comment | ; |
Note that the rename and comment keys (n, ;) match IDA and Cutter; Ghidra’s L is the odd one
out. Navigation history is bound in Binary Ninja’s keybinding editor if you want it to match
whatever you use elsewhere.
Scripting
Binary Ninja’s Python API is widely considered the most pleasant of the four, and the BNIL layers
are exposed directly to it. The catch is licensing: the Free tier has no API at all, the
Non-Commercial tier allows scripting only from inside the GUI, and headless automation requires a
Commercial license. For batch work on a student budget, Ghidra’s analyzeHeadless is the
realistic option.
Getting Started with Cutter
Loading a File
Launch Cutter and pick Open File. The load dialog shows detected architecture, bits, OS, and base address — usually correct. For shellcode or firmware, toggle Load in write mode, Load bin info, and Use virtual addressing as needed. Click Ok and Cutter runs Rizin’s auto-analysis (aaa under the hood).
The Interface
Cutter’s UI is fully dockable: every panel (widget) can be dragged, detached, or closed. The default layout includes:
- Disassembly — main code view; press Space to toggle between linear and graph.
- Decompiler — select between jsdec (Rizin’s built-in, lightweight) and Ghidra (via
rz-ghidra) in the view selector. Use Ghidra for anything non-trivial. - Functions — searchable function list with offsets, sizes, and xref counts.
- Imports / Exports / Strings / Symbols — standard triage pivots.
- Graph Overview — miniature control-flow graph of the current function.
- Hexdump — byte-level view with computed hashes (MD5, SHA1, SHA256, CRC32) and format conversion to C, Python, JSON.
- Console — direct Rizin command line; anything the GUI can’t do, Rizin commands can.
Close unused panels via Windows → [panel name] and save your preferred layout with Windows → Save Layout.
Navigation
| Action | Shortcut |
|---|---|
| Go to address / symbol | G |
| Toggle disassembly / graph | Space |
| Back / forward | Alt+Left / Alt+Right |
| Follow reference at cursor | Enter |
| Show xrefs | X |
| Seek to entry point | . (period) |
| Toggle decompiler sync with cursor | sync button in decompiler toolbar |
Annotation
| Action | Shortcut |
|---|---|
| Rename | N |
| Add comment | ; |
| Define function | P |
| Undefine function | U |
| Edit function signature | right-click → Edit function |
| Add flag (label) | Shift+N |
The Rizin Console
The console at the bottom exposes the full Rizin command surface. A few commands worth knowing:
| Command | Effect |
|---|---|
aaa |
Re-run full analysis |
afl |
List all functions |
pdf @ main |
Print disassembly of main |
izz |
List all strings (not just those in data sections) |
axt <addr> |
Show xrefs to address |
/ <string> |
Search for string |
? |
Help |
Rizin uses an operation-on-what @ where syntax. pdf @ 0x401000 prints function disassembly at 0x401000. This is Cutter’s escape hatch when the GUI doesn’t expose what you need.
Decompiler Selection
Switch decompiler engines via the dropdown in the Decompiler panel header:
- jsdec — fast, JavaScript-based, approximate. Fine for small functions.
- rz-ghidra (Ghidra) — the real Ghidra decompiler. Slower on first run (loads language definitions) but produces output comparable to Ghidra itself.
For serious analysis, always use the Ghidra backend.
Side-by-Side: Common Operations
| Task | Ghidra | IDA | Binary Ninja | Cutter |
|---|---|---|---|---|
| Go to address | G | G | g | G |
| Toggle graph/text | Window → Function Graph | Space | Space | Space |
| Decompile current function | always visible (right pane) | F5 | i cycles to HLIL; F5/Tab for Pseudo C | always visible (Decompiler panel) |
| Rename | L | N | n | N |
| Add comment | ; | : or ; | ; | ; |
| Xrefs to | Ctrl+Shift+F | X | x | X |
| Back / forward | Alt+Left / Alt+Right | Esc / Ctrl+Enter | see the keybinding editor | Alt+Left / Alt+Right |
| Undefine | C (clear) | U | right-click → Undefine | U |
| Define as function | F | P | p | P |
| Apply struct type | drag from Data Type Manager | T | y (change type) | right-click → Structure offset |
| Scripting console | Window → Python | IDAPython (File → Script File) | built-in Python console (not in Free) | Console (Rizin commands) or Python plugin |
Ghidra’s L for rename is the main thing that trips people moving between tools — N is rename
in the other three.
A Suggested First-Binary Workflow
This workflow applies to all four tools. The specifics of how you do each step are covered above.
- Triage recap: before loading anything, you should already know the file’s hash, architecture, import table highlights, and any obvious strings. If you don’t, go back to triage.
- Load and let auto-analysis finish. Don’t touch anything until the progress bar clears.
- Scan Imports. Flag network APIs (
WSAStartup,connect,HttpSendRequest), process manipulation (CreateProcess,WriteProcessMemory,CreateRemoteThread), persistence (RegSetValue,CreateService), crypto (CryptEncrypt,BCryptEncrypt), and file I/O (CreateFile,WriteFile). - Scan Strings. Look for URLs, file paths, registry keys, mutex names, user-agent strings, ransom notes, and error messages. Double-click interesting strings to jump to the code that uses them.
- Find
main(orWinMain, orDllMain). Start from the entry point and follow calls. - Decompile each called function. Rename as you identify behavior:
sub_401200becomesresolve_c2_domain;FUN_00402000becomesbuild_rc4_key. - Follow xrefs from imports you flagged in step 3. If
CreateProcessAis only called in one place, you want to read that function first. - Save frequently.
- When stuck, toggle views. If the decompiler output is confusing, read the assembly. If the assembly is too tedious, check the decompiler. If both are confusing, look at the graph — the shape of the control flow sometimes reveals the construct (loop, switch, error handling) faster than either text view.
Scripting and Automation
All four platforms expose their analysis database through scripting APIs. You don’t need these for basic analysis, but they become essential once you start dealing with obfuscated or packed samples.
| Platform | Languages | Typical use case |
|---|---|---|
| Ghidra | Java, Jython, PyGhidra (CPython3) | Headless batch analysis, custom decompiler transformations, Version Tracking |
| IDA | IDC (built-in), IDAPython | Automated string decryption, batch renaming, custom analyzers |
| Binary Ninja | Python (API absent from the Free tier; headless needs Commercial) | Working directly on BNIL layers, custom lifters, type recovery |
| Cutter | Python plugins, C++ plugins, Rizin commands | Quick one-liners via the console, Python scripts for custom widgets |
For coursework, start with Ghidra’s Script Manager (Window → Script Manager), which ships with hundreds of example scripts, and analyzeHeadless for anything batch. Neither needs a license, which is not true of the commercial options.
Choosing a Tool
This course standardizes on Ghidra. Assignments, worked examples, and screenshots all assume it, and the reasons are practical rather than ideological: it is free for every student on every platform, its decompiler is the strongest of the free options, it scales to multi-binary malware families, and its headless mode is scriptable without buying anything.
That said, working analysts settle on a primary tool and use the others as needed:
- Ghidra — your default. Reach for it especially on multi-binary families, non-x86 architectures, and anything you need to automate.
- IDA — the industry reference. Most published malware write-ups, conference talks, and plugin ecosystems assume it, so you should be able to read an IDA screenshot even if you do not run it. Its graph view and FLIRT signature database remain excellent.
- Binary Ninja — reach for its BNIL layers when a decompiler is lying to you and you want to see the intermediate steps, or when you are writing analysis tooling and want a pleasant API.
- Cutter — when you want a Rizin command line beside a GUI, when working on unusual firmware architectures, or when you want something that starts in under a second.
You will develop strong opinions about which one feels right; they are all correct opinions. What matters is that you can navigate any binary handed to you, and that you can read someone else’s analysis regardless of which tool produced it.
Troubleshooting
| Problem | Cause / fix |
|---|---|
| IDA hangs on load | Very large binary or statically-linked runtime; wait, or disable some analysis passes in Options → General → Analysis |
Ghidra decompiler shows UNRECOVERED_JUMPTABLE |
Indirect jump (virtual call or computed jump); right-click the jump → Create Jump Table, or fix parameter types upstream |
| Cutter decompiler is empty or wrong | Switch backend from jsdec to Ghidra in the decompiler toolbar |
| Binary Ninja plugin or script won’t run | The Free tier has no Python API; scripting needs Non-Commercial (GUI only) or Commercial (headless) |
| Functions tab is empty | Auto-analysis didn’t run or was skipped; trigger it manually (IDA: Options → Analysis; Ghidra: Analysis → Auto Analyze; Cutter: aaa in console) |
| Can’t see PE header / resource section | Load manually (IDA: Manual Load checkbox; Ghidra: Import format options; Cutter: toggle Load bin info) |
| Variable names don’t propagate | You renamed in the decompiler but the disassembly didn’t update, or vice versa — save the project and refresh the view |
Further Reading
Official documentation
- Ghidra on GitHub — official source, releases, and security advisories
- Binary Ninja documentation — user guide and API reference
- BNIL overview — how LLIL, MLIL, and HLIL relate
- Hex-Rays IDA documentation — Basic Usage, Graph View, Cross-References, Subviews
- IDA Pro Basic Usage
- IDA Graph View reference
- Ghidra on GitHub — official source, releases, and security advisories
- Introduction to Ghidra Student Guide — NSA’s own class material, best free Ghidra tutorial
- Cutter documentation — official user and developer docs
- Rizin documentation — the command reference for Cutter’s console
- Igor’s Tip of the Week — Cross-references (Hex-Rays blog)
Books
- Practical Malware Analysis (Sikorski & Honig, No Starch Press, 2012) — chapter 5 covers IDA in depth; see Advanced Static Analysis summary.
- The IDA Pro Book, 2nd Edition (Chris Eagle, No Starch Press, 2011) — the definitive IDA reference.
- The Ghidra Book (Chris Eagle & Kara Nance, No Starch Press; 2nd edition 2026 adds PyGhidra and BSim) — the Ghidra reference.
Community writeups
- Intro to Cutter — GoggleHeadedHacker
- How to Use Ghidra to Reverse Engineer Malware — Varonis
- Ghidra vs. IDA Pro — hackmag
- Comparison of Reverse-Engineering Tools — reHex Ninja
- Get started with the Ghidra reverse-engineering framework — TechTarget
Source repositories
- NationalSecurityAgency/ghidra
- rizinorg/cutter
- rizinorg/rizin
- rizinorg/rz-ghidra — the Ghidra decompiler integration used by Cutter
- Vector35/binaryninja-api — Binary Ninja’s open-source API and plugin examples