CVSS 10.0
GitLab's own CVSS 3.1 score for CVE-2026-97229
2
GitLab upgrades Alpine made that left the server exposed
8
GitLab worker crashes the attacker caused at Alpine
4
GitLab CVEs one set of Ruby regex releases fixes
The version that said patched was the wrong one
A GitLab server can report a fixed version number for CVE-2026-97229 and still be exploitable, because the bug is not really in GitLab. It is in Onigmo, the regular expression engine inside Ruby, and the fix only reaches your server if the Ruby under GitLab carries it. GitLab's own packages ship a patched Ruby. A GitLab running on any other Ruby gets a new application and keeps the old engine.
That is the argument of this post, and Alpine Linux's incident proves it better than we could. Alpine runs a public GitLab for its package repository. It upgraded twice after the fix shipped, and on 26 Oct it found the instance still vulnerable. Its own explanation is one line long: "Our image used standard Ruby, so it didn't get the patch."
Most vulnerability programs check the product version and close the ticket. For this flaw that check answers the wrong question. The question that matters is which Ruby the GitLab process is running, who built it, and whether that build carries the regex fixes Ruby released on 23 Oct. By default nobody owns that question, because almost nobody thinks of Ruby as something they installed.
We wrote about the same shape a week ago with Brotli, where the vulnerable library arrived inside runtimes and proxies under version numbers that did not move. This is the sharper case. Brotli was a dependency your scanner might miss. Here the dependency is the runtime itself, the fix is real, the vendor shipped it, and a careful operator still ended up on the wrong side of it.
What is GitLab CVE-2026-97229?
GitLab published the fix on 12 Oct 2026 in its 19.4.2, 19.3.5 and 19.2.8 patch release. The advisory title is "Integer Overflow issue in CI/CD Regular Expression Compiler impacts GitLab CE/EE". GitLab says the flaw could have allowed an unauthenticated user to run arbitrary code on the GitLab server through a specially crafted regular expression in a CI/CD configuration. It scores it CVSS 10.0 under version 3.1, with network access, low complexity, no privileges, no user interaction and a changed scope. The issue came in through GitLab's HackerOne bug bounty program.
-
Product //
GitLab Community Edition and Enterprise Edition, self-managed -
Affected //
19.2 before 19.2.8, 19.3 before 19.3.5, 19.4 before 19.4.2 -
Fixed in //
GitLab 19.4.2, 19.3.5, 19.2.8, plus Ruby 3.3.13, 3.4.12 or 4.0.9 underneath -
CVSS //
10.0 (3.1, GitLab) -
Root cause //
integer overflow in compiled pattern size in Onigmo, Ruby's regex engine -
Exploited //
Yes, CISA KEV from 29 Oct 2026, due 1 Nov
The release notes say where the work went. Alongside the advisory, the bug fix list carries two entries headed "Add Ruby regexp program size patch for 3.3 and 3.4" and a repeat range double free patch, filed against the Linux package and the cloud native images. GitLab patched the Ruby it ships. It could not patch the Ruby anyone else ships.
Ruby confirmed the link on 23 Oct in a post titled regexp fixes for GitLab CVEs. It maps four GitLab CVEs onto three Onigmo bugs: CVE-2026-89078, a double free when a pattern fails after an alternation; CVE-2026-93577 and CVE-2026-97229, an integer overflow in the compiled pattern size; and CVE-2026-110264, an overflow of internal IDs when a pattern repeats many times. The sentence operators need is short: "Ruby 4.0.9, 3.4.12 and 3.3.13 contain all of these fixes." Ruby 4.0.8 carries the CVE-2026-97229 fix but not CVE-2026-110264, so 4.0.9 is the floor on the 4.0 line. Ruby has not requested CVE identifiers of its own "at least for now", and asks trackers to use GitLab's.
That last detail matters more than it looks. A scanner that matches CVE IDs to installed packages sees four GitLab CVEs. Nothing in its feed says the Ruby package on the same host is the thing to upgrade.
The sibling flaw is the wider one. GitLab fixed CVE-2026-110264 on 21 Oct in 19.5.1 and six older lines, also CVSS 10.0 with the same vector, and its affected range starts at GitLab 7.0. Every self-managed GitLab older than 18.11.13 is in scope for that one.
CISA added CVE-2026-97229 to the Known Exploited Vulnerabilities catalog on 29 Oct, based on evidence of active exploitation, with a due date of 1 Nov for federal civilian agencies. Three days. The entry marks forensic triage as required under BOD 26-04, lists known ransomware use as unknown, and carries a note: other products can potentially be affected by the same underlying Ruby and Onigmo integer overflow. CISA is telling you the catalog row is narrower than the bug.
Public exploit material is out. Rapid7 published its first analysis on 13 Oct, reproduced code execution against the official GitLab 19.4.1 Community Edition image with address space layout randomization on, confirmed the same input did not execute on the patched 19.4.2 image, and later added a link to a proof of concept repository. BleepingComputer reports that Shadowserver tracks nearly 2,800 internet-exposed GitLab Community Edition instances, without a count of how many are fixed.
How Alpine upgraded twice and stayed exposed
Alpine's incident post, dated 28 Oct and written plainly, is the most useful public document on this flaw. Here is its timeline in its own terms.
On 13 Oct, the day after the fix, Alpine upgraded to GitLab 19.3.4 instead of 19.3.5, "by mistake". The upgrade missed the fixed release by one patch version. On 20 Oct a newly registered account began probing, and on 20 and 21 Oct that account "sent crafted CI configurations" to the instance. The main attack on 21 Oct showed up as GitLab crashes, 502 errors and failed CI jobs. The attacker crashed GitLab worker processes 8 times, and in 4 of those crashes "got partway through the exploit and failed at the next step." The attacker also downloaded Alpine's GitLab container image, which Alpine reads as tuning the exploit to its exact build.
On 22 Oct Alpine upgraded again, to 19.3.6. That release is past the fix for CVE-2026-97229 and is the fix release for CVE-2026-110264 on the 19.3 line. It did not fix the vulnerability, because Alpine's image used standard Ruby. On 23 Oct Alpine blocked the attacker's account, the same day Ruby shipped its fixes. On 25 and 26 Oct the attacker came back and the attempts failed. On 26 Oct Alpine found the instance still vulnerable after the upgrade.
So two upgrades went in, and neither closed the hole: the first missed the version, the second had the right version on the wrong runtime. The account block and luck did the protecting. Alpine says the attack "came close to working".
What Alpine did next is the part to copy. It closed GitLab to everyone except developers and build servers on 27 Oct and started a rebuild. It found no evidence the attacker ran code on the server, "but we cannot rule it out", so it treated the instance as compromised and rebuilt it from scratch. It checked aports commits from 20 to 22 Oct against records the attacker could not reach, a developer's clone and all 45 builders, and says releases and packages were not modified and no signing keys were exposed. The rebuild finished on 28 Oct with all passwords reset and GitLab's secret keys replaced. GitLab reopened on 29 Oct on 19.3.7, and Alpine's follow up on 30 Oct says the new server runs Ruby 3.3.13 and that passwords, two factor settings and tokens were reset.
The order there is the lesson. Alpine did not stop at "patched". It asked what an attacker who had been inside would have touched, which for a forge that feeds a package repository means the source and the build chain, and it verified those against copies outside the forge. That is the same question we asked about the LiteLLM release pipeline, where every control checked who pressed the button and none checked what source went in.
Alpine also publishes a GitLab image other people use, and its advice to them is specific: pull alpinelinux/gitlab:19.3.6 again, because the image published on 27 Oct contains Ruby 3.3.13, and any 19.3.6 image pulled before 27 Oct, along with all older tags, is vulnerable. Same tag, two different answers, separated by a rebuild date.
Which GitLab installs are still vulnerable after the upgrade?
GitLab's patch pages carry a standard line: when no deployment type is named, all types are affected. The fix, though, does not arrive the same way for every type. It arrives with whoever supplies the Ruby.
Figure 01
The GitLab upgrade lands everywhere. The Ruby fix does not.
GITLAB UPGRADE
19.4.2, 19.3.5, 19.2.8
-
LINUX PACKAGE
ships its own patched Ruby
-
SOURCE INSTALL
your Ruby, your upgrade
-
OFFICIAL IMAGES
patched Ruby built in
-
CUSTOM IMAGE
standard Ruby, still exposed
Alpine states the rule in one sentence that every GitLab operator should read: if you run GitLab with your own Ruby, from source or in your own container image, rather than GitLab's packages, "upgrading GitLab is not enough: you also need Ruby 3.3.13, 3.4.12, 4.0.9 or later."
In practice the exposed population after patching looks like this:
- Source installs. The self-compiled install path runs on whatever Ruby the administrator built or the distribution provides. The GitLab upgrade changes the application. The interpreter stays where it was.
- Custom container images. Teams that build their own GitLab image, often to pin a distribution base or to meet an internal image standard, inherit the base image's Ruby. Alpine's own image is the public example.
- Distribution packages of GitLab. Where a distribution packages GitLab against its own system Ruby, the fix depends on the distribution shipping the new Ruby. Alpine moved its Ruby packages to 3.4.12 on 3.22, 3.23, 3.24 and edge, and 3.3.13 on 3.21; on Alpine that means apk upgrade, not only a GitLab bump.
- Stale images with a good tag. A tag that has been rebuilt does not change on the host that pulled it earlier. The 19.3.6 case above is the pattern.
GitLab.com and GitLab Dedicated are already patched, per GitLab. This is a self-managed problem.
The check itself is not hard. Ask the running GitLab process which Ruby it is using, not the host's default Ruby, which can differ, and not the image tag. Then compare it against the three fixed releases. The hard part is organizational. The GitLab owner patched GitLab. The platform team owns the base image. The Ruby version sits in neither team's ticket.
Why a CI file is server input
The second half of this flaw is where the input comes from. A CI/CD configuration feels like something a developer writes for their own project. On a GitLab server it is also data the server parses, and regular expressions in it are compiled by the server's Ruby. Any account that can put a configuration in front of that parser can hand the regex engine a pattern of its choosing.
Rapid7 is precise about the precondition. GitLab's score says fully unauthenticated, but an attacker must first have a way to plant a malicious CI/CD configuration in a repository. Then the sentence that decides most real exposure: "On GitLab instances where new users can self register and create projects, this constraint is removed." Alpine's attacker did exactly that. A newly registered account, a crafted configuration, eight crashes.
So the population that matters most is the GitLab that lets strangers in. Open source projects run public forges by design. Universities and research groups often leave sign up open. Some companies run an old GitLab where sign up was never switched off after the instance was first set up. On those servers, account creation is the whole precondition.
On closed instances the precondition is a developer account, or a token, or a compromised laptop with a session. That is a lower bar than it sounds. We have argued before that the deploy pipeline is a standing way into the cloud account; our CI pipeline trust review walks the questions. CVE-2026-97229 adds a step in front: the pipeline definition is also a way into the server that runs every pipeline.
Ruby's own mitigation advice reads like a principle for this whole class: "If you cannot upgrade, please avoid compiling regular expressions from untrusted input." It adds that Regexp.timeout does not protect against these bugs, and that limiting pattern length does not reliably protect either, because some can be triggered by short patterns. The usual guard rails for hostile regexes are about time. These bugs are about memory, and the guard rails do not see them.
That is also why the PHP stale worker problem we wrote up on 21 Oct rhymes with this one. In both, the interesting code is not the application. It is the long-lived runtime underneath, handling input the application author thought of as configuration.
How we test a self-managed GitLab on an engagement
When a self-managed GitLab turns up on a sanctioned engagement, it matters because it is the system that holds the deploy keys, the runner tokens and the source for everything else. When we find one, the work stays on what an attacker would learn, not on running anyone's exploit against a client server.
Can a stranger get an account? We check whether sign up is open, whether it requires approval, whether email domain restrictions hold, and whether a new account can create a project and run a pipeline. Each answer moves the precondition. Open sign up with project creation is the finding, before any version is checked.
What does the version check miss? We record the GitLab version from the instance and, with the client's administrators, the Ruby the GitLab process actually runs and where it came from: the Linux package, an official image, a distribution package or a custom build. For this flaw we report both numbers side by side. A fixed GitLab on an unfixed Ruby is reported as exposed, with the build path that produced it.
What does a foothold on this server reach? We map runner registrations, stored CI/CD variables by name, deploy keys, integrations and any cloud trust tied to the instance. That map is the blast radius, and it is what the client needs if the answer to "were we hit" is ever "we cannot rule it out", as it was for Alpine.
Would anyone notice? GitLab published six detections for this CVE, by name: Onigmo native worker crash, GraphQL CI lint hostile regexp, CI regexp oversized non ASCII path, CI regexp guard rejection, CI lint Workhorse worker crash, and CI lint scripted client error burst. We ask whether any of those signals would reach a person. Alpine's timeline records the main attack as crashes, 502 errors and failed CI jobs, the kind of noise an on call engineer restarts and forgets. A worker crash on a forge is a security event until shown otherwise.
None of this needs a working exploit. The useful finding is the combination: who can submit a configuration, which engine compiles it, what the server can reach, and whether the crash would be read.
What is still coming
Three things are worth watching over the next few weeks.
First, other Ruby applications. CISA's note says other products can potentially be affected by the same Onigmo issue. Any service that compiles a regular expression from user input on a Ruby runtime below the fixed releases is in the same position, whether or not it ever appears in a GitLab advisory. Ruby's choice not to issue its own CVEs, at least for now, means those products may never get a scanner signature for it. The inventory question is Ruby versions across the estate, not GitLab alone.
Second, the older lines. CVE-2026-110264 reaches back to GitLab 7.0. The fixes cover 18.11 and the 19 series. Anyone still running an older major release has a migration ahead, not a patch, and the Ruby under it is likely older too. Ruby's fixes cover the 3.3, 3.4 and 4.0 lines; Ruby's post does not mention 3.2.
Third, more forges. Alpine disclosed because it runs in public. Other projects and companies saw the same probing pattern, or will, and most will not write it up. If your instance had unexplained worker crashes from 13 Oct onwards, the date of the first public analysis, read them again.
The broader pattern is the one this site keeps returning to. The fix shipped quickly. The vendor was clear. The version check passed. The gap was between the thing that got patched and the thing that ran.
What to do today
-
Upgrade every self-managed GitLab. At least 19.4.2, 19.3.5 or 19.2.8 for CVE-2026-97229, and the 21 Oct releases (19.5.1, 19.4.3, 19.3.6 and the older lines) for CVE-2026-110264. CISA's federal deadline is 1 Nov.
-
Check the Ruby the GitLab process runs, not the GitLab version. It must be 3.3.13, 3.4.12, 4.0.9 or later. Source installs, custom images and distribution packages need their own Ruby upgrade. Re-pull rebuilt image tags.
-
Close open sign up, or require admin approval, until both checks pass. Rapid7 notes that self registration with project creation removes the attacker's only precondition.
-
Turn on GitLab's six detections and treat worker crashes as security events. Look back to 13 Oct for Onigmo crashes, CI lint errors and unexplained 502s.
-
If you find crashes you cannot explain, do what Alpine did. Assume compromise, verify source and build outputs against copies outside the server, rotate passwords, tokens, runner registrations and GitLab's secret keys, and rebuild.
-
Inventory Ruby across the estate. CISA warns other products may share the bug. Our atarus-recon tool on the open source page lists what you expose externally, which is where to start looking for forgotten forges.
SOURCES
- GitLab patch release 19.4.2 // CVE-2026-97229, the 10.0 score, affected and fixed versions, the six detections
- Ruby // the Onigmo fixes behind four GitLab CVEs and the fixed releases 3.3.13, 3.4.12 and 4.0.9
- Alpine Linux // the attempted exploitation, two upgrades that did not fix it, and the rebuild
- CISA KEV catalog // lists CVE-2026-97229 as exploited from 29 Oct 2026 with a 1 Nov due date
- Rapid7 // independent reproduction, and that open sign up removes the precondition