acceptodds
Under review as a conference paper at ICLR 2027

Bridging Implicit Semantic Gaps: LLM-Guided Graph Completion for Static Vulnerability Detection

Abstract

Hybrid approaches that combine large language models (LLMs) with classical program analysis have advanced static vulnerability detection, yet many real-world vulnerabilities still evade detection. A key source of these false negatives is implicit semantic gaps: semantically mediated relations that connect attacker-controlled inputs to security-sensitive sinks but are absent from conventional interprocedural control-and data-flow graphs, leaving the end-to-end vulnerability path disconnected. We present SEMBRIDGE, a hybrid framework that bridges these implicit gaps via LLM-guided graph completion. SBMBRIDGE first applies conventional static analysis to recover explicit interprocedural structure and identify candidate sinks. It then uses LLMs to extract bridge facts from heterogeneous repository artifacts and materializes them as typed edges in a Semantic Bridge-Augmented Program Graph(SBPG). These edges reconnect program fragments that are semantically related but structurally disconnected, enabling end-to-end vulnerability reasoning over paths that standard analyses cannot recover. On the 213-case release of C WE-Bench-Java,our approach successfully detects 125 vulnerabilities, whereas the current state-of-the-art tool, IRIS, detects 81, yielding a 54.3% relative improvement over IRIS. More importantly, SEMBRIDGE also uncovers 27 previously unknown (0-day)vulnerabilities in 50 real-world projects.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
LLM for Security, Vulnerability Detection

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_ixMiOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper uses a static analysis to generate several graphs structures for vulnerability detection in Java (call graph, dataflow graph, etc). However, these graphs often have gaps due to features that are difficult to resolve statically, such as reflection. Sembridge uses an LLM to fill in those gaps so that they can discover more vulnerabilities via graph queries/vulnerability path search. They outperform all evaluated baselines.

Critical strengths

It's a solid neurosymbolic approach, intuitive, and outperforms the baselines.

Generally I think it's a pretty good paper. It identifies a problem (vulnerability detection), proposes a solution using ML, and evaluates it against existing baselines.

Critical weaknesses

I think there are two issues with this paper.

The first is novelty. Specifically, it is very similar to CaLLME: Call Graph Augmentation with Large Language Models for Javascript, COLM 2025, https://openreview.net/forum?id=xZi2rMUcAO, where the idea is to use an LLM to fill in gaps in static analysis that are very difficult to resolve statically. I feel the differences are all very superficial (CaLLME is just the call graph, Sembridge runs iteratively while CaLLME runs just once). The general idea of using an LLM to fill in the gaps of a static analysis I think has been done many times, so the novelty is kind of low.

The second is that it's unclear what the contribution of the paper is, although that's a general criticism of neurosymbolic approaches these days. It's a lot less clear that the SOTA is included, because I wouldn't be surprised at all if Mythos/a more powerful model would outperform all these approaches. I think the framing needs to be a bit clearer with that. Is the benefit of Sembridge that it allows smaller models to punch above their weight class, and therefore save tokens? I think at the very least it needs to be addressed in the limitations - it's not an accept-blocker for me.

Questions for authors

Mainly the weaknesses above.

  1. What is the novelty/research contribution over CaLLME or other neurosymbolic approaches that use an LLM to address the blind spots of static analysis?

  2. Is this a we-are-SOTA paper, or a token-saving/cost savings paper? If it's a we-are-SOTA paper, is there good reason to think that Sembridge will still have good improvements if the model is replaced with Mythos? This is more of a framing issue than anything else.

Reviewer_mfKPOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The authors introduce Sembridge, which targets missing relations (reflection, execution, cross-artifact interaction) in Interprocedural data flow and control flow graphs. Sembridge builds a semantic database and uses LLMs for a sink-guided backward analysis. They also validate the bridge relations with four checks and add only the validated edges in the Semantic Bridge Augmented Program Graph(SBPG). They evaluated SEMBRIDGE on CWE-Bench-JAVA, and it outperforms other baselines, IRIS and Repoaudit.

Critical strengths
  • The paper is well written and easy to follow.

  • The ablation study is insightful and provides evidence for the specific design choices

  • Backbone model performance analysis also assures the model sensitivity

  • The performance gain is substantial over baselines

Critical weaknesses
  • Neither the main text nor the appendix contains the implementation details of the four edge validation checks (Section 3.2). 

  • The paper does not measure precision, as the semantic edges are added using LLMs; many false edges could be added. 

  • The paper mentions “repository-scale exploration”; however, it doesn’t state the token cost and latency

  • CWE-Bench-Java is a well-known public dataset; the LLMs may have memorised the knowledge of vulnerable methods or source-sinks. The authors don’t account for this possible data leakage.

Questions for authors
  • Could the authors provide details on their four “edge validation” checks? Especially how they performed check 4, as it seems to be a semantic judgment.

  • Could the authors report the precision score on the patched versions of the CWE-Bench-Java or on the zero-day discovery projects?

  • Could the authors provide a cost and latency report per project for Sembridge against the baselines?

  • For data contamination, did the authors run any memorisation probing experiments?

Reviewer_TxnJOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes SemBridge, which uses LLMs to recover these relations from repository artifacts. It first builds a semantic database and a basic program graph, then works backward from potential sinks to identify missing connections. The inferred relations are checked and added to the graph, which is then used for vulnerability detection.

Critical strengths
  1. The problem is interesting and well motivated. The motivating example shows that identifying the correct sources and sinks is not always sufficient for vulnerability detection. The connections between them can depend on information outside control and data flow. Using LLMs to recover these connections is a reasonable approach.
  2. The method is reasonably designed. Adding the inferred relations to a program graph allows later analysis to reuse them and connect information across different files and artifacts.
  3. The results are overall good. SemBridge detects 125 vulnerabilities, compared with 81 for IRIS. The paper also reports discovering 27 zero-day bugs.
Critical weaknesses
  1. The bridge-validation step is not explained inn detail. The 4th check in Section 3.2 is intended to establish this, but the paper does not explain how it is exactly implemented within validateBridge in Algorithm 1.
  2. The exploration strategy can ignore information needed to recover longer vulnerability paths. Algorithm 1 keeps only the top 10 candidates. Due to this, an essential relation can be missed because it is ranked too low or its supporting evidence is not yet available.
  3. The method has limited coverage beyond taint-style vulnerability detection. As I understand it, SemBridge improves the connections in the graph but still inherits the source-to-sink formulation. Recovering additional edges therefore cannot address vulnerabilities whose security properties are not represented by this formulation. Appendix I attributes 56 of the 88 missed cases to unsupported vulnerability models.
Questions for authors
  1. Can the authors explain how the validateBridge is implemented?
  2. What happens when none of the top 10 candidates produces a valid bridge? Can the system expand the search or revisit rejected candidates after discovering new evidence? How sensitive are the results to this cutoff?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.