Skip to main content
Systems Engineering

Patch Self-Hosted GitHub Actions Runners for the NoisyTCP Linux Kernel Flaw (CVE-2026-99288)

NoisyTCP (CVE-2026-99288) can panic any Linux host with a reachable TCP listener. Self-hosted GitHub Actions runners are yours to patch: inventory kernels, drain and reboot one runner at a time, and use the SYN cookie stopgap where Ubuntu has no fix yet.

Vibrant close-up of code displayed on a monitor with various programming details.

CVE-2026-99288, published as NoisyTCP, is a race in the Linux kernel’s TCP established-socket lookup. An unauthenticated attacker who can send TCP packets to any listening port can use it to panic the kernel, on hosts with two or more receive queues or with RPS spreading packets across CPUs. GitHub looks after its own hosted runners. Self-hosted Linux runners are yours: install a kernel that carries the fix (upstream 6.12.117, 6.18.63 or 7.3.4, Debian trixie 6.12.117-1, Debian bookworm 6.1.192-2), and reboot one runner at a time, stopping the runner service only after its current job has finished. On 19 November Ubuntu still listed its releases from 16.04 LTS to 26.10 as vulnerable. Where no fixed kernel exists yet, set net.ipv4.tcp_syncookies to 0 in every network namespace as a stopgap, accept weaker SYN flood protection while it is in place, and put it back once the fixed kernel is running.

#Why this flaw lands on your self-hosted runners

GitHub’s documentation splits the work cleanly. When you use a GitHub-hosted runner, machine maintenance and upgrades are taken care of for you, and apart from single-CPU runners each job gets a new virtual machine. A self-hosted runner is a system you deploy and manage, and GitHub says plainly that you are responsible for updating the operating system and all other software on it. Only the runner application updates itself. So a kernel flaw in the TCP stack lands on your patch list for every Linux machine registered as a runner, whether it sits at repository, organisation or enterprise level.

The flaw needs very little from the target. In the researcher’s advisory, a host that does nothing more than call listen() is enough, and the examples given are Nginx, Apache and SSH in their default configuration. On virtual machines where vCPU preemption happens, the advisory reports a crash after between about 5 seconds and 2 minutes. On a quiet bare-metal server with 8 receive queues it took about 14 hours with a carefully tuned proof of concept. The researcher says the second path, a use-after-free, is hard to hit and the flaw is not, so far, remote code execution. Treat it as a practical remote denial of service, quickest against virtual machines.

Runner hosts often carry listeners: SSH for administration, service containers a job starts, a cache. The advisory points out that when the panic is triggered through a containerised service, the whole host goes down, not just the container. On a runner, that means every job on the machine fails at once. There is also the inside route. GitHub warns that self-hosted runners can be persistently compromised by untrusted code in a workflow and should almost never serve public repositories. Our inference is that a job from an untrusted pull request on such a runner is a convenient place to send crafted packets to other Linux hosts on the same network, so patching the runners and patching what they can reach belong in the same change.

#Under the hood of the lookup race

The kernel’s own description of the fix explains the mechanism. TCP lookups in the established hash table are lockless, and the socket caches involved use SLAB_TYPESAFE_BY_RCU, so memory can be reused while a reader still holds an old address. After a tuple match, __inet_lookup_established() and its IPv6 counterpart take a reference and check the tuple again, but they never check whether the object they now hold is hashed. If the slot has been reused by a new socket with the same tuple, the lookup returns that new object.

In the reproduced crash the new object is a request socket rebuilt from a SYN cookie. It is unhashed and has a NULL rsk_listener, and tcp_v4_rcv() then reads through that NULL pointer in interrupt context, which ends in “Kernel panic – not syncing: Fatal exception in interrupt”. The fix makes both lookups drop the reference and restart when the socket is unhashed or the tuple no longer matches.

Two conditions shape the mitigations. The race needs two receive contexts working at once, which is why the advisory says it applies to servers with two or more RX queues or with RPS enabled, and the attacker uses the difference in receive hash between IPv4 fragments and ordinary TCP packets to split the work. And the reliable path goes through SYN cookies, which most distributions enable by default. The kernel documentation gives tcp_syncookies a default of 1: a fallback that sends cookies when a socket’s SYN backlog overflows.

The bug arrived with commit 079096f103fa in October 2015 and is fixed by 4e2b3ef19e0e, dated 3 November 2026, with backports to the stable trees. The OSV record lists fixed upstream releases of 6.12.117 for kernels from 4.4, 6.18.63 for 6.13 onwards and 7.3.4 for 6.19 onwards. Distribution kernels carry their own version numbers, so check your distribution’s tracker rather than comparing uname -r with upstream numbers.

Detailed shot of Ethernet cables connected to server ports highlighting technology infrastructure.
Photo by Brett Sayles on Pexels

#Rolling it out one runner at a time

The rollout is a drain, patch and return loop, one runner at a time, so the pool keeps enough capacity to keep queues moving. If your runners are packed tightly, the arithmetic in our guide to bin-packing CI jobs across runner fleets is a quick way to see how many machines you can take out together.

Rendering diagram...

Start with an inventory. In the repository or organisation settings, open Actions, then Runners, to see every self-hosted runner and its labels. Then, on each Linux runner, record what is actually running:

1uname -r
2uname -v
3dpkg-query -W 'linux-image-*'
4sudo sysctl net.ipv4.tcp_syncookies
5sudo ethtool -l eth0

uname -r and uname -v print the kernel release and version. On Debian and Ubuntu, dpkg-query -W prints each installed kernel package with its version, which is what the trackers compare against. The sysctl line should show net.ipv4.tcp_syncookies = 1 on a default system, and ethtool -l shows how many channels the interface has, where a channel is an IRQ and the queues that can trigger it. Use your real interface name in place of eth0.

If you would rather collect this through Actions itself, give each runner a unique custom label and run a manually triggered, read-only job against each one. When runs-on is an array, a job runs only on a runner that has all of the labels, and setting fail-fast to false stops one failed job from cancelling the rest of the matrix. The job reads the setting straight from /proc/sys, which is where sysctl gets it, so it needs no root:

1name: runner-kernel-inventory
2on: workflow_dispatch
3permissions: {}
4jobs:
5  kernel:
6    strategy:
7      fail-fast: false
8      matrix:
9        runner: [build-01, build-02, build-03]
10    runs-on: [self-hosted, linux, "${{ matrix.runner }}"]
11    steps:
12      - run: |
13          uname -r
14          uname -v
15          cat /proc/sys/net/ipv4/tcp_syncookies

Then compare each result with the tracker for its distribution. On 20 November the Debian tracker showed bookworm fixed in 6.1.192-2 from the security archive and trixie fixed in 6.12.117-1, the version DSA-6628-1 shipped on 13 November. Ubuntu’s page, last updated 19 November, rated the issue High priority and listed the linux package as vulnerable on every release it showed from 16.04 LTS to 26.10, so Ubuntu runners have no fixed kernel to install yet.

For each runner with a fixed kernel available:

  1. Take a backup you can return to: a snapshot if the runner is a virtual machine, or confirm the current kernel package stays installed alongside the new one so it remains bootable.
  2. Check the runner is idle. In the runner’s directory, sudo ./svc.sh status shows the service, and sudo journalctl -u actions.runner.<org>-<repo>.<runnerName>.service should end with a “Job … completed” line. If the last line is “Running job”, wait for it to finish.
  3. Stop the runner with sudo ./svc.sh stop. GitHub keeps it registered in an Offline state and sends it no jobs until the service starts again.
  4. Install the kernel update through your normal package channel and reboot.
  5. After the reboot, run the inventory commands again, then sudo ./svc.sh start if the service did not start at boot.

Do the first runner alone and let it take real jobs before moving on. Ephemeral or just-in-time runners built from a template need the template patched and the machines replaced; larger runners on custom images need the image rebuilt.

Where no fixed kernel exists yet, the advisory offers two stopgaps. The first disables SYN cookies:

1sudo sysctl -n net.ipv4.tcp_syncookies
2sudo sysctl -w net.ipv4.tcp_syncookies=0

Record the first command’s output before you change anything. The setting is per network namespace, so a host-level change does not reach containers with their own namespace, including service containers a job starts; each needs the same value. To survive a reboot, put the setting in a file under /etc/sysctl.d/. The cost is real: with cookies off, a socket whose SYN backlog overflows has no fallback, so the host is easier to SYN flood. The second stopgap reduces the receiving interface to a single RX queue and disables RPS and RFS. It blocks the race but gives up receive parallelism, so on a busy build host treat it as a last resort.

#Checking it worked on each runner

A runner counts as done only when all of these hold:

  • dpkg-query -W 'linux-image-*' shows the fixed version from the tracker, and uname -r shows that kernel is the one running, not just installed.
  • The runner shows as Idle under Settings, Actions, Runners, and its journal shows “Connected to GitHub” followed by “Listening for Jobs”.
  • A real job, or the inventory workflow above, completes on it.
  • If you disabled SYN cookies there earlier, sysctl net.ipv4.tcp_syncookies is back to 1 in every namespace and the /etc/sysctl.d/ file is gone.

On a runner still waiting for its distribution’s fix, check instead that tcp_syncookies reads 0 on the host and inside each long-running container, and that the value survives a reboot.

#What goes wrong during the rollout

The most common self-inflicted failure is stopping the service while a job is running, which fails that job. Read the journal first. A quieter one comes from needrestart on Debian-based systems, which can restart the runner service in the middle of a job after a package upgrade. GitHub documents a one-line configuration that tells needrestart to leave the runner service alone:

echo '$nrconf{override_rc}{qr(^actions\.runner\..+\.service$)} = 0;' | sudo tee /etc/needrestart/conf.d/actions_runner_services.conf

Do not leave a stopped runner parked for long. GitHub removes a self-hosted runner that has not connected for more than 14 days, and an ephemeral runner after more than 1 day, so a runner left Offline while you wait for a vendor kernel will need registering again. If that happens, GitHub’s documented shortcut is to delete the .runner file in the runner application directory, which lets the machine register again without downloading the application.

A mitigation applied only on the host is the other trap. The service containers that run beside a job may have their own network namespace and keep the default of 1. And if a runner host also exposes the Docker socket to jobs, as described in fixing permission denied on docker.sock in GitHub Actions, a job can start its own containers, each of which may get a new network namespace at the default of 1, so the stopgap only holds where you control every container that starts.

Close-up of a computer monitor displaying cyber security data and code, indicative of system hacking or programming.
Photo by Tima Miroshnichenko on Pexels

#Permissions on the runners during the fix

Removing a runner from a user repository needs the repository owner; for an organisation, its owners can remove repository and organisation runners. Stopping and starting the service needs root on the machine, because svc.sh runs under sudo. Keep the patch work with the people who already hold those rights, rather than widening them to speed things up. Use runner groups to restrict which repositories can schedule onto the runners you have not patched yet. Move any public repository off self-hosted runners entirely, as GitHub advises, so untrusted pull requests never run on machines inside your network, patched or not.

#Backing out a kernel or sysctl change

If the new kernel will not boot or breaks a driver, return to the snapshot, or pick the previous kernel from the boot menu if you kept it installed, and leave the runner service stopped until you know why. Then apply the SYN cookie stopgap to that runner while you investigate, because going back to the old kernel puts the flaw back. To undo the stopgap, run sudo sysctl -w net.ipv4.tcp_syncookies=1, or the value you recorded, in each namespace you changed, and delete the file you added under /etc/sysctl.d/. If you changed RX queues, restore the channel count that ethtool -l showed before.

#Where the fleet stands when you finish

At the end of the first pass, every Debian runner should be on a fixed kernel, every Ubuntu runner should have SYN cookies off in each namespace with a note of when to undo it, and any runner that could not be changed should be out of the groups that untrusted repositories can use. Check the Ubuntu CVE page and your distribution’s tracker until the fixed kernel ships, then run the same drain and patch loop on the remaining runners and remove the stopgap from each. If you roll changes like this through a gated pipeline, the approach in deterministic rollout gating for progressive delivery fits the one-runner-first pattern. Then decide whether long-lived runners should become ephemeral, so the next kernel fix means rebuilding one image.

About this page

Credited to

Dates

Published

Sources

This page lists no external sources.

Corrections

No corrections are listed for this page. Some review sweeps corrected pages without naming each one; those are in the corrections log.

Reader Interaction

Comments

Add a thoughtful note on Patch Self-Hosted GitHub Actions Runners for the NoisyTCP Linux Kernel Flaw (CVE-2026-99288). Comments are checked for spam and held for moderation before appearing.

Loading comments...

Discover more

Was this useful?

Reports go to the site owner and are used to correct pages. Corrections are listed at /corrections.

Engineering insights, direct to you.

Receive the latest Systems Engineering tutorials, production guides, Engineering Labs and operational best practices.