binja-diff - GitLite

KO | EN

gitlite — search

#python #ai #llm #machine-learning #rust #deep-learning #linux #macos #awesome #cli #kubernetes #vue #awesome-list #pytorch

binja-diff

(★ 90)

Binary Ninja diffing tool

File Explorer

Download Latest Version (.zip)

- __init__.py
- align.py
- backend.py
- engine.py
- persist.py
- scope.py
- similarity.py
- symbols.py
- __init__.py
- bootstrap.py
- run_all.py
- stub_binaryninja.py
- test_align.py
- test_backend.py
- test_cli.py
- test_engine.py
- test_live.py
- test_persist.py
- test_scope.py
- test_similarity.py
- test_symbols.py
- __init__.py
- diffview.py
- dropzone.py
- graphpane.py
- matchtable.py
- progresspanel.py
- scopedialog.py
- textpane.py
- theme.py
.gitignore
.pre-commit-config.yaml
__init__.py
binja-diff.py
CLAUDE.md
LICENSE
plugin.json
README.md
requirements.txt
ruff.toml
ty.toml

# Installation Guide

1. Get the code

git clone https://github.com/matteyeux/binja-diff

Downloads the entire project code from GitHub to your computer.

cd binja-diff

Moves into the project folder you just downloaded.

2. Python

Easy Recommended

Prerequisites

Git Needed to download the project code from GitHub.
Python 3 On Windows, be sure to check 'Add Python to PATH' during installation.

pip install -r requirements.txt

Installs the Python libraries listed in requirements.txt (or similar).

python <실행할 파일명>.py # README에서 정확한 실행 파일명을 확인하세요

Runs the Python script (or module).

✅ If it runs without errors and prints output in the terminal, it worked.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Binary Diff

A Binary Ninja plugin for side-by-side binary diffing, powered by
[QBinDiff](https://github.com/quarkslab/qbindiff).

Drop a second binary onto the diff view and the plugin loads it, analyzes it,
matches its functions against the current binary, and shows the differences at
five levels: control flow graph, assembly, LLIL, MLIL and HLIL.

![Capture](https://matteyeux.com/images/binja-diff2.png)

## Features

- No other tools required
- Supports BNDB import
- Control flow graph, disassembly, LLIL, MLIL and HLIL diffing views
- Save and restore diffs from the BNDB or json file
- Port function names from one binary to the other
- Diff a single kext from a kernelcache, or one SEP module
- QBinDiff as a provider for Binary Similarity sessions

## Requirements

- Python 3.10+
- [QBinDiff](https://github.com/quarkslab/qbindiff)

On Linux, QBinDiff also loads the system `libmagic` through `python-magic`, you may need to install `libmagic1` on Debian-based systems

### Linux aarch64 is not supported

`lapjv`, which QBinDiff uses for the linear assignment step, has **no working build on Linux aarch64** ([src-d/lapjv#90](https://github.com/src-d/lapjv/issues/90)): QBinDiff pulls in `lapjv-numpy2` there and that package is x86-only. macOS gets `lapx` instead and is unaffected. Testing has been done on **macOS and Linux x86-64**.

## Installation

I usually make symlinks:
```bash
# macOS
ln -s "$PWD" ~/Library/Application\ Support/Binary\ Ninja/plugins/binja-diff
# Linux
ln -s "$PWD" ~/.binaryninja/plugins/binja-diff
```

Restart Binary Ninja, then open a binary and pick **Diff** from the view type
dropdown at the bottom left, or use **Plugins > Binary Diff**.

## Usage

Drag a binary anywhere onto the drop zone, or click **Choose file...**.

![Capture](https://matteyeux.com/images/binja-diff1.png)

Expect this to take a while on real firmware. Matching is quadratic in the
number of functions. sep-firmware M5 26.5 against 26.5.2 takes about 38 minutes.
Saving the result is worth it: restoring one costs only the reload of the second
binary.

### Binary Similarity

QBinDiff also registers as a provider for Binary Ninja's **Binary Similarity**
sidebar (Ultimate), alongside Google BinDiff and WARP, so a session can weigh
all three against each other. It works headlessly too:

```python
from binaryninja import SimilarityProviderType, SimilaritySession

provider_type = SimilarityProviderType["QBinDiff"]
session = SimilaritySession()
session.add_provider(provider_type.create(provider_type.get_default_settings()))
```

The similarity it reports is the share of a function's lines that did not
change, the same number the match table shows, because a resolver thresholds on
it to decide what to apply.

Rendering a result colours **individual instructions** rather than whole blocks:
yellow for a changed instruction, green for one only in the new build, red for
one only in the old. A block that exists on a single side is filled whole, and
lines that differ only in an address or a register are left plain — in a rebased
binary those are most of the lines, and colouring them hides the real change.

### Reading the diff

| Status | Meaning |
| --- | --- |
| identical | no differing instructions at all |
| offsets only | only addresses, immediates, stack offsets or register choice differ |
| changed | at least one real instruction difference |
| differs | too large to classify while scrolling; open it to see |

| Marker | Meaning |
| --- | --- |
| (blank) | identical |
| `~` | same operation, an operand spelled differently |
| `!` | genuinely different operation |
| `+` | present only in the secondary |
| `-` | present only in the primary |

### Dev

Ensure you run pre-commit before contributing
```bash
uv run pre-commit install
```