Skip to main content

LobeChat CVE-2025-62505

LOW
Server-Side Request Forgery (SSRF) (CWE-918)
2025-10-17 security-advisories@github.com
3.0
CVSS 3.1 · Vendor: github
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Authenticate with valid user token
  2. Delivery
    Call tools.search.crawlPages tRPC endpoint
  3. Exploit
    Supply internal URL with impls naive
  4. Execution
    Server-side fetch of internal/metadata endpoint
  5. Impact
    Exfiltrate internal API data or cloud credentials

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V4 - API and Web Service URL allowlisting, SSRF prevention
MITRE ATT&CK

2 techniques across 2 tactics: Initial Access, Credential Access

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires that the client can invoke the tools.search.crawlPages tRPC endpoint and supply both an arbitrary urls array and impls containing the value "naive", which routes the request to the unvalidated naive crawler fetch in packages/web-crawler. In production, a valid authenticated user token is required (limiting exploitation to authenticated users); in development mode only, authentication can be bypassed with the lobe-auth-dev-backend-api:1 header. Affected: LobeChat/@lobehub/chat <= 1.136.1. The limiting factors are the authentication requirement in production and the need for the attacker to control the target URL and impl selection; impact is maximized only where the server can reach sensitive internal services or the cloud metadata endpoint (169.254.169.254).

Impact

This is a genuinely low-priority issue despite being a network-reachable SSRF (CWE-918). Multiple signals align downward: the GitHub-assigned CVSS 3.1 vector (AV:N/AC:H/PR:H/UI:N/S:C/C:L/I:N/A:N) scores only 3.0, EPSS is 0.32% (23rd percentile), there is no CISA KEV listing (not actively exploited), and impact is limited to confidentiality (C:L) with no integrity or availability effect. The one escalating signal is that a working PoC exists in the GHSA advisory (publicly available exploit code), but POC availability is not the same as active exploitation. There is a notable internal inconsistency in the vendor/GitHub metrics versus the description: the CVSS sets PR:H and AC:H, yet the description and PoC indicate exploitation needs only a valid user token (any authenticated user, PR:L) and a single straightforward tRPC request (AC:L) - so the vector likely understates ease and overstates required privilege. Against that, real-world risk is moderated by the authentication requirement in production (the dev auth-bypass header only works in development mode), and by the limited confidentiality-only impact. The most serious realistic consequence - reaching the cloud metadata endpoint (169.254.169.254) to steal instance credentials - would be higher-impact than C:L implies, so the true confidentiality impact is deployment-dependent.

Exploit ScenarioDerived

An authenticated LobeChat user (or, in a development deployment, anyone able to set the lobe-auth-dev-backend-api:1 bypass header) sends a single tools.search.crawlPages tRPC request with a urls array pointing at an internal address and impls:["naive"]. The server performs an unvalidated server-side fetch and returns the internal response body, letting the attacker read internal APIs, management ports, or cloud instance-metadata credentials. A working PoC with a curl example is published in the GHSA advisory.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 08, 2026

Server-side request forgery in LobeChat 1.136.1 and earlier lets an authenticated user drive the server's own network position by calling the tools.search.crawlPages tRPC endpoint with an arbitrary urls array and impls set to ["naive"], causing the naive web-crawler implementation to fetch attacker-chosen URLs - including localhost, private ranges, and the cloud metadata address 169.254.169.254 - without any internal-address validation. In production this requires a valid user token (the CVSS vectors agree on an authenticated prerequisite, though NVD rates it PR:H and our assessment PR:L); the development-mode-only lobe-auth-dev-backend-api:1 header bypass is what the published proof-of-concept uses to read an internal API at localhost:8889, so publicly available exploit code exists. Impact is bounded to read-only information disclosure from reachable internal HTTP services, EPSS is low at 0.32% (23rd percentile), there is no CISA KEV entry, and the vendor shipped a fix in version 1.136.2.

RemediationAI

Upgrade to LobeChat 1.136.2 or later - the vendor-released patch, which adds the ssrf-safe-fetch workspace package and replaces the raw fetch(url) call in packages/web-crawler/src/crawImpl/naive.ts with ssrfSafeFetch(url) (commit 8d59583dca16f218b99213d641733d8ba77f182c); see advisory https://github.com/lobehub/lobe-chat/security/advisories/GHSA-fgx4-p8xf-qhp9. The vendor explicitly states no known workarounds exist, so until the upgrade is applied, treat the tools.search.crawlPages endpoint as privileged: put it behind an authenticating reverse proxy and restrict it to trusted roles, accepting that this only limits who can trigger the fetch and does nothing about the missing URL validation. Harden the blast radius at the network layer by denying server egress to loopback, RFC1918, and link-local space (especially 169.254.169.254) via firewall, security group, or an egress proxy - the trade-off is that legitimate crawling of private documentation hosts will break, and an egress proxy must resolve and re-check the destination itself or DNS rebinding can bypass the rule. Where the platform is a cloud instance, enforce IMDSv2 (or disable the metadata service entirely) so a successful SSRF cannot mint credentials, and never run the development auth-bypass header lobe-auth-dev-backend-api:1 in production, since it removes the only mitigating prerequisite in the assessed vector. Note that all of these are compensating controls with residual risk; patching remains the only complete fix.

Affected Packages

npm @lobehub/chat fix: 1.136.2

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in npm

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The flaw is a classic server-side request forgery (CWE-918) in the standalone web-crawler package (packages/web-crawler) that LobeChat exposes through its tRPC API. Client-supplied input - the urls array plus an impls selector - flows through the tools.search.crawlPages router into Crawler.crawl, which honors the caller's requested implementation; when the value \"naive\" is chosen, the naive crawler calls the platform fetch(url) directly with no allow-list, scheme check, DNS-rebinding guard, or block on loopback, RFC1918 ranges, link-local space, or cloud instance metadata endpoints (169.254.169.254). Because the request originates from the Node.js server rather than the browser, the attacker borrows the server's network trust and reachability. The upstream fix in commit 8d59583dca16f218b99213d641733d8ba77f182c is precise: it adds a new workspace dependency, ssrf-safe-fetch, to packages/web-crawler/package.json and swaps fetch(url) for ssrfSafeFetch(url) inside packages/web-crawler/src/crawImpl/naive.ts, i.e. the patch is a drop-in SSRF-safe fetch wrapper rather than a change to the tRPC surface. CPE data is limited to the npm package identity @lobehub/chat, so the affected component set is the self-hosted LobeChat server distribution containing the web-crawler package, not any downstream client SDK. Any residual exposure hinges on what the deployment can reach: internal APIs, admin/management ports, and metadata-derived credentials are the highest-value targets, and those are exactly what the fixed fetch wrapper now filters.

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (github) PRIMARY 3.0 LOW
AV:N/AC:H/PR:H/UI:N/S:C/C:L/I:N/A:N
vuln.today AI 5.0 MEDIUM

A valid user token is any authenticated user (PR:L, not PR:H) and a single request triggers it (AC:L); SSRF reaching internal systems is a scope change (S:C) with confidentiality-only disclosure (C:L).

3.1 AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:N/A:N
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (github).

CVSS VectorVendor: github

Attack Vector
Network
Attack Complexity
High
Privileges Required
High
User Interaction
None
Scope
Changed
Confidentiality
Low
Integrity
None
Availability
None

DescriptionCVE.org

LobeChat is an open source chat application platform. The web-crawler package in LobeChat version 1.136.1 allows server-side request forgery (SSRF) in the tools.search.crawlPages tRPC endpoint. A client can supply an arbitrary urls array together with impls containing the value naive. The service passes the user URLs to Crawler.crawl and the naive implementation performs a server-side fetch of each supplied URL without validating or restricting internal network addresses (such as localhost, 127.0.0.1, private IP ranges, or cloud instance metadata endpoints). This allows an attacker with a valid user token (or in development mode using a bypass header) to make the server disclose responses from internal HTTP services, potentially exposing internal API data or cloud metadata credentials. Version 1.136.2 fixes the issue. Update to version 1.136.2. No known workarounds exist.

Threat Intelligence Overview

EPSS Score
0.3%
Top 77% exploitable
Prevalence
Low
self-hosted open-source AI chat app, limited production enterprise footprint
Data Quality
4 sources
Confidence: Medium

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity LOW
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Defer
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact· derived
Low

Priority Score

15
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +15
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy