Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach exposed GitLab GraphQL endpoint
-
DeliveryCraft low-scored high-cost query
-
ExploitSubmit repeated unauthenticated requests
-
ExecutionComplexity check under-counts real cost
-
PersistServer resources exhausted
-
ImpactGitLab becomes unavailable to legitimate users
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The prerequisite is a GitLab CE/EE instance running an affected version with its GraphQL API endpoint reachable by the attacker (normally /api/graphql, enabled by default and commonly exposed wherever the web UI is exposed). The attacker must be able to reach the endpoint without authenticating, i.e. it must not be behind an authenticating reverse proxy, IP allowlist, or VPN - GitLab permits a subset of GraphQL operations without credentials, and the advisory states the impact is reachable by an unauthenticated user, so this is a pre-existing exposure rather than a special configuration toggle. What limits real-world exploitation: the flaw is in complexity estimation, so the specific query shapes needed mirror whatever the POC uses and may need tuning against the target's instance size - small instances can be knocked over more easily, while very large horizontally scaled deployments require proportionally more traffic; additionally, the impact is availability only (no data read or write), so an attacker gains nuisance/denial value rather than access, and instances that already gate /api/graphql behind a WAF, rate limiter, or network allowlist (a common hardening step, though not the default) are effectively shielded. |
| Impact | The signals here agree rather than conflict: CVSS 3.1 is 7.5 with AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, meaning a remote, unauthenticated, no-interaction attack with low complexity that degrades availability only - a textbook availability-flood profile rather than a data-breach profile, which is why the score stops at High instead of Critical. The description explicitly says 'unauthenticated user', and the vector's PR:N is consistent with that, so no authentication precondition should be assumed. Public exploit code exists (HackerOne report 3461590), which raises the practical likelihood that opportunistic actors replicate the technique, but GitLab's GraphQL endpoint exposure and the fact that this targets availability rather than data mean the payoff is vandalism-grade: even a mid-sized operator such as a municipal IT team in boleslawiec should treat this as a genuine uptime risk during peak pipeline hours, though not as a data-compromise emergency. No EPSS score was provided in this record and the CVE is not in CISA KEV, so widespread exploitation is unconfirmed and any claim of active campaigns would be unsupported. The main caveat is the missing EPSS value and the wildcarded CPE - verify the exact vulnerable build against the vendor advisory rather than assuming every GitLab instance is affected. |
| Exploit ScenarioDerived | An unauthenticated attacker sends a series of carefully shaped GraphQL queries to a reachable GitLab /api/graphql endpoint, choosing nested or high-fan-out selections that the complexity calculator scores as cheap. Each request costs the server far more work than the estimator assumes, so a modest request volume drives CPU, database connections, or worker saturation until the instance stops serving legitimate users - including git pushes, CI jobs, and the web UI. Publicly available exploit code from the linked HackerOne report makes replication straightforward for anyone with network reachability to the target. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 16, 2026
Unauthenticated denial of service in GitLab CE/EE (all versions from 18.4.6 before 19.1.8, 19.2 before 19.2.6, and 19.3 before 19.3.2) allows a remote attacker with no credentials to exhaust server resources through the GraphQL API by submitting queries whose true cost the complexity calculation under-counts. The flaw is an improper resource-allocation limit (CWE-770), scored CVSS 7.5 with the entire impact on availability (A:H) and none on confidentiality or integrity. Publicly available exploit code exists - a HackerOne report is linked from the advisory - but there is no CISA KEV listing, so active in-the-wild exploitation is not confirmed; EPSS data was not supplied with this record.
RemediationAI
GitLab has released fixes in 19.1.8, 19.2.6, and 19.3.2, so the primary action is to upgrade to the appropriate patched release for your maintenance line - vendor-released patch: 19.3.2 (also 19.2.6 and 19.1.8) - following the instructions at https://docs.gitlab.com/releases/patches/patch-release-gitlab-19-3-2-released/. If immediate upgrade is not feasible, compensating controls focus on making the GraphQL endpoint harder to reach or cheaper to defend: block or allowlist /api/graphql at the reverse proxy or WAF so only known CI runners and trusted networks can reach it (trade-off: breaks legitimate external API integrations, IDE plugins, and any unauthenticated public project queries), or apply edge rate limiting and request-size/timeout caps on that path (trade-off: legitimate heavy GraphQL consumers and large CI pipelines may be throttled or see timeouts). GitLab's own application-level settings - reducing the GraphQL max complexity setting, tightening request timeouts in gitlab.rb, or scaling out with a load balancer that sheds load under saturation - reduce blast radius but do not fix the underlying under-counting logic, so they should be considered temporary. Monitor for sustained spikes on the GraphQL endpoint and unusual query shapes as a detection measure, and note that because the flaw is in the complexity estimator itself, simply lowering the ceiling without patching may still be bypassable by a determined attacker.
Affected VersionsENISA
Affected Packages
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
GitLab exposes a GraphQL API (typically at /api/graphql) that accepts a single endpoint for both authenticated and, for a subset of operations, unauthenticated requests. To prevent abuse, GitLab computes a per-query 'complexity' score and rejects queries exceeding a configured ceiling, effectively a rate/shape limit on expensive resolvers. CWE-770 (Allocation of Resources Without Limits or Throttling) is the root-cause class here: the complexity calculation logic did not correctly account for the resources a crafted query would actually consume, so queries that score below the threshold can still trigger disproportionate server work - resolver fan-out, nested relation expansion, or similar amplification. Because the guard rail is a calculation rather than a hard resource cap, the mismatch is exploitable by shaping queries to look cheap while being expensive. The supplied CPE (cpe:2.3:a:gitlab:gitlab:*:*:*:*:*:*:*:*) is fully wildcarded, so the authoritative version boundaries come from the vendor description and the GitLab patch-release advisory rather than from CPE version constraints.
Know when Graphql 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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Unauthenticated GraphQL endpoint reachable over the network with a ready-made query technique, so PR:N/AV:N/AC:L; only availability is impacted.
Primary rating from Vendor (GitLab).
CVSS VectorVendor: GitLab
Lifecycle Timeline
2DescriptionCVE.org
GitLab has remediated an issue in GitLab CE/EE affecting all versions from 18.4.6 before 19.1.8, 19.2 before 19.2.6, and 19.3 before 19.3.2 that under certain conditions could have allowed an unauthenticated user to cause denial of service due to improper resource allocation limits in the GraphQL complexity calculation logic.
Articles & Coverage 1
Executive ViewAI
GitLab CE and EE deployments spanning the 18.4.6-through-pre-19.1.8, 19.2, and 19.3 release lines are exposed to a remote availability attack that lets an attacker with no credentials exhaust server resources through the GraphQL API, with the entire security impact falling on service availability. Because GitLab is typically the system of record for source code, CI/CD pipelines, and code review, a sustained outage would stall engineering delivery and could cascade into dependent build and deployment workflows for the duration of the disruption. Publicly available exploit code exists, so the barrier to attempting this attack is low, though there is no confirmed actively exploited (CISA KEV) status at this time.
No vendor-released patch identified at time of analysis; interim mitigations are rate limiting and request-size caps on the GraphQL endpoint at the proxy/WAF layer, tight administrator-configured GraphQL complexity/depth limits, network restriction of GraphQL access to trusted clients, and enhanced resource-exhaustion monitoring with a rehearsed failover or shutdown procedure.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Unauthenticated attackers can publish arbitrary persisted query documents and claim (squat) query aliases on WordPress s
Stump through 0.1.10 allows any authenticated user with the shared AccessSmartList permission to overwrite, delete, or t
Authorization bypass in Craft CMS 5.0.0 through 5.10.x allows an authenticated holder of a narrowly site-scoped GraphQL
Versions of the package graphql from 16.3.0 and before 16.8.1 are vulnerable to Denial of Service (DoS) due to insuffici
Server-side request forgery in Chaskiq through 2.0.3 allows unauthenticated attackers to make the server fetch arbitrary
Prototype pollution in `@graphql-tools/utils` `mergeDeep()` lets a remote, unauthenticated client submit a single aliase
JWT authentication bypass in @neo4j/graphql allows unauthenticated remote clients to forge arbitrary JWT claims over Gra
Uncontrolled resource consumption in the Strawberry GraphQL library's legacy graphql-ws subscription handler (versions 0
Authentication bypass in @neo4j/graphql exposes admin-restricted custom-resolver fields to any authenticated user holdin
silverstripe-graphql is a package which serves Silverstripe data in GraphQL representations. Rated high severity (CVSS 7
`silverstripe/graphql` serves Silverstripe data as GraphQL representations. Rated high severity (CVSS 7.5), this vulnera
Field-level read permission bypass in Twenty CRM before 2.22.0 lets an authenticated workspace member or API key that is
EUVD-2026-80122
GHSA-8c2h-q92r-2j66
NVD
CVE.org
EPSS
VulDB
Exploit-DB