Skip to main content

Neo4j GraphQL Library CVE-2026-92682

| EUVDEUVD-2026-97486 HIGH
Incorrect Authorization (CWE-863)
2026-10-12 Neo4j
8.6
CVSS 4.0 · Vendor: Neo4j
View

Attack ChainAIDerived

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

  1. Access
    Authenticate to GraphQL API with valid JWT
  2. Exploit
    Issue query/mutation on records guarded by a 'none' @authorization filter
  3. Execution
    Inverted Cypher translation returns denied records instead of excluding them
  4. Impact
    Read, create, or delete sensitive data the typedefs intended to block

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Authorization logic validation
MITRE ATT&CK

1 technique across 1 tactic: Privilege Escalation

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

Exploitation Conditions

Requires (1) an authenticated user - the CVSS vector specifies PR:L, so the attacker must hold a valid JWT accepted by the API; and (2) the target application must define an @authorization filter that uses the 'none' quantifier on a relationship or connection field (e.g. @authorization(filter: [{ where: { node: { creator: { none: { id: { eq: "$jwt.sub" } } } } } }])). Applications that never use the 'none' quantifier in authorization filters are NOT exploitable. No user interaction is needed and the attack works against default library behavior in affected versions (7.0.0 through 7.6.3). The key limiting factor is this configuration dependency on the 'none' quantifier, which narrows real-world exposure despite the network, low-complexity profile.

Impact

This is a genuine authorization-bypass priority rather than a merely inflated CVSS number. The vendor-supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N) describes a network-reachable, low-complexity flaw requiring only low privileges (any authenticated API user), and the dual VC:H/VI:H impact is consistent with the description - protected records can be both read and mutated (created/deleted). The root cause is unambiguous and confirmed by the patch diff: the 'none' quantifier was translated to Cypher without the required Cypher.not() negation, so it silently behaved like 'some', inverting every rule that used it. No EPSS score, CISA KEV listing, or public POC was provided in the input, so there is no public exploit identified at time of analysis and no evidence of active exploitation; the risk signal here comes from exploitation ease and logic certainty, not from observed attacks. One caveat to flag: exploitation is conditional on an application actually using the 'none' quantifier inside an @authorization filter on a relationship or connection - deployments that never use 'none' are not exploitable, so real-world blast radius depends on configuration and is narrower than the raw 8.6 suggests.

Exploit ScenarioDerived

An application uses @neo4j/graphql with an @authorization filter such as 'none of the related users matches $jwt.sub' to hide records from denied users. Because 'none' is inverted to 'some', an authenticated attacker simply issues a normal GraphQL query (or mutation) and receives exactly the records the rule was meant to deny - and can likewise create or delete them. No special tooling is needed and complexity is low; no public exploit code was provided in the input.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.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 12, 2026

Authorization bypass in @neo4j/graphql 7.0.0 through 7.6.3 lets an authenticated user read, create, and delete records that @authorization filter rules were written to deny, because the library translates the 'none' quantifier on relationship and connection filters into Cypher without the required negation so the predicate is evaluated as though it were 'some'. The flaw only manifests in applications whose typedefs actually use the 'none' quantifier inside an @authorization filter on a relationship or connection field (for example creator: { none: { id: { eq: "$jwt.sub" } } }), so applications that never use that construct are not affected; the CVSS vector specifies PR:L, meaning the attacker must hold a valid JWT accepted by the API. No confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis; a vendor patch and the upstream fix commit are available.

RemediationAI

Upgrade @neo4j/graphql to 7.6.4 or later (vendor-released patch: 7.6.4), which wraps the generated EXISTS predicate in Cypher.not() for the NONE operator in both AuthRelationshipFilter and AuthConnectionFilter; the release is available via npm at https://www.npmjs.com/package/@neo4j/graphql and the exact fix commit is https://github.com/neo4j/graphql/commit/17650cc370445a6bb9d394d34063d3623e987aa2, with details in the advisory https://github.com/neo4j/graphql/security/advisories/GHSA-h873-p2wr-fjx6. If an immediate upgrade is not possible, the effective compensating control is to eliminate the vulnerable construct from typedefs: rewrite any @authorization filter that uses the 'none' quantifier on a relationship or connection as an explicitly positive allowlist predicate (for example matching the permitted subject rather than excluding a denied one), or push the check into a custom Cypher directive / middleware where the negation can be expressed directly - the trade-off being added translation work and the risk of re-introducing the same logic error if the rewrite is not carefully reviewed and tested against both read and mutation operations. Because the same defect permits unauthorized creates and deletes, teams should also treat data written while an affected version was deployed as untrusted and audit recently created or deleted nodes for records that violate the intended authorization rules before assuming the post-upgrade state is clean; disabling the authorization feature entirely is not a viable workaround since it removes all enforcement rather than fixing the inverted equality, and restricting the JWT issuer/audience or API reachability only narrows the attacker population without closing the bypass.

Affected VersionsENISA

@neo4j/graphql 7.0.0 <7.6.4

Affected Packages

euvd neo4j_graphql fix: 7.6.4

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

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

Technical ContextAI · show details

@neo4j/graphql is the JavaScript/TypeScript library that compiles GraphQL type definitions into Cypher statements executed against a Neo4j database; its @authorization directive is the application-level access-control layer that injects filter predicates into generated queries based on claims such as $jwt.sub. The query-AST translation classes AuthConnectionFilter and AuthRelationshipFilter, which build predicates for relationship and connection fields, emitted a bare Cypher EXISTS(...) clause for the 'none' quantifier instead of wrapping it in Cypher.not(), so the semantics were inverted: 'none of the related nodes match the JWT subject' was evaluated as 'at least one related node matches', returning exactly the records the rule was meant to exclude. Because the same translation path is used for write operations, the inversion also affects mutations, allowing unauthorized creation and deletion rather than only disclosure. This is a CWE-863 (Incorrect Authorization) defect in an authorization-enforcement mechanism, and the affected CPE (cpe:2.3:a:neo4j:@neo4j/graphql:*:*:*:*:*:*:*:*) confirms the exposure is limited to the npm client library - the Neo4j DBMS itself is not implicated - with the fix landing in 7.6.4 per the commit diff and the .changeset note 'Fix "none" quantifier being inverted in authorization relationship and connection filters'.

Know when Neo4j 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 (Neo4j) 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 GraphQL API with low-privilege authenticated access (PR:L) and no user interaction; inverted filter exposes and allows modification of protected records (C:H/I:H), with no direct availability impact.

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 (Neo4j).

CVSS VectorVendor: Neo4j

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

DescriptionCVE.org

In @neo4j/graphql versions from 7.0.0 up to but not including 7.6.4, the none quantifier in @authorization filters on relationships and connections is not negated when translated to Cypher, so it behaves like some. A rule such as "none of the related denied users matches the JWT subject" therefore returns exactly the records it was meant to exclude, and excludes those it was meant to return. An authenticated user whom such a rule is meant to deny can read the protected records. This is also the case for mutations, so the impact is that sensitive data could also be created and deleted by users that shouldn't have access according to the typedefs. Fixed in 7.6.4.

Technical POC Analysis

CWE-863 (Incorrect Authorization): a boolean-polarity defect in the GraphQL-to-Cypher translation of authorization filter predicates, not a missing check.

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

@neo4j/graphql versions 7.0.0 through 7.6.3 contain an authorization bypass that allows any holder of a valid JWT to read, create, and delete records that application-level @authorization rules were explicitly written to deny, undermining the access-control guarantees customers and auditors rely on. Only GraphQL APIs whose type definitions use the 'none' quantifier on relationship or connection filters are exposed, so leadership should treat this as a targeted but potentially serious integrity and confidentiality risk for affected services. Given the authenticated attack path and the possibility of unauthorized data modification, owners of affected Neo4j-backed APIs should prioritize remediation and assess whether any data was altered.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 78% exploitable
Prevalence
Low
official Neo4j GraphQL library, ecosystem-specific and niche deployment footprint
Data Quality
5 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 HIGH
CISA KEV No
Public POC No
EPSS 0.3%
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.

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

More in Neo4j

View all
CVE-2018-1000820 CRITICAL POC
10.0 Dec 20

neo4j-contrib neo4j-apoc-procedures version before commit 45bc09c contains a XML External Entity (XXE) vulnerability in

CVE-2021-34371 CRITICAL POC
9.8 Aug 05

Neo4j through 3.4.18 (with the shell server enabled) exposes an RMI service that arbitrarily deserializes Java objects,

CVE-2018-18389 CRITICAL POC
9.8 Oct 16

Due to incorrect access control in Neo4j Enterprise Database Server 3.4.x before 3.4.9, the setting of LDAP for authenti

CVE-2023-23926 HIGH POC
8.1 Feb 16

APOC (Awesome Procedures on Cypher) is an add-on library for Neo4j. Rated high severity (CVSS 8.1), this vulnerability i

CVE-2022-37423 HIGH POC
7.5 Aug 12

Neo4j APOC (Awesome Procedures on Cypher) before 4.3.0.7 and 4.x before 4.4.0.8 allows Directory Traversal to sibling di

CVE-2026-92681 CRITICAL
9.3 Oct 12

Schema-level and Query/Mutation type-level @authentication directives are silently ignored for top-level @cypher fields

CVE-2021-34802 HIGH
8.8 Jul 30

A failure in resetting the security context in some transaction actions in Neo4j Graph Database 4.2 and 4.3 could allow

CVE-2026-5423 HIGH
8.2 Aug 06

JWT authentication bypass in @neo4j/graphql allows unauthenticated remote clients to forge arbitrary JWT claims over Gra

CVE-2026-19869 HIGH
7.6 Aug 18

Authentication bypass in @neo4j/graphql exposes admin-restricted custom-resolver fields to any authenticated user holdin

CVE-2013-7259 MEDIUM
6.8 Apr 29

Multiple cross-site request forgery (CSRF) vulnerabilities in Neo4J 1.9.2 allow remote attackers to hijack the authentic

CVE-2024-34517 MEDIUM
6.5 May 07

The Cypher component in Neo4j 5.0.0 through 5.18 mishandles IMMUTABLE privileges in some situations where an attacker al

CVE-2026-14587 MEDIUM
5.5 Aug 05

Bolt protocol handshake decoder in Neo4j Enterprise and Community Editions fails to distinguish overlong capability mask

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