Open Source · Ledger Donjon × Télécom Paris × KMSEC (PTY) LTD

Automated vulnerability detection in Go binaries

Zorya is a concolic execution engine built in Rust. It translates binaries to Ghidra's P-Code, drives symbolic exploration with Z3, and finds vulnerabilities in compiled Go programs: from memory-safety panics to concurrency bugs surfaced by an event-driven plugin layer. This is a deterministic tool that records coverage and explored paths in real time.

View on GitHub Read the docs
How it works
From binary to vulnerability report
Zorya captures a running binary at a breakpoint with GDB, recording CPU registers, memory regions, and per-thread state, then lifts the machine code to Ghidra's P-Code so a single Rust engine can execute any supported architecture. It drives that P-Code through concolic execution backed by the Z3 solver, tracking a symbolic view of memory and registers alongside the concrete run. At every conditional branch (CBRANCH) Zorya inspects the abstract syntax tree around the branch to locate reachable panic call sites, then forks an overlay concolic execution down the alternative path to expose de facto bugs and vulnerabilities that never appear on the nominal run. Detector plugins observe the whole execution over an event bus and contribute their own verdicts, and Zorya emits proof-of-concept inputs, execution traces, and findings for everything it reaches.
Zorya architecture overview: a Go/C ELF binary is dumped with GDB (CPU registers + memory), lifted to Ghidra P-Code, then driven through the Rust concolic engine and Z3 solver, exploring panic call sites and overlay paths at each branch and emitting proof-of-concept inputs, traces, and plugin findings.
The Zorya analysis pipeline, from ELF binary to proof-of-concept findings.
Capabilities
Engineered for Go's complexity
Go binaries embed a heavyweight runtime that general-purpose symbolic executors don't model. Zorya was built from the ground up to handle it.
01

Panic-Guided Exploration

Multi-layer filtering concentrates symbolic reasoning on panic-relevant paths, achieving 1.8–3.9× speedups by pruning 33–70% of irrelevant branches.

02

Built for Binary Analysis

Zorya analyzes executables with symbols to help developers find bugs in the binaries they build before production deployment.

03

Detection Strategies

Zorya discovers bugs in two complementary ways: runtime panic-function checks, and de facto bug discovery through overlay concolic execution on alternative paths.

04

P-Code Intermediate Representation

Ghidra's intermediate representation abstracts ISA specifics. Analyze x86_64, ARM, or any Ghidra-supported architecture through one engine.

05

Real-World Validated

Tested against go-ethereum (Geth), Kubernetes, Gin framework, Omni Network, and known CVEs including CVE-2022-30631.

06

Guided & Fuzzer Modes

Interactive guided mode for exploration, plus a fuzzer module for automated batch campaigns with JSON configs and timeout management.

07

Event-Driven Plugin Layer

The executor fires typed events: memory accesses, branches, calls, syscalls, thread events, panics, onto an event bus. Detectors subscribe only to what they need, hold private state, and return a verdict, so they extend analysis without touching the core.

08

Concurrency-Aware Detection

Multi-threaded Go binaries are restored thread-by-thread from GDB, and plugin detectors reason over goroutine interleavings: data races, TOCTOU check-use windows, and send-on-closed-channel panics, each reported with the input that triggers it.

Detection
What Zorya finds
Logic-related bugs and language-specific vulnerabilities that traditional fuzzers and static analyzers miss.
PANIC
Nil Pointer Dereference
Unchecked pointer access causing runtime panic
Test Zorya on this findingtests/programs/crashme-go
PANIC
Index Out of Bounds
Array/slice access beyond allocated length
Test Zorya on this findingtests/programs/panic-index
LOGIC
Integer Overflow
Arithmetic overflow in unchecked operations
Test Zorya on this findinglogic_bombs_go: evm-gascost-2017
RACE
Data Races
Concurrent unsynchronized access across goroutines, with the triggering input class
Test Zorya on this findingtests/programs/race-counter
RACE
TOCTOU
Check-use race windows (e.g. SO_PEERCRED then /proc/<pid>/exe)
Test Zorya on this findingtests/programs/toctou-test2-with-input
PANIC
Send on Closed Channel
Channel send after close: an unrecoverable Go runtime panic
Test Zorya on this findingtests/programs/panic-send-closed-channel
Documentation
Learn Zorya, synced with the repository
Loading documentation...
Open in GitHub →

Fetching latest documentation from the repository...

Plugin Layer
Detectors as event-driven plugins
The concolic executor fires typed events: memory accesses, branches, calls, syscalls, thread events, panics, onto an event bus. Each plugin subscribes only to the events it needs, keeps private state, reads engine state through a read-only context, and returns a verdict: continue, prune the path, report a finding, or abort. Detectors coexist without touching the core.
Zorya plugin architecture: the concolic executor dispatches events onto an event bus that fans out to subscribing detector plugins
The core dispatches events onto the bus; detectors subscribe and fold their verdicts by severity.
Volos · data races

Data-race detector

Observes cross-thread memory accesses and lock-primitive calls, classifies each cell with vector-clock happens-before plus lockset analysis, and couples every race witness to the symbolic inputs, reporting whether it races for every input or only for a specific input class, with the triggering value.

TOCTOU · check-use

Time-of-Check-Time-of-Use

Pairs a security-sensitive check (SO_PEERCRED, stat, access) with its later use and flags the exploitable window. Overlay concolic execution reaches checks gated behind attacker-influenced input and Z3-solves the triggering byte.

ChanCheck · channels

Send on closed channel

Tracks channel create, close and send, then flags a send on an already-closed channel: a deterministic panic when the close precedes the send in one goroutine, or a schedule-dependent race across goroutines, verified feasible with Z3.

The scheduler, a WaitGroup invariant checker, and a weak-memory-model detector are planned subscribers on the same bus. Volos originates from the zorya-volos work by Keith Makan / KMSEC and is ported onto the plugin layer.

Get Started
Installation
Docker or build from source. Requires Rust, Go, Python, and Ghidra.
Docker (recommended)
git clone --recursive \ https://github.com/Ledger-Donjon/zorya cd zorya docker build -t zorya:latest . # Run interactively docker run -it --rm \ --security-opt seccomp=unconfined \ --cap-add=SYS_PTRACE \ -v $(pwd)/results:/opt/zorya/results \ zorya:latest
From source
git clone --recursive \ https://github.com/Ledger-Donjon/zorya cd zorya # Setup Ghidra + Pyhidra make ghidra-config # Build everything make all # Run on a test binary zorya /path/to/binary
Research
Publications
Zorya is developed as part of a CIFRE PhD thesis at Télécom Paris (LTCI) in collaboration with Ledger Donjon.
From TinyGo to gc Compiler: Extending Zorya's Concolic Framework to Real-World Go Binaries
ACM EASE 2026, International Conference on Evaluation and Assessment in Software Engineering
arXiv →
2026
Zorya: Automated Concolic Execution of Single-Threaded Go Binaries
ACM SAC 2026, 41st Symposium on Applied Computing, Thessaloniki
arXiv →
2026
Concolic Execution Optimized for Go Binaries using Ghidra's P-Code
Springer, Software Engineering and Management: Theory and Applications
Springer →
2026
Exposing Go's Hidden Bugs: A Novel Concolic Framework
SERA 2025, IEEE/ACIS International Conference on Software Engineering
IEEE Xplore →
2025
Talks
Presentations
Arsenal
Black Hat Asia 2026
Singapore, Tool demonstration

Official Black Hat Arsenal session page with schedule details and project context.

Open event page →
Talk
EthCC[8] 2025
Cannes, Blockchain client security

Recorded conference talk:

Watch on YouTube →
EthCC 2025 talk thumbnail Watch video
Talk
Pass the SALT 2026
Concolic execution for multi-threaded Go binaries

Recorded conference talk:

Watch on UbiCast →
Seminar
Cybersecurity & Defense Day
Institut Polytechnique de Paris
Open Source
Start analyzing Go binaries today
Zorya is free, open source, and actively maintained. Contributions welcome.