BuyRDPs.
Linux kernel CVE-2026-98276 patching a VPS server in a data center

Patch the Linux Kernel on Your VPS: CVE-2026-98276 (UDP Socket Flaw)

Linux kernel CVE-2026-98276 is the kind of bug that sounds boring until you read what it actually does: any ordinary user account on your VPS can crash the kernel or, on Red Hat family systems, get root. No password guessing, no open port, no phishing link — just a local account running a program. The fix has been out for weeks, it installs with a normal package update, and the only real work is a reboot. If your VPS runs Linux and you have not patched the kernel since early November, this is the one update to do today.

This guide covers what the flaw is, who is actually at risk, the exact fixed kernel versions for Ubuntu, Debian, AlmaLinux and Rocky Linux, and the step-by-step commands to patch and verify on each of them. It also covers the awkward cases: RHEL users still waiting on a Red Hat kernel, container-based VPS plans where you cannot patch the kernel yourself, and how to patch without a reboot if downtime is not an option.

What Is Linux Kernel CVE-2026-98276?

CVE-2026-98276 is a use-after-free bug in the Linux kernel’s UDP socket code, published by the kernel CVE team on 6 October 2026. It was reported by Jungwoo Lee and Wongi Lee, and the upstream fix was written by kernel networking maintainer Eric Dumazet as commit 9ed55f3dbef4, titled “net: lock the socket in sock_gettstamp()”. The fix shipped in mainline stable kernel 6.6.158 and was backported to the stable branches from there.

The two severity scores tell you something honest about this bug. The Linux kernel CVE team scores it CVSS 7.8 (High). Red Hat scores it 7.0 (Moderate), judging the race hard to win reliably. Both scores describe the same flaw; the difference is how confident each team is that an attacker can win the race every time. TuxCare settled the argument on the practical side: it built a working root exploit from code recovered from a crashed server and confirmed privilege escalation on Enterprise Linux 8, 9 and 10. On EL 7 the same exploit only crashes the machine. So treat the “moderate” label with suspicion — on most VPS distros this is a local-root bug, not just a crash.

Three facts frame everything else in this guide. First, the bug is local only: an attacker needs an account that can run code on your server. It cannot be triggered by network traffic alone. Second, there is no practical workaround — no sysctl to flip, no firewall rule, no module to block, because the trigger is an ordinary ioctl on an ordinary UDP socket. Third, the bug has been present since the start of the kernel’s git history (2.6.12), which means just about every Linux VPS ever shipped was running vulnerable code until the November patches landed.

How the Bug Works (Without the Jargon)

Every socket in the kernel carries a word of flag bits, and changing one of those bits is a read-modify-write of the whole word. The kernel’s rule is simple: only change those bits while holding the socket lock, or two CPUs can read the same old value, each set their own bit, and whichever writes last silently undoes the other. One place broke that rule.

The SIOCGSTAMP family of ioctls — the calls an application uses to ask when a packet arrived — turns on packet timestamping for a socket the first time it is called, and it did so without taking the socket lock. Meanwhile, when a UDP socket is bound to a port, the kernel marks it with a flag that says “free this socket only after a grace period”, because the UDP receive path looks sockets up without taking any lock and relies on that delay to stay safe.

If the timestamp ioctl races with bind() on the same socket, the ioctl’s unlocked write can wipe out that grace-period flag. The socket is then freed immediately when it is closed, while the receive path may still be holding a pointer to it. That is the use-after-free: the kernel keeps using memory it has already handed back. Depending on what lands in that memory next, the result is a kernel crash or — as TuxCare demonstrated — code running with kernel privileges, which is root.

You do not need to remember any of that to patch it. What matters is the shape of the risk: the attacker needs to run code on your box, and the code is a small program racing two ordinary system calls against each other. That is a low bar, and it is why “local only” should not make you relax.

Who Is Actually at Risk on a VPS?

Not every VPS is equally exposed, and the honest answer depends on who else can run code on your machine. Here is how to think about it:

Your setup Risk level Why
Shared hosting / reseller VPS with customer accounts Patch today Untrusted users already run code on the box — this is exactly the exposure the bug needs
VPS running containers or user-supplied code (CI runners, Docker hosts, build machines) Patch today Any container escape-adjacent local account, or any job that runs untrusted code, can trigger it
VPS hosting a web app with file-upload or plugin features High An attacker who gets in through one vulnerable site counts as a local user — CloudLinux’s wording, and it is correct
Single-user VPS, only you have SSH, no untrusted code Moderate No local attacker exists yet — but one compromised web app changes that instantly, and the patch is free
Managed VPS where the provider owns the kernel Check with your provider You may not be able to patch at all — see the section on shared kernels below

The uncomfortable truth is that the “single-user, only me” case is the one most VPS owners assume they are in, and it is the one that quietly stops being true the moment a WordPress plugin, a web app, or an AI agent running on the server has a vulnerability. Our PHP2Shell patch guide from October covered exactly that kind of chain: a flaw in the application layer hands the attacker a local account, and then a kernel flaw turns that account into root. Kernel bugs like CVE-2026-98276 are the second half of that chain, and they are the half people forget to patch.

One more thing the bug cannot do: it cannot be triggered from the network. Nobody can crash your VPS by sending it a clever packet. If your server has no local accounts beyond your own and no service that runs other people’s code, the practical risk today is low — but the patch is still a ten-minute job, and “low risk today” is not a plan.

The Timeline: From Quiet Disclosure to Real Crashes

This flaw was not a zero-day. The fix was upstream and in the stable branches before anyone reported an attack. What changed in November is that the theoretical risk became a demonstrated one — and the distros moved at very different speeds.

Date (2026) What happened
6 Oct Kernel CVE team publishes CVE-2026-98276; upstream fix already in stable kernels
31 Oct ConoHa urges action on a second kernel flaw, CVE-2026-98432 — a reminder to patch the kernel, not just this CVE
4 Nov An exploit crashes a CloudLinux 8 server 12 times; only crashes seen on that server
6 Nov AlmaLinux ships patched kernels to its testing repository; Red Hat and AlmaLinux publish advisories
9 Nov TuxCare confirms privilege escalation on EL 8, 9 and 10; KernelCare rebootless patches reach production for EL 8/9 and Debian 12/13; Red Hat still has no fixed kernel
11 Nov AlmaLinux promotes the patched kernels to production — a plain dnf upgrade now fixes it
15 Nov ConoHa, XServer VPS and Shin VPS warn of a KUSANAGI HTTP header injection flaw, CVE-2026-117477, in Nginx-based setups — update those too
18 Nov ConoHa issues its advisory on CVE-2026-98276, telling Linux VPS customers to apply security updates and reboot
20 Nov Ubuntu updates its CVE tracker — fixed kernels confirmed for 22.04, 24.04 and 26.04

The lesson in that timeline is about speed, not panic. AlmaLinux shipped a fix ahead of its upstream within days; Red Hat, at the time of writing, had still not shipped one for RHEL. Ubuntu and Debian moved through their normal security updates. If your distro has a fixed kernel, install it. If it does not, the livepatch route in the sections below is your bridge — and if neither is available, limiting who can run code on the box is the only lever you have left.

Check If Your VPS Is Vulnerable

Before patching anything, find out what kernel you are actually running. It takes one command:

uname -r

That prints something like 6.8.0-148-generic or 5.14.0-687.66.1.el9_8.x86_64. The number before the first dash is the upstream kernel version; the rest is your distro’s build number, and that is the part that tells you whether the fix is in. Compare it against the fixed versions in the table in the next section. If your build number is lower than the fixed one for your release, you are vulnerable.

Two more checks are worth running while you are there. First, confirm which kernel you will boot into after a reboot, because the running kernel and the newest installed kernel are not always the same:

# Debian / Ubuntu
dpkg -l | grep linux-image

# RHEL / AlmaLinux / Rocky
rpm -q kernel

Second, check whether your VPS even runs its own kernel. On a container-based plan (OpenVZ, LXC), the kernel belongs to the host node, and uname -r shows the host’s kernel, not yours. You cannot patch that yourself — jump to the shared-kernel section near the end. On KVM, Xen or VMware, the kernel is yours and this guide applies directly. If you are not sure which you have, systemd-detect-virt will usually tell you.

Checking the Linux kernel version on a VPS terminal
One command tells you whether your VPS is running a vulnerable kernel.

Fixed Kernel Versions by Distro

The fix is already in the regular security updates for the distros most VPS owners run. Here are the versions to look for, verified against the vendors’ own trackers on 22 November 2026:

Distro / release Fixed kernel (or newer) How it arrives
Ubuntu 26.04 LTS 7.0.0-42.42 Regular apt upgrade
Ubuntu 24.04 LTS 6.8.0-149.149 Regular apt upgrade
Ubuntu 22.04 LTS 5.15.0-202.212 Regular apt upgrade
Ubuntu 20.04 LTS (HWE kernel) 5.15.0-202.212~20.04.1 HWE stack only — main 20.04 kernel still listed vulnerable
Debian 12 / 13 Fixed kernels in security updates Regular apt upgrade
AlmaLinux 8 kernel-4.18.0-553.184.2.el8_10 Production repos since 11 Nov
AlmaLinux 9 kernel-5.14.0-687.66.2.el9_8 Production repos since 11 Nov
AlmaLinux 10 kernel-6.12.0-211.74.2.el10_2 Production repos since 11 Nov
RHEL 8 / 9 / 10 No fixed kernel shipped yet (as of 9 Nov) KernelCare livepatch, or watch Red Hat’s CVE page
CloudLinux 7h / 8 / 9 / 10 Fixed kernels in staged rollout / stable channel Regular update, or KernelCare livepatch

A few notes on that table. Ubuntu 26.10 is not affected at all. Ubuntu 20.04’s main kernel is still listed as vulnerable on Canonical’s tracker — standard support for 20.04 has ended, so if you are still running it, the HWE kernel or an upgrade to 22.04 is your way out, not waiting for a fix that is not coming. And if your kernel is newer than the versions above, you already have the fix: the patched build is a floor, not an exact match. Anything equal to or higher than the listed version is fine.

For the full authoritative detail behind this table, the AlmaLinux advisory on CVE-2026-98276 is the best single source — it explains the bug, lists every fixed build, and is the post that documented the fix landing in production on 11 November.

Patch Ubuntu and Debian

On Ubuntu and Debian the fix is a normal security update. There is nothing special to install and no third-party repository to add — just update, upgrade, and reboot so the new kernel actually loads. A kernel update that never gets booted into is not a patch.

sudo apt update
sudo apt upgrade -y linux-image-generic linux-headers-generic
sudo reboot

If you would rather update everything at once, which is usually the right call on a VPS that has not been touched in a while, replace the second line with a full upgrade:

sudo apt update
sudo apt full-upgrade -y
sudo reboot

Before you reboot, check that the fixed kernel is actually installed and will be the one that boots. The package version should be at or above the fixed version for your release — 6.8.0-149.149 on Ubuntu 24.04, 5.15.0-202.212 on 22.04:

dpkg -l | grep linux-image-generic
# look for 6.8.0-149.149 (24.04) or 5.15.0-202.212 (22.04), or higher

# confirm the new kernel is the default boot entry
grep -E "menuentry|set default" /boot/grub/grub.cfg | head -5

Schedule the reboot for a quiet moment. It takes a minute or two on most VPS plans, and anything running on the server — your website, your apps, your cron jobs — will be down for that window. If you cannot afford even that, the livepatching section below has you covered. After the reboot, verify with uname -r as described in the verification section.

One Debian-specific note: Debian’s fixed kernels for 12 (Bookworm) and 13 (Trixie) come through the regular security updates, so the same apt update && apt full-upgrade flow applies. If you pin your kernel or hold packages with apt-mark hold, the upgrade will skip the kernel silently — check for held packages with apt-mark showhold before assuming you are patched.

Installing a patched Linux kernel on a VPS with apt upgrade
The fix is a normal package update — then a reboot to load the new kernel.

Patch AlmaLinux, Rocky Linux and RHEL

AlmaLinux users have the easiest path of anyone affected: the patched kernels have been in the production repositories since 11 November, so a plain upgrade does it. No testing repository, no special flags.

sudo dnf clean metadata
sudo dnf upgrade -y
sudo reboot

After the reboot, confirm the running kernel is at or above the fixed build for your release — 4.18.0-553.184.2.el8_10 on AlmaLinux 8, 5.14.0-687.66.2.el9_8 on 9, 6.12.0-211.74.2.el10_2 on 10:

uname -r
rpm -q kernel

Rocky Linux tracks RHEL’s kernel, so the same dnf upgrade flow applies — but whether the fix is in your repos depends on whether Rocky has shipped the backport yet, so verify the installed version against the AlmaLinux builds above rather than assuming the upgrade covered it. If the version is still below the fixed one, the KernelCare route below works on Rocky too.

RHEL itself is the awkward case. As of 9 November, Red Hat had still not shipped a fixed RHEL kernel for any of versions 8, 9 or 10, and listed no mitigation. That is a strange position for a paid enterprise distro to be in, and it is worth saying plainly: if you pay for RHEL on a VPS, you are currently relying on Red Hat to move, and the clock is ticking. Your options while you wait are the KernelCare livepatch in the next section, or migrating the workload to AlmaLinux or Rocky Linux, where the fix is already in production. Check Red Hat’s CVE page for CVE-2026-98276 before assuming the situation has not changed — this is the one part of this guide most likely to be out of date by the time you read it.

Patch Without Rebooting: Livepatching

A kernel patch only takes effect when the new kernel boots, and a reboot means downtime. If your VPS cannot go down — a busy store, a game server, a client site with no maintenance window — livepatching applies the fix to the running kernel without restarting anything. It is a bridge, not a replacement: you should still reboot into the fixed kernel at your next maintenance window. But it closes the hole today.

KernelCare is the option that covers this CVE most broadly. Its rebootless patches for CVE-2026-98276 are on the production feed for RHEL, AlmaLinux and CloudLinux 8 and 9, plus Debian 12 and 13, with EL 10 on the test feed. The commands are short:

# install the KernelCare patch for the running kernel
sudo kcarectl --update

# confirm this CVE is covered
sudo kcarectl --patch-info | grep 'CVE-2026-98276'

On EL 10 and CloudLinux 10, where the patch is still on the test feed, add --prefix test to the update command. If the grep returns a line for the CVE, the running kernel is patched — no reboot needed for the fix to be live.

Ubuntu users have a built-in alternative: Canonical Livepatch, which patches the running kernel on Ubuntu LTS releases. It is free for up to five machines with an Ubuntu Pro account, and it covers many kernel CVEs. Check whether your kernel is covered before relying on it — livepatch supports specific kernel flavours, and a VPS running a cloud or HWE kernel may or may not be eligible. Either way, livepatching buys you time; it does not remove the need to install the fixed kernel and reboot when you can.

Be honest with yourself about which of these you need. If your VPS hosts a personal blog and you can reboot at 3am, just reboot — it is simpler, it is permanent, and it costs you two minutes of downtime. Livepatching earns its keep on servers that genuinely cannot stop.

Verify the Patch Actually Took

Most patching failures are silent: the update ran, the reboot happened, and the old kernel is still running because the boot order picked it, or the upgrade never actually included the kernel package. Verify from the running system, not from your memory of running the command.

# 1. What kernel is actually running right now?
uname -r

# 2. Is it at or above the fixed version for your release?
# Ubuntu 24.04: 6.8.0-149.149 or higher
# Ubuntu 22.04: 5.15.0-202.212 or higher
# AlmaLinux 9: 5.14.0-687.66.2.el9_8 or higher

# 3. Did the system actually reboot into the new kernel?
uptime
last reboot | head -3

# 4. If you used KernelCare instead of rebooting:
sudo kcarectl --patch-info | grep 'CVE-2026-98276'

If uname -r still shows a version below the fixed one after a reboot, the usual culprits are: the upgrade never installed the new kernel (check for held packages), GRUB is booting an older entry (check grub.cfg and grubby --info=ALL on EL systems), or you are on a container-based VPS where the kernel is not yours to change. That last one deserves its own section.

What If Your VPS Shares the Host Kernel?

Here is the part of this story that catches people out. Not every VPS runs its own kernel. On KVM, Xen and VMware, it does — the kernel is yours, and everything in this guide applies. On container-based virtualisation — OpenVZ, Virtuozzo, LXC — every VPS on the node shares the host’s kernel. Your uname -r shows the host node’s kernel, and no command you run inside your container can change it.

If that is your setup, patching is your provider’s job, not yours. Ask them directly whether the host node has been patched for CVE-2026-98276, and ask for the host kernel version in writing. A provider that cannot answer that question is a provider to think twice about. ConoHa, for example, issued a public advisory on 18 November telling its Linux VPS customers to apply security updates and reboot — that is what a provider communicating properly looks like.

If your provider has not patched the host and will not say when it will, your real options are: limit who can run code on your VPS (the only mitigation that exists), or move to a KVM-based plan where the kernel is yours. That second option is not as drastic as it sounds — most budget VPS plans today are KVM, and the migration is usually a fresh server plus a data copy, which our new VPS setup checklist walks through. Staying on an unpatched shared kernel because moving is inconvenient is exactly how a local-root bug becomes a bad week.

How do you know which kind you have? Run systemd-detect-virt. If it prints kvm, xen or vmware, the kernel is yours. If it prints openvz, lxc or container, it is shared. If it prints nothing, you are likely on bare metal or a full VM — again, yours to patch.

Hardening to Do While You Are In There

You are already logged into the server with root, already thinking about security, and already planning a reboot. That is the cheapest moment to fix the three things that make kernel bugs like this one dangerous in the first place.

Turn on automatic security updates. The reason CVE-2026-98276 is still live on so many servers is not that the fix does not exist — it is that nobody installed it. On Ubuntu and Debian, unattended-upgrades with security updates enabled installs kernel updates as they land (you still need the reboot, but the package will be waiting). On AlmaLinux and Rocky, dnf-automatic with apply_updates = yes and the security filter does the same. Set it up now, while you remember why it matters.

Audit who can run code. This bug needs a local account. Every account on your server is a potential trigger — old developer accounts, service accounts with shells they do not need, a forgotten test user. List them with cat /etc/passwd | grep -E "sh$" and remove or lock anything that should not be there. The same logic applies to web applications: a site that lets visitors upload files or run code is a local account by another name.

Patch the rest of the stack at the same time. CVE-2026-98276 is not the only November flaw. The same ConoHa advisories that flagged it also covered CVE-2026-98432, another kernel flaw needing a reboot, and the KUSANAGI header injection flaw CVE-2026-117477 for Nginx-based setups. Run the full upgrade, not just the kernel — a kernel patch on a server with an unpatched web stack is a locked front door with the windows open. Our VPS security guide covers the full hardening pass, and the November RDP vulnerabilities post covers the Windows side of the same month’s patching.

FAQ

Can CVE-2026-98276 be exploited remotely over the internet?

No. It needs a local account that can run code on the server — an ordinary user creating a UDP socket and racing two system calls. It cannot be triggered by network traffic alone. That is genuinely reassuring, but it is not a reason to skip the patch: the moment any web app, plugin or service on your server is compromised, the attacker has exactly the local account this bug needs.

Do I have to reboot after patching?

Yes, unless you use a livepatch service. A kernel update installs the new kernel files, but the running kernel is the old one until the machine boots into the new one. KernelCare or Canonical Livepatch can apply this fix to the running kernel without a reboot, but you should still reboot into the fixed kernel at your next maintenance window.

My VPS is managed — is it already patched?

Maybe, but do not assume so. Managed providers patch on their own schedule, and kernel patches need reboots they may be waiting to coordinate with you. Ask your provider for the host kernel version, or check uname -r yourself and compare it with the fixed versions in the table above.

Does this affect Docker containers on my VPS?

Yes — containers share the host kernel, so a container escape is not even needed. Any process inside any container that can run code is a local user as far as this bug is concerned. Patch the host kernel and the containers are covered. The reverse is also true: patching inside a container does nothing, because there is no kernel inside a container to patch.

I run RHEL and there is no fixed kernel yet. What do I do?

Use KernelCare’s livepatch, which covers RHEL 8 and 9 on the production feed, while you wait for Red Hat. If you would rather not depend on a third-party patch feed, migrating the workload to AlmaLinux — where the fixed kernel has been in production since 11 November — is a real option, and AlmaLinux is binary-compatible with RHEL.

I am still on Ubuntu 20.04. Am I covered?

Only if you run the HWE kernel, which is fixed in 5.15.0-202.212~20.04.1. The main 20.04 kernel is still listed as vulnerable on Ubuntu’s tracker, and standard support for 20.04 has ended. If you are still on 20.04, treat this CVE as one more reason to upgrade to 22.04 or 24.04 rather than waiting for a fix.

How do I know the patch actually worked?

After rebooting, run uname -r and compare the version against the fixed version for your release in the table above. If it is equal or higher, you are patched. If you used KernelCare, kcarectl --patch-info | grep 'CVE-2026-98276' should return a line. Do not trust the fact that the upgrade command ran — verify the running kernel.

The Bottom Line

Linux kernel CVE-2026-98276 is a local privilege-escalation bug in code that has been in the kernel since version 2.6.12, and it stopped being theoretical on 4 November, when an exploit crashed a real server twelve times — and then turned into root on Enterprise Linux 8, 9 and 10. The fix is already in the regular security updates for Ubuntu, Debian and AlmaLinux. Install it, reboot, and verify with uname -r. If you run RHEL, use KernelCare’s livepatch while Red Hat catches up. And if your VPS shares its host’s kernel, ask your provider whether the host is patched — because in that setup, their patch is your patch.

Kernel updates are the patch people postpone because they need a reboot, and then forget. This one is worth the two minutes of downtime. Your VPS has been running vulnerable code since the day it was built; the only question is how much longer you want that to be true.

Leave a Comment

Your email address will not be published. Required fields are marked *