/

CVE-2026-45245

Severity:

HIGH RISK

(7.4)

Server-Side Request Forgery (SSRF) via UI Event Abuse

CVE-2026-45245

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF) via UI Event Abuse

CWE:

CWE-918, CWE-940

Impact:

Authenticated Server-Side Request Forgery to Local and Internal Services

Severity:

HIGH RISK

(7.4)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Summarize prior to 0.15.1 contains a vulnerability in its hover summary feature where synthetic mouseover events on attacker-controlled links can trigger authenticated requests through a local daemon.

Because the extension does not verify the trustworthiness of these events, an attacker can route authenticated requests to local or private-network URLs, potentially accessing sensitive internal endpoints when users hover over crafted content.

Affected context

This issue affects environments where the Summarize extension is installed and configured to talk to a local or background daemon using stored authentication tokens.

The vulnerability manifests when the hover summary feature is active on web pages that can render attacker-controlled HTML, such as untrusted websites or embedded content.

In this context, the extension treats any mouseover event as legitimate, including programmatically generated events, and will issue daemon requests based on the target link without validating the event's origin or intent.

Exploit preconditions

  • Attack surface: Web pages rendered in a browser with the Summarize extension installed and hover summary enabled.
  • Required access: Ability to cause the user to visit or embed attacker-controlled content (e.g., a malicious website, compromised page, or injected HTML).
  • Trigger point: Synthetic or scripted mouseover events fired over specially crafted links or elements that the extension monitors for hover summaries.
  • Why exploitation is possible: The extension assumes that all mouseover events are trustworthy user interactions and forwards the associated URL to the daemon with stored tokens, without distinguishing between genuine user actions and programmatic events or constraining target URL schemes and network locations.

Why this happens

The root cause is a failure to validate both the origin and trust level of UI events and the target of daemon-bound requests, resulting in an SSRF-style condition.

The extension's hover summary logic responds to any mouseover event on monitored elements, including synthetic events dispatched via JavaScript, treating them as if they were genuine user interactions.

These unvalidated events drive the construction of authenticated requests to a local or background daemon, which in turn can reach local host and private-network resources.

This maps primarily to CWE-918: Server-Side Request Forgery (SSRF), as the daemon is coerced into making network requests to attacker-specified internal endpoints, and also relates to CWE-940: Improper Verification of Source of a Communication Channel, because the extension fails to ensure that the triggering event originates from a trusted user action rather than script-driven automation.

Potential impact

  • The daemon may send authenticated HTTP requests to attacker-specified internal or local URLs.
  • Attackers could use the daemon as a proxy to reach private-network services that are not directly accessible from the internet.
  • Sensitive metadata or response bodies from internal APIs could be exposed to the attacker via the extension's response handling.
  • Internal endpoints that trigger state changes based on HTTP requests may be abused, potentially modifying internal configurations or data.
  • The vulnerability could serve as a pivot point for further network reconnaissance of local and private-network services.

General mitigation guidance

Effective mitigation focuses on strictly validating event trust and hardening the daemon's request handling:

  • Treat UI events as untrusted by default and only act on trusted user gestures, such as real mouse movement or click events explicitly marked as user-generated by the browser, avoiding programmatic triggers.
  • Introduce origin and context checks so that only events from expected, foreground contexts, and from allowed frames or domains, can drive daemon requests.
  • Implement URL allowlisting or scheme/domain restrictions on all daemon-bound requests:
  • Exclude localhost, loopback, link-local, and private-network address ranges unless explicitly required.
  • Disallow non-HTTP(S) schemes and sensitive ports by default.
  • Apply least-privilege token use, scoping tokens so that they cannot be reused to access arbitrary endpoints.
  • Add rate limiting and defensive parsing on responses from internal services to minimize data leakage and follow-on abuse.
  • Favor secure-by-default configuration so features that generate authenticated background requests must be explicitly enabled and are clearly surfaced to users.

How teams detect issues like this

Detection typically combines review of extension logic and network behavior:

  • Static analysis and code review:
  • Search for code paths that send network requests based on DOM events without checks like isTrusted or equivalent event integrity indicators.
  • Flag places where URLs for daemon requests are derived directly from page-controlled elements (e.g., href, data-* attributes) without normalization or allowlisting.
  • Identify any logic that allows the daemon to contact arbitrary hostnames or IP addresses, notably private-network ranges, without policy enforcement.
  • Behavioral and network monitoring:
  • Monitor for patterns where the daemon issues requests to local or RFC1918 addresses triggered by browsing untrusted sites.
  • Use browser or proxy logging to detect background requests that do not correlate with visible user navigation.
  • Automated security tooling:
  • Configure browser extension security linters or SAST tools to highlight event-driven network calls lacking trust checks.
  • Apply policy-based checks in CI/CD to reject changes that introduce unbounded internal network access from UI event handlers.

Sources

SourceLink
github.comgithub.com/steipete/summarize/commit/ecbb2c414255aa480a15d0d8b205224c14cfdbcb
github.comgithub.com/steipete/summarize/pull/218
github.comgithub.com/steipete/summarize/releases/tag/v0.15.2
vulncheck.comvulncheck.com/advisories/summarize-unauthorized-daemon-request-via-untrusted-events

Frequently asked

questions

Yes. An attacker only needs to lure a user with the vulnerable Summarize extension into visiting attacker-controlled content. From there, synthetic hover events can trigger the daemon to issue internal requests, without additional local compromise.

The attacker must be able to deliver web content to the victim's browser—such as a malicious site, an injected ad, or compromised page. They do not need direct access to the daemon or internal network; the extension and daemon act as the access path.

Enforce strict trust checks on UI events (processing only genuine user-driven interactions), combine that with URL allowlisting and network egress restrictions for the daemon, and ensure that stored tokens cannot be used to reach arbitrary internal services.

Design any browser extension or desktop integration so that untrusted page content cannot directly influence authenticated background requests. Require explicit, high-confidence user gestures, constrain where those requests can go via allowlists and network policies, and include security reviews that specifically look for SSRF and event-trust issues in early design and implementation phases.

Find out what's already
exploitable in your codebase.