When GitLab publishes a patch on the third Wednesday of the month, outside its second-and-fourth-Wednesday schedule, you are looking at an emergency fix. The one released on 21 October 2026 fixes CVE-2026-110264, rated CVSS 10.0: an unauthenticated visitor can run code on a self-managed GitLab CE or EE server through the Org-mode file renderer, and every release back to GitLab 7.0 is affected. If you upgraded on 12 October for the earlier CI regex fixes, you’re still exposed, because 19.4.2, 19.3.5 and 19.2.8 are all vulnerable. Two more patch releases have shipped since, so the build to install today is newer than the one that first fixed the RCE.
This guide shows you how to check your GitLab version, pick the right build for your branch and patch Omnibus, Docker and Helm installs, plus the Runner step the vendor notice buries. We patched Ubuntu 26.04, Rocky Linux 10 (SELinux enforcing) and Docker servers in October, then retested the Omnibus upgrades against the builds current in November 2026.
Which GitLab versions CVE-2026-110264 affects
Every self-managed GitLab CE and EE release from 7.0 up to the fixed builds in this table is vulnerable, on every install type: Omnibus packages, Docker images, the Helm chart and source installs. GitLab.com is already patched, and GitLab Dedicated tenants on the internal 19.3.5 or 19.4.2 builds or later need no action. Because the bug is this severe, GitLab backported the fix to four older branches as well as the three it normally maintains. The first fixed build is what closed the RCE; the last column is what to install today:
| Your branch | Vulnerable builds | First RCE-fixed build | Latest patched build | Omnibus package to install (CE) |
|---|---|---|---|---|
| 19.5 | 19.5.0 | 19.5.1 | 19.5.4 | 19.5.4-ce.0 |
| 19.4 | 19.4.0 to 19.4.2 | 19.4.3 | 19.4.6 | 19.4.6-ce.0 |
| 19.3 | 19.3.0 to 19.3.5 | 19.3.6 | 19.3.8 | 19.3.8-ce.0 |
| 19.2 | 19.2.0 to 19.2.8 | 19.2.9 (backport) | 19.2.10 | 19.2.10-ce.0 |
| 19.1 | 19.1.0 to 19.1.8 | 19.1.9 (backport) | 19.1.10 | 19.1.10-ce.0 |
| 19.0 | 19.0.0 to 19.0.9 | 19.0.10 (backport) | 19.0.11 | 19.0.11-ce.0 |
| 18.11 | 18.11.0 to 18.11.12 | 18.11.13 (backport) | 18.11.14 | 18.11.14-ce.0 |
| 7.0 to 18.10 | all | none | none | upgrade to a fixed branch |
Don’t go looking for 19.5.2 or 19.4.4. GitLab skipped both numbers, and the package repository on our Ubuntu server jumps from 19.5.1 to 19.5.3 and from 19.4.3 to 19.4.5. Each later build sits above the first fixed build on its branch, and GitLab’s upgrade path documentation tells you to run the latest patch release of your major.minor version anyway. Our upgraded lab servers report 19.5.4 (through the API) and 19.4.6 (in the version file), both above the 19.5.1 and 19.4.3 builds that first closed the RCE.
Enterprise Edition uses the same numbers with an -ee.0 suffix and the gitlab-ee package. Anything older than 18.11 has no patch at all, so those servers have to climb GitLab’s required upgrade stops (18.2, 18.5, 18.8 and 18.11 on the 18.x line) and land on 18.11.14 or a patched 19.x build. If you’re still on 17.x, our GitLab 17 to 18 upgrade walkthrough covers the first part of that climb. One small detail from the package repository: the Ubuntu 26.04 suite has no 18.11, 19.0, 19.1 or 19.2 builds, so a 26.04 server is always on a branch with a direct fix.
The same release fixes two other serious bugs: CVE-2026-15723 (CVSS 8.2), an account takeover through OmniAuth-to-LDAP auto-linking, and CVE-2026-112212 (CVSS 7.5), cache poisoning of the OAuth and OIDC discovery documents. Both are fixed only in 19.3.6, 19.4.3 and 19.5.1, though. The four backport builds carry the regex fix alone, so a server patched to 18.11.13 through 19.2.9 is still open to the LDAP takeover. The full list is in GitLab’s critical patch release notes.
Understanding the two newer patch releases
Neither of the follow-up releases mentions CVE-2026-110264. They fix different bugs, but they change which build you should pin, and the second one leaves the older branches behind:
- 29 October: 19.5.3, 19.4.5, 19.3.7, 19.2.10, 19.1.10, 19.0.11 and 18.11.14, for CVE-2026-111943 (trust removed for eight compromised eMudhra intermediate CAs, no CVSS score in the notice)
- 10 November: 19.5.4, 19.4.6 and 19.3.8 only, for CVE-2026-105437 (a heap buffer overflow in Git, rated critical, affecting every release from 16.2)
The second release is the one that should change your plans. GitLab shipped no 19.2, 19.1, 19.0 or 18.11 build for the Git bug, so a server on a backport branch is still exposed to it, as well as to the LDAP takeover above. Install the latest build in the table today, then schedule the move to 19.3.8 or later. The 29 October notice also says its builds run database migrations, so a single-node server goes down while they finish. Plan for downtime on the 10 November builds too. Their notice says they add no new migrations, yet our Ubuntu jump from 19.5.1 to 19.5.4 and our Rocky jump from 19.4.3 to 19.4.6 both ran two AI Gateway timeout migrations that our earlier 19.5.1 to 19.5.3 run had not. Source installs need one more step: the fixes ship only in GitLab’s packages and images, so the 21 October notice asks for Ruby 3.3.13, 3.4.12 or 4.0.9 or later, and the 10 November notice asks for distribution Git 2.56.1 or later (or a build your distribution has patched for CVE-2026-105437), while self-compiled installs follow GitLab’s Gitaly update steps and rebuild the Git that git.bin_path points to.
How the Org-mode renderer turns into code execution
GitLab renders .org files with the org-ruby gem whenever someone opens one in the repository browser or a preview. GitLab’s detection notes explain the rest: the gem copies the raw keyword from a file’s #+TODO: line into a Ruby regular expression. A keyword built to overflow a counter in Onigmo, the regex engine inside Ruby, makes it write outside its buffer while matching, and GitLab’s detection notes say a prepared request turns that into a system() call running as the git user. An attacker only needs one public project to work against, which is why no login is required.
Code running as git on a GitLab server is about as bad as it gets for a small team, because that account can read everything GitLab keeps:
/etc/gitlab/gitlab-secrets.jsonand the database encryption keys- every CI/CD variable, including deploy credentials
- runner authentication tokens and personal access tokens
- read and write access to every repository on the instance
The fix patches the regex engine in the Ruby that GitLab bundles and updates gitlab-markup. Don’t try to confirm the patch from the Ruby or gem versions: the Ruby build string doesn’t change, and the gem bumps differ from branch to branch (the 18.11.13 notes list no gitlab-markup update at all). We compared the vulnerable and fixed Docker images side by side:
for v in 19.3.5 19.3.6; do printf "%s: " $v; sudo docker run --rm --entrypoint sh gitlab/gitlab-ce:$v-ce.0 -c 'ls /opt/gitlab/embedded/lib/ruby/gems/*/gems/ | grep -E "^(org-ruby|gitlab-markup)-" | tr "\n" " "; /opt/gitlab/embedded/bin/ruby -v'; done
Both images report the same Ruby build and the same org-ruby release, and only gitlab-markup moves:
19.3.5: gitlab-markup-2.1.0 org-ruby-0.9.12 ruby 3.3.12 (2026-07-16 revision 0581089df9) [x86_64-linux]
19.3.6: gitlab-markup-2.2.0 org-ruby-0.9.12 ruby 3.3.12 (2026-07-16 revision 0581089df9) [x86_64-linux]
The GitLab version number is the only check that counts, so the next section starts there.
Checking your GitLab version
On the server itself, the package manager answers the question in one line. On Ubuntu and Debian Omnibus installs, ask dpkg (use gitlab-ee for Enterprise Edition):
dpkg -l gitlab-ce | tail -n 1
Our Ubuntu 26.04 server was on the vulnerable 19.5.0 build:
ii gitlab-ce 19.5.0-ce.0 amd64 GitLab Community Edition (including NGINX, Postgres, Redis)
On Rocky Linux, AlmaLinux and RHEL, rpm gives the same answer. Swap in gitlab-ee if you run Enterprise Edition:
rpm -q gitlab-ce
The Rocky box was on 19.4.2, the build many teams installed on 12 October and assumed was safe:
gitlab-ce-19.4.2-ce.0.el10.x86_64
For Docker, read the version file inside the running container, since the image tag in your Compose file only tells you what you meant to run:
sudo docker exec gitlab cat /opt/gitlab/embedded/service/gitlab-rails/VERSION
The container on our Docker host printed a vulnerable build:
19.3.5
To check a server from your workstation, use the API. A personal access token with the read_api scope is enough for this check, and both values appear in several commands below, so export them once:
export GITLAB_URL="https://gitlab.example.com"
export GITLAB_TOKEN="your-token-here"
Without a token the endpoint returns 401 Unauthorized, so an outsider cannot read your version this way. With the token you get the exact build and its revision:
curl -s -H "PRIVATE-TOKEN: ${GITLAB_TOKEN}" "${GITLAB_URL}/api/v4/version" | jq -c '{version,revision}'
Compare the result with the table above:
{"version":"19.5.0","revision":"4c9e34e1faa"}
On a Helm chart deployment, the API check above is the one to trust. The APP VERSION column of helm list only repeats the chart’s metadata, so it can disagree with the running pods if your values pin an image tag.
Patching Omnibus GitLab on Ubuntu and Debian
Install the latest patched build of the branch you already run, and pin the exact version. A plain apt upgrade installs the newest release in the repository, so a 19.4 server would jump straight to 19.5. That is allowed (19.5 is a required stop), but it also runs a minor version’s migrations during an emergency change window, and most teams don’t want that. Refresh the package lists first:
sudo apt-get update
apt-cache policy gitlab-ce | head -n 4
To see every build the repository offers for your branch, list them with madison. Our second Ubuntu 26.04 server, deliberately left on 19.5.1 (the first RCE fix), shows the candidate and the gaps where 19.5.2 and 19.4.4 would be:
apt-cache madison gitlab-ce | grep -E ' 19\.(5|4)\.'
The candidate is 19.5.4, and the 19.4 line runs 19.4.3, 19.4.5, 19.4.6 with nothing in between:

Install the latest build for your branch. Replace the version with the one from the table (19.4.6-ce.0, 18.11.14-ce.0 and so on), or use gitlab-ee=19.5.4-ee.0 for Enterprise Edition:
sudo apt-get install -y gitlab-ce=19.5.4-ce.0 #https://docs.gitlab.com/releases/patches/patch-release-gitlab-19-5-4-released/
Before the new files go in, the package’s preinstall step dumps the database and archives /etc/gitlab. Then it stops everything except the services the migrations need, migrates and reconfigures. The run ends like this:
Get:1 https://packages.gitlab.com/gitlab/gitlab-ce/ubuntu/resolute resolute/main amd64 gitlab-ce amd64 19.5.4-ce.0 [1218 MB]
Fetched 1218 MB in 20s (60.9 MB/s)
2026-11-12 01:05:07 UTC -- Backup 1794445501_2026_11_12_19.5.1 is done.
Running configuration backup
Configuration backup archive complete: /etc/gitlab/config_backup/gitlab_config_1794445508_2026_11_12.tar
Unpacking gitlab-ce (19.5.4-ce.0) over (19.5.1-ce.0) ...
main: == 20261007171127 ChangeAiGatewayTimeoutSecondsDefault: migrated (0.4780s) ====
main: == 20261007171157 BackfillAiGatewayTimeoutSecondsDefault: migrated (0.4664s) ==
main: == 20261013104217 AddKindToAuditEventsInstanceStreamingEventTypeFilters: migrated (0.0187s)
Upgrade complete! If your GitLab server is misbehaving try running
sudo gitlab-ctl restart
before anything else.
On our 4 vCPU, 16 GB cloud server the whole run took six minutes, of which the 1.2 GB download was only 20 seconds. We polled the readiness endpoint every five seconds during the upgrade: it stopped answering 234 seconds in, returned 502 while Puma booted the new code, and came back with 200 at 446 seconds. Budget about three and a half minutes of downtime on a small single-node server, more if your database is large. The same server after the upgrade, with the API now reporting 19.5.4:

The October run on another server, from the vulnerable 19.5.0 to 19.5.1, is the one that showed the RCE fix landing. We keep it here because it is the before and after for CVE-2026-110264 itself:

If the server is not set up from the GitLab repository yet, the repository steps are in our guide to installing GitLab CE on Ubuntu 26.04 and 24.04. Debian 13 and 12 use the same apt-get install line, because their suites in the GitLab repository carry the same fixed builds.
Error: “404 Not Found” for gitlab-ce_19.5.1-ce.0_amd64.deb
Our first attempt in October failed before downloading anything:
Err:1 https://packages.gitlab.com/gitlab/gitlab-ce/ubuntu resolute/main amd64 gitlab-ce amd64 19.5.1-ce.0
404 Not Found [IP: 104.18.39.11 443]
E: Failed to fetch https://packages.gitlab.com/gitlab/gitlab-ce/ubuntu/pool/main/g/gitlab-ce/gitlab-ce_19.5.1-ce.0_amd64.deb 404 Not Found [IP: 104.18.39.11 443]
The repository index listed the package, but the download link briefly returned 404 instead of its normal redirect to the storage bucket. Running sudo apt-get update and then the same install command worked a minute later. If it keeps failing, wait a few minutes rather than switching mirrors, since nothing was wrong with the server.
Patching Omnibus GitLab on Rocky, AlmaLinux and RHEL
The RHEL family has the same minor-jump trap, and dnf makes it easier to miss. Our November Rocky Linux 10 server sat on 19.4.3, the first RCE fix for its branch, and the update check offered 19.5.4 instead of 19.4.6:
sudo dnf check-update gitlab-ce
A team that runs dnf upgrade on autopilot ends up on a new minor version:
gitlab-ce.x86_64 19.5.4-ce.0.el10 gitlab_gitlab-ce
Pin the latest build for your branch instead. The release suffix follows the OS major, so use .el9 or .el8 on older hosts, and gitlab-ee-19.4.6-ee.0.el10 for Enterprise Edition:
sudo dnf install -y gitlab-ce-19.4.6-ce.0.el10 #https://docs.gitlab.com/releases/patches/patch-release-gitlab-19-5-4-released/
The transaction replaces one package and runs the same preinstall backup and migrations as on Ubuntu. The download took 21 seconds and the whole run just under five minutes:

SELinux stayed in enforcing mode the whole time, in October and again in November. Check the audit log for denials from the upgrade:
sudo ausearch -m avc -ts today
No denials were logged and the readiness check answered 200. The bundled Git now reports a 2.54.1 build, while 19.5.1 on our Ubuntu server had shipped a 2.55.0 release candidate. The 10 November notice ties the Git 2.56.1 requirement to Git from your distribution, and says the packages and images already include the patched Git, so a 2.54.1 string here is not a failed patch. Treat the GitLab version as the check and the Git string only as a sign that the package really changed:

An empty gitlab-ctl status | grep -v '^run' at the bottom of that capture means every service came back, so there is nothing to restart by hand. For a fresh server on the RHEL family, our GitLab CE guide for Rocky Linux and AlmaLinux 10 covers the install from scratch.
Error: “listen tcp 127.0.0.1:9090: bind: address already in use”
After the October patch, sudo gitlab-ctl status on that first Rocky server showed down: prometheus: 143s, normally up, and its log repeated the bind error every second. It wasn’t caused by the patch. The Rocky Linux 10 image on our October server enabled cockpit.socket, which owns port 9090, and the bundled Prometheus had been failing like this since the first install. The failure only got noticed because a patch is when you read the status output carefully:
systemctl list-sockets | grep 9090
Cockpit’s socket sits on the port:
[::]:9090 cockpit.socket cockpit.service
Keep Cockpit and move GitLab’s Prometheus to another loopback port. Reconfigure alone doesn’t restart it, so restart it explicitly:
echo "prometheus['listen_address'] = 'localhost:9091'" | sudo tee -a /etc/gitlab/gitlab.rb
sudo gitlab-ctl reconfigure
sudo gitlab-ctl restart prometheus
Prometheus now listens on 9091 and Cockpit keeps 9090:
LISTEN 0 2048 127.0.0.1:9091 0.0.0.0:* users:(("prometheus",pid=64366,fd=7))
LISTEN 0 4096 *:9090 *:* users:(("systemd",pid=1,fd=173))
That output comes from sudo ss -ltnp | grep -E ':909[01]'. After the restart, gitlab-ctl status reported every service as running.
Patching GitLab in Docker
A container install is patched by changing the image tag and recreating the container. The data volumes stay where they are, and the new container runs the same database migrations an Omnibus upgrade would. Unlike the packages, the image takes no database backup before it starts, so run your usual Docker backup first. Our Docker host ran the official image from a Compose file in /srv/gitlab, and in October we bumped it from 19.3.5 to the first RCE fix in place. Today, use the latest tag for your branch from the table instead (19.3.8-ce.0 on this branch). We checked Docker Hub: all seven current tags exist, with 19.5.4, 19.4.6 and 19.3.8 last updated on 10 November and the other four on 29 October. For a 19.3.5 server, this swaps the tag straight to today’s 19.3.8 build. Put your own old and new tags in if you run another branch:
cd /srv/gitlab
sudo sed -i 's|gitlab/gitlab-ce:19.3.5-ce.0|gitlab/gitlab-ce:19.3.8-ce.0|' compose.yaml #https://docs.gitlab.com/releases/patches/patch-release-gitlab-19-5-4-released/
grep image: compose.yaml
The image: line should now name the new tag. Our October run targeted 19.3.6, the first RCE fix at the time, so its line and the status output further down show that tag; yours should read 19.3.8-ce.0:
image: gitlab/gitlab-ce:19.3.6-ce.0
Pull the image before recreating the container, so the download (1.4 GB compressed, 5.4 GB on disk, 300 seconds on our link) doesn’t count against your downtime:
sudo docker compose pull
sudo docker compose up -d
Compose replaces the container in place:
Container gitlab Recreate
Container gitlab Recreated
Container gitlab Starting
Container gitlab Started
The image’s health check turns healthy once reconfigure and the migrations finish, which took 76 seconds here:
sudo docker ps --format "{{.Names}} {{.Image}} {{.Status}}"
The container is on the fixed tag and healthy:
gitlab gitlab/gitlab-ce:19.3.6-ce.0 Up About a minute (healthy)
If you start GitLab with a plain docker run instead of Compose, the steps are the same: pull the new tag, stop and remove the old container, then run it again with the same volume flags. The old image stays on disk until you remove it with docker image rm gitlab/gitlab-ce:19.3.5-ce.0.
Patching a Helm chart install
Chart deployments need one extra lookup, because the GitLab chart has its own version numbers and they don’t line up neatly with GitLab’s. Refresh the repository and search for the latest build on every supported branch in one go:
helm repo update gitlab
helm search repo gitlab/gitlab --versions | grep -E '^NAME|\sv(19\.5\.4|19\.4\.6|19\.3\.8|19\.2\.10|19\.1\.10|19\.0\.11|18\.11\.14)\s'
Read the APP VERSION column, not the chart number. Our November search with Helm 4.3.1 returned eight charts for seven GitLab builds:
NAME CHART VERSION APP VERSION DESCRIPTION
gitlab/gitlab 10.5.5 v19.5.4 GitLab is the most comprehensive AI-powered Dev...
gitlab/gitlab 10.4.7 v19.4.6 GitLab is the most comprehensive AI-powered Dev...
gitlab/gitlab 10.3.10 v19.3.8 GitLab is the most comprehensive AI-powered Dev...
gitlab/gitlab 10.2.10 v19.2.10 GitLab is the most comprehensive AI-powered Dev...
gitlab/gitlab 10.1.10 v19.1.10 GitLab is the most comprehensive AI-powered Dev...
gitlab/gitlab 10.0.11 v19.0.11 GitLab is the most comprehensive AI-powered Dev...
gitlab/gitlab 9.11.16 v18.11.14 GitLab is the most comprehensive AI-powered Dev...
gitlab/gitlab 9.11.15 v18.11.14 GitLab is the most comprehensive AI-powered Dev...
The chart and GitLab numbers drift further apart with every patch round. GitLab 19.3.8 is chart 10.3.10, not 10.3.8, and 18.11.14 appears twice, as charts 9.11.15 and 9.11.16. Both deploy the same GitLab build, and we’d take the higher one because it is the newer chart release. The same search, captured on our lab host:

Pick your branch’s row from this table, which is that output cut down to what you type:
| Latest GitLab build | Chart version |
|---|---|
| 19.5.4 | 10.5.5 |
| 19.4.6 | 10.4.7 |
| 19.3.8 | 10.3.10 |
| 19.2.10 | 10.2.10 |
| 19.1.10 | 10.1.10 |
| 19.0.11 | 10.0.11 |
| 18.11.14 | 9.11.16 |
Back up first, because the chart takes no backup on its own. Then export your current values and upgrade, swapping 10.5.5 for your branch’s chart from the table. This is GitLab’s documented upgrade command. We confirmed the chart mapping above, but our lab doesn’t run the chart, so follow the chart upgrade notes if your release uses zero-downtime upgrades:
helm get values gitlab > gitlab.yaml
helm upgrade gitlab gitlab/gitlab --version 10.5.5 -f gitlab.yaml --set gitlab.migrations.enabled=true #https://docs.gitlab.com/charts/installation/version_mappings/
Add -n with your namespace to both commands if GitLab doesn’t run in the current one. helm list shows the new APP VERSION as soon as the release is recorded, before any pod has restarted, so confirm the patch with the API check in the next section once the webservice pods have rolled.
Confirming the patch took
A finished package install doesn’t mean GitLab is serving the new code yet. Puma needs a couple of minutes, and until then /api/v4/version answers with “GitLab is not responding” and a 502. The readiness endpoint answers on localhost without a token, so run it on the server and wait for a 200. Use the HTTPS form if your external_url starts with https, because the plain HTTP form then prints 000 with your own certificate, or a redirect code with Let’s Encrypt (we checked both forms on the Rocky box with a self-signed certificate):
curl -sk -o /dev/null -w "%{http_code}\n" https://localhost/-/readiness
On a plain HTTP instance, drop the k and use http://localhost/-/readiness. A ready server returns:
200
Then repeat the API check from your workstation. The version should match the fixed build for your branch:
curl -s -H "PRIVATE-TOKEN: ${GITLAB_TOKEN}" "${GITLAB_URL}/api/v4/version" | jq -c '{version,revision}'
Our Ubuntu server, upgraded in November from 19.5.1, now reports the latest build with a new revision (it was 449ed2875c2 on 19.5.1):
{"version":"19.5.4","revision":"b9d911743d5"}
Last, run sudo gitlab-ctl status | grep -v '^run'. Empty output means every bundled service is up, and anything it prints is worth sorting out now, like the Prometheus port clash we found on Rocky.
Updating GitLab Runner, CI images and AI Gateway
The 29 October release fixed a different problem, CVE-2026-111943, and its notice says the server package alone does not finish the job. GitLab removed trust in eight compromised eMudhra intermediate certificate authorities, and three pieces sit outside the Omnibus package: GitLab Runner, any CI/CD job image that brings its own ca-certificates package, and a self-managed AI Gateway. The 19.5.3 release notice lists what each one needs:
- GitLab Runner: update to 19.5.1, whatever server branch you run
- CI/CD images that install their own
ca-certificates: rebuild them so they pick up the current trust store - Self-managed AI Gateway: at least 18.11.8, 19.0.13, 19.1.9, 19.2.5, 19.3.3, 19.4.3 or 19.5.3, matching your branch
- GitLab Dedicated tenants on 19.4.3-internal0 or later: no action
We wanted to see what actually changed inside the server package, so we compared the bundled CA file on the Ubuntu box before and after its upgrade from 19.5.1 to 19.5.3. It went from 150 certificates built from Mozilla data dated 4 November 2025 to 120 certificates from Mozilla data dated 20 October 2026. Four emSign roots (eMudhra’s brand) were in the old file and one remains:
grep -c 'BEGIN CERTIFICATE' /opt/gitlab/embedded/ssl/certs/cacert.pem
grep -i -E '^emSign' /opt/gitlab/embedded/ssl/certs/cacert.pem
grep -i 'Certificate data from Mozilla' /opt/gitlab/embedded/ssl/certs/cacert.pem
On our later 19.5.4 server the same three checks print the same count, the one surviving emSign root and the same Mozilla date:

Don’t read too much into the emSign drop on its own. This was a full refresh of the Mozilla bundle, so Entrust, QuoVadis and several older DigiCert roots left the file in the same change, and the notice names intermediates rather than roots. On 19.5.3 a copy of roots.pem inside the bundled gRPC gem still had 12 emSign matches; the 10 November changelog lists a change to use the system CA bundle for gRPC default roots. If your own services chain to an Entrust or old DigiCert root, test them against the upgraded server before you call the change done.
Pinning GitLab Runner to 19.5.1
Runner has its own package repository. Add it on each runner host, then check which builds it offers:
curl -fsSL https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh | sudo bash
apt-cache madison gitlab-runner | head -n 4
Our Ubuntu 26.04 runner host saw four 19.5 builds. A Runner 19.5.2 exists even though the server skipped that number, so don’t let the server’s gaps guide you here:
gitlab-runner | 19.5.3-1 | https://packages.gitlab.com/runner/gitlab-runner/ubuntu resolute/main amd64 Packages
gitlab-runner | 19.5.2-1 | https://packages.gitlab.com/runner/gitlab-runner/ubuntu resolute/main amd64 Packages
gitlab-runner | 19.5.1-1 | https://packages.gitlab.com/runner/gitlab-runner/ubuntu resolute/main amd64 Packages
gitlab-runner | 19.5.0-1 | https://packages.gitlab.com/runner/gitlab-runner/ubuntu resolute/main amd64 Packages
Our first install pinned only gitlab-runner=19.5.1-1, and apt refused it. The runner package depends on gitlab-runner-helper-images at exactly the same version, and apt won’t pick an older helper on its own:
gitlab-runner : Depends: gitlab-runner-helper-images (= 19.5.1-1) but it is not going to be installed
E: Unable to satisfy dependencies. Reached two conflicting assignments:
Pin both packages to the same version and the install goes through:
sudo apt-get install -y gitlab-runner=19.5.1-1 gitlab-runner-helper-images=19.5.1-1 #https://docs.gitlab.com/releases/patches/patch-release-gitlab-19-5-3-released/
gitlab-runner --version
The version check confirms the build the notice asks for, from the 19-5-stable branch:

The notice names Runner 19.5.1 specifically, and that is the build we tested. It also tells you to keep these components on their latest versions, so the newer 19.5.3 in the list is a reasonable choice, though we didn’t install it. We only ran the runner on Ubuntu. If dnf on a RHEL family host reports the same dependency, the same fix should apply: name gitlab-runner and gitlab-runner-helper-images at one version in a single install. For runners that run as containers, the gitlab/gitlab-runner image on Docker Hub carries v19.5.1, alpine-v19.5.1, ubuntu-v19.5.1 and alpine3.21-v19.5.1 tags, all pushed on 22 October, so change the tag in your Compose file or Helm values.
Rebuilding CI images and the AI Gateway
The CI image step only matters for images you build yourself that install ca-certificates from a distro repository. Rebuild them with --pull so the base layer and the package both come fresh, push them, and let new pipelines pick them up. Images that inherit the trust store from an upstream base just need that base updated. The AI Gateway applies only if you self-host it for GitLab Duo. GitLab.com and Dedicated customers have nothing to do there. We don’t run a self-managed AI Gateway in the lab, so we can’t show the upgrade. Check its version against the minimums in the list above and follow the gateway’s own install method.
Checking logs for exploitation attempts
Patching closes the hole, but it doesn’t tell you whether someone used it first. GitLab’s security team published two detections for this bug, and both read logs an Omnibus server already writes. Neither one can clear you, though. GitLab says a successful attack can be quiet and leave no crash, so treat a clean result as “nothing obvious”, not “nothing happened”. The checks below cover the three traces you can search with standard tools. You’ll need jq on the server (sudo apt-get install -y jq or sudo dnf install -y jq):
- Puma crash reports in
/var/log/gitlab/puma/puma_stderr.log - Org-mode render timeouts in
/var/log/gitlab/gitlab-rails/exceptions_json.log - The payload itself, a
.orgfile with an oversized#+TODO:line in some repository
A crash during an attempt makes Ruby write a [BUG] report whose backtrace runs through org-ruby or Onigmo functions. Run the search through sh -c so the glob expands as root and also picks up rotated, compressed logs:
sudo sh -c 'zgrep -h -A40 "\[BUG\]" /var/log/gitlab/puma/puma_stderr.log*' | grep -E 'org-ruby|onig_compile|onig_search|match_at|compile_tree'
No output is the result you want. A hit shows lines such as org-ruby/headline.rb:100:in `parse_keywords' or ruby(match_at+0x26f0 ...) from GitLab’s published samples.
GitLab describes the attack as a noisy grind in which most attempts don’t land cleanly. Many of them push the renderer past its time limit, and each timeout lands in the exceptions log as a Timeout::Error from the OtherMarkup class on a .org file. The log starts with a plain-text header line, so filter the JSON lines before handing them to jq:
sudo sh -c 'zgrep -h "\"OtherMarkup\"" /var/log/gitlab/gitlab-rails/exceptions_json.log*' | jq -c 'select(."exception.class" == "Timeout::Error" and (."extra.file_name" // "" | endswith(".org"))) | {time, client: ."meta.client_id", ip: ."meta.remote_ip", project: ."meta.project", file: ."extra.file_name"}'
One or two timeouts on a huge document can be legitimate. GitLab’s rule fires at five or more from the same meta.client_id within 30 minutes. On Docker the same files are under the host volume, /srv/gitlab/logs in our Compose layout. GitLab’s notes name two more signals worth adding to a SIEM: a 502 from Workhorse on a .org blob URL (the request that crashes a worker never reaches the Rails logs), and a Projects::BlobController#preview request in production_json.log whose file_path ends in .org while the URL points at a different file. The Org-mode detection write-up has the Sigma rules for all of them.
The third check looks for the payload itself. Real Org files keep their #+TODO: keywords short, so a line thousands of characters long has no business being there. A clean scan only covers committed files, though: GitLab notes that the editor preview can force the Org renderer onto text that is never saved, which is why the log checks above still matter. This script maps GitLab’s hashed storage paths to project names through the database, then searches every branch and tag of every project and wiki. Create it on the GitLab server:
sudo vim /usr/local/sbin/org-todo-scan.sh
Paste the script exactly as we ran it:
#!/bin/bash
# List .org files whose #+TODO line is longer than MAX characters, on every branch and tag of every project and wiki.
MAX=${MAX:-500}
GIT=/opt/gitlab/embedded/bin/git
ASGIT="/opt/gitlab/embedded/bin/chpst -u git"
ROOT=/var/opt/gitlab/git-data/repositories
gitlab-psql -At -F ' ' -c "select pr.disk_path, r.path from project_repositories pr join routes r on r.source_id = pr.project_id and r.source_type = 'Project'" |
while read -r disk name; do
for repo in "$ROOT/$disk.git" "$ROOT/$disk.wiki.git"; do
[ -d "$repo" ] || continue
revs=$($ASGIT $GIT --git-dir="$repo" for-each-ref --format='%(objectname)' refs/heads refs/tags | sort -u)
[ -n "$revs" ] || continue
$ASGIT $GIT --git-dir="$repo" grep -I -E '^#\+(SEQ_|TYP_)?TODO:' $revs -- '*.org' 2>/dev/null |
awk -v max="$MAX" -v name="$name${repo##*$disk}" -F: 'length($0) > max { print name ": " $2 " (" length($0) " chars)" }'
done
done | sort -u
Make it executable and run it as root:
sudo chmod 0755 /usr/local/sbin/org-todo-scan.sh
sudo /usr/local/sbin/org-todo-scan.sh
To test it, we committed a harmless file whose TODO keyword was 6,000 plain letters, alongside a normal on-call runbook in another project. The script flagged only the planted file, in 0.26 seconds across our three projects:
root/release-notes.git: docs/odd.org (6069 chars)
The same script runs inside the official Docker image without changes: sudo docker exec -i gitlab bash -s < /usr/local/sbin/org-todo-scan.sh. It assumes the default single-node layout, with repositories in hashed storage under /var/opt/gitlab/git-data/repositories. On a custom git_data_dirs path, a separate Gitaly node or Gitaly Cluster it finds nothing and stays silent, so empty output there proves nothing. It also skips snippet repositories and group wikis. If anything turns up, check who committed the file and when, keep the logs, and treat the server as compromised. That means rotating runner tokens, personal and project access tokens, deploy keys and every CI/CD variable, and reviewing the admin accounts.
Reducing exposure if you cannot patch today
No setting turns off the Org-mode renderer, so nothing short of the patch removes the bug. You can make it much harder to reach, because an unauthenticated attacker needs a public project, and an authenticated one needs an account. Start by seeing what an anonymous visitor sees. This request carries no token on purpose:
curl -s "${GITLAB_URL}/api/v4/projects?visibility=public&per_page=100" | jq -r '.[].path_with_namespace'
Our test server listed both of its public projects to the anonymous request:
root/release-notes
root/team-handbook
Then close sign-ups and stop anyone creating new public projects. The settings API needs an administrator’s token with the full api scope (plus the admin_mode scope if your instance has Admin Mode turned on), so re-export GITLAB_TOKEN with one before running the next three commands:
curl -s -X PUT -H "PRIVATE-TOKEN: ${GITLAB_TOKEN}" "${GITLAB_URL}/api/v4/application/settings?signup_enabled=false&restricted_visibility_levels[]=public" | jq -c '{signup_enabled, restricted_visibility_levels}'
The response confirms both settings:
{"signup_enabled":false,"restricted_visibility_levels":["public"]}
If you run that call with the read_api token from the version check, it fails with {"error":"insufficient_scope","error_description":"The request requires higher privileges than provided by the access token.","scope":"api read_api"} and changes nothing.
This is the part that catches people out: restricting the Public level doesn’t change projects that are already public. Our anonymous request still listed both projects after the setting changed. Each one has to be switched to internal. This loop does that for up to 100 public projects per run and keeps a list of what it changed in changed-projects.txt; run it again until the anonymous check comes back empty:
curl -s -H "PRIVATE-TOKEN: ${GITLAB_TOKEN}" "${GITLAB_URL}/api/v4/projects?visibility=public&per_page=100" | jq -r '.[].id' | while read -r id; do curl -s -X PUT -H "PRIVATE-TOKEN: ${GITLAB_TOKEN}" "${GITLAB_URL}/api/v4/projects/${id}?visibility=internal" | jq -r '[.path_with_namespace, .visibility] | join(" ")'; done | tee -a changed-projects.txt
Each project reports its new visibility, and the anonymous request now comes back empty:
root/release-notes internal
root/team-handbook internal
Keep changed-projects.txt so you can make those projects public again after patching. Public snippets aren’t touched by any of this, and a snippet can hold an .org file too, so list them with the admin token:
curl -s -H "PRIVATE-TOKEN: ${GITLAB_TOKEN}" "${GITLAB_URL}/api/v4/snippets/public?per_page=100" | jq -r '.[] | [.id, .title, .web_url] | join(" ")'
Our test server had one public snippet, which we created for this check:
1 notes http://git01.example.lan/-/snippets/1
Switch any you don’t need public to internal in the snippet’s settings. The same settings are in the Admin area if you prefer the UI, and our older guide on disabling sign-up on the GitLab welcome page walks through that screen. If the server only serves your own team, putting it behind a VPN or an IP allowlist removes the anonymous path completely. These measures buy you hours, not weeks: every logged-in user can still open an .org file, so patch at the first window you get.
Keeping GitLab patched
GitLab shipped four CE/EE patch releases in a month (12, 21 and 29 October, then 10 November), and a server patched on 21 October was already two builds behind by mid November. The teams who got caught by this RCE had treated 12 October as done. Scheduled patches land on the second and fourth Wednesdays, so a release on any other day deserves a same-day read of its notice. A small team can keep up with four habits:
- the patch release feed in your reader or chat
- your own copy of
gitlab-secrets.jsonandgitlab.rb - a pinned patch build for your branch on every upgrade
- an alert on bursts in
exceptions_json.log
The secrets copy matters because the automatic preinstall backup covers only the database, and GitLab says so in the output. A restore without gitlab-secrets.json leaves every encrypted CI variable and token unreadable. Pinning keeps an emergency patch from turning into a minor upgrade, and the exceptions log is the one place this bug left render timeouts, so a sudden burst from one IP deserves a look whatever the exception class.
If the instance also runs your CI, the runner tokens are among the secrets this bug exposes. A compromise check therefore covers the runners as well, and our GitLab Runner setup guide shows how a runner is registered and where its token lives. The PHP flaw from the same week follows the same check, patch and verify routine in our PHP2Shell check and patch guide.