CVE-2026-19478: GitLab's Critical GraphQL Flaw Lets Anyone Delete Your Public Projects

GitLab shipped a patch this week for a bug that lets a stranger on the internet delete your public repositories without logging in. CVE-2026-19478 is a code injection flaw in GitLab’s GraphQL API, CVSS 9.4, and it doesn’t just leak data, it lets an unauthenticated attacker modify or delete public projects and user data outright. If you run a self-managed GitLab CE or EE instance, this is a patch-today issue, not a patch-this-sprint one.

What the bug actually does

The vulnerability lives in how GitLab’s GraphQL endpoint handles a specific directive in incoming queries. A crafted request can inject code through that directive, and because the endpoint doesn’t require authentication for the vulnerable path, anyone who can reach your GitLab instance over the network can trigger it. No account, no session token, no user interaction from a victim.

The practical impact is worse than a typical unauthenticated info-leak: instead of just reading data an attacker shouldn’t see, this bug lets them write. Public projects can be modified or deleted outright. For a team that treats its public repos as the canonical, backed-up source of truth, “someone deleted it via an API call you didn’t know existed” is a different category of incident than a read-only leak.

# The pattern being exploited is a malicious directive attached to a
# GraphQL query against the public API, no auth header required:
POST /api/graphql
Content-Type: application/json

{"query": "query { project(fullPath: \"org/repo\") @maliciousDirective { ... } }"}

GitLab hasn’t published the exact directive or payload, and this piece deliberately doesn’t reconstruct it. The point isn’t to hand out a working exploit, it’s to explain why “no auth required” plus “GraphQL directive” plus “write access to project data” adds up to something you patch immediately rather than schedule.

Affected versions and what to run instead

Your version range	Status	Fixed in
CE/EE 18.2 – 18.11.10	Vulnerable	18.11.11
CE/EE 19.0 – 19.0.7	Vulnerable	19.0.8
CE/EE 19.1 – 19.1.5	Vulnerable	19.1.6
CE/EE 19.2 – 19.2.3	Vulnerable	19.2.4
GitLab.com / Dedicated	Already patched	n/a, SaaS-hosted

Check your running version from the admin area (/help) or gitlab-rake gitlab:env:info on a self-managed box, match it against the table, and upgrade to the corresponding fixed build. GitLab’s own upgrade path documentation covers the supported jump between minor versions if you’re several patches behind.

Why this one deserves priority over your normal patch cadence

Three things push this ahead of a routine dependency bump. It’s unauthenticated, so there’s no phishing step or credential theft required to trigger it, just network reachability. It’s a write primitive, not a read one, which means the worst case is data loss, not just exposure. And GitLab is exactly the kind of software that tends to sit exposed longer than it should, because self-managed instances are often stood up once, treated as internal infrastructure, and then not prioritized for patching the way public-facing customer apps are. If your GitLab instance is reachable from the open internet, or even from a broad internal network with more access than it strictly needs, that assumption is the actual risk here.

This is also the second unauthenticated, maximum-severity flaw in developer tooling disclosed this month. GitLab’s GraphQL bug follows the Metabase password-reset SQL injection that CISA added to its Known Exploited Vulnerabilities list on August 11. Neither vendor did anything wrong by having a bug; that happens. What’s worth noticing is the pattern: internet-facing developer and business-intelligence tools, running with real access to your code and data, are a consistently attractive target, and “we’ll get to the patch next sprint” is the exact gap that turns a disclosed CVE into an incident.

What to actually do this week

Patch first, then audit exposure. Confirm your GitLab version, upgrade to the fixed release for your line, and if you can’t patch immediately for change-control reasons, restrict network access to the instance as an interim measure rather than leaving it reachable while you wait. If you maintain a broader dependency and infrastructure hardening checklist for your CI/CD pipeline, the npm supply chain hardening guide covers the adjacent problem of what runs inside your pipeline once an attacker has a foothold near it, worth a look while you’re already in patching mode.

There’s no evidence of active exploitation yet, and no public proof-of-concept. Treat that as a head start, not a reason to deprioritize. The gap between a patch shipping and exploit code appearing for unauthenticated, high-severity bugs in widely deployed software has been shrinking for years, and a self-managed GitLab instance running an unpatched build for even a few weeks is a bet against that trend that isn’t worth making.