AI-generated illustration
GitLab CVE-2026-97229 has the highest severity score a bug can get, a 10.0 out of 10, and a working proof-of-concept exploit is now public. The flaw lets an attacker run code on a self-managed GitLab server without logging in. If your team runs its own GitLab, this is a same-day patch, not something for the next sprint.
A Timeline That Should Worry You
GitLab published its advisory on October 13, 2026. The same day, Rapid7 researchers released technical details and a proof-of-concept exploit. A day later, coverage spread across security sites, and at that point no in-the-wild attacks had been confirmed. On October 30, BleepingComputer reported that CISA now lists the flaw as actively exploited.
That gap is about 17 days between a public exploit and confirmed attacks. It’s a pattern worth remembering. Once working code is public, attackers don’t need deep skill to use it. Teams that waited for proof of attacks lost the head start they needed to patch first.
What the Bug Actually Does
The problem sits in GitLab’s CI/CD regular expression compiler. CI/CD is the system that builds, tests, and deploys code automatically. Developers write pipeline files that often include regular expressions to match patterns, and GitLab compiles those expressions when it reads the file. If you’re new to pipeline security, our guide to cloud-native security practices covers the basics of locking down build systems like this one.
The bug is an integer overflow. A number inside the compiler wraps around when it grows too large, and the result is memory the code shouldn’t touch. GitLab’s validation of these expressions doesn’t catch the problem before it’s too late. The advisory rates the flaw at CVSS 10.0, and the attack vector is network access with no privileges and no user interaction needed.
In plain terms, someone who can reach your GitLab instance and get a crafted pipeline file processed may be able to run commands on the server. That’s why the score is so high.
How the Public Exploit Works
Rapid7’s write-up describes a careful method. The exploit hides an inline comment inside a regex quantifier. That trick helps it slip past a scanner built to spot repeated patterns and a US-ASCII size check. The attacker then commits a crafted CI configuration file, along with a UTF-8 repository path, to a public project branch.
When GitLab’s CI lint endpoint compiles the expression using Ruby’s Onigmo engine, the overflow happens. According to the research, the exploit can also get around address-space randomization, a defense that makes memory attacks harder to aim. The result is command execution as the git user.
The exploit needs a public project branch to deliver the payload, which helps explain why attackers can start without an account. It also means that any instance accepting pipeline checks from outside sources needs special attention.
Which Versions Are Affected
The vulnerable releases are self-managed GitLab Community and Enterprise Editions from 19.2 before 19.2.8, 19.3 before 19.3.5, and 19.4 before 19.4.2. Fixed versions are 19.2.8, 19.3.5, and 19.4.2. GitLab.com has already been patched, so hosted users don’t need to act.
If you’re not sure which branch you run, check your version in the admin area before doing anything else. Teams running older point releases should move straight to the fixed version for their branch.
Is It Being Used in Real Attacks?
BleepingComputer’s October 30 report says CISA has confirmed attacks and added the flaw to its Known Exploited Vulnerabilities catalog. I could only check that from the article’s headline, because the full page wouldn’t load for me. Treat that listing as the signal that the risk has moved from theory to live.
Attackers have been moving fast on developer platforms lately. Our coverage of the Hugging Face hack shows how a single compromised tool can reach many downstream users.
Being on the catalog usually means U.S. federal agencies must patch on a set deadline. Private companies aren’t bound by that rule, but the listing is a clear warning that attackers are actively using the bug.
What to Do Now
Patch first. Upgrade to 19.2.8, 19.3.5, or 19.4.2, depending on your branch. Do this before anything else on the list.
Search your pipeline files. Look through recent CI configuration files for unusual regular expressions, especially in public or shared projects. A crafted pattern often looks out of place.
Review commits. Check for changes to CI configuration from unfamiliar accounts and for pipelines that ran with odd output or unexpected commands.
Audit server activity. Look at logs for processes started by the git user that don’t match normal GitLab behavior.
Reduce exposure. Limit which networks can reach your instance, and restrict who can create public projects if your team doesn’t need that feature.
If You Can’t Patch Today
Some teams can’t upgrade right away because of change-freeze rules or testing needs. In that case, cut off outside access to the instance until the patch is in place. Block public project creation, and watch CI activity closely while you wait. Good habits for this kind of trade-off are covered in our piece on cybersecurity risk management. A short outage is better than a compromised build server, and a compromised pipeline can spread into everything your team ships.
This is a developing story. I’ll add CISA’s details and any confirmed attack reports as they’re published.
Sources:
