Just-In-Time (JIT) compiler is a core component of JavaScript engines, which takes JavaScript code as input and applies a series of optimization passes on it and transforms it to machine code. The optimization passes often have some assumptions (e.g., variable types) on the input program, and therefore will yield vulnerabilities if the assumptions are violated. To discover such bugs, it is essential to thoroughly test different optimization passes, but previous work fails to do so and mainly focused on exploring code coverage. In this paper, we present the first optimization path guided fuzzing solution for JavaScript JIT compilers, namely OptFuzz, which focuses on exploring optimization paths. Specifically, we utilize an optimization subpath metric to approximate the optimization path, and use it as feedback to guide seed preservation and seed scheduling. Furthermore, we identify optimization triggering by analyzing code transformations at the JIT intermediate representation (IR) level, and preserve optimization subpaths only when optimizations are triggered. We implemented OptFuzz on four baseline fuzzers and evaluated it on 4 mainstream JavaScript engines. On earlier engine versions, OptFuzz found several times more bugs than baselines. On the latest engines, OptFuzz discovered 52 new bugs, among which 43 have been confirmed or fixed.

Decompilation is foundational to binary analysis, yet conventional tools prioritize human readability over strict recompilability and verifiable runtime correctness. While recent LLM-based approaches attempt to refine decompiled pseudocode, they typically either optimize solely for readability or rely on static analysis for evaluation. This makes them prone to "semantic hallucinations" that compromise accuracy and fail to resolve actual runtime failures. For critical tasks like software modernization and vulnerability remediation, recovered code must not only compile but replicate the original binary's behavior. We present PCodeTrans, a feedback-driven framework that bridges the gap between decompilation, recompilation, and rigorous function-level dynamic validation. After extracting a minimal yet coherent context to guarantee recompilability, PCodeTrans employs an in situ substitutable engine to hot-swap the compiled function directly into the unmodified binary, natively preserving its authentic execution context and global dependencies. Guided by fine-grained differential tracing, PCodeTrans generates precise runtime feedback to iteratively guide an LLM in repairing semantic discrepancies. Evaluated on Coreutils and Binutils, PCodeTrans achieves unprecedented recovery performance when rectifying raw Hex-Rays outputs, attaining 100

Large reasoning models (LRMs), which autonomously produce a reasoning chain of thought (CoT) before producing final responses, offer a promising approach to interpreting and monitoring model behaviors. Inspired by the observation that certain CoT patterns–e.g., Wait, did I miss anything?–consistently emerge across tasks, we explore whether LRMs exhibit human-like cognitive habits. Building on Habits of Mind, a well-established framework of cognitive habits associated with successful human problem-solving, we introduce CogTest, a principled benchmark designed to evaluate LRMs’ cognitive habits. CogTest includes 16 cognitive habits, each instantiated with 25 diverse tasks, and employs an evidence-first extraction method to ensure reliable habit identification. With CogTest, we conduct a comprehensive evaluation of 16 widely used large language models (LLMs) (13 LRMs and 3 non-reasoning ones). Our findings reveal that LRMs, unlike conventional LLMs, not only exhibit human-like habits but also adaptively deploy them according to different tasks. Finer-grained analyses further uncover patterns of similarity and difference in LRMs’ cognitive habit profiles, particularly certain inter-family similarity (e.g., Qwen3 models and DeepSeek-R1). Extending the study to safety-related tasks, we observe that certain habits, such as taking responsible risks, are strongly associated with the generation of harmful responses. These findings suggest that studying persistent behavioral patterns in LRMs’ CoTs is a valuable step toward deeper understanding of LLM misbehavior. The code is available at: https://github.com/jianshuod/CogTest .

Directed fuzzing aims to trigger specific vulnerabilities by steering execution towards predefined target code. However, state-of-the-art directed fuzzers predominantly focus on reaching the target code quickly, often lacking effective follow-up strategies to satisfy the vulnerability constraints required to trigger them. We find that this can be a key factor limiting their performance in directed fuzzing tasks such as crash reproduction. The main challenge is that existing directed fuzzers cannot accurately identify the triggering conditions of target vulnerabilities and effectively exploit them to guide fuzzing. To address this challenge, we propose TrigFuzz, a directed fuzzing solution guided by triggering conditions. Our approach leverages pre-trained large language models (LLMs) to automatically generate the triggering conditions of target vulnerabilities. We design a formalized representation for generated triggering conditions, along with a novel dynamic triggering validation technique to verify their correctness. The verified conditions are further transformed into “triggering distance” metrics that serve as fuzzing runtime feedback to guide seed scheduling and mutation strategies, enabling directed fuzzing to effectively generate vulnerability-triggering test cases. Our evaluations demonstrate that TrigFuzz can generate highquality triggering conditions for 96.67 % of target vulnerabilities and outperform state-of-the-art directed fuzzers with over a $1.72 \times$ speedup in reproducing target vulnerabilities on the benchmark Magma. Lastly, we detected 7 previously unknown vulnerabilities with 2 CVE IDs assigned in well-tested realworld software using TrigFuzz.

To improve the accuracy of lightweight detectors, researchers have extensively employed feature-level knowledge distillation. However, existing methods often rely on ground-truth bounding boxes to localize salient regions, thereby directing the representation learning of student models. These approaches ignore the significant structural and semantic divergence of teacher–student networks, making it challenging to transfer effective knowledge. Our method, BAD, constitutes a new framework for distillation that introduces bidirectional attention guidance across spatial and channel dimensions. The core of BAD is to extract spatial response patterns from both teacher and student networks and fuse them into a joint attention mask. This mask identifies semantically aligned regions without relying on ground-truth boxes, enabling adaptive guidance for the student to focus on task-relevant areas while preserving its representational flexibility. Meanwhile, the masking mechanism helps mitigate training imbalance caused by overly strict alignment. The spatial attention module helps localize contextually important regions, while the channel attention enhances global semantic alignment. We perform comprehensive experiments on multiple popular object detectors, including YOLOv8, RetinaNet, FCOS, and Faster R-CNN. The results demonstrate that BAD achieves stable and effective knowledge transfer under heterogeneous architectures and limited model capacity.

The rapid advancement of Large Language Models (LLMs) has created new opportunities for Automated Penetration Testing (AutoPT), spawning numerous frameworks aimed at achieving end-to-end autonomous attacks. However, despite the proliferation of related studies, existing research generally lacks systematic architectural analysis and large-scale empirical comparisons under a unified benchmark. Therefore, this paper presents the first Systematization of Knowledge (SoK) focusing on the architectural design and comprehensive empirical evaluation of current LLM-based AutoPT frameworks. At systematization level, we comprehensively review existing framework designs across six dimensions: agent architecture, agent plan, agent memory, agent execution, external knowledge, and benchmarks. At empirical level, we conduct large-scale experiments on 13 representative open-source AutoPT frameworks and 2 baseline frameworks utilizing a unified benchmark. The experiments consumed over 10 billion tokens in total and generated more than 1,500 execution logs, which were manually reviewed and analyzed over four months by a panel of more than 15 researchers with expertise in cybersecurity. By investigating the latest progress in this rapidly developing field, we provide researchers with a structured taxonomy to understand existing LLM-based AutoPT frameworks and a large-scale empirical benchmark, along with promising directions for future research.

Recent advancements in AI-integrated automated penetration testing (AutoPT) methodologies demonstrate that agent training based on simulation modeling can significantly enhance cost-efficiency while reducing feedback latency. However, despite the growing body of AutoPT research, a critical gap remains: the absence of a unified framework for simulation modeling methods. This paper systematically reviews and synthesizes existing techniques, proposing MDCPM to categorize studies based on their objectives, network simulation complexity, technical and tactical operation dependencies, and scenario feedback and variation. To address the lack of a unified method for multi-dimensional, multi-level simulation modeling, especially in dynamic environments, we propose AutoPT-Sim, a novel policy-automation-driven framework capable of simulating arbitrary sub-dimensional element across three key dimensions. AutoPT-Sim offers a holistic approach to modeling network environments, attackers, and defenders, overcoming the limitations of static and linear modeling techniques. Furthermore, we contribute a standardized network environment dataset and a network generator tool capable of generating networks of diverse sizes. By seamlessly integrating such datasets, AutoPT-Sim enables diverse simulation modeling levels for policy automation in MDCPM, while the network generator empowers researchers to create customized target network data, supporting tailored experimentation.

Security Patch Detection (SPD) is critical for protecting systems against vulnerabilities, yet vendors often release security patches silently without CVE assignments, making detection crucial for security maintenance. Existing binary-level SPD methods face key challenges: limited context analysis focusing only on local modifications, coarse-grained basic block representations, and poor scalability on real-world executables. We present SPDAgent, a context-aware framework for binary-level SPD that combines optimized pseudocode diffing with LLM-powered analysis. First, we propose an Iterative Maximal Unique Match based Pseudocode Diff algorithm (IMP-Diff) that progressively eliminates variable renaming noise, reducing diff size by an average of 30%. Second, we develop an LLM-driven multi-agent architecture comprising a pattern-based pre-filter and an iterative analysis loop, where agents dynamically retrieve inter-procedural dependencies on demand for comprehensive vulnerability assessment. To evaluate SPDAgent, we construct SPD-BIN, the first binary-level dataset with 6,250 executable pairs from 625 commits across 15 projects. Experiments show SPDAgent achieves 73.44% accuracy and 0.75 F1 score, outperforming existing methods while reducing false negatives to 18.73%. On real-world cross-version binaries, it achieves 84.48% recall across 58 CVEs, demonstrating practical applicability for detecting security patches in production software.

Traditional database fuzzing techniques primarily focus on syntactic correctness and general SQL structures, leaving critical yet obscure DBMS features, such as system-level modes (e.g., GTID), programmatic constructs (e.g., PROCEDURE), advanced process commands (e.g., KILL), largely underexplored. Although rarely triggered by typical inputs, these features can lead to severe crashes or security issues when executed under edge-case conditions. In this paper, we present FuzzySQL, a novel LLM-powered adaptive fuzzing framework designed to uncover subtle vulnerabilities in DBMS special features. FuzzySQL combines grammar-guided SQL generation with logic-shifting progressive mutation, a novel technique that explores alternative control paths by negating conditions and restructuring execution logic, synthesizing structurally and semantically diverse test cases. To further ensure deeper execution coverage of the back end, FuzzySQL employs a hybrid error repair pipeline that unifies rule-based patching with LLM-driven semantic repair, enabling automatic correction of syntactic and context-sensitive failures. We evaluate FuzzySQL across multiple DBMSs, including MySQL, MariaDB, SQLite, PostgreSQL and Clickhouse, uncovering 37 vulnerabilities, 7 of which are tied to under-tested DBMS special features. As of this writing, 29 cases have been confirmed with 9 assigned CVE identifiers, 14 already fixed by vendors, and additional vulnerabilities scheduled to be patched in upcoming releases. Our results highlight the limitations of conventional fuzzers in semantic feature coverage and demonstrate the potential of LLM-based fuzzing to discover deeply hidden bugs in complex database systems.

Decompilation of stripped binaries is hindered by the loss of user-defined data structures, causing pseudocode to degrade into raw offsets, casts, and generic pointers. Recovering these structures remains challenging for three main reasons: local evidence becomes fragmented once accesses go beyond simple one-hop forms, program-wide aggregation fragments under polymorphism, and residual cases such as dynamic offsets or irreconcilable conflicts are not reliably resolvable by static rules alone. We present CiRCLE, a staged framework for recovering complex data structures from stripped binaries. CiRCLE first constructs the MOSAIC graph, a shared evidence representation that explicitly preserves computed and intermediate pointer expressions at expression granularity. It then performs conflict-aware interprocedural aggregation directly on the same evidence graph, enabling evidence reuse across monomorphic flows while isolating true polymorphic boundaries. For the small residue of underdetermined cases, it invokes LLM refinement only on localized evidence packages and falls back to the deterministic static result when refinement fails. On the OSPREY dataset, CiRCLE surpasses the best prior method by up to 15.6 % in Structure Identification, 47.7 % in Relationship Recovery, and 33.6 % in Layout Recovery. On a corpus of 140,000 functions from real-world applications, it achieves $59.7 \% ~\mathrm{F} 1$ in Layout Recovery, a 51.1 % relative improvement over the best prior method in that setting.

Binary reverse engineering is pivotal in the realm of cybersecurity, enabling critical applications such as malware analysis, legacy code hardening, and vulnerability detection. However, the challenge of recovering structural information from binaries, especially stripped ones, persists due to the significant loss of variable boundaries, types, names, and dataflow information during compilation. In this article, we introduce Hybrid REasoning for Structure Recovery (HyRES), an innovative hybrid reasoning technique that energizes static analysis, Large Language Model (LLM), and heuristic methods to recover data structures from stripped binaries. It analyzes the structure layout and proficiently infer its semantics via LLM, and utilizes semantics to perform semantic-enhanced structure aggregation, which overcomes the need for complete dataflow. HyRES outperforms State-of-the-Art (SOTA) solutions in terms of structure pointer identification and layout recovery. Specifically, HyRES achieves 65.1% higher recall and 33.4% higher accuracy than the SOTA, while also being 64.2% faster than existing SOTA solutions. Comprehensive experiments demonstrate HyRES's superior performance and practical utility in real-world reverse engineering tasks, marking a significant advancement in binary analysis.

Intel SGX provides hardware-enforced trusted execution environments for security-critical applications, yet the enclave-host interface remains vulnerable to buffer overflows and TOCTOU attacks. While fuzzing tools effectively discover these vulnerabilities, manual patching requires deep SGX expertise and prevents continuous security improvement. We present EnclavePatch, the first LLM-driven automated patching system for SGX applications that integrates with fuzzing to form a continuous discovery-patching loop. EnclavePatch automatically analyzes root causes, synthesizes patches following SGX security principles, and validates patches through coverage-driven regression testing. Evaluation on 6 real-world SGX applications shows EnclavePatch successfully fixes all 69 discovered vulnerabilities with 100% success rate and 345-582× speedup over manual patching (median 8.7min vs 2-5 days), while maintaining or improving code coverage. The iterative approach discovers 43.8% more vulnerabilities than single-pass fuzzing by enabling exploration of deeper code paths.

The rendering engine is a cornerstone of modern web browsers, responsible for transforming heterogeneous inputs—HTML, CSS, and JavaScript—into visual page content. This complex process involves constructing and updating the render tree, which governs layout and painting, but also introduces subtle defects that manifest as robustness and security challenges. Existing browser fuzzers largely fall short in thoroughly testing the rendering engine due to two fundamental challenges: (i) the vast, multidimensional input space makes efficient exploration difficult; (ii) the periodic, incremental rendering model of modern rendering engines merges multiple updates of the render tree within each rendering cycle, reducing activation of deep pipeline logic such as layout and painting. In this paper, we aim to enhance the testing depth of the rendering pipeline—rather than simply increasing code coverage—by focusing on updating the render tree, the central data structure linking frontend inputs to backend layout and painting modules. Our approach incorporates (i) correlation-based pruning strategies for HTML elements and CSS properties to prioritize high-yield input combinations, and (ii) a time-sliced testing scheme that intentionally distributes mutations across multiple rendering cycles within a single test case, thereby increasing the trigger frequency of backend rendering modules. We implement a prototype, RTFuzz, and evaluate it extensively. Compared to state-of-the-art fuzzers Domato, FreeDom, and Minerva, RTFuzz helps uncover 43.1%, 28.7%, and 75.7% more unique crashes, 83.3% of which occur in the rendering pipeline, and further identified 20 real-world defects during long-running experiments. Ablation studies confirm that correlation-based pruning increases unique crashes by 79.2%, and the time-sliced scheme contributes a 16.2% improvement.

Fuzz drivers are essential components of greybox fuzzing, as they encapsulate target interfaces, define test spaces, and largely determine fuzzing effectiveness. Existing fuzz drivers typically rely on crash-based oracles for security testing, overlooking library functionality and limiting bug detection capability. In this paper, we present the first study on metamorphic-based fuzz oracle enhancement (MFOE), which augments existing fuzz drivers with metamorphic-based oracles derived from metamorphic relations (MRs). Since constructing and integrating such oracles requires substantial domain knowledge, automating MFOE is challenging. To address this challenge, we propose MetaFOE, an LLM-based framework that automatically generates and integrates metamorphic-based oracles. We evaluate MetaFOE on OSS-Fuzz drivers using three modern LLMs and five prompt strategies. MetaFOE generates 3,475 MRs, of which 77.3