PatchFuzz: Patch Fuzzing for JavaScript Engines

Junjie Wang, Yuhan Ma, Xiaofei Xie, Xiaoning Du, Xiangwei Zhang

Abstract

Patch fuzzing is a technique aimed at identifying vulnerabilities that arise from newly patched code. While researchers have made efforts to apply patch fuzzing to testing JavaScript engines with considerable success, these efforts have been limited to using ordinary test cases or publicly available vulnerability PoCs (Proof of Concepts) as seeds, and the sustainability of these approaches is hindered by the challenges associated with automating the PoC collection. To address these limitations, we propose an end-to-end sustainable approach for JavaScript engine patch fuzzing, named PatchFuzz. It automates the collection of PoCs of a broader range of historical vulnerabilities and leverages both the PoCs and their corresponding patches to uncover new vulnerabilities more effectively. PatchFuzz starts by recognizing git commits which intend to fix security bugs. Subsequently, it extracts and processes PoCs from these commits to form the seeds for fuzzing, while utilizing code revisions to focus limited fuzzing resources on the more vulnerable code areas through selective instrumentation. The mutation strategy of PatchFuzz is also optimized to maximize the potential of the PoCs. Experimental results demonstrate the effectiveness of PatchFuzz. Notably, 54 bugs across six popular JavaScript engines have been exposed and a total of $62,500 bounties has been received.

Introduction

JavaScript (JS) engines serve as the foundational execution environment for modern web browsers, making their security paramount. Traditional fuzzing techniques often struggle with the vast and complex codebases of these engines. "Patch fuzzing" offers a more targeted alternative, operating on the premise that recently modified or patched code is more likely to contain residual vulnerabilities or "follow-up" bugs. However, existing patch fuzzing workflows are often manual and unsustainable.

The primary challenges in automating JS engine patch fuzzing include:

  1. Data Collection Complexity: Identifying security-relevant commits in massive repositories is difficult, as many fixes are committed without explicit security labels or CVE IDs.
  2. Seed Usability: Proof-of-Concept (PoC) files found in commits often rely on internal testing frameworks (e.g., $vm calls) and fail to execute in standard environments.
  3. Resource Allocation: Standard fuzzers instrument the entire engine, wasting cycles on stable code rather than the volatile "hot" areas where patches are concentrated.

The PatchFuzz Framework

PatchFuzz addresses these challenges through an end-to-end automated pipeline. The system is divided into four primary stages: recognizing security patches, processing PoCs, selective instrumentation, and optimized fuzzing.

The end-to-end architecture of PatchFuzz, illustrating the four main stages: recognition, processing, instrumentation, and fuzzing.

1. Rule-Based Patch Recognition

Rather than relying on generic machine learning models, PatchFuzz utilizes a set of domain-specific heuristic rules. These rules analyze git commits for security-related keywords, links to bug tracking systems, and specific code patterns (such as a high ratio of new conditional checks). This approach ensures high precision in identifying security-critical modifications.

2. PoC Extraction and Repair

PatchFuzz extracts JS files from identified commits. To ensure these seeds are viable for fuzzing, the system automatically "repairs" them by replacing engine-specific internal calls with standard equivalents. This process reduced the grammar error rate of extracted PoCs from 27.5% to 8.4%, creating a robust library of over 17,000 high-quality seeds.

3. Selective Instrumentation

To maximize efficiency, PatchFuzz focuses its feedback mechanism on "hot code." By analyzing call graphs, the tool instruments only the functions modified by a patch and their immediate neighbors. This ensures that the fuzzer prioritizes exploring code paths that have historically been prone to vulnerabilities.

4. Dual-Intensity Mutation

The mutation strategy is designed to preserve the "penetrating power" of the original PoC. PatchFuzz employs a hybrid approach: 80% of mutations are low-intensity (expression-level) to stay close to the original buggy logic, while 20% are high-intensity (statement-level) to explore broader state changes.

Key Insights and Evaluation

A critical finding of this research is the inadequacy of general-purpose vulnerability detection models when applied to JS engines. As shown in the table below, state-of-the-art models like VulCurator and GraphSPD achieved extremely low F1 scores (averaging 0.09 and 0.04, respectively) on JS engine data. This underscores the necessity of PatchFuzz's specialized heuristic approach.

Performance comparison of state-of-the-art vulnerability detection models (VulCurator and GraphSPD) on JS engine security patches.

Furthermore, the study confirmed the existence of "hot code" within JS engines, finding that 35.8% of source files are patched repeatedly. By targeting these areas, PatchFuzz achieved 30% higher code coverage than established baselines like Superion and Fuzzilli.

Results and Impact

PatchFuzz was evaluated against six major engines: JavaScriptCore, V8, SpiderMonkey, ChakraCore, JerryScript, and QuickJS. The framework successfully identified 54 unique bugs, 25 of which were assigned CVEs. The practical impact of this work is highlighted by the $62,500 in bug bounties awarded by major vendors.

While PatchFuzz represents a significant step forward, future work will focus on further reducing the 8.4% residual error rate in PoC repair and adapting the patch-centric model to other large-scale software ecosystems.

The PatchFuzz source code is available at https://github.com/PatchFuzz/patchfuzz.

Summary updated

Abstract

Patch fuzzing is a technique aimed at identifying vulnerabilities that arise from newly patched code. While researchers have made efforts to apply patch fuzzing to testing JavaScript engines with considerable success, these efforts have been limited to using ordinary test cases or publicly available vulnerability PoCs (Proof of Concepts) as seeds, and the sustainability of these approaches is hindered by the challenges associated with automating the PoC collection. To address these limitations, we propose an end-to-end sustainable approach for JavaScript engine patch fuzzing, named PatchFuzz. It automates the collection of PoCs of a broader range of historical vulnerabilities and leverages both the PoCs and their corresponding patches to uncover new vulnerabilities more effectively. PatchFuzz starts by recognizing git commits which intend to fix security bugs. Subsequently, it extracts and processes PoCs from these commits to form the seeds for fuzzing, while utilizing code revisions to focus limited fuzzing resources on the more vulnerable code areas through selective instrumentation. The mutation strategy of PatchFuzz is also optimized to maximize the potential of the PoCs. Experimental results demonstrate the effectiveness of PatchFuzz. Notably, 54 bugs across six popular JavaScript engines have been exposed and a total of $62,500 bounties has been received.
BibTeX
@inproceedings{wang2026patchfuzz,
  author = {Junjie Wang and Yuhan Ma and Xiaofei Xie and Xiaoning Du and Xiangwei Zhang},
  title = {{PatchFuzz: Patch Fuzzing for JavaScript Engines}},
  booktitle = {Information},
  year = {2026},
  doi = {10.1016/j.infsof.2026.108087},
}
Figure