Skip to main content

LangGraph API EUVDEUVD-2026-112487

| CVE-2026-118668 HIGH
Authorization Bypass Through User-Controlled Key (CWE-639)
2026-10-28 GitHub_M GHSA-4hm6-w6qq-w73v
8.6
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Authenticate as ordinary user
  2. Exploit
    Issue Store operation targeting another namespace
  3. Execution
    Handler's namespace rewrite not applied across runtime boundary
  4. Impact
    Read, overwrite, search, or delete victim's Store data

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Object-level authorization, IDOR prevention
Exploitation Conditions

Exploitation requires ALL of: a vulnerable langgraph-api version (>=0.1.2, <0.15.0); the deployment running JavaScript or TypeScript custom authentication (NOT Python); the Store authorization handler relying on REWRITING the requested namespace to isolate users (handlers that reject unauthorized namespaces are not affected); an attacker able to authenticate as an ordinary user; and multiple users' data stored through the affected authorization path. Limiting factors that reduce real-world exposure: authentication as a valid user is required (PR:L), Python custom authentication is entirely unaffected, and the vulnerable namespace-rewriting pattern is a specific implementation choice rather than a guaranteed default. No administrator privileges, user interaction, race condition, or mitigation bypass is required per the advisory.

Impact

The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:N, 8.6 High) describes a network-reachable, low-complexity authorization flaw (CWE-639/CWE-863) requiring only ordinary authenticated-user privileges (PR:L) and no user interaction, with high confidentiality and integrity impact on other users' Store data. However, exploitability is strongly gated by deployment configuration: the GitHub Security Advisory confirms the flaw only manifests when langgraph-api runs JavaScript/TypeScript custom authentication AND the Store authorization handler isolates users by REWRITING the requested namespace rather than rejecting it. Python handlers and JS/TS handlers that reject unauthorized namespaces are explicitly unaffected. No EPSS score was supplied, this CVE is not on CISA KEV, and no public exploit or PoC was provided (only the vendor advisory is referenced). The priority signal provided is 'this_week' rather than act_now/emergency. Net assessment: a genuinely high-severity authorization bug for the subset of deployments matching the vulnerable pattern, but with no evidence of active exploitation and a materially narrower real-world footprint than the raw 8.6 suggests - the score reflects impact on an affected deployment, not the likelihood that any given deployment is affected.

Exploit ScenarioDerived

In a LangGraph deployment that uses JavaScript/TypeScript custom authentication and enforces per-user Store isolation by rewriting namespaces, an attacker authenticates as an ordinary user and issues Store operations (read, search, put/overwrite, delete). Because the namespace rewrite returned by the JS/TS authorization handler is not carried across the runtime boundary and applied before the Store operation, the attacker's original (unauthorized) namespace is used, granting access to another user's data. No public PoC or exploit code was provided; only the vendor advisory is referenced.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available

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

Alert me

AnalysisAIv1 – Oct 28, 2026

Cross-user Store access in LangGraph API (pip package langgraph-api) versions 0.1.2 through 0.14.x lets an ordinary authenticated user read, overwrite, search or delete Store data belonging to another user. The flaw only manifests in deployments running JavaScript or TypeScript custom authentication whose Store authorization handler restricts users by rewriting the requested namespace: the rewritten namespace is not carried across the runtime boundary and applied before the Store operation, so the original (attacker-supplied) namespace is used instead (CWE-639). Python custom authentication and JS/TS handlers that reject unauthorized namespaces rather than rewriting them are unaffected; vendor CVSS 4.0 scores it 8.6 High and the issue is fixed in 0.15.0, with no public exploit identified at time of analysis.

RemediationAI

Vendor-released patch: upgrade to langgraph-api 0.15.0 or later (langgraph-api>=0.15.0), which carries authorization-handler changes across the runtime boundary, applies them before the Store operation, and validates the resulting namespace, rejecting malformed or unapplicable changes. Deployments that cannot upgrade immediately should rewrite every JavaScript or TypeScript Store authorization handler exposed by the deployment so that it rejects requests for unauthorized namespaces instead of depending on namespace rewriting, and this workaround must be applied to every Store action the deployment exposes. Note the side effects: switching from rewriting to rejection means legitimate callers that previously relied on transparent namespace remapping will start receiving authorization errors and must send the already-correct namespace, and any custom handler that returns a malformed namespace will be rejected outright after the patch rather than silently falling back. Audit Store data for cross-user reads or writes, and note that Python-based custom authentication deployments and JS/TS handlers that already reject unauthorized namespaces need no change. Advisory and fix details: https://github.com/langchain-ai/langgraph/security/advisories/GHSA-4hm6-w6qq-w73v.

Affected VersionsENISA

langgraph-api 0.1.2, < 0.15.0

Affected Packages

pypi langgraph-api fix: 0.15.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in pypi

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

Technical ContextAI · show details

langgraph-api is the server component that implements the LangGraph API, and its pluggable custom authentication layer lets deployments supply authorization handlers, including handlers written in JavaScript or TypeScript. The affected pattern is an authorization handler that enforces per-user isolation by returning a rewritten Store namespace (for example, prefixing the caller's user ID); the intended design is that the runtime applies that rewrite before executing the Store operation. In versions 0.1.2 to 0.14.x the rewrite produced on the JavaScript/TypeScript side did not survive the boundary into the server runtime, so the Store operation was evaluated against the namespace originally requested by the caller. This is CWE-639 (authorization bypass through a user-controlled key), classified additionally as CWE-863 in the advisory, and yields cross-tenant reads, overwrites, searches and deletions of Store data. Per the vendor, no administrator privileges, user interaction, race condition or bypass of another mitigation is required, and the trigger is the mismatch itself rather than any timing or memory-safety condition. The fix in 0.15.0 propagates the handler's changes across the runtime boundary, applies them before the Store call, and validates the resulting namespace, rejecting requests whose authorization change is malformed or cannot be safely applied.

Know when Langgraph Api gets its next vulnerability

  • 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_M) PRIMARY 8.6 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N
vuln.today AI 8.1 HIGH

Network-reachable via authenticated ordinary user (PR:L), low complexity with no special trigger described; cross-user read and overwrite/delete give C:H/I:H, availability of the service unaffected (A:N), same component so S:U.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Oct 28, 2026 - 22:04 EUVD
CVE Published
Oct 28, 2026 - 21:06 cve.org
HIGH 8.6

DescriptionCVE.org

langgraph-api implements the LangGraph API for rapid development and testing. From 0.1.2 until 0.15.0, JavaScript or TypeScript custom authentication Store authorization handlers can return a rewritten namespace that is not carried across the runtime boundary and applied before the Store operation. An authenticated user can therefore access another user's Store namespace when a deployment relies on namespace rewriting for isolation, allowing unauthorized reads, overwrites, searches, or deletions. Python custom authentication and handlers that reject unauthorized namespaces instead of rewriting them are not affected. This issue is fixed in version 0.15.0.

Technical POC Analysis

Bug class: CWE-639, Authorization Bypass Through User-Controlled Key (advisory also tags CWE-863, Incorrect Authorization).

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

CVE-2026-118668 is a high-severity authorization bypass in LangGraph API (pip package langgraph-api) versions 0.1.2 through 0.14.x, affecting deployments that use JavaScript/TypeScript custom authentication with namespace-rewriting Store handlers. An ordinary authenticated user can read, overwrite, search, or delete Store data belonging to other users, creating a risk of data exposure and integrity loss for organizations relying on this pattern. Leadership should prioritize remediation because the flaw undermines tenant isolation and could lead to unauthorized access to sensitive application data.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis, but version 0.15.0 is fixed and available; upgrade to 0.15.0 or later. Interim mitigations include: disabling JavaScript/TypeScript custom authentication handlers that rewrite Store namespaces, or modifying them to reject unauthorized namespace access instead of rewriting; restricting Store access to trusted users; and monitoring Store access logs for anomalous cross-user activity.

Threat Intelligence Overview

Prevalence
Medium
popular AI agent framework but narrow vulnerable deployment configuration
Threat Intel
1
1 source
Social Media
1
Sightings
Data Quality
3 sources
Confidence: Low

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 HIGH
CISA KEV No
Public POC No
EPSS N/A
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
High

Priority Score

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

Attack Technique

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

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