An Updated Version Is Not a Patched Runtime

After a critical GitLab fix was released, Alpine Linux upgraded its GitLab server twice. The first upgrade went to the wrong version. The second went to the right version and still left the vulnerability in place, because the fix lived in a component Alpine's own image did not carry. The record said the server had been upgraded. What was actually running had not changed where it mattered.

Alpine Linux upgraded its GitLab server twice after a critical fix was released, and the vulnerability survived both. The first upgrade went to a version without the fix. The second went to a version number that had it, but the fix was a patch to the Ruby that GitLab bundles in its own packages, and Alpine’s image ran standard Ruby. This piece reads one distinction inside that sequence: a completed update is a fact about what was installed, while a removed vulnerability is a fact about what is actually running. The second establishes whether the vulnerability is gone. Neither, on its own, establishes whether the server is fit to reopen.

Two upgrades, one vulnerability still open

CVE-2026-97229 is a critical flaw, rated CVSS 10.0, in how GitLab evaluates regular expressions in CI configuration. The underlying bug is in Onigmo, the regular-expression engine built into Ruby. GitLab released fixed versions on October 12, 2026. According to Alpine’s incident report, the fix itself is a set of patches to the Ruby that GitLab ships inside its official packages and container images. Upstream Ruby released its own fix on October 23.

On October 13, the day the CVE was published, Alpine upgraded its GitLab instance to 19.3.4. The release that carried the fix was 19.3.5. Alpine’s report calls this a mistake.

On October 20 and 21, a newly registered account sent crafted CI configurations to the instance, which was still on 19.3.4. GitLab worker processes crashed eight times; in four of those, according to the report, the attacker got partway through the exploit and failed at the next step. The attacker also downloaded Alpine’s GitLab container image.

On October 22, Alpine upgraded to 19.3.6. That did not fix the vulnerability. Alpine’s image used standard Ruby rather than GitLab’s bundled build, so the Ruby patch never arrived. On October 26, Alpine found the instance still vulnerable. On October 27 it closed GitLab to everyone except developers and build servers and began rebuilding it. On October 28 the rebuild was complete, all passwords were reset and GitLab’s secret keys were replaced. GitLab reopened on October 29, on 19.3.7, running a Ruby that includes the fix.

Why “we upgraded” reads like “we are fixed”

Most remediation is tracked by version. An advisory names the fixed release; the operator installs that release or a later one; the version string on the server is compared with the advisory, and the item is closed. For software installed from the vendor’s own packages, that comparison is usually a good proxy. The vendor builds the fix into the release, and installing the release installs the fix.

That reading is reasonable, and for most installations it holds. This case shows the conditions under which it does not.

Three states that are easy to merge

The sequence separates three states that a single status line tends to merge.

The first is the update has been performed. A new version was installed. That is a record of an action, and on October 22 it was true.

The second is the vulnerable component has been fixed. The code path the vulnerability depends on now runs the corrected version. For this CVE that component was Ruby’s regular-expression engine, not GitLab’s own code. On October 22 the first state was true and the second was not.

The third is the system is fit to be open now. That depends on the second state, and also on whatever happened while the system was exposed. It is a judgment about the present, made with whatever evidence is still available.

The version number was evidence of the first state. It was taken as evidence of the second because, in the vendor’s own packaging, the two travel together. In Alpine’s own image they did not. Nothing in the version string could show that, because the version string describes GitLab, and the fix was in something GitLab sat on.

Alpine’s own list of changes names the gap directly: apply critical GitLab security releases within a day, and check each release for Ruby or other component patches that its own build must apply. The second half of that sentence is the check that connects the record of an update to the state of the runtime.

When the evidence is gone, the question stays open

The rebuild follows the same line of reasoning one step further.

Alpine found no evidence that the attacker’s code ran. Timing probes showed no delays, and it found no unexpected files, keys, hooks or processes. It also explains why that is not the same as knowing nothing ran: a successful exploit would leave no crash and no trace in the web logs, some logs from the attack day were gone, and there was no logging of outbound network connections.

So the answer to “was this server compromised?” was neither yes nor no. It was unknown, and the evidence that could have resolved it no longer existed. Alpine’s report states the decision plainly: because it could not rule out code execution, it treated the instance as compromised and rebuilt it from scratch.

That is the same distinction applied to a different question. “We found nothing” is a fact about the search. Whether the system is fit to reopen is a fact about the system. When the first cannot settle the second, the open question has to be closed some other way, and Alpine closed it by replacing the system rather than vouching for it.

A rebuild is not the only possible answer to an unresolved question like this one. It is the conservative answer Alpine chose, given lost logs and a vulnerability that left little trace. The point is not that every uncertainty calls for a rebuild. It is that the uncertainty had to be answered by a decision, and could not be answered by the absence of findings.

What this case does not show

It does not show that the attack succeeded. Alpine’s report says it found no evidence of that and cannot rule it out, and this piece does not go further than the report.

It does not show that any packages or releases were affected. Alpine verified the aports commits from October 20 to 22 and the packages built from October 20 to 24 against records outside GitLab, and reports no tampering. It states that its package and release signing keys were never on the GitLab server, and it is extending the same checks to October 27.

It does not explain why the remaining exposure went unnoticed from October 22 to October 26. The report gives the date of discovery, not the internal sequence that led to it.

It does not show that version tracking is wrong in general. For installations built from the vendor’s own packages, the version is usually a reliable signal. The gap appears when the runtime is assembled differently from the package the fix was written for.

Where the check belongs

Any operator that builds its own images, compiles from source, or runs a vendor’s software on its own base layers is in the position Alpine was in. The vendor’s advisory describes the vendor’s packaging. The operator’s runtime may not match it.

The useful question at the point of reopening is not “which version is installed?” It is “does the component this vulnerability lives in, as it runs here, contain the fix?” And when an exposure window has passed and the evidence is incomplete, there is a second question: is the system fit to be open now, given what can and cannot still be known about that window?

The proposition

An update is an action recorded against a version. A fix is a property of the runtime. They coincide when the installed runtime actually contains the required fix — not merely when its version matches the vendor’s fixed release.

An updated version tells you what was installed. Whether the vulnerability is gone is a question about what is running, and whether to reopen is a question about what can still be known.


Source note. This piece draws on Alpine Linux’s incident report, GitLab security incident: attempted exploitation of CVE-2026-97229 (posted October 28, 2026, updated October 30, 2026), including its timeline, its account of what was and was not found, and its list of changes. Version numbers, dates and the description of the Ruby patch come from that report. Contemporaneous reporting by The Hacker News was consulted for context. This piece has not independently verified the technical details. The execution-boundary reading is FO Lens’s.

Related

The essay as a webtoon

Twelve-panel FO Lens webtoon for Cases 38. Alpine Linux upgraded GitLab to 19.3.4 when the fix was in 19.3.5, then to 19.3.6, but its own image ran standard Ruby without the patch; attack attempts crashed workers; no evidence the attack succeeded, but incomplete logs meant it could not be ruled out, so Alpine rebuilt the server and reopened on 19.3.7 with a fixed Ruby. A version shows what was installed; whether it is fixed depends on what is running.
FO Lens Cases 38. A summary of the essay above, which remains the reference text. Select the image to open it at full size.

The same characters also star in a daily-life webtoon, Rurun Clocks In.