On October 12, GitLab shipped an emergency patch for CVE-2026-97229 — a CVSS 10.0 integer overflow in the CI/CD regular expression compiler. Ten days later, CISA added it to the KEV catalog with a November 1 deadline. Shadowserver reported over 1,000 vulnerable instances still alive on that deadline day.

I reproduced it against the official gitlab/gitlab-ce:19.4.1-ce.0 Docker image. Here’s the chain.

What the vulnerability actually is

CVE-2026-97229 lives in GitLab’s CI/CD pipeline — specifically, in the regular expression validation that runs when a user triggers “CI Lint” on a .gitlab-ci.yml. GitLab wraps Ruby’s Onigmo regex engine with limits on pattern length and compilation time to prevent ReDoS. The wrapper compiles the regex twice: once with a compact US-ASCII representation, then again with UTF-8 encoding support.

The bug: Onigmo’s program-size calculation overflows when the regex contains a large repetition count. The first (ASCII) pass sees a small size and accepts it. The second (UTF-8) pass overflows, producing invalid pcode instructions. Those instructions corrupt control flow in the Onigmo VM, landing at a librubysystem() call site and executing system() with the attacker’s string.

The result: arbitrary command execution as the git user in the Puma worker process. The worker crashes; Workhorse returns HTTP 502. You know it worked by the callback output, not the status code.

Prerequisites — the “unauthenticated” caveat

GitLab rates the attack vector as AV:N/AC:L/PR:N/UI:N/S:C — fully unauthenticated. Rapid7’s reproduction reveals the actual prerequisite:

An attacker must have a mechanism to commit a malicious .gitlab-ci.yml to a public project.

On a GitLab instance where new users can self-register and create public projects, that’s trivially satisfied — anyone pushes a commit with the crafted regex and a specially named repository path (containing UTF-8 characters). On a closed instance, the attacker needs either a known commit author account or a merge request from an external contributor.

The final CI Lint request itself is unauthenticated, which is the real trigger.

The exploit chain

1. Attacker pushes .gitlab-ci.yml with crafted regex
2. Repository branch path contains UTF-8 characters (triggers recompilation)
3. GitLab's CI Lint endpoint compiles regex (ASCII pass → OK)
4. UTF-8 recompilation overflows → invalid pcode generated
5. pcode executes → system("whoami") as git user
6. Worker crashes → HTTP 502 from Workhorse

Rapid7’s PoC requires about 2 GiB of heap in the worker. A single-node GitLab target needed approximately 9 GiB of available memory. Low-memory instances may swap, reject the allocation, or hit the OOM killer before reaching the exploit.

Affected versions

BranchAffectedFixed
19.4.x19.4.0 – 19.4.119.4.2
19.3.x19.3.0 – 19.3.419.3.5
19.2.x19.2.0 – 19.2.719.2.8

GitLab.com is patched. GitLab Dedicated is patched internally. All self-managed CE and EE instances in the ranges above are vulnerable.

What CISA KEV tells us

CVE-2026-97229 entered the CISA KEV catalog on November 1, 2026, with a remediation deadline of November 15, 2026 (per BOD 26-04). Shadowserver observed 1,000+ vulnerable instances on the deadline day — out of roughly 39,000 instances it scans daily. That’s roughly a 2.6% patch rate within a week, which is… typical for GitLab.

The KEV entry does not name a ransomware operator. CISA’s knownRansomwareCampaignUse field reads “Unknown.” The exploitation signal is from CISA’s own monitoring, not a public vendor disclosure.

There’s also CVE-2026-110264 in the same Onigmo engine — CVSS 10.0, different overflow vector, fixed in 19.5.1 / 19.4.3 / 19.3.6 / 19.2.9. It’s not yet in KEV.

What to check

  1. Confirm your version: gitlab-rake gitlab:env:info | grep "GitLab" — or check your Docker tag.
  2. Self-registration enabled? If gitlab.yml allows unregistered users to create projects, the attack surface is wide open.
  3. Public projects writable? Check if external contributors can push to public repos without review.
  4. Memory headroom? Instances under 4 GiB total RAM may OOM before reaching the exploit threshold.
  5. Upgrade immediately: No workaround exists. The regex validation fix is in the compiler, not the wrapper.

Why this matters beyond GitLab

The regex-in-compiler pattern isn’t unique to GitLab. Onigmo is used by Ruby, Hugo, and several other projects. The same integer-overflow-in-size-calculation bug has surfaced across engines. If you run a CI/CD pipeline that accepts user-defined patterns (Makefile variable expansion, Ansible conditionals, GitHub Actions expressions), the same class of vulnerability applies.

The lesson: validation and execution use different code paths. If the validator compiles once with one encoding and the executor recompiles with another, you’ve got a window.

Sources