Skip to content

CVE-2026-110264: GitLab CE/EE Unauthenticated Onigmo Regular Expression Integer Overflow Remote Code Execution (Shadowserver Telemetry)

Density:
C-Level Executive Briefing CVE-2026-110264 CRITICAL SCORE 99/100

Maximum-severity unauthenticated Remote Code Execution (RCE) flaw designated CVE-2026-110264 affecting self-hosted GitLab Community Edition (CE) and Enterprise Edition (EE) deployments. Originating in the low-level Onigmo regular expression compiler integrated within the Ruby runtime, the flaw is triggered when processing specially crafted, recursively nested regular expression queries submitted through unauthenticated repository search, branch filtering, or public Git endpoints. The integer overflow leads directly to heap memory corruption in the Ruby worker process, enabling an unauthenticated remote attacker to gain complete administrative and shell access over the GitLab host, compromise corporate source code repositories, and harvest CI/CD deployment credentials. Actively tracked by The Shadowserver Foundation with sensor telemetry confirming over 1,000 vulnerable instances exposed to the public Internet.

HYBRID

HERMES THREAT SCORE & ENTERPRISE DEVSECOPS COMPROMISE EVALUATION

Target: GitLab Ruby VM Onigmo Regular Expression Compiler & Search Routing Engine
Confidence: 99%
99 / 100
CRITICAL

Measures real-world operational relevance, exploit weaponization, and active threat posture.

Dimension Breakdown
Exploitability 20 / 20
Threat Activity 20 / 20
Weaponization 20 / 20
Exposure 20 / 20
Prevalence 19 / 20
Impact 20 / 20
Exploit Maturity 20 / 20
Attack Chain Potential 20 / 20

GitLab relies on Rubyโ€™s native regular expression engine, which incorporates Onigmo (a fork of Oniguruma). When parsing search expressions, routing rules, or ref-filtering parameters, GitLab passes user-supplied patterns into Rubyโ€™s Regexp.compile subsystem.

flowchart TD
A["Attacker (Unauthenticated Remote HTTP Client)"] -->|"1. Submits crafted HTTP request with nested regex pattern"| B["GitLab Public Ingress (Nginx / Workhorse)"]
B -->|"2. Forwards request to Puma Ruby Application Server"| C["Ruby VM: Regexp.compile(pattern)"]
C -->|"3. Delegates compilation to embedded Onigmo engine"| D["onig_compile(): Node Tree Traversal"]
D -->|"4. Integer overflow in bytecode buffer allocation (size_t wraparound)"| E["Heap Buffer Under-allocation"]
E -->|"5. Bytecode emission exceeds buffer boundary"| F["Heap Memory Corruption / Metadata Overwrite"]
F -->|"6. Function pointer overwrite in Ruby allocator (rb_gc_call)"| G["Arbitrary Code Execution as git user"]
G -->|"7. Steals CI/CD secrets, database credentials, & SSH keys"| H["Full Supply Chain Takeover"]

The Low-Level Integer Overflow in Onigmo Bytecode Allocation

Section titled โ€œThe Low-Level Integer Overflow in Onigmo Bytecode Allocationโ€

During compilation of complex regex patterns containing deeply nested quantifiers or capture group permutations (e.g., (?<=(...)){65536}), Onigmo computes the required memory size for the bytecode buffer by accumulating node lengths into a 32-bit integer:

/* Vulnerable buffer calculation pattern in Onigmo regcomp.c */
static int
compile_length_tree(Node* node, regex_t* reg)
{
int len = 0;
int r;
switch (NTYPE(node)) {
case NT_LIST:
do {
r = compile_length_tree(NCAR(node), reg);
if (r < 0) return r;
/* VULNERABILITY: 32-bit signed integer accumulation without overflow check */
len += r;
} while (IS_NOT_NULL(node = NCDR(node)));
break;
case NT_ENCLOSE:
r = compile_length_tree(node->u.enclose.target, reg);
if (r < 0) return r;
/* Integer multiplication overflow when repeat count is large */
len = r * node->u.enclose.repeat_count + SIZE_OP_REPEAT_INC;
break;
...
}
return len; /* Wraparound yields small positive integer */
}

When len wraps around past 0x7FFFFFFF, the allocator receives a truncated size value (e.g., a few hundred bytes). Subsequently, during the bytecode emission phase (compile_tree), Onigmo writes the actual compiled instructions into the undersized heap buffer, overrunning allocated bounds and corrupting adjacent heap structures, free list pointers, and Ruby object headers.


Threat actors have weaponized CVE-2026-110264 into an automated initial access pipeline:

  1. Reconnaissance & Exposure Probing: Attackers scan IP ranges for GitLab login portals (/users/sign_in) and API health endpoints (/api/v4/version, /-/readiness), extracting instance versions from static asset finger-prints.
  2. Payload Delivery: An unauthenticated POST request is dispatched to search or explore endpoints (e.g., /search with parameter search_code=1 or public repository blob search), embedding the malicious regex pattern within the query parameters.
  3. Control-Flow Hijack: The Puma Ruby worker triggers the heap overflow. Attackers groom the heap using concurrent HTTP pipeline requests to align Ruby method tables, overwriting function dispatch pointers to execute /bin/sh.
  4. Post-Exploitation & Secret Exfiltration: Once code execution as the git user is achieved, adversaries dump /etc/gitlab/gitlab-secrets.json, extract database encryption keys, clone private repositories, and pivot into corporate Kubernetes clusters via GitLab CI/CD runner tokens.

Security Operations Centers (SOC) must inspect reverse proxy logs, Puma access logs, and system crash dumps for indicators of CVE-2026-110264 exploitation.

title: GitLab Onigmo Regexp Integer Overflow Exploitation Attempt
id: 9a4e8102-1102-4c22-b519-cve2026110264
status: critical
description: Detects unauthenticated HTTP requests targeting GitLab search and public repository endpoints with anomalous nested regular expressions indicative of CVE-2026-110264 exploitation.
references:
- https://about.gitlab.com/releases/2026/10/21/patch-release-gitlab-19-5-1-released/
- https://dashboard.shadowserver.org/
author: Hermes Codex Cyber Defense Team
date: 2026-11-02
logsource:
category: webserver
product: gitlab
detection:
selection_endpoints:
cs-uri-stem|startswith:
- '/search'
- '/api/v4/projects'
- '/api/v4/groups'
- '/-/autocomplete'
selection_payload:
cs-uri-query|contains:
- '(?<='
- '(?<!'
- '%28%3F%3C%3D'
- '%28%3F%3C%21'
selection_repetition:
cs-uri-query|re: '(\(\?(\<|\=|\!)[^\)]{50,}\)){3,}'
condition: selection_endpoints and (selection_payload or selection_repetition)
falsepositives:
- Advanced developer queries searching for regex expressions in code (examine authentication context)
level: critical
tags:
- attack.initial_access
- attack.t1190
- attack.execution
- attack.t1059
Indicator TypeObservable / IndicatorAttribution & RoleStatusSource
IPv4 Address194.38.20[.]114Distributed GitLab scanner delivering nested regex probesACTIVEShadowserver
IPv4 Address45.142.182[.]28Weaponized exploit node attempting heap sprayingACTIVEGreyNoise
IPv4 Address185.196.220[.]49Reconnaissance probe crawling GitLab public reposACTIVECrowdSec CTI
IPv4 Address109.205.213[.]61Secondary staging host capturing reverse shellsACTIVEVulnCheck
HTTP PatternGET /api/v4/projects?search=(?<=(...)){65536}Arithmetic wraparound trigger in regex compilationMALICIOUSGitLab Workhorse
HTTP PatternPOST /api/v4/ci/lint with deep capture groupsCI/CD linting parser exploit deliveryMALICIOUSWAF Ingress
Host Logpuma_stderr.log: SIGSEGV in compile_length_treeProcess crash indicator signifying heap corruptionCONFIRMEDProduction Logs
alert http any any -> $HTTP_SERVERS any (
msg:"ET EXPLOIT GitLab Onigmo Regexp Integer Overflow RCE (CVE-2026-110264)";
flow:established,to_server;
http.uri; content:"/api/v4/";
pcre:"/search=[^&]*\(\?[\<\=\!][^\)]{25,}\)\{\d{4,}\}/i";
classtype:web-application-attack;
sid:202611026;
rev:1;
)

The GitLab security team patched this vulnerability across all active and maintenance releases by incorporating an upstream Onigmo fix for regcomp.c:compile_length_tree(). The patch enforces strict SIZE_MAX bounds checking and rejects arithmetic wraparound during bytecode compilation:

Product BranchVulnerable VersionsFixed ReleasePatch Status
GitLab 19.519.5.019.5.1Primary Security Release
GitLab 19.419.4.0 โ€“ 19.4.219.4.3Official Security Release
GitLab 19.319.3.0 โ€“ 19.3.519.3.6Official Security Release
GitLab 19.219.2.0 โ€“ 19.2.819.2.9Long-Term Support Backport
GitLab 19.119.1.0 โ€“ 19.1.819.1.9Long-Term Support Backport
GitLab 19.019.0.0 โ€“ 19.0.919.0.10Long-Term Support Backport
GitLab 18.11 and prior7.0.0 โ€“ 18.11.1218.11.13Extended Security Maintenance
  1. Apply Critical Security Update: Upgrade self-hosted GitLab CE/EE instances immediately to the latest patched releases for your respective branch:
    • 19.5.1 (for 19.5.x)
    • 19.4.3 (for 19.4.x)
    • 19.3.6 (for 19.3.x)
    • 19.2.9 (for 19.2.x)
    • 19.1.9 (for 19.1.x)
    • 19.0.10 (for 19.0.x)
    • 18.11.13 (for 18.11.x and prior)
  2. Restrict Public Search Access: Enforce require_authenticated_search = true in gitlab.rb to prevent anonymous visitors from accessing search endpoints and triggering regex evaluation.
  3. Audit CI/CD Runner Tokens & Deploy Keys: If an instance was exposed to the public Internet without patches, rotate all runner registration tokens, personal access tokens (PATs), and database credentials stored in /etc/gitlab/gitlab-secrets.json.
  4. Deploy WAF Inspection Rules: Implement perimeter WAF inspection to filter nested recursive regex constructs containing excessive nested groups in query string parameters.