VulHunt: A Framework for Hunting Vulnerabilities in Binaries

Francesco Evangelista (Research Scientist · Binarly), Sam L. Thomas (Chief Scientist · Binarly)

RE//verse 2026 · Day 2 · Coral Ballroom A

Overview

In an era of escalating software complexity and a rapidly growing number of reported vulnerabilities, Binarly introduced VulHunt, an innovative open-source framework designed to streamline the arduous process of hunting for vulnerabilities in binaries. Presented by Francesco Evangelista at RE//verse, this talk unveiled a powerful, extensible platform that unifies multiple analysis techniques, moving beyond traditional syntactic matching to embrace semantic analysis. VulHunt’s core mission is to provide security teams and developers with more actionable findings, offering crucial reachability information and significantly improved vulnerability explanability—a critical need when triaging thousands of alerts that often lack sufficient context.

Watch on YouTube

Visual summary for VulHunt: A Framework for Hunting Vulnerabilities in Binaries by Francesco Evangelista, Sam L. Thomas
Visual summary for VulHunt: A Framework for Hunting Vulnerabilities in Binaries by Francesco Evangelista, Sam L. Thomas

Key moments

  1. 1:06 Introducing VulHunt: An extensible, open-source analysis framework
  2. 3:05 Demo: Scanning 400+ binaries for vulnerabilities in 50 seconds
  3. 5:48 Why existing vulnerability detection tools fall short
  4. 15:00 Data flow analysis and code pattern matching capabilities
  5. 22:00 Enhancing vulnerability explainability with rich, annotated output
  6. 45:50 Demo: Automated vulnerability triaging using VulHunt and LLMs
  7. 52:00 Clarifying intra-procedural analysis for all presented examples

VulHunt: A Framework for Hunting Vulnerabilities in Binaries

Speakers: Francesco Evangelista (Research Scientist, Binarly); Sam L. Thomas (Chief Scientist, Binarly)

Conference: RE//verse

YouTube: https://www.youtube.com/watch?v=bMYaQcs03wQ

Overview

In an era of escalating software complexity and a rapidly growing number of reported vulnerabilities, Binarly introduced VulHunt, an innovative open-source framework designed to streamline the arduous process of hunting for vulnerabilities in binaries. Presented by Francesco Evangelista at RE//verse, this talk unveiled a powerful, extensible platform that unifies multiple analysis techniques, moving beyond traditional syntactic matching to embrace semantic analysis. VulHunt’s core mission is to provide security teams and developers with more actionable findings, offering crucial reachability information and significantly improved vulnerability explanability—a critical need when triaging thousands of alerts that often lack sufficient context.

The development of VulHunt was driven by the recognition that manual vulnerability analysis is time-consuming and expertise-intensive. To address this, the framework not only offers a unified platform for disassembly, intermediate representation (IR), and decompiled code with easy mapping between them but also integrates with Large Language Models (LLMs) to reduce manual effort. This LLM integration leverages VulHunt's rich, low-level binary context to provide more intelligent and nuanced analysis. The framework's initial demonstration showcased its impressive speed and scalability, successfully identifying vulnerabilities across over 400 binaries, encompassing diverse architectures and ecosystems, in approximately 50 seconds, delivering results with annotated decompiled code and type information.

VulHunt is designed for broad utility, supporting vulnerability detection, malware analysis, and general software property checking. It represents a significant evolution from Binarly's earlier work, such as the open-source UEFI firmware vulnerability tool Firmware-Ant, by adding sophisticated semantic analysis capabilities. By open-sourcing VulHunt, Binarly aims to cultivate a community of contributors and users, fostering collaborative development and widespread adoption of its advanced binary analysis capabilities, ultimately raising the bar for binary security across the industry.

Background

▶ Watch: Introducing VulHunt: An extensible, open-source analysis framework (1:06)

The landscape of modern software development is increasingly complex, characterized by heavy reliance on third-party libraries and a corresponding explosion in dependencies. This intricate web of components directly correlates with a rising tide of vulnerabilities, as evidenced by the consistently increasing number of published CVEs each year. Compounding this challenge, the rapid advancements in Artificial Intelligence (AI) are not only accelerating vulnerability discovery but also introducing new risks through AI-generated code. Research indicates that while AI solutions are functionally correct in 61% of cases, a concerning 10.5% of their solutions are not secure, potentially introducing new vulnerabilities when deployed with minimal human review. A practical experiment cited in the talk demonstrated this risk, where an LLM generated a wrapper around a Rust crate that pulled in an outdated and vulnerable dependency, illustrating how rapidly AI can inject security flaws into a codebase.

Existing vulnerability detection solutions often fall short in addressing these evolving challenges. Traditional binary scanners relying on version strings frequently generate an overwhelming number of false positives due to vendors backporting patches without updating version numbers, and they fail to provide crucial reachability context. Source code scanners are limited by the availability of source code and cannot analyze pure binary components or entire firmware images. Pattern-based detection using known signatures struggles with novel vulnerabilities or slight variants, leading to incomplete coverage. While graph-based analysis techniques, such as taint tracking, are powerful for certain vulnerability classes, they often miss logic-based vulnerabilities that don't fit the taint model. Lastly, reverse engineering tool APIs offer immense flexibility but demand significant manual effort to scale for large projects.

Furthermore, combining different tools to achieve comprehensive analysis is notoriously difficult. Disparate tools often maintain their own "sources of truth" and representations of binaries, leading to inconsistencies in recovered Control Flow Graphs (CFGs) and functions. This makes it challenging to integrate their findings or leverage their capabilities synergistically. Ultimately, the accuracy of all binary analysis tools, including VulHunt, hinges on the foundational quality of CFG reconstruction and function recovery. These limitations collectively underscored the critical need for a unified, scalable, and highly accurate framework like VulHunt that can address the multifaceted challenges of modern binary vulnerability hunting.

Key Findings

▶ Watch: Why existing vulnerability detection tools fall short (5:48)

VulHunt introduces several pivotal advancements and capabilities that redefine binary vulnerability hunting. A primary contribution is its ability to unify multiple analysis techniques—including data flow analysis, code pattern matching, byte pattern matching, and intermediate representation (IR) matching—within a single, coherent platform. This unification allows for comprehensive vulnerability detection that transcends the limitations of individual approaches, offering both syntactic and semantic analysis.

A cornerstone of VulHunt's design is its commitment to improved vulnerability explanability. By generating richly annotated decompiled code, complete with type information and detailed descriptions, VulHunt significantly reduces the time and expertise required for triaging findings. This enhanced context allows analysts to quickly understand why a binary is vulnerable and where the issue lies, facilitating faster remediation. The framework's impressive scalability is another key finding, exemplified by its ability to scan over 400 diverse binaries in approximately 50 seconds and, in a more targeted scenario, filter over 6,000 components in an Arch Linux Docker container down to 161 relevant ones, scanning them in a mere 13 seconds. This speed is attributed to its Rust-based architecture and efficient execution preconditions.

The seamless LLM integration is a significant innovation, allowing Large Language Models to leverage VulHunt's granular binary primitives for automated vulnerability analysis, triaging, and even suggesting fixes. This empowers LLMs with a deeper context than they would otherwise have, lowering the bar for manual analysis. Furthermore, VulHunt addresses a long-standing challenge in binary analysis through its integration of Type Libraries and Function Signatures (Adafl). These components dramatically improve the quality of decompilation, enabling more reliable pattern matching and clearer vulnerability explanations, especially in stripped binaries where type information is typically absent.

VulHunt's Lua-based rules engine provides a flexible and powerful mechanism for users to define custom detection logic. These rules can detect complex vulnerabilities, including variants, by combining different analysis techniques and leveraging type libraries and signatures. The framework also introduces a patch validation capability, allowing users to verify if a vulnerability has been effectively remediated, which is crucial for reducing false positives from other scanners. Finally, the open-source release of VulHunt, along with Bias (its underlying binary analysis framework), an MCP server for LLM integration, and a Type Library Toolkit, democratizes these advanced capabilities, inviting community collaboration and innovation in binary security.

Technical Deep Dive

▶ Watch: Data flow analysis and code pattern matching capabilities (15:00)

VulHunt is engineered from the ground up for performance and scalability, with its core written entirely in Rust. This choice of language is fundamental to its ability to process large volumes of binaries quickly and efficiently. For the crucial task of instruction lifting, VulHunt leverages Fugue via its GRA language definition, a modular binary analysis framework known for its reusable components in data handling and disassembly. The framework also integrates a modified version of Ghidra's decompiler, providing high-quality decompiled code, while maintaining a pluggable architecture that allows for the integration of other decompilers.

The analysis within VulHunt is categorized into two main types:

  • Core Analysis: This foundational analysis runs for all binaries, performing essential tasks such as instruction lifting, Control Flow Graph (CFG) reconstruction, and function recovery.
  • Specialized Analysis: These analyses are tailored to specific platforms, such as POSIX (e.g., no-returning functions analysis) or UEFI, providing deeper, context-aware insights.

VulHunt offers two primary modes of interaction: through its Lua-based rules engine or via LLMs. For input, it can directly process binary files or utilize Binary Ninja database files as a source of truth for symbols and function starts, enhancing integration with existing reverse engineering workflows. Developer experience is prioritized through the VulHunt Jupyter Kernel, an SDK that enables interactive development, and the VulHunt Shell, a command-line interface front-end. While certain advanced features like inter-procedural analysis, container handling, and the full SDK are part of the Enterprise edition, the core framework and many capabilities are available in the Community edition.

The framework's detection capabilities are robust and multifaceted:

  • Data Flow Analysis: VulHunt performs intra-procedural data flow analysis in the community edition (with inter-procedural available in enterprise), crucial for identifying vulnerabilities where untrusted data flows to sensitive operations without proper validation, such as command injection or buffer overflows. A key feature is sanitization support, allowing users to define functions that stop taint propagation, thereby reducing false positives. For more complex checks involving conditional guards, data flow analysis can be combined with code pattern matching.
  • Code Pattern Matching: Operating on the decompiled code, this technique detects vulnerabilities that adhere to recognizable code structures or known dangerous programming patterns. Its engine is pluggable, currently shipping with one based on Waggley, but capable of integrating others. This approach is architecture-independent, with effectiveness relying on decompilation quality, and crucially, it maintains a precise mapping between decompiled findings and original instruction addresses.
  • Type Libraries and Function Signatures: Addressing the challenge of stripped binaries, VulHunt integrates Type Libraries (C files containing types and function prototypes for 32/64-bit systems) and Function Signatures, specifically using Adafl for function naming. This combination dramatically improves the reliability of pattern matching and the clarity of vulnerability explanations by populating decompiled output with accurate types and function names. Type libraries are designed to be stable across library versions and build configurations for targeted structures.
  • Annotations: To enhance explanability, VulHunt meticulously tracks a mapping between instruction addresses and code ranges, allowing for precise annotations of various code elements like function calls, variable assignments, loops, and conditional statements directly within the decompiled output.
  • Byte Pattern Matching: For low-level scenarios, particularly in UEFI firmware or malware analysis, VulHunt supports matching raw bytes and instruction sequences using firmware-compatible patterns.
  • Intermediate Representation (IR) Matching: Building on Ghidra's Pcode, IR matching offers the same granularity as byte pattern matching but with the significant advantage of being architecturally independent, allowing patterns to be written once and reused across different platforms. This was exemplified in its ability to detect the LogoFAIL vulnerability.

VulHunt's rules engine, written in Lua, provides a flexible and high-level yet semantically rich way to define detection logic. Rules consist of a preamble (specifying details, execution preconditions like target platform, architecture, binary name, GUID, and validators such as specific byte patterns or strings for static filtering) and scopes that define the analysis context:

  • Scope Project: Provides a global view, executing logic once for the entire binary (e.g., for LogoFAIL byte pattern detection).
  • Scope Functions: Targets specific functions based on criteria, executing logic for each matching function (e.g., identifying function pointer calls in XML_parse_buffer).
  • Scope Calls: Focuses on specific call sites, leveraging the data flow engine for precise propagation analysis (e.g., detecting buffer overflows in svcn_create's memcpy call).

Rules can also return a result_patch_finding to indicate a patched vulnerability, aiding in false positive reduction.

The LLM integration is facilitated via an MCP server that exposes VulHunt's APIs. LLMs, such as Cloud Code, can load projects, execute Lua queries against these APIs, and leverage additional MCP tools to load signatures and types. This enables LLMs to perform advanced tasks like vulnerability triaging by looking up CVE information, querying for potentially vulnerable functions, checking validation logic, and providing summaries, annotated decompilation, and remediation suggestions. An agentic workflow further demonstrates this, where a first agent identifies candidate vulnerability classes (e.g., buffer overflow, command injection) using data flow, and a second agent then uses decompiler and call site skills to triage these candidates, understand component interactions, and pinpoint specific vulnerabilities with structured output including code paths and addresses.

Demo / Proof of Concept

▶ Watch: Demo: Automated vulnerability triaging using VulHunt and LLMs (45:50)

The presentation included several compelling demonstrations showcasing VulHunt's capabilities and its practical application.

The initial demo (02:50) highlighted VulHunt's raw scanning power. It involved loading over 400 binaries with diverse architectures and ecosystems. VulHunt successfully identified all instances of a specific vulnerability in approximately 50 seconds, presenting the results as decompiled code with clear annotations, a detailed description, and applied type information, significantly easing the triage process.

A deeper dive into the VulHunt Jupyter Kernel (26:30) illustrated the SDK's interactive nature. Using a libssh binary, the demo showed how to query various metadata such as dynamic libraries, functions, code blocks, instructions, and even intermediate representation (IR) statements. It then demonstrated a data flow analysis, pinpointing a call site for SSH_channel_request_exec and propagating a symbolic cmd variable to identify a potential command injection. The demo also showed how to decompile a function, apply a code pattern match, and significantly improve the decompiled output by loading type libraries, which populated fields and structures, making the code much more readable.

The utility of VulHunt Shell combined with its Lua-based rules was demonstrated with real-world vulnerabilities (40:30). Scanning an sshd binary with a rule pack quickly identified a race condition in OpenSSH, a regression bug where an async function called a non-async-safe function. The output included CVSS scores and advisories. Another scan, this time on rsync, successfully found a buffer overflow, presenting the familiar annotated, typed decompiled output. The rule for this vulnerability used code pattern matching to validate the presence or absence of specific validation logic. Finally, a UEFI SMM module was scanned, revealing several SMM vulnerabilities, with the rule leveraging reliable byte pattern matching for detection in the low-level firmware environment.

The integration with LLMs was powerfully illustrated through a Cloud Code LLM demo (45:30). By providing a CVE ID and a target binary, the LLM was shown to autonomously:

  1. Look up CVE information and description.
  2. Load the binary into VulHunt, triggering core analyses.
  3. Query the project for potentially vulnerable functions identified in the CVE details.
  4. Check for the presence of any validation logic.
  5. Ultimately identify the vulnerability, providing a summary, the annotated decompilation from VulHunt, and even a remediation suggestion. This showcased the potential for massive time savings in triaging thousands of findings.

An advanced agentic LLM workflow (47:30) further demonstrated the sophisticated capabilities. Targeting an RC binary, a first agent loaded the binary and a data flow skill to identify candidate vulnerability classes (e.g., buffer overflow, command injection). A second agent then took these candidates, loaded decompiler and call site skills, decompiled affected functions, analyzed component interactions, and identified a specific vulnerability, outputting a structured report with type, description, code path, conditions, and vulnerable addresses, even while working with decompiled code.

These demonstrations collectively proved VulHunt's effectiveness in rapid, accurate, and context-rich binary vulnerability detection, both for human analysts and AI-driven security workflows.

Defensive Implications

▶ Watch: Clarifying intra-procedural analysis for all presented examples (52:00)

VulHunt offers profound implications for defensive security strategies, empowering organizations to proactively address binary vulnerabilities across their software supply chain. Its capabilities equip defenders with tools to move beyond reactive patching and into a more robust, preventative posture.

Firstly, VulHunt enables proactive vulnerability hunting in a highly scalable manner. Security teams can integrate VulHunt into their continuous integration/continuous delivery (CI/CD) pipelines to scan binaries—whether custom-developed, third-party libraries, or even AI-generated code—for known and novel vulnerabilities before deployment. This is crucial given the high rate of insecure AI-generated code (10.5% identified in the talk).

Secondly, the framework's emphasis on improved vulnerability explanability directly translates to faster and more efficient triaging and patching. By providing richly annotated decompiled code with type information, reachability context, and detailed descriptions, VulHunt drastically reduces the manual effort and specialized expertise traditionally required to understand and fix binary vulnerabilities. This context helps developers quickly map discovered bugs back to source code, accelerating remediation cycles.

Thirdly, VulHunt's patch validation capability is invaluable for reducing false positives from other binary scanners that rely solely on version strings. Defenders can write specific VulHunt rules to confirm whether a reported vulnerability has indeed been patched, ensuring that resources are allocated to genuine issues rather than chasing ghost alerts caused by backported fixes.

Fourthly, for organizations dealing with firmware and low-level components, particularly in the UEFI ecosystem, VulHunt's specialized analysis and byte pattern matching capabilities provide critical visibility into a domain often opaque to higher-level tools. This is essential for addressing vulnerabilities like LogoFAIL that reside deep within the system's foundational software.

Finally, the LLM-assisted security analysis offered by VulHunt represents a paradigm shift for security operations. By exposing its primitives to LLMs, VulHunt allows for automated vulnerability triaging, hunting for context-dependent logic flaws, and even generating potential remediations. This augments human analysts, allowing them to focus on more complex, novel threats while routine or well-understood vulnerabilities are handled by AI, making security analysis more scalable and efficient in the face of ever-increasing CVE volumes. The open-source nature of VulHunt also encourages community contribution, allowing defenders to share and benefit from a collective pool of rules and analysis techniques.

Key Takeaways

  • Unified Binary Analysis Framework: VulHunt is an extensible, open-source framework unifying diverse analysis techniques (data flow, code pattern matching, byte pattern matching, IR matching) for comprehensive vulnerability detection in binaries.
  • Enhanced Vulnerability Explanability: It significantly improves the understanding and triaging of vulnerabilities by providing richly annotated decompiled code, complete with type information and detailed descriptions.
  • Leveraging Type Libraries and Signatures: VulHunt integrates type libraries and function signatures (like Adafl) to drastically improve decompilation quality and pattern matching reliability in stripped binaries.
  • Powerful Lua-based Rules Engine: Users can write flexible, high-level, yet semantically rich Lua rules to detect complex vulnerabilities and their variants, supported by execution preconditions and scopes for targeted scanning.
  • Scalable and Efficient: Built in Rust, VulHunt demonstrates impressive speed, scanning hundreds of binaries in seconds and efficiently filtering large component sets to reduce analysis time.
  • LLM Integration for Automation: The framework seamlessly integrates with Large Language Models, exposing its primitives to enable automated vulnerability triaging, hunting, and even remediation suggestions, leveraging rich binary context.

About the Speaker(s)

The work on VulHunt was presented by Francesco Evangelista, a Research Scientist at Binarly. He highlighted that the project was a collaborative effort involving a large team, including Sam L. Thomas, the Chief Scientist at Binarly and the inventor of VulHunt, alongside Jagger, Fabio, Han, Alex, Fernando, Chris, Clauddio, Eugene, Lucy, Lucas, and Takayo, all of whom made significant contributions to bringing the framework to fruition.

Reviews

Dr. Zero (Offensive Security Researcher) — SOLID

Binarly dropped a genuinely useful binary analysis framework that actually makes LLMs effective for triage by giving them deterministic primitives via an MCP server. The architecture is solid and the speed is impressive, but walling off inter-procedural data flow behind an Enterprise license keeps this from being a perfect release.

Heather Calloway (CISO) — STRONG ACCEPT

An open-source binary analysis framework that uses semantic analysis to prove vulnerability reachability, rather than just flagging outdated version strings. For organizations drowning in third-party supply chain alerts, this is a highly relevant tool for reducing false positives and accelerating AppSec triage.

→ Top-rated talks at RE//verse 2026

All talks from RE//verse 2026