79% vs 51%: independent neobanks lag on app security. Read the report

Deep Dive

Deep Dive

GitLab Unauthenticated RCE Across 12 Years (CVE-2026-110264)

CVE-2026-110264, a 10.0 integer overflow, exposes every self-managed GitLab since 7.0 to unauthenticated RCE; fixed October 21; its sibling is in KEV.

TL;DR

  • CVE-2026-110264 is an integer overflow in the regular-expression compiler of self-managed GitLab, rated CVSS v3.1 10.0, the maximum, by GitLab. Under conditions GitLab has not disclosed, an unauthenticated attacker can execute arbitrary code on the server by supplying a specially crafted regular expression.
  • Every self-managed GitLab CE/EE release from 7.0 (2014) onward is affected, because the flaw sits in Onigmo, the regex engine of Ruby, which GitLab ships and patches inside its own packages. GitLab fixed seven release lines at once on October 21, 2026, backporting further than its normal policy.
  • No exploitation of CVE-2026-110264 has been reported and the flaw is not in the CISA KEV catalog.
  • Its October 12 sibling, CVE-2026-97229, a different Onigmo overflow reached through CI configuration, has now been attacked in the wild: an attacker hit Alpine Linux's own GitLab server with it on October 20 and 21, 2026, and Rapid7 published proof-of-concept code for it on October 13. CISA added CVE-2026-97229 to its Known Exploited Vulnerabilities catalog on October 29, 2026, with a federal due date of November 1, 2026.
  • GitLab has published no workaround for either flaw: because the preconditions are undisclosed, no configuration rules an instance out, so the update is the only certain protection.
  • Update to 19.5.1, 19.4.3, 19.3.6, 19.2.9, 19.1.9, 19.0.10 or 18.11.13 now. If you patched on October 12 for CVE-2026-97229, you are in range again: those builds sit one patch below the new fixed versions. If your GitLab runs its own Ruby, built from source or in an image that installs Ruby separately, the GitLab upgrade alone is not enough: you also need Ruby 3.3.13, 3.4.12, 4.0.9 or later.

Am I affected?

You are affected if both of these hold:

  • You run self-managed GitLab Community Edition or Enterprise Edition, in any deployment type: omnibus packages, Docker, Helm charts or source installs. GitLab.com already runs a fixed version, and GitLab Dedicated tenants on 19.3.5-internal0 and 19.4.2-internal0 or later need no action.
  • Your version is in an affected range. GitLab has not said which features or settings an attacker needs, so no instance below the fixed versions can be ruled out by configuration.

If your install runs its own Ruby rather than GitLab's bundled copy, the table below is not the whole test. GitLab's October 12 and October 21 fixes patch the Ruby inside GitLab's own packages and images, so a self-compiled install or a container image that installs Ruby separately keeps the flaw until Ruby itself is updated. This is how Alpine Linux's GitLab stayed vulnerable for days after its upgrade to 19.3.6.

Branch Affected versions Fixed version
19.5 19.5.0 19.5.1
19.4 19.4.0 to 19.4.2 19.4.3
19.3 19.3.0 to 19.3.5 19.3.6
19.2 19.2.0 to 19.2.8 19.2.9
19.1 19.1.0 to 19.1.8 19.1.9
19.0 19.0.0 to 19.0.9 19.0.10
18.11 and every older branch back to 7.0 7.0 to 18.11.12 18.11.13

Check the version on every instance, including staging and CI-only servers. In the web interface, the version appears under Help and in the Admin Area overview. On the host:

cat /opt/gitlab/embedded/service/gitlab-rails/VERSION        # omnibus package install
docker exec gitlab cat /opt/gitlab/embedded/service/gitlab-rails/VERSION   # Docker: adjust the container name
cat /home/git/gitlab/VERSION                                  # source install
ruby -v                                                       # source install: needs 3.3.13, 3.4.12, 4.0.9 or later

Instances running 19.2.8, 19.3.5 or 19.4.2, the October 12 fix for CVE-2026-97229, are inside the affected ranges and must move one patch higher. Instances on 19.3.4 must move to 19.3.6 directly: GitLab's October 12 advisory originally named 19.3.4 as the fixed version for the 19.3 branch and its current revision lists 19.3.4 as affected, with 19.3.5 the first fixed release.

How do I fix it?

Upgrade to the fixed version for your branch, following GitLab's documented upgrade path for old instances. Four of the seven fixed versions, 18.11.13, 19.0.10, 19.1.9 and 19.2.9, are backports GitLab reserves for severe issues; its normal policy covers only the three most recent monthly releases.

Plan the upgrade window. The 19.4.3 and 19.3.6 releases include database migrations that run during the upgrade, so a single-node server is down while they finish; multi-node installations can apply the patch without downtime using GitLab's zero-downtime procedure. The 19.4.3 release also runs post-deploy migrations.

There is no published workaround, and the limits of any improvised one should be stated plainly: GitLab has not disclosed the preconditions, so restricting features, signups or CI usage is not a documented defense. Network-level restriction of who can reach the instance reduces exposure but is not a fix GitLab stands behind. The upgrade is the protection.

Rapid7 suggests restricting anonymous access to public projects, stopping untrusted users from creating or writing to public projects, or blocking the CI lint route. Its tested exploit route for the sibling flaw CVE-2026-97229 needs a malicious .gitlab-ci.yml and an unusual file path committed to a public project first, and the company states those steps cover only its own route and do not fix the vulnerable regular expression compiler.

If your install runs its own Ruby, the GitLab upgrade is only half the fix. Update Ruby as well to 3.3.13, 3.4.12, 4.0.9 or later, because GitLab's packages carry the patched Ruby only for themselves. Ruby 3.2 reached end of life in April 2026 and has no fixed release, yet GitLab's self-compiled installation guide still lists it as the minimum, so a source install on 3.2 must move to one of the fixed series. Alpine Linux's own image was caught exactly here: its 19.3.6 image published before October 27 remained vulnerable, and the one published on October 27 carries Ruby 3.3.13. Users of the alpinelinux/gitlab image should pull 19.3.6 again, and every older tag is vulnerable.

The same October 21 release fixes 10 other issues, two of them high severity: CVE-2026-15723, an account takeover through the OmniAuth-to-LDAP auto-linking email lookup when SAML and LDAP auto-linking are both enabled, and CVE-2026-112212, a cache-poisoning flaw in the OAuth and OpenID Connect discovery endpoints. Updating once covers all of them.

What is the root cause?

GitLab compiles regular expressions that its users supply, and the engine it compiles them with, Onigmo, counted two kinds of internal identifiers with unbounded counters, so a pattern carrying enough repeat constructs wrapped the identifiers and corrupted the compiled program.

GitLab is a Ruby on Rails application, and Ruby's built-in regex engine is Onigmo, a C library. GitLab's own packages and images do not use the system Ruby: they bundle their own Ruby, patched by GitLab, which is why an Onigmo weakness travels into every GitLab release since 7.0 and why GitLab ships the fix by patching the Ruby it carries.

Ruby's own advisory names the bug behind CVE-2026-110264 precisely: "overflow of internal IDs in a pattern with many repeats". The fix, merged upstream in ruby/ruby pull request #16801, "Reject overflowed repeat/null-check IDs in huge regexps", shows the mechanics in two lines. When Onigmo compiles a range repeat such as (?:foobar){0,100}, it emits a pair of virtual-machine instructions that need a numeric identifier:

   r = add_mem_num(reg, num_repeat); /* OP_REPEAT ID */
   reg->num_repeat++;
+  if ((MemNumType)reg->num_repeat <= 0) return ONIGERR_TOO_MANY_RANGE_REPEAT;

The added line is the check that was missing. The ID is stored as a MemNumType, which Onigmo defines as short int, a signed 16-bit integer with a maximum of 32,767. Before the fix, reg->num_repeat incremented forever with no comparison against that limit, so once the counter passed 32,767 the value written as the ID wrapped to a negative number. The new check casts the counter to MemNumType and stops compilation as soon as the cast value is zero or negative, before a wrapped ID reaches the compiled program. The same gap existed for the null-check identifiers that Onigmo assigns when it compiles constructs it must verify for empty matches:

     r = add_mem_num(reg, reg->num_null_check); /* NULL CHECK ID */
     if (r) return r;
     reg->num_null_check++;
+    if ((MemNumType)reg->num_null_check <= 0) return ONIGERR_TOO_MANY_NULL_CHECK;

A crafted pattern with a very large number of these constructs pushes the counters past the identifier range; the stored values wrap and collide inside the compiled program. The regression tests added with the fix show the two trigger shapes, each repeated 100,000 times in a single pattern:

'(?:foobar){0,100}' * 100000          # range repeats
'(?:(?:foo)?|(?:bar)?)*' * 100000     # constructs needing null checks

GitLab's advisory states that this integer overflow, reached while compiling such a pattern, could be turned into arbitrary code execution on the server. Researcher Johan Carlsson, who uses the handle joaxcar, reported the flaw through GitLab's HackerOne bug bounty program, the fourth regex-engine code-execution flaw of his in GitLab in a month, and the first to reach versions before 19.2.

How is it exploited?

No exploit code for CVE-2026-110264 is public, so the steps below follow the advisory, the upstream patch and Ruby's description of the input path rather than a released proof of concept.

  1. The attacker supplies a crafted regular expression to a GitLab feature that compiles user-supplied patterns. GitLab compiles patterns its users provide, such as those in CI configuration, though it has not disclosed which features reach this bug.
  2. The pattern is generated, not typed: it repeats a quantified construct tens of thousands of times, like the two shapes in the regression tests.
  3. During compilation, the repeat and null-check identifier counters pass the range of MemNumType and wrap, so the compiled program carries colliding identifiers.
  4. The corrupted compilation state yields memory corruption, which GitLab states could be turned into code execution as the GitLab server process.

The sibling flaw CVE-2026-97229, fixed on October 12 and caused by a different Onigmo overflow, in the size of a compiled pattern, has public code and a documented route. Rapid7 built a working exploit in a lab and published proof-of-concept code on October 13, 2026: it runs commands as GitLab's git user on an unpatched official 19.4.1 image and does not run on the patched 19.4.2 image.

Rapid7's route needs write access first, a malicious .gitlab-ci.yml file and a file path with UTF-8 characters committed to a branch of a public project, and in Rapid7's words "only the final CI lint request is unauthenticated". On servers where new users can register and create projects, that write step is available to anyone. How the attack in the original report to GitLab, which is still private, avoids the write step is not yet known.

How does the attack flow?

The flow is short: a machine-generated pattern full of repeats reaches the compiler, its identifiers wrap, and the corrupted program either crashes the worker or hands execution to the attacker.

flowchart LR A["Crafted pattern with tens of
thousands of repeat constructs"] --> B["Submitted to a GitLab feature
that compiles user patterns"] B --> C["Onigmo assigns OP_REPEAT and
null-check IDs from unbounded counters"] C --> D["Counters pass MemNumType range:
no bounds check, IDs wrap"] D --> E["Colliding IDs corrupt the
compiled program"] E --> F["Worker crash, or memory corruption
turned into code execution"]

What can an attacker do?

  • Run arbitrary code on the GitLab server as the GitLab process user, without authentication. The CVSS vector carries scope Changed, meaning the score accounts for impact beyond the vulnerable component itself.
  • Reach everything the GitLab process can reach: repositories and their history, CI/CD variables and other stored secrets, the container and package registries, and the host running the instance.
  • Pivot through CI: runners execute jobs defined in the affected instance, so server-side code execution can influence the workloads and machines that trust it.

Conditions the attacker needs: network access to the GitLab web interface, and the undisclosed preconditions. No authentication is required per the CVSS vector, CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H, and no user interaction is indicated. Since the preconditions are not published, an internet-reachable self-managed instance should be treated as exposed.

What did the Alpine Linux attack show?

The first publicly reported attack attempt on this bug family hit Alpine Linux's own GitLab server, gitlab.alpinelinux.org, on October 20 and 21, 2026, eight to nine days after GitLab released the October 12 fix for CVE-2026-97229, which the server had not received.

Alpine's October 28 disclosure describes an attack that came close to working. A newly registered account sent crafted CI configurations to the server, still on 19.3.4 without the fix, and crashed GitLab worker processes 8 times; in 4 of those crashes the attacker got partway through the exploit and failed at the next step. The main attack on October 21 also caused 502 errors and failed CI jobs. The attacker downloaded Alpine's GitLab container image, which Alpine says "suggests they were tuning the exploit to our exact build". Alpine blocked the account on October 23, and the attacker returned on October 25 and 26 without getting back in.

Alpine found no evidence that the attacker's code ran. Timing probes showed no delays. There were no unexpected files, keys, hooks or processes, and no private data returned to the attacker through any web or API request Alpine can see. But the evidence needed to confirm code execution no longer exists, because a successful exploit would leave no crash and no trace in the web logs, and some logs from the attack day are gone, including background job logs and the old container's filesystem. Neither Alpine nor its hosting provider logged outbound network connections. Alpine therefore treated the server as compromised, closed it on October 27, rebuilt it from scratch, replaced GitLab's secret keys and reset every account's password.

The stakes explain the rebuild. The server hosts aports, the repository Alpine's packages are built from, and the October 21 releases, 3.21.9, 3.22.7, 3.23.7 and 3.24.3, include the minirootfs tarballs the official Alpine Docker images are built from.

  • Alpine verified every aports commit added from October 20 to 22 against records the attacker could not reach: a developer's clone and all 45 build servers.
  • It confirmed that every package built from October 20 to 24 came from commits as published on git.alpinelinux.org.
  • The keys that sign Alpine packages and releases have never been on the GitLab server.

CISA added CVE-2026-97229 to its Known Exploited Vulnerabilities catalog on October 29, 2026, with a federal due date of November 1, 2026 (verified against the catalog's JSON feed on October 30). CVE-2026-110264 itself is still not listed.

Why does the fix work?

Ruby pull request #16801 closes the overflow at both counters. After each increment, the new code casts the counter to MemNumType and returns a hard error if the value has wrapped:

/* regcomp.c, compile_range_repeat_node() */
if ((MemNumType)reg->num_repeat <= 0) return ONIGERR_TOO_MANY_RANGE_REPEAT;

/* regcomp.c, compile_tree_empty_check() */
if ((MemNumType)reg->num_null_check <= 0) return ONIGERR_TOO_MANY_NULL_CHECK;

Two new error codes, ONIGERR_TOO_MANY_RANGE_REPEAT (-224) and ONIGERR_TOO_MANY_NULL_CHECK (-225), with messages in regerror.c, mean a pattern whose identifiers would overflow is now rejected as a RegexpError before the compiled program exists. Colliding identifiers cannot be produced, so the corruption path is closed. The fix is complete for this flaw, and it carries regression tests for both trigger shapes.

Deployment is the interesting part. The upstream fix was merged into ruby/ruby on April 29, 2026, and no Ruby release carried it until October 23, 2026: Ruby 4.0.9, 3.4.12 and 3.3.13, which the advisory confirms as the first releases of their series containing it, and Ruby 4.0.8 explicitly does not contain this one. GitLab did not wait: its October 21 packages carry its own backport of the patch, which its release notes list as "Add Ruby regexp repeat ID overflow patch for 3.3, 3.4 and 4.0" across the 19.2 through 19.5 builds, alongside the earlier repeat-range fix reaching the older branches. Installing a fixed GitLab package or image applies the fix through the bundled Ruby.

How do I check if I was compromised?

No exploitation of CVE-2026-110264 has been reported, and the attempted exploitation of the sibling flaw CVE-2026-97229 against Alpine Linux's server is the only publicly reported in-the-wild activity in this bug family. CISA added CVE-2026-97229 to its KEV catalog on October 29, 2026, with a federal due date of November 1, 2026, while CVE-2026-110264 is still not listed as of October 30, 2026. GitLab has published seven detection rules for exploitation attempts against self-managed servers, all marked experimental and written in the Sigma format in its open-source TLDR detection framework, and its guidance with them warns that a successful exploit can leave no crash.

  • The Sigma rules run against GitLab's application logs. For CVE-2026-110264, GitLab published two, Onigmo native worker crash and Org mode render error burst. For CVE-2026-97229, it published six: the same Onigmo crash rule and five more that look for:
    • Hostile patterns in GraphQL ciLint requests.
    • CI regexp guard rejections.
    • Oversized file paths with non-ASCII characters.
    • CI lint worker crashes behind Workhorse.
    • Bursts of CI lint errors from scripted clients.
  • The Alpine attack shows what an attempt looks like in practice: clusters of GitLab worker crashes tied to crafted CI configurations, 502 errors and failed CI jobs around them.
  • GitLab's further steps with the rules:
    • Look for files owned by the git user in /tmp, unexpected child processes of Puma or Sidekiq, outbound connections, and changed crontabs or SSH keys for the git user.
    • If there are signs of code execution, treat the server as compromised and rotate the secrets in gitlab-secrets.json, all CI/CD variables, all runner tokens and all access tokens, and limit who can create accounts and personal access tokens.
    • Alpine's response is the reference for that playbook: it rebuilt the instance from scratch on the same reasoning.

Timeline

  • 2026-04-29: the fix, ruby/ruby pull request #16801, "Reject overflowed repeat/null-check IDs in huge regexps", is merged upstream.
  • 2026-09-23: GitLab fixes the first two joaxcar regex-engine flaws, CVE-2026-89078 and CVE-2026-93577, both rated 9.9 and requiring an account, in 19.4.1.
  • 2026-10-12: GitLab fixes CVE-2026-97229, an unauthenticated 10.0 regex-compiler overflow, in 19.2.8, 19.3.5 and 19.4.2.
  • 2026-10-13: Rapid7 publishes proof-of-concept code for CVE-2026-97229 running as GitLab's git user on an unpatched 19.4.1 image. The same day, Alpine Linux upgrades its server to 19.3.4 instead of the fixed 19.3.5 by mistake.
  • 2026-10-20 to 21: a newly registered account attacks Alpine Linux's GitLab with crafted CI configurations, crashing GitLab workers 8 times. The server is on 19.3.4, without the October 12 fix.
  • 2026-10-21: GitLab fixes CVE-2026-110264 in 19.5.1, 19.4.3, 19.3.6, 19.2.9, 19.1.9, 19.0.10 and 18.11.13, backporting beyond its normal policy.
  • 2026-10-22: CVE-2026-110264 published with the CVSS v3.1 10.0 rating. Alpine upgrades its server to 19.3.6.
  • 2026-10-23: Ruby releases 4.0.9, 3.4.12 and 3.3.13 with the underlying Onigmo fixes and its advisory naming the bug behind each GitLab CVE. Alpine blocks the attacker's account.
  • 2026-10-26: Alpine finds its upgraded server still vulnerable, because its image uses standard Ruby rather than GitLab's patched copy.
  • 2026-10-27: Alpine closes its GitLab to everyone except its developers and build servers and starts a rebuild. The 19.3.6 image published this day carries Ruby 3.3.13.
  • 2026-10-28: Alpine's rebuild finishes, all passwords are reset and GitLab's secret keys are replaced. Alpine publishes its incident disclosure.
  • 2026-10-29: CISA adds CVE-2026-97229 to its Known Exploited Vulnerabilities catalog with a federal due date of November 1, 2026.

FAQ

I patched on October 12 for CVE-2026-97229. Am I safe now?

No. The October 12 builds, 19.2.8, 19.3.5 and 19.4.2, are inside the affected ranges of CVE-2026-110264, whose fixed versions sit one patch higher at 19.2.9, 19.3.6 and 19.4.3. The earlier flaw stopped at 19.2; this one does not, so every self-managed instance needs the October 21 release regardless of what it applied before. One advisory revision matters here: GitLab's October 12 post originally named 19.3.4 as the fixed version for the 19.3 branch, and its current revision lists 19.3.4 as affected with 19.3.5 the first fixed release, so a server on 19.3.4 must move to 19.3.6.

Does the GitLab upgrade fix a self-compiled install or an image with its own Ruby?

No. GitLab's October 12 and October 21 fixes are patches to the Ruby that GitLab bundles in its own Linux packages and container images, and a GitLab upgrade does not change a server's own Ruby. Self-compiled installs and images that install Ruby separately, as Alpine Linux's did, keep the flaw until Ruby itself is updated to 3.3.13, 3.4.12, 4.0.9 or later. Ruby 3.2 reached end of life in April 2026 and has no fixed release, so a source install on 3.2 must move to one of those series.

Is GitLab.com or GitLab Dedicated affected?

No. GitLab.com already runs a fixed version, and GitLab Dedicated tenants on internal releases 19.3.5-internal0 and 19.4.2-internal0 or later already include the fix. The exposure is self-managed CE and EE installations of every deployment type.

Which GitLab features does the attacker need?

GitLab has not disclosed the preconditions, so there is no documented way to rule an instance out by configuration. GitLab compiles regular expressions its users supply, such as CI configuration patterns, and the published detection rules watch for Onigmo worker crashes and Org mode render error bursts. Treat any internet-reachable self-managed instance as exposed until it is patched.

Does Regexp.timeout or a pattern length limit protect my own Ruby applications?

No. Ruby's advisory states that Regexp.timeout does not protect against these bugs and that length limits are unreliable because short patterns can trigger some of them. Applications that compile attacker-controlled strings with Regexp.new, Regexp.union, Regexp.compile or interpolation into a regexp literal should upgrade Ruby and stop compiling untrusted patterns.

Will a CVE scanner flag vulnerable Ruby installations?

Not through a Ruby CVE identifier: Ruby has not requested one, at least for now, and directs users to track GitLab's four CVE numbers, whose records name only GitLab as the affected product. Track Ruby by version instead: 4.0.9, 3.4.12 and 3.3.13 are fixed, Ruby 4.0.8 lacks the fix for CVE-2026-110264, and Ruby 3.2 and earlier are end of life without a fix.

What does the upgrade cost on a single-node server?

The 19.4.3 and 19.3.6 releases include database migrations that must finish before GitLab starts, which means downtime on a single-node installation. Multi-node installations can apply the patch with GitLab's zero-downtime procedure, and 19.4.3 additionally runs post-deploy migrations after the upgrade.

Find unpatched GitLab instances before attackers do

Scan your external assets and container images with Ostorlab to surface every self-managed GitLab instance in your estate still running a version from before the October 21, 2026 releases, including staging and CI-only servers that rarely receive attention.

References

  • GitLab Critical Patch Release 19.5.1, 19.4.3, 19.3.6, 19.2.9, 19.1.9, 19.0.10 and 18.11.13, October 21, 2026, with the CVE-2026-110264 description, CVSS 10.0 vector, affected ranges, backport note, joaxcar credit, detection links and migration warnings: https://docs.gitlab.com/releases/patches/patch-release-gitlab-19-5-1-released/ (checked October 25, 2026)
  • CVE-2026-110264 record with the affected-version ranges and the HackerOne report reference: https://cveawg.mitre.org/api/cve/CVE-2026-110264 (checked October 25, 2026)
  • Ruby advisory, "Regexp compilation fixes related to GitLab's CVE-2026-89078, CVE-2026-93577, CVE-2026-97229 and CVE-2026-110264", October 23, 2026, with the bug-per-CVE table, affected-input definition, workaround limits and credits: https://www.ruby-lang.org/en/news/2026/10/23/regexp-fixes-for-gitlab-cves/ (checked October 25, 2026)
  • ruby/ruby pull request #16801, "Reject overflowed repeat/null-check IDs in huge regexps", merged April 29, 2026, with the two counter checks, the new error codes and the regression tests: https://github.com/ruby/ruby/pull/16801 (checked October 25, 2026)
  • Ruby 4.0.9 release, October 23, 2026, the first 4.0 release carrying the CVE-2026-110264 fix: https://www.ruby-lang.org/en/news/2026/10/23/ruby-4-0-9-released/ (checked October 25, 2026)
  • Ruby 3.4.12 and 3.3.13 releases, October 23, 2026: https://www.ruby-lang.org/en/news/2026/10/23/ruby-3-4-12-released/ and https://www.ruby-lang.org/en/news/2026/10/23/ruby-3-3-13-released/ (checked October 25, 2026)
  • GitLab omnibus merge request adding the Ruby regexp repeat ID overflow patch to the 19.5 build, from the release's bug-fix list: https://gitlab.com/gitlab-org/omnibus-gitlab/-/merge_requests/9922 (checked October 25, 2026)
  • GitLab detection rule "Onigmo native worker crash", Sigma format, in the TLDR framework: https://gitlab.com/gitlab-security-oss/tldr/-/blob/main/Detections/platforms/GitLab/Vulnerability%20Detections/onigmo_native_worker_crash.md (checked October 25, 2026)
  • GitLab detection rule "Org mode render error burst", Sigma format, in the TLDR framework: https://gitlab.com/gitlab-security-oss/tldr/-/blob/main/Detections/platforms/GitLab/Vulnerability%20Detections/org_mode_render_error_burst.md (checked October 25, 2026)
  • The HackerOne report for CVE-2026-110264, reference 4093475: https://hackerone.com/reports/4093475 (referenced from the CVE record, checked October 25, 2026)
  • The Hacker News, "Critical GitLab Flaw (CVSS 10.0) Could Allow Unauthenticated RCE Across 12 Years of Releases", October 21, 2026, with the fixed-version matrix, the re-exposure of October 12 patchees and the upgrade-downtime detail: https://thehackernews.com/2026/10/critical-gitlab-flaw-cvss-100-could.html (checked October 25, 2026)
  • The Hacker News, "Ruby Fixes Three Regex Engine Bugs Responsible for Four Critical GitLab RCE Flaws", October 23, 2026: https://thehackernews.com/2026/10/ruby-fixes-three-regex-engine-bugs.html (checked October 25, 2026)
  • CVE-2026-97229, the October 12 companion fixed in 19.2.8, 19.3.5 and 19.4.2: https://www.cve.org/CVERecord?id=CVE-2026-97229 (checked October 25, 2026)
  • Alpine Linux, "GitLab security incident: attempted exploitation of CVE-2026-97229", October 28, 2026, the primary disclosure of the attack: the attacker's registration and crafted CI configurations, the 8 worker crashes and 4 partial exploits, the container-image download, the upgrade that did not fix the server, the aports verification against outside records, and the rebuilt Ruby guidance: https://alpinelinux.org/posts/GitLab-security-incident-CVE-2026-97229.html (checked October 29, 2026)
  • Rapid7 attack and exploitation team, proof-of-concept code for CVE-2026-97229 published October 13, 2026, running as the git user on an unpatched 19.4.1 image and not on the patched 19.4.2 image: https://www.rapid7.com/blog/post/etr-cve-2026-97229-critical-unauthenticated-remote-code-execution-in-gitlab/ and the code at https://github.com/jburgess-r7/CVE-2026-97229-PoC (checked October 29, 2026)
  • Rapid7 technical analysis of CVE-2026-97229, with the exploit route needing a malicious .gitlab-ci.yml and a UTF-8 file path committed to a public project first, and "only the final CI lint request is unauthenticated": https://www.rapid7.com/blog/post/ra-gitlab-ci-cd-regex-integer-overflow-technical-analysis-cve-2026-97229/ (checked October 29, 2026)
  • GitLab's October 12 patch release post, which named 19.3.4 as the fixed version at publication, in the Internet Archive capture of October 12, 2026; the current revision lists 19.3.4 as affected and 19.3.5 as fixed: https://web.archive.org/web/20261012125119/https://docs.gitlab.com/releases/patches/patch-release-gitlab-19-4-2-released/ (checked October 29, 2026)
  • GitLab's detection-rule index for CVE-2026-97229 exploitation attempts, six Sigma rules in the TLDR framework, all marked experimental: https://docs.gitlab.com/releases/patches/patch-release-gitlab-19-4-2-released/#detecting-cve-2026-97229-exploitation-attempts (checked October 29, 2026)
  • GitLab's self-compiled installation guide, which still lists Ruby 3.2 as the minimum version: https://docs.gitlab.com/install/self_compiled/ (checked October 29, 2026)
  • Ruby branch end-of-life dates, showing Ruby 3.2 end of life in April 2026: https://www.ruby-lang.org/en/downloads/branches/ (checked October 29, 2026)
  • GitLab zero-downtime upgrade documentation: https://docs.gitlab.com/update/zero_downtime/ (checked October 25, 2026)
  • GitLab upgrade paths for old versions: https://docs.gitlab.com/update/ (checked October 25, 2026)
  • CISA Known Exploited Vulnerabilities catalog, CVE-2026-97229 added on October 29, 2026 with a federal due date of November 1, 2026, CVE-2026-110264 not listed: https://www.cisa.gov/known-exploited-vulnerabilities-catalog (checked against the catalog JSON feed on October 30, 2026)