text stringlengths 0 1.99k |
|---|
'------------------------------------------------------------------' |
When E0 symbolically followed that branch, its SMT solver produced a value |
of w0 = 0xFFFFFFF8. Adding 8 makes w26 wrap to zero, so the check always |
passes. That crafted input was generated in the ninth round of mutations, |
after eight earlier samples had gradually solved header and chunk-length |
constraints to push parsing toward the final buffer boundary. |
After the integer overflow, the parser repeatedly processed the same chunk, |
hanging the decoding thread in an infinite loop. In real-world tests, |
sending the malformed WebP to Apple's Messages app caused a zero-click |
denial-of-service: the app would lock up on a blank screen, remain |
unresponsive through both app and device restarts, and rapidly drain the |
battery while causing the device to overheat. |
Although the IIO_Reader_WebP::validateWebP routine, its caller, and all |
downstream functions include multiple boundary checks to prevent out-of- |
bounds accesses, the integer overflow that wrapped w26 to zero was the |
only way to bypass every guard and disrupt service availability. Because |
that flaw was located on a path directly explored by E0's SMT-based |
symbolic engine, E0 generated the triggering sample without any extra |
bug-finding logic. In contrast, vulnerabilities that fall outside those |
straightforward data-flow paths, requiring higher-level or cross-path |
reasoning, would be missed by symbolic execution alone. Rather than |
burdening the symbolic layer with ad hoc detection rules, we delegate |
those more complex cases to the AI analysis component. As described next. |
--[ 12 - LLM Integration & Symbolic-Guided Analysis |
E0 integrates large language models (LLMs) not as speculative classifiers, |
but as structured reasoning agents guided by symbolic context. Its |
analysis pipeline constrains and informs the model using real data-flow |
derived from symbolic definitions and SMT-solved constraints, expanding |
context dynamically via the Model Context Protocol (MCP) only when |
necessary. The result is an AI-assisted workflow that is grounded, |
verifiable, and modular by design. |
---[ 12.1 - Instruction-Following Models |
While there is a clear difference in scale between open-source LLMs and |
large frontier models, we found that this gap narrows significantly when |
prompts and context are crafted to align with the model's understanding |
and reasoning patterns. Performance improves substantially when prompts |
are phrased in a way that matches the model's strengths, especially when |
refined through reverse prompt engineering techniques discussed in Section |
(12.6). In this setting, smaller open-source models that excel at |
instruction following often outperform larger general-purpose models, |
particularly in tasks like vulnerability analysis, provided they are |
guided by accurate context and well-scoped prompts. |
Modern LLMs vary widely in their ability to follow explicit instructions. |
For vulnerability analysis, instruction adherence is critical: imprecise |
or overly general reasoning can result in hallucinations, false positives, |
or overlooked vulnerabilities. |
In our experience, smaller instruction-tuned models consistently |
outperform larger general-purpose ones for tasks like symbolic def-use |
analysis. As a result, E0 adopts a dual-model strategy: |
- Phi-4 is used for function-level vulnerability analysis. Its |
instruction-following behavior, predictable output formatting, and |
minimal hallucination make it ideal for interpreting well-scoped |
symbolic expressions and constraints. |
- Qwen3 is employed for tool-assisted reasoning and cross-function |
analysis. It supports structured tool-calling and larger context |
windows, making it well-suited for issuing get_function_code |
requests via the MCP and tracking data across multiple functions. |
This division of responsibilities helps balance precision and scalability |
across different stages of E0's AI-driven analysis pipeline. |
While Mixture-of-Experts (MoE) architectures promise efficiency by |
activating only a subset of experts per token, they introduce subtle |
non-determinism in routing that can alter outputs depending on batch |
composition, scheduling, floating-point precision, or even low-level GPU |
execution order and state changes. This unpredictability can occur even |
when temperature is set to zero, since expert selection is sensitive to |
tiny numerical differences in floating-point computations rather than |
sampling randomness. For instance, MoE models such as Qwen3-Coder and |
GPT-OSS variants may yield different continuations across identical runs. |
Dense models, by contrast, are far less sensitive to these variables, |
producing more predictable behavior under consistent prompting. The LLM |
techniques discussed in the following sections are therefore applicable |
only to dense instruction-tuned models in vulnerability analysis, while |
we continue to experiment with alternative pipelines for MoE models. |
---[ 12.2 - Guiding LLM Attention with Symbolic Expressions and Constraints |
Effective vulnerability analysis using LLMs hinges on precisely directing |
the model's attention to semantically meaningful elements within code. E0 |
achieves this by anchoring each prompt to symbolic expressions derived |
from real data-flow paths. Extracted during guarded memory access and |
symbolic emulation, these expressions originate from untrusted inputs and |
are refined with SMT-solved value ranges. |
Rather than issuing long, monolithic prompts that dilute model focus, E0 |
deploys a modular prompting strategy. Each prompt is scoped to a single |
symbolic definition or a tightly related set of expressions. Each includes: |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.