CVE-2026-98432: Linux TCP and Sophos Hotfix Checks
Check CVE-2026-98432 Linux TCP exposure and running-kernel fixes, plus Sophos Firewall HF110626.1 installation, restart and SD-RED firmware checks.
Check CVE-2026-98432 Linux TCP exposure and running-kernel fixes, plus Sophos Firewall HF110626.1 installation, restart and SD-RED firmware checks.

CVE-2026-98432 is the IPv4 TCP options lifetime flaw; CVE-2026-98276 is a separate local UDP socket flag race; CVE-2026-43499 is a local rtmutex/futex cleanup flaw. The Linux CNA rates them 9.8 Critical, 7.8 High, and 7.8 High respectively. Their records were published October 15, October 6, and May 21, 2026. These dates distinguish renewed interest from a new disclosure.
| CVE | Attack vector in the CNA record | Affected code | Closure scope |
|---|---|---|---|
| CVE-2026-98432 | Network; no privileges required | IPv4 TCP request/child socket IP options | Vendor-fixed kernel plus active rollout on TCP termination hosts |
| CVE-2026-98276 | Local; low privileges required | sock_gettstamp and UDP socket lifetime | Separate vendor determination for the socket-locking correction |
| CVE-2026-43499 | Local; low privileges required | rtmutex waiter cleanup during futex requeue | Separate vendor determination for the waiter-task correction |
Sources: CVE Record, CVE Record, and CVE Record. None of these records identifies PHP as the affected component. A shared host may need several fixes, but one ticket’s closure should not silently clear the other CVEs.
For a concrete example, the upstream 6.12 branch correction for CVE-2026-98276 begins at 6.12.112, while the record for CVE-2026-98432 begins at 6.12.113. A host fixed for the former therefore still needs an independent determination for the latter. Distribution backports can have different package numbers; the vendor mapping remains decisive.
The Ubuntu tracker checked November 9 includes a temporary IPv4 packet-filtering mitigation for TCP packets carrying IPv4 options. Its stated assumptions include not needing those IP options, root access, and a particular nftables management setup. Ubuntu explicitly says this reduces risk and does not fully prevent exploitation. TCP timestamps and window scaling are TCP options and are not the IP options targeted by that procedure.
Apply a vendor mitigation only after checking firewall ownership, persistence, local traffic, and container networking against its documented prerequisites. Avoid inserting a generic firewall rule into an appliance or a UFW/firewalld-managed host. Record the remaining exposure and the kernel update deadline; the temporary filter is not a correction to the memory-lifetime error.
Sophos update checked November 7, 2026. Sophos revised its Linux TCP vulnerability advisory on November 6. It lists hotfix HF110626.1 for Sophos Firewall v23.0 GA, v23.0 EAP1 and v22.0 MR3. The vendor says a firewall restart is required to install the hotfix. With automatic hotfix installation enabled, the hotfix downloads automatically; a download is not evidence that the corrected code is active.
| Product | Vendor correction | Evidence to retain |
|---|---|---|
| Sophos Firewall v23.0 GA, v23.0 EAP1, v22.0 MR3 | HF110626.1, released November 6; restart required for installation | Appliance ID, supported firmware branch, hotfix evidence, maintenance restart and post-change status |
| Sophos SD-RED 20 and SD-RED 60 | Firmware 3.0.012, released November 5 as a Sophos Firewall pattern update | Device model, installed firmware, rollout evidence and post-update health |
| Other Sophos releases or products | Use the product-specific vendor status; the advisory says further investigation and updates continue | Supplier confirmation or a tracked exception, not an assumed match to another product’s fix |
Use the supported Sophos installation and verification procedure for an appliance. The generic Linux shell checks later in this article are for systems you administer as Linux hosts; they are not appliance-console instructions. Check every serving member of a high-availability deployment and retain the restart evidence. If a firewall runs a different release, follow Sophos’s supported upgrade guidance instead of inferring that an arbitrary build contains this hotfix.
Sophos also states that it was not aware of public in-the-wild exploitation reports in the advisory reviewed. Keep that dated vendor statement separate from the public laboratory RCE demonstration and from the exploitation status of unrelated vulnerabilities.
CVE-2026-98432 is a Linux kernel use-after-free in the IPv4 TCP handshake path, involving the lifetime of shared IP options data. The Ubuntu security tracker describes the request-socket and child-socket race; the running vendor kernel and its backports determine the applicable fix. A distribution version or an installed package name alone is not a complete remediation record.
Decision summary for CVE-2026-98432
| Question | Evidence required | Unsafe shortcut |
|---|---|---|
| Can untrusted traffic reach the affected network stack? | Listener inventory, network path, load-balancer termination point and namespace/node mapping | Assuming the application diagram identifies the TCP endpoint |
| Is the installed vendor build fixed? | Distribution or provider advisory for the exact product, release, architecture and kernel flavor | Comparing only uname -r with an upstream first-fixed version |
| Is the fixed kernel active? | Post-maintenance uname -r, package ownership, boot/node image and rollout evidence | Closing the finding when the package download finishes |
| Does the public MPTCP exploit configuration apply? | ss -Mani, service ownership, MPTCP settings and authorized reachability checks | Equating a global enable flag with an exposed listener |
cat /etc/os-release
uname -r
ss -Mani
ss -lntp
sysctl net.mptcp.enabled 2>/dev/null
sysctl net.ipv4.tcp_migrate_req 2>/dev/null
These commands collect local facts; they do not prove that the vendor package contains the fix. Complete the record with the applicable vendor advisory and a post-update running-kernel check. For containers, assess the host or managed node kernel rather than only the application image.
For an exposed host, identify reachable TCP services and any MPTCP listeners, check the vendor’s release and kernel-flavor status, install the verified fixed build, and confirm the kernel that is active after the required restart or reboot. The public MPTCP exploit research demonstrates a specific lab configuration; it does not establish the same exploit outcome for every Linux listener. The detailed mechanism, provider tables and validation steps below preserve those distinctions.
AWS service status checked November 9, 2026: The service table below reflects the November 6 bulletin revision. Verify workload replacement as well as available packages and images.
Ubuntu patch and fix status: The dated Ubuntu release-and-kernel-flavor table below distinguishes work-in-progress tracker entries from published corrections. Verify the exact source package and active kernel before closing a finding.
The Linux CNA record assigns CVSS 3.1 9.8. Distribution assessments must be read against their own products and metric versions; consult the current Red Hat advisory for RHEL rather than applying an upstream score to every distribution. Separately, Anthropic reported remote root command execution against a server with a Multipath TCP listener in a controlled lab. That demonstrates serious exploitability under a specific configuration, not universal compromise of every Linux TCP listener.
Defenders should treat those statements as complementary. The upstream record identifies a dangerous memory-lifetime error and its theoretical maximum impact. A distribution score describes the vendor’s shipped code, configuration, mitigations, and expected exploit conditions. A research exploit demonstrates one concrete path through a particular target. None of the three should be discarded, and none should be stretched beyond its scope.
The practical response is direct: identify reachable Linux TCP services, determine which vendor kernel is actually running, install the vendor-provided fixed build, reboot into it, and retain evidence that the running kernel contains the correction. Hosts that expose MPTCP listeners deserve immediate attention because the public research specifically validated that environment. Internet-facing gateways, load balancers, Kubernetes nodes, VPN endpoints, reverse proxies, and appliances that use Linux networking also deserve a fast inventory even if they do not intentionally enable MPTCP.
For administrators searching for CVE-2026-98432 on AlmaLinux or Ubuntu, package status must be checked against the exact distribution release and kernel flavor. The AlmaLinux status could not be independently confirmed from a CVE-specific official advisory in this October 30, 2026 research snapshot; Ubuntu publishes a live package-by-package tracker. Do not interpret missing advisory evidence as proof of safety.
The vulnerable behavior was introduced by older upstream changes, including commit 079096f103fa, which allowed TCP and DCCP request sockets to be installed in the established hash table without the listener lock, and another change associated with request migration. Because the affected history spans many maintained branches, the Linux CVE record enumerates branch-specific fixes rather than one simple vulnerable range.
Upstream stable fixes were issued across maintained lines. The first corrected releases identified in the public record include 5.10.272, 5.15.223, 6.1.190, 6.6.159, 6.12.113, 6.18.56, 7.2.10, and the 7.3 development line containing the mainline fix. These numbers are useful for upstream kernels. They must not be used as a universal rule for vendor packages because vendors may backport the correction to builds with lower base numbers or maintain a branch with additional revision identifiers.
Debian’s tracker, for example, marks Bookworm’s 6.1.190-1 security package and Trixie’s 6.12.113-1 package fixed. It also records fixed builds in later suites. Those package versions are the correct evidence for Debian systems. On Ubuntu, the security page lists many separate kernel source packages, including generic, AWS, Azure, GCP, KVM, Oracle, OEM, low-latency, and real-time variants. A status for one flavor does not automatically prove another flavor is fixed.
Red Hat customers should use the Red Hat CVE page and errata applicable to the exact RHEL or OpenShift product. Enterprise kernels deliberately retain stable interfaces and version families while incorporating security patches. A version-only scanner that expects the upstream first-fixed version may flag a corrected Red Hat kernel. Conversely, seeing a high base version in an appliance does not prove the vendor included every stable patch.
The SUSE CVE page, Gentoo security advisories, cloud-provider notices, and appliance vendor bulletins should be consulted for their respective products. When a vendor has not published a determination, administrators can ask for a VEX or support statement identifying whether the vulnerable code is present and which build includes the fix.
Containers deserve special attention. Containers normally share the host kernel. Updating an application image does not replace the kernel that handles its TCP traffic. Managed Kubernetes customers may need a node-image update, a node-pool rollout, or a provider maintenance action. Self-managed clusters need host package updates and node reboots. After replacement, verify every node rather than assume the control plane rollout reached the entire fleet.
Live patching may or may not cover this change. The correction affects object reclamation in network destructors, and coverage depends on the vendor’s live-patch implementation and support decision. Treat a live-patch status as valid only when the vendor explicitly associates it with CVE-2026-98432. If no such confirmation exists, install the fixed kernel and reboot.
The authoritative technical description comes from the Linux kernel CVE process and the upstream patch. The issue involves ownership and reclamation of IPv4 option data associated with a TCP request socket. During the server side of a TCP handshake, the kernel creates a lightweight request socket to represent a connection that has not yet become a full child socket. When the handshake progresses, tcp_v4_syn_recv_sock() transfers the request’s ireq_opt pointer to the new child socket as inet_opt. It does not duplicate the object.
At the same time, a different CPU can process a retransmitted SYN associated with the same request. That second path can send another SYN-ACK through tcp_check_req(). Functions such as tcp_v4_send_synack() and inet_csk_route_req() read the request’s IP options inside an RCU read-side critical section. Later helpers, including ip_build_and_send_pkt() and ip_options_build(), dereference fields from the options object. The Debian security tracker reproduces the upstream explanation and maps the issue to fixed Debian kernel packages.
The lifetime mismatch is the core problem. The reader behaves as though RCU protects the object, but the destructor frees it with ordinary kfree(). Ordinary kfree() makes the allocation available for reuse without waiting for existing RCU readers to finish. If the child socket is destroyed while a retransmitted-SYN path still uses the options, the second CPU can continue reading memory that no longer belongs to that object. The primary upstream fix replaces immediate freeing with kfree_rcu() in the relevant destructors, delaying reclamation until an RCU grace period has elapsed.
The vulnerability also has a related request-migration case. If net.ipv4.tcp_migrate_req=1 is enabled, or if a BPF_SK_REUSEPORT_SELECT_OR_MIGRATE program controls request migration, the kernel may clone a request socket. The old request and its clone can temporarily share the same options object. A CPU holding a reference to the old request can still use the object while the clone is freed. The kernel description therefore changes both inet_sock_destruct() and tcp_v4_reqsk_destructor() to use RCU-aware reclamation.
The first issue is specific to the IPv4 child-socket path because the corresponding IPv6 function duplicates options instead of transferring the same pointer. The upstream text also notes an IPv6 request-migration concern involving ipv6_opt when CALIPSO is present and says that condition is handled separately. That distinction matters: a statement that “IPv6 is unaffected” is too broad, while a statement that the main IPv4 ownership-transfer bug does not apply to the ordinary IPv6 child creation path is accurate.
The patch was merged upstream as commit e3f33b0a1d89, titled “ipv4: free inet_opt and ireq_opt after an RCU grace period.” The Ubuntu CVE page identifies the same introduction and fix commits and tracks many Ubuntu kernel flavors independently. This is useful evidence that a generic kernel version check cannot replace distribution-specific status.
No authoritative source cited here establishes widespread exploitation across the public internet. Anthropic established that its researchers could turn the flaw into remote root command execution against a controlled target with an MPTCP listener. That is stronger than a crash-only proof and should influence urgency. It still does not provide a measured prevalence of vulnerable MPTCP services, a universal success rate, or proof that the same exploit chain works unchanged across kernel builds, CPU architectures, allocators, hardening profiles, and network paths.
The public material also does not justify assuming that any high volume of SYN retransmissions is exploitation. Retransmitted SYN packets occur naturally because of packet loss, asymmetric routing, overloaded services, client retry behavior, and middleboxes. Exploitation of a race may generate unusual patterns, but those patterns need correlation with a vulnerable host, relevant options, kernel symptoms, and timing. A network alert can prioritize investigation; it cannot prove a use-after-free occurred inside the kernel.
There is no single upstream version string that accurately labels every vendor kernel. Enterprise distributions routinely backport security fixes while retaining an older-looking base version. Cloud providers and appliance vendors may ship their own kernel builds. A scanner that compares only uname -r against an upstream release list can produce both false positives and false negatives. The defensible conclusion comes from a vendor advisory, package changelog, build metadata, VEX statement, or direct confirmation that the relevant fix commit was backported.
Finally, disabling MPTCP does not remove the underlying IPv4 lifetime bug. It removes the exact listener configuration used in the public research chain and can meaningfully reduce immediate exposure where MPTCP is unnecessary. The upstream technical description covers the ordinary IPv4 TCP request and child socket paths as well as request migration. Patch deployment remains the durable correction.
A TCP server normally receives a SYN, replies with SYN-ACK, and waits for the final ACK. The kernel avoids allocating a complete connected socket at the first packet because an attacker could otherwise exhaust resources cheaply. Instead, it creates a compact request socket that stores enough state to validate and complete the handshake. When the ACK arrives and the connection is accepted, the kernel creates a full child socket and moves or copies selected state into it.
IPv4 options complicate that transition. IP options can carry metadata that influences routing or packet processing. The kernel parses the incoming information and stores an internal representation for later response construction. In the affected path, the request socket’s ireq_opt pointer becomes the child socket’s inet_opt pointer. The transfer avoids a copy, but it means the lifetime of one allocation crosses the boundary between two socket objects.
A second SYN for the same connection tuple can arrive before the handshake state has completely settled. Retransmission is a normal part of TCP. The kernel may process that SYN on another CPU and build a SYN-ACK using the original request socket. Since Linux networking is highly parallel, the child socket can progress toward teardown while the other CPU is still constructing the reply. The request path takes an RCU read lock, indicating that the data it reads must remain valid until the read-side critical section ends.
The old destructor behavior violated that expectation. The child socket did not carry the SOCK_RCU_FREE behavior that would defer its entire release, and inet_sock_destruct() freed inet_opt directly. The second CPU could retain the pointer and read optlen from memory that had already returned to the allocator. A later allocation could place unrelated data at that address, changing the value between reads or letting subsequent code operate on attacker-influenced contents.
Use-after-free bugs are dangerous because the immediate symptom depends on what replaces the freed allocation. The stale access may read the old bytes and appear harmless. It may encounter poisoned or unmapped memory and crash. It may read a new kernel object and disclose data. With sufficient control over allocation patterns and timing, a researcher may turn the stale reference into a more powerful read, write, or control-flow primitive. The vulnerability class therefore supports outcomes ranging from intermittent handshake failure through denial of service to code execution, but a specific outcome must be demonstrated for a specific target.
The request-migration variant follows the same lifetime principle through a different topology. Reuseport allows multiple sockets to share a listening port, and BPF can participate in choosing a target. Request migration may move pending connections when a listener changes state. The kernel clones request state, creating a window in which two request objects refer to the same options allocation. Clearing the pointer in one object does not protect a CPU that already holds a reference to it. If the other object’s destructor immediately frees the shared allocation, that reader becomes stale.
The patch does not attempt to serialize every operation behind one global lock. That would harm scalability in a hot network path. It instead aligns reclamation with the synchronization model that readers already use. This is precisely the kind of problem Read-Copy Update is designed to solve.
Read-Copy Update lets readers access shared data with very low overhead while writers publish replacements and defer freeing old versions. A reader enters an RCU read-side critical section, obtains a pointer, uses the object, and exits. A writer can remove the object from the data structure so new readers no longer find it, but it must wait for a grace period before reclaiming memory. A grace period ensures that all readers that could have seen the old pointer have finished.
The Linux kernel’s RCU documentation describes the essential removal-and-reclamation split. Removal changes reachability. Reclamation returns storage to the allocator. Conflating those operations is a common source of use-after-free errors. An RCU lock does not place a reference count on an arbitrary object and does not make direct kfree() safe. The corresponding writer must use an RCU-aware mechanism such as call_rcu() or kfree_rcu().
In CVE-2026-98432, the read paths already use RCU. The correction makes the destructor honor that contract. kfree_rcu() schedules the object for release after a grace period rather than releasing it immediately. The CPU building the SYN-ACK can finish reading the old options object. Later readers will no longer obtain it, and the allocation becomes reusable only after the preexisting readers are gone.
This design preserves concurrency. It does not require the server to stop processing retransmissions, place a large lock around handshake construction, or copy the options object for every read. The security property is narrow and clear: an object visible to an RCU reader remains allocated for the duration in which that reader might access it.
RCU fixes also explain why packet filtering alone cannot be a complete remedy. The memory-safety defect is in object lifetime management. Filtering may make a trigger harder to reach, and disabling unneeded features can reduce the set of paths. Only corrected reclamation restores the invariant for every legitimate and hostile packet that reaches the code.

The CVE record’s CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, producing 9.8. This vector assumes a network attacker needs no account and no user interaction, that attack complexity is low, and that successful exploitation can have high impact across confidentiality, integrity, and availability. It expresses the CNA’s base characterization of the vulnerable upstream component.
Ubuntu displays that 9.8 value but also publishes a CVSS 4.0 assessment of 8.3 with attack requirements present. CVSS 4.0 can represent prerequisites that do not fit cleanly into the older vector. Ubuntu’s page labels the vulnerability high priority and exposes package-by-package states rather than treating the numeric score as the entire decision.
Red Hat’s product assessment and remediation state belong to the exact RHEL product and kernel package listed in its live advisory. Do not carry an earlier preliminary score into a current risk decision without checking that source. A distribution assessment does not establish exploitability on a different vendor’s build, and the MPTCP research result does not establish the same outcome on every RHEL configuration.
CVSS disagreement is common for open-source components distributed in different forms. The same source defect may be present in two products but exposed through different configurations. One vendor may enable a feature by default, another may omit it, and a third may carry a partial backport that changes reachability. Kernel hardening, allocator behavior, architecture, compiler options, and service topology can all affect exploit development without changing the vulnerable source line.
For operational prioritization, a single universal score is less useful than a short environment-specific analysis:
| Environment factor | Why it changes urgency | Defender action |
|---|---|---|
| Publicly reachable TCP service | Untrusted users can exercise handshake paths without an account | Patch in the earliest emergency window |
| MPTCP listener enabled | The public research demonstrated remote root execution in this configuration | Patch immediately and disable MPTCP if unused |
| Management-only host behind strong filtering | Network access is constrained but insider and lateral paths remain | Patch quickly through normal change control |
| Request migration or reuseport BPF | The upstream description identifies a related shared-object path | Inventory the configuration and prioritize affected listeners |
| Vendor marks installed build fixed | The relevant correction may be backported despite an old base version | Verify the running build and retain vendor evidence |
| Unsupported kernel | No reliable security update or vendor analysis may arrive | Upgrade to a supported kernel or isolate the host |
The Linux CNA score, a vendor product assessment, and the MPTCP lab demonstration answer different questions. None measures exploit prevalence. Use each within its scope when setting patch priority.
Anthropic’s October 27 research post describes a remote, zero-click Linux kernel exploit against a server with a Multipath TCP listener. According to the researchers, the exploit used the race-induced use-after-free in two stages. The first stage obtained a kernel pointer and defeated Kernel Address Space Layout Randomization. The second stage converted the memory corruption into control-flow hijacking and ultimately ran an attacker-chosen command as root.
The team reports that its proof of concept took approximately 48 minutes to disclose a kernel pointer and another five minutes to reach command execution. A failed attempt could leave the handshake incomplete without necessarily crashing the host, allowing repeated trials. That behavior is relevant because race-condition exploits often become practical when failure is cheap and retries are plentiful.
The research is credible evidence that the vulnerability can exceed denial of service. It also tells defenders which public exposure deserves the highest priority: untrusted network access to an MPTCP-enabled listener on a vulnerable kernel. The official Linux MPTCP documentation explains how Multipath TCP extends ordinary TCP so a connection can use multiple subflows while remaining compatible with existing applications. Linux distributions may provide MPTCP support without every application or service using it, so administrators need to check runtime state and listeners rather than infer exposure from package presence.
The published summary is not a reusable exploit recipe. It omits the target-specific details required to reproduce heap state, timing, address disclosure, and reliable control. Responsible defense does not require reproducing those stages on production systems. The existence of a working research chain, coordinated disclosure, upstream correction, and stable backports supplies enough evidence to patch.
Several boundaries should remain explicit. The research target used MPTCP. Kernel builds differ. The reported time is one experimental result, not a guaranteed minimum or maximum. Network latency, CPU count, load, allocator behavior, hardening, and service implementation can change the race. The post does not say that an ordinary TCP service with default settings on every distribution is equivalently exploitable.
The most defensible wording is therefore: CVE-2026-98432 is remotely reachable through Linux networking; Anthropic demonstrated unauthenticated root code execution against a vulnerable MPTCP listener in a controlled environment; broader exploitability and reliability depend on the target. This statement preserves both urgency and accuracy.
The Go Security Team notice archived on October 30 warns that Go services can expose MPTCP listeners on Linux even when their operators did not deliberately select MPTCP. The original announcement was sent on October 29 in US Pacific time. The team recommends a patched kernel: disabling MPTCP in individual programs is fragile, can leave another listener exposed, and assumes that every viable exploit needs MPTCP.
Go’s GODEBUG documentation records the Go 1.24 default as multipathtcp=2, enabling MPTCP for listeners. Effective defaults also depend on the toolchain, module or workspace Go version, and explicit debug directives. A Go version string alone therefore does not establish the behavior of a deployed service.
| Configuration layer | Setting to review | Scope and limitation |
|---|---|---|
| Process environment | GODEBUG=multipathtcp=0 | Disables the program’s default MPTCP use; merge with other required GODEBUG values. |
| Build configuration | godebug multipathtcp=0 | Sets the build default in the main module’s go.mod; workspace builds use go.work. Requires rebuilding and deploying the binary. |
| Per-socket code | lc.SetMultipathTCP(false) on a net.ListenConfig | Controls listeners created through that configuration. An explicit true setting elsewhere can enable a different listener. |
The net.ListenConfig.SetMultipathTCP API overrides the default and GODEBUG setting. Review calls to this method and net.Dialer.SetMultipathTCP when auditing source. Changing a deployment variable is insufficient evidence if application code overrides it. These settings control application behavior; they do not replace the kernel’s vulnerable code.
For each service, record the deployed binary, effective configuration, listener owner and network namespace. Apply any temporary configuration change through the service’s supported restart or rollout procedure, then inspect the newly created listeners. Keep kernel remediation open until the vendor-fixed build is active. This is an operational exposure check, not a test of exploitability.
Checked October 30, 2026. Treat this Linux kernel vulnerability as a kernel-package investigation: the platform name, an installed update, and the kernel currently running are three different pieces of evidence.
Run the following read-only inventory on each Proxmox VE host, rather than relying on a guest’s distribution label:
uname -r
pveversion -v
dpkg-query -W 'proxmox-kernel*' 'pve-kernel*'
proxmox-boot-tool kernel list
Compare the running release with the installed versioned kernel package and its repository. Review the node’s Updates view, the applicable Proxmox update announcement, and that package’s changelog for the correction or an explicit vendor mapping. If the changelog does not establish inclusion, obtain Proxmox support confirmation before marking the host fixed. The Proxmox VE Administration Guide describes bootable-kernel selection; an installed update can coexist with an older kernel selected for boot. After the maintenance reboot, repeat uname -r on every node and confirm that the expected vendor-fixed build is active.
Community discussion is a lead for checking source history and package changelogs, not official confirmation of a fixed Proxmox release. This review does not assign a first-fixed Proxmox build from forum claims or assume that an Ubuntu tracker row establishes the status of a Proxmox package. LXC workloads use the host kernel; a Linux virtual machine has its own guest kernel to assess separately.
For self-managed EC2 instances, identify the guest OS, kernel flavor, package and running release. EC2 security responsibilities include customer management of guest OS patches. Ubuntu linux-aws needs Canonical\’s determination, not an Amazon Linux package status. Check the Amazon Linux package advisory matrix for the exact release and architecture.
The AWS bulletin, checked November 9, displays a last update of November 6, 2026 at 13:45 PST. Match the service and deployment below. An available image, a provider mitigation and replacement of an existing workload are different states.
| Service | Provider status | Customer verification |
|---|---|---|
| Amazon Linux 2 and Amazon Linux 2023 | Corrected kernel packages are available. AL2023 instances pinned to a release need 2023.12.20261102 or later. | Update the applicable kernel package and reboot; verify the running build. |
| Self-managed EC2 and Lightsail | Customers manage the guest operating-system kernel. | Use the guest distribution’s fixed package and verify it after reboot. |
| EKS customer-managed nodes | Updated EKS-optimized AL2023 AMI release v20261031 is available. | Replace managed node-group, self-managed and Karpenter nodes using these AMIs with v20261031 or later. |
| EKS Auto Mode | Updated images were released October 31. Existing nodes are replaced automatically, subject to NodePool disruption budgets. | Check the OS-IMAGE value and actual node replacement state. An image release is not proof every node has moved. |
| EKS Fargate | Pods launched after November 1, 2026 at 09:00 PST / 17:00 UTC use the patched platform. Older pods are replaced within the provider’s 14-day cycle. | Check pod age and replacement evidence; keep older pods in the rollout record. |
| ECS on EC2 | Updated ECS-optimized AMI release 20261031 is available. | Update and reboot container instances or replace them with the updated AMI. |
| ECS Fargate and Managed Instances | New tasks and managed instances launched after November 1 at 09:00 PST / 17:00 UTC use the patched platform or AMI. | Fargate tasks follow retirement settings; Managed Instances drain after 14 days or earlier event windows. Verify replacement or drain earlier through supported controls. |
| ElastiCache and MemoryDB | AWS was deploying mitigations. Self-service updates elasticache-20261106-arm, elasticache-20261106-intel and memorydb-20261106-arm were rolling out. | Apply the update appropriate to the instance type when available and retain completion evidence. Do not treat rollout availability as completion. |
| RTB Fabric | Gateways terminate TCP and open separate endpoint connections. AWS is updating gateway infrastructure and specifies no customer gateway action. | Update kernels on customer-managed endpoints; the gateway boundary does not remove endpoint ownership. |
| Elastic Beanstalk | Corrected AL2023 platforms were released November 4 using AMI 2023.12.20261102. | Update the platform or verify its managed update. Updating only existing instances leaves future scale-out dependent on the platform AMI. |
| Bottlerocket | Patched Bottlerocket v1.68.1 AMIs were released October 31. | Verify the release running on each node, rather than an earlier forecast or an available image. |
| RDS and Aurora | AWS says worldwide mitigation is fully deployed and an OS patch is available. | Keep database ports off the public internet and apply the available database OS patch. |
| Redshift | AWS says all Redshift customers have been mitigated for this CVE. | Retain the dated provider determination and follow service maintenance guidance. |
| CodeBuild | On-demand x86_64 hosts were updated by November 5 and ARM hosts by November 6. Reserved capacity coverage differs by compute type; ARM container-compute rollout was still in progress. | Check the applicable fleet. Rebuild a custom host AMI with the fixed kernel; changing only the build image or buildspec does not replace the host kernel. |
| Lambda | AWS lists workloads as not affected because functions expose no public IPv4 TCP port for this trigger. Infrastructure patching is defense in depth. | No customer action is required for this CVE according to the bulletin. |
For interim risk reduction where a kernel update cannot be applied immediately, AWS describes disabling MPTCP and filtering IPv4 IP options as mitigations. These measures reduce exposure but do not replace the fixed kernel and reboot. Review the current AWS bulletin for the complete command examples, service caveats, and rule-order requirements before applying network rules.
This October 30 review did not verify an AlmaLinux advisory and corresponding fixed kernel RPM explicitly addressing CVE-2026-98432. Keep the status unconfirmed. Consult the official AlmaLinux errata for the exact major release, architecture and kernel package; update this determination only when the advisory or vendor confirmation maps the CVE to that release and its corrected package. Neither RHEL compatibility nor RHEL’s affected or fixed status supplies an AlmaLinux determination.
cat /etc/os-release
uname -r
rpm -q kernel kernel-core
rpm -q --whatprovides "kernel-uname-r = $(uname -r)"
These commands collect local evidence; they do not establish whether the package contains the fix. Compare their results with AlmaLinux’s own advisory. After installing a confirmed correction and rebooting, repeat the running-kernel and package checks.
The Ubuntu tracker, checked November 9, 2026, lists the following states for the generic linux source package. A work-in-progress version is not an available correction. Cloud, HWE, OEM and other kernel packages have separate tracker rows.
| Ubuntu release | Generic linux status | Tracker version or limitation |
|---|---|---|
| 26.10 | Fixed | 7.3.0-10.10 |
| 26.04 LTS | Vulnerable; work in progress | 7.0.0-43.43 |
| 24.04 LTS | Vulnerable; work in progress | 6.8.0-149.149 |
| 22.04 LTS | Vulnerable; work in progress | 5.15.0-203.213 |
| 20.04 LTS | Vulnerable; work in progress | No released generic fix recorded at this check |
This table is a dated subset of the tracker, not a complete Ubuntu flavor or support matrix. HWE, OEM, Azure, GCP, and other source packages have their own rows. A status for linux cannot be transferred to linux-aws or another flavor. “Ignored,” “not affected,” “vulnerable,” and “released” are different vendor dispositions and require their accompanying notes. A source-package version is also not identical to the binary image package name or the output of uname -r.
On an Ubuntu host you administer, collect release and running-kernel evidence, then query the package corresponding to that kernel:
cat /etc/os-release
uname -r
dpkg-query -W -f='${binary:Package}\t${Version}\t${Status}\n' "linux-image-$(uname -r)"
apt-cache policy "linux-image-$(uname -r)"
These inventory commands do not install an update. Repository metadata may be stale, the running kernel may not be owned by a normal distribution package, and query failure is an unresolved mapping rather than proof of safety. Match the exact installed and candidate binary package to the vendor’s source-package row and published advisory. When a correction is released and installed, reboot into the intended kernel unless the vendor explicitly confirms an applicable live patch; then repeat the running-kernel and package checks.
The upstream Linux record now lists fixed stable-kernel boundaries, while Red Hat has issued product-specific errata. Red Hat’s page, updated November 2, rates the issue Critical for Red Hat Enterprise Linux and shows fixed kernel advisories for supported RHEL streams. Rocky Linux operators should map the applicable RHEL-compatible erratum through Rocky’s own repositories and advisories rather than installing a Red Hat package or copying an upstream version number. See the current Red Hat product status.
| Red Hat stream | Published erratum in the November 3 source snapshot |
|---|---|
| RHEL 8 kernel | RHSA-2026:93414 |
| RHEL 8 kernel-rt / NFV | RHSA-2026:93415 |
| RHEL 10 kernel | RHSA-2026:93413 |
Additional extended-update and SAP streams have separate advisories, and the vendor table can change. Check the current Red Hat page for the exact product lifecycle and package state before publication or remediation.
uname -r
rpm -q kernel kernel-core kernel-rt 2>/dev/null
rpm -q --last kernel kernel-core kernel-rt 2>/dev/null | head -20
Package installation is not enough. If uname -r still identifies an older kernel after the corrected package is installed, schedule the required reboot or approved live-patching workflow and verify again. Retain the distribution release, repository source, installed package, running kernel, reboot time and vendor advisory used for the decision.
Vendor fixes must be matched to the exact distribution, service or appliance. Backported packages and embedded kernels cannot be assessed reliably from an upstream version string alone. The following vendor status was reviewed on November 3, 2026.
| Platform | Status confirmed in the November 3 source snapshot | Operational action |
|---|---|---|
| Upstream Linux | Fixed stable boundaries include 5.10.272, 5.15.223, 6.1.190, 6.6.159, 6.12.113, 6.18.56, 7.2.10 and 7.3. | Use the exact stable branch or the distribution backport; verify the running kernel. |
| Red Hat Enterprise Linux | Red Hat published product-specific errata for supported RHEL streams, including RHEL 8, 9 and 10 kernel advisories in the captured source. | Apply the advisory for the exact stream and kernel flavor, reboot or use the approved live-patch path, then check uname -r. |
| Rocky Linux and compatible rebuilds | Use the distribution’s own repositories and errata corresponding to its supported stream. | Do not install Red Hat packages directly or clear a host from a marketing version alone. |
| Debian | Debian’s tracker listed bookworm security 6.1.190-1, trixie security 6.12.115-2, forky 7.2.12-1 and sid 7.2.15-1 as fixed in the captured page; it also lists a fixed bookworm 6.12 source package. | Use the current Debian tracker and advisory for the exact source package and release, update and boot the corrected kernel. |
| Ubuntu | Ubuntu publishes per-release and per-kernel-package state; the table is too granular and time-sensitive to reproduce safely as one static version. | Use the live Ubuntu CVE table for the exact release and kernel flavor. Do not infer fixed status from another distribution. |
| AWS | AWS released corrected Amazon Linux packages and updated several managed-service images. EKS-optimized AL2023 AMI release v20261031 or later is listed as addressing the issue. Service responsibilities vary. | Follow the service-specific bulletin. Self-managed instances and nodes still require kernel replacement and a reboot; managed services may use provider maintenance. |
| MikroTik RouterOS | The live MikroTik notice lists stable 7.25.1, long-term 7.24.6 and development 7.26beta5 as fixed; RouterOS 6 is not affected. Older cached copies may still say the stable fix is pending. | Upgrade and restrict TCP services running on the router itself from untrusted networks. Routed-through traffic is a different boundary. |
| F5 | The F5 knowledge article is the required source of truth; the public page may be dynamically rendered and product status can change. | Do not label F5 products fixed, affected or unaffected without a current readable F5 product table or support confirmation. |
| Azure | A product-specific Azure correction is not established by the sources cited here. | Check Microsoft guidance for the exact Azure service and guest operating system; do not infer a service-wide state from another cloud vendor. |
Use the vendor’s package or firmware mapping and then verify the active runtime. The upstream Linux fix is not a universal package number. Ubuntu tracks the generic, cloud, OEM, low-latency and real-time kernel source packages separately; Red Hat publishes product-specific errata; appliances require an explicit vendor firmware statement. Check the Ubuntu CVE tracker and Red Hat product status.
| Environment | Current decision | Closure evidence |
|---|---|---|
| Ubuntu | Select the exact release and kernel flavor in Ubuntu’s live CVE tracker. A work-in-progress build is not a released fix. | Installed package, uname -r, reboot/live-patch evidence and tracker row used. |
| RHEL / compatible enterprise Linux | Use the applicable vendor erratum and repository package; do not copy an upstream version threshold. | Erratum, installed kernel package, running kernel and reboot record. |
| UniFi OS — Dream Machines | Ubiquiti lists UniFi OS 5.1.35 as Official and explicitly names the CVE-2026-98432 fix in its Dream Machines release notes, checked November 5, 2026. | Match the product family, release channel and installed firmware to the vendor release; do not generalize this result to every UniFi device. |
| Container host | The host kernel is the security boundary; changing only the container image does not replace it. | Host package and running-kernel evidence for every node. |
uname -r
cat /etc/os-release
rpm -q kernel kernel-core kernel-rt 2>/dev/null
dpkg-query -W 'linux-image*' 2>/dev/null | grep '^linux-image'
Retain the command output with the vendor advisory. If the corrected package is installed but uname -r still reports an older build, remediation is not active. Reboot or use an explicitly supported live-patch path, then verify again.
Ubiquiti’s UniFi OS Dream Machines 5.1.35 release page explicitly states that the release fixes CVE-2026-98432. The live page showed Official on November 5, 2026; an older search result can still show Release Candidate. This replaces the earlier unverified vendor-release status for this product family. It does not establish the status of every Cloud Gateway, CloudKey or other UniFi product.
Match the exact device family and its available firmware channel to the release before planning the change. Record the installed UniFi OS build after installation and restart. Keep the OS version separate from the bundled UniFi Network application version. Preserve the device backup and test the routing, VPN and management functions that the deployment uses; a successful download or an update notification alone does not establish that corrected firmware is active.
uname -r
# Debian and Ubuntu observations
dpkg-query -W 'linux-image*' 2>/dev/null
# RHEL, Rocky and compatible distributions
rpm -q kernel kernel-core kernel-rt 2>/dev/null
A package-manager result proves what is installed, not what is running. Retain the vendor advisory, distribution release, kernel flavor, corrected package, reboot or replacement time, uname -r output and the inventory of every node behind a load balancer or cluster service.
A good inventory separates vulnerability presence from attack reachability. Presence asks whether the running kernel contains the affected code without the correction. Reachability asks which untrusted networks and services can exercise the relevant handshake paths. Both matter. A vulnerable but isolated lab host can follow a planned update window, while a public MPTCP service should move to the front of the queue.
Start with systems that terminate TCP directly on Linux: reverse proxies, web servers, API gateways, ingress nodes, VPN concentrators, load balancers, mail gateways, DNS-over-TCP services, SSH bastions, database endpoints, and custom daemons. Include appliances if their vendor identifies Linux internally. A hardware-looking edge product can still expose a Linux network stack.
Determine whether a separate device terminates the external connection. A cloud load balancer may absorb the public handshake and establish a second connection to a backend. That can reduce direct reachability of the backend kernel from the internet, but the load balancer itself and any internal untrusted clients remain in scope. Preserve the actual connection path in the asset record instead of relying on application architecture diagrams that omit network termination.
Check MPTCP status. On systems with an appropriate iproute2 version, ip mptcp endpoint show and ip mptcp limits show can display configured endpoints and limits. Inspect sysctl net.mptcp.enabled where available. Also identify applications that deliberately create MPTCP sockets; a global enable flag alone does not prove a listener exists. The MPTCP upstream project documentation provides testing and deployment references.
Inspect request-migration settings with sysctl net.ipv4.tcp_migrate_req. The default and availability can vary with kernel and configuration. A value of one increases relevance of the migration path described upstream. Identify reuseport BPF programs attached to listening groups. The kernel’s IP sysctl documentation explains request migration and the BPF_SK_REUSEPORT_SELECT_OR_MIGRATE policy. Absence of these features does not prove the primary IPv4 path is safe, but presence helps prioritize testing and rollout.
Record the effective kernel, package, booted image, architecture, and vendor. For immutable systems, record the node image or operating-system release. For appliances, record the firmware. For managed services, capture the provider advisory or support case. This evidence is more useful than a spreadsheet cell that only says “Linux.”
Map trust boundaries. A service reachable only from a corporate VLAN may still be reachable by compromised laptops, workloads, or partners. Kubernetes node ports can expose listeners in ways that differ from ingress configuration. IPv4 exposure remains relevant even in organizations that prefer IPv6, because dual-stack services and management networks often keep IPv4 enabled.
The upstream MPTCP debugging guide recommends ss -Mani to display MPTCP sockets, including listening state. On a host you administer, use an iproute2 build with MPTCP diagnostics support:
ss -Mani
ss -lntp
sysctl net.mptcp.enabled
ip mptcp endpoint show
ip mptcp limits show
Use the MPTCP socket listing to identify listening addresses and ports, then correlate them with service and process inventory. Run the check in each relevant network namespace. The sysctl reports a configuration flag; endpoint and limit commands describe path-manager configuration. None alone inventories every listener. Unsupported options, missing diagnostic support or insufficient visibility make the result inconclusive; empty output is not a kernel patch verdict. These commands are documented inventory examples, not a detector validated across every distribution.
Production validation should answer four questions: what kernel is running, what vendor package supplied it, whether relevant services are reachable, and whether the vendor says that exact build is fixed. It should not attempt to win the race, corrupt kernel memory, disclose addresses, or run commands through a proof of concept.
The following commands collect local facts on a system you administer. They do not trigger the vulnerability:
uname -a
uname -r
cat /etc/os-release
# Debian and Ubuntu package evidence
dpkg-query -W 'linux-image*' 2>/dev/null | sed -n '1,40p'
# RHEL-family package evidence
rpm -q kernel kernel-core 2>/dev/null
# Listening TCP sockets
ss -lntp
# MPTCP state when supported
sysctl net.mptcp.enabled 2>/dev/null
ip mptcp endpoint show 2>/dev/null
ip mptcp limits show 2>/dev/null
# Request migration setting when present
sysctl net.ipv4.tcp_migrate_req 2>/dev/null
Run commands with the least privilege needed. Process names in ss output may require elevated permission, but listener addresses and ports are still useful without them. Do not paste full command output into a public ticket if it contains hostnames, internal addresses, or service details.
Next, compare the installed package with the distribution’s advisory. On Debian, use the Debian tracker and the installed source-package version. On Ubuntu, select the exact kernel flavor and release row. On Red Hat, use the applicable product state and erratum. If the vendor says a build is fixed through a backport, accept that mapping over a generic upstream comparison.
Confirm that the system booted the updated kernel. Package installation can succeed while the running kernel remains old. Compare uname -r with the expected installed image after reboot. On systems with multiple boot entries, verify the bootloader selected the correct image. In a cluster, collect the result from every node.
For externally reachable services, validate exposure from an authorized assessment host using ordinary connection attempts, load-balancer configuration, firewall policy, and service discovery. There is no need to transmit malformed IP options or repeated race-triggering handshakes. Standard TCP connectivity is enough to establish that untrusted traffic reaches the host.
If a lab team needs deeper assurance, build a disposable environment using the same vendor image, enable kernel sanitizers only in that environment, and run vendor-approved regression tests. KASAN documentation describes the kernel’s memory-error detector. KASAN is valuable for development and confirmation, but its performance cost and altered memory layout make it unsuitable as a production mitigation and can change exploit timing.
A safe validation report should contain the asset identifier, business service, network exposure, MPTCP state, request-migration state if relevant, package version, running kernel, vendor advisory URL, update timestamp, reboot evidence, service-health result, and any temporary exception. That record supports incident response, audit, and later rescanning.
This deterministic Python example models the lifetime invariant, not the vulnerability’s trigger. It sends no packets, opens no sockets, accesses no kernel memory, and needs no privileges or special operating system. The Boolean object state deliberately replaces real allocation and freeing. It cannot establish whether a host is vulnerable or patched.
def simulate(deferred):
readers = 1 # An existing reader holds the object
allocated = True
free_requested = True
if not deferred:
allocated = False # Models immediate reclamation
elif readers == 0:
allocated = False # Deferred path must wait
stale_read_possible = not allocated
readers -= 1 # Existing reader exits
if deferred and free_requested and readers == 0:
allocated = False
return stale_read_possible, allocated
assert simulate(False) == (True, False)
assert simulate(True) == (False, False)
print("Immediate reclaim: reader can outlive allocation")
print("Deferred reclaim: existing reader finishes before free")
Both paths eventually reclaim the object. Only the immediate path marks it reclaimed while the modeled reader is active. Real Linux RCU grace periods are more sophisticated than a reader counter; this example teaches the ordering requirement without implementing RCU or reproducing the kernel race. The security regression criterion is that all preexisting readers finish before reclamation. The operational criterion remains the vendor’s fixed-build mapping plus evidence of the booted kernel.
Memory-corruption exploitation rarely produces one definitive log line. Detection should combine kernel telemetry, network behavior, host state, and the known vulnerable build. A kernel crash with a stack near ip_options_build(), ip_build_and_send_pkt(), TCP SYN-ACK construction, or socket destruction deserves immediate review. KASAN reports that identify a use-after-free involving inet_opt or ireq_opt are especially relevant in test or debug environments.
Review journalctl -k, dmesg archives, crash dumps, and platform serial-console logs. Cloud instances may reboot before local logs are flushed, so centralized kernel logs and provider console history matter. If kdump is deployed, preserve the vmcore, matching unstripped kernel symbols, package metadata, and boot configuration. Do not immediately recycle an affected node if evidence collection is part of the incident plan.
Network telemetry can identify clients that send repeated connection attempts with unusual option combinations or sustain retries against an MPTCP listener. Baseline first. Mobile networks, lossy links, health checks, and SYN proxies can generate high retransmission counts. An alert should include destination service, source distribution, TCP option summary, rate, duration, and whether the target was vulnerable at the time.
An exploit described by Anthropic needed repeated opportunities over a long interval. Long-lived patterns from a single source or coordinated sources may therefore be more interesting than a small burst. Attackers can distribute retries, and normal clients can also retry for extended periods. Treat the pattern as investigative context rather than a signature.
Endpoint detection agents have limited visibility into an exploit that begins and executes inside the kernel. A successful control-flow hijack might later create a user-space process or alter credentials, but it may also perform actions that blend into normal privileged activity. Correlate unexpected root processes, changes to startup configuration, new network connections, module activity, audit events, and integrity-monitoring alerts with kernel and network evidence.
If exploitation is suspected, isolate the host through network controls that preserve evidence, capture volatile state according to the organization’s incident process, rotate credentials that the host could access, and investigate adjacent systems. A kernel-level compromise invalidates assumptions about user-space logs and agent integrity. Rebuild from a trusted image after evidence collection rather than treating a package update as remediation for an already compromised machine.
Check whether the system exposed MPTCP and whether the suspicious source could reach it. Preserve firewall, load-balancer, flow, packet-capture, and service configuration around the event time. Record the exact booted kernel and package before changing it. If the only symptom is a crash, retain the possibility of accidental trigger or an unrelated bug while still patching promptly.
Separate an official workaround, an operational exposure control, and a code correction. The Linux kernel CVE announcement recommends updating to a current stable kernel; its Mitigation heading does not establish that disabling MPTCP repairs the bug.
| Decision | Action and required evidence | What it establishes |
|---|---|---|
| Does the vendor provide an official mitigation? | Check the exact product advisory. Red Hat’s mitigation guidance currently refers readers to security bulletin RHSB-2026-016 for a detailed mitigation procedure. Check the exact bulletin and product scope before applying it. | Use only the vendor-supported scope; absence of a workaround is not evidence of safety. |
| Can exposure be reduced temporarily? | Restrict unnecessary inbound TCP paths and review unused MPTCP with the service owner. Verify listener state and service behavior after any configuration change. | Temporary risk reduction only. Neither disabling MPTCP nor filtering traffic corrects the memory-lifetime error. |
| Is a formal fix available? | Match the CVE to an issued vendor advisory and exact fixed kernel package, architecture and release. If no package is confirmed, retain an open remediation item. | A supported corrected build is available. Installing it does not prove it is running. |
| Is the corrected kernel active? | After the maintenance reboot, run uname -r, map it to the installed vendor-fixed package, and check service health on every host. | Runtime evidence of the correction. If using live patching instead, require explicit vendor coverage for this CVE and proof of activation. |
The preferred remediation is a vendor kernel containing the RCU reclamation fix, followed by a reboot into that kernel. Use the distribution’s normal update mechanism and its advisory. Avoid cherry-picking a single mainline commit into an enterprise kernel unless the kernel vendor or an experienced kernel engineering team owns the resulting build. Stable branches may require related context, and unsupported custom kernels create future patch and support risk.
For a fleet, rank systems by public reachability, MPTCP usage, request migration, business criticality, tenant exposure, and vendor support. Begin with internet-facing nodes and infrastructure that terminates large volumes of untrusted TCP. Patch redundant members in a rolling sequence: drain connections, update, reboot, verify the running kernel, perform service checks, and return the node to rotation before continuing.
Where immediate reboot is impossible, reduce exposure. Disable MPTCP if the organization does not use it. Restrict inbound TCP to required sources and ports. Move management services behind authenticated gateways. Remove unused public listeners. Apply rate controls or SYN proxying at an upstream device where operationally safe. These are operational proposals that need service-specific validation. They may reduce opportunities but do not prove every vulnerable path is blocked or correct the stale pointer.
Evaluate net.ipv4.tcp_migrate_req and reuseport BPF only with the service owner. Turning off request migration may reduce one affected path but can change failover behavior. Removing a BPF program may change traffic distribution. Configuration changes need functional testing and a rollback plan.
Blocking all IPv4 options at an edge may reduce exposure to paths that rely on option data, but it is an incomplete and potentially disruptive control. Some networks use options for specialized behavior, and the precise relationship between a filter and every vulnerable path must be established. Middleboxes can normalize or terminate connections in ways that differ from simple packet filtering. Use such controls as temporary risk reduction only.
Do not rely on container restarts, application redeployments, or user-space library updates. The vulnerable code runs in the host kernel. Do not assume that a web application firewall sees or understands the relevant IP and TCP handshake state. A WAF that begins processing after a TCP connection is established is downstream of the vulnerable operation.
Unsupported kernels present a straightforward decision. Move the workload to a supported build or isolate it until replacement. A locally patched kernel can be appropriate for specialized products, but it requires owners who can validate the backport, test networking behavior, maintain symbols, publish provenance, and deliver future fixes. For most organizations, moving to a vendor-supported kernel is safer and faster.
For teams evaluating Penligent as part of an authorized assessment workflow, keep the engagement scoped to exposed-service inventory, configuration evidence, and post-change checks that the agreed tooling can actually perform. Do not assume an application-testing workflow establishes kernel exploitability or backport provenance. Closure still requires the vendor’s exact package determination, the active kernel, and service-health evidence.

A successful update job is not the same as a remediated host. Verification begins after reboot. Confirm the active kernel with uname -r and map it to the vendor’s fixed package. Confirm the update installed on the expected boot partition and that the bootloader did not fall back after an error. Check that secure-boot policy accepted the image where applicable.
Validate the service from both sides of its trust boundary. An internal health check may pass while the public listener is absent, and a public check may pass while a private backend path is broken. Exercise normal TCP connection establishment, TLS negotiation, protocol health, and representative requests. For MPTCP services, use the organization’s normal MPTCP functional test without hostile timing or memory-corruption attempts.
Review kernel logs for warnings introduced by the rollout. Network fixes can interact with drivers, offload, BPF, load balancing, and custom modules. A regression does not justify returning indefinitely to a vulnerable kernel. Follow the vendor’s rollback or replacement guidance, apply temporary exposure reduction, and escalate for a corrected package.
Rescan with a tool that understands vendor backports. If the scanner still flags the asset, attach the vendor advisory, installed package version, running-kernel evidence, and fix provenance. Suppress only the exact finding for the exact build, with an expiration or review date. Broad exceptions based on an upstream version comparison can hide later vulnerable nodes.
For Kubernetes and autoscaling fleets, verify templates as well as current instances. An old machine image can recreate vulnerable nodes after the initial rollout. Update launch templates, node images, golden images, recovery media, and disaster-recovery definitions. Test a scale-out event and confirm the new node boots a fixed kernel.
For appliances, confirm that the firmware upgrade changed the relevant kernel build. Keep the vendor bulletin and firmware checksum. If the appliance vendor has not published a fix, document compensating controls and obtain a support statement. Avoid assuming that a firmware release date after the upstream patch automatically includes it.
Close the remediation item only when all of the following are true:
The first mistake is treating “Linux” as one product. The kernel is shipped through distributions, cloud images, embedded firmware, managed node images, and custom builds. Each may carry different backports. Use the exact product channel.
The second mistake is equating a CVSS score with exploit prevalence. A 9.8 base score describes technical severity under a metric model. It does not count vulnerable hosts or prove active exploitation. A lower distribution-specific score does not negate a successful lab exploit against another configuration. Risk combines severity, exposure, evidence, asset value, and available controls.
The third mistake is reading the Anthropic result as universal. The research proves that a capable team could exploit a vulnerable MPTCP listener remotely in its lab. It does not establish identical behavior for every TCP listener. Use it to prioritize MPTCP and exposed networking, not to make unsupported claims.
The fourth mistake is declaring IPv6 universally safe. The primary child-socket transfer issue is IPv4-specific, while the upstream description separately calls out an IPv6 migration concern involving CALIPSO. Dual-stack systems also continue to expose IPv4. Evaluate both protocols and follow subsequent vendor fixes.
The fifth mistake is scanning only application containers. Container images do not carry the active host kernel in the normal model. Inventory and patch nodes. Serverless and managed-container customers should consult the provider, because the provider controls the kernel even when customers control images.
The sixth mistake is attempting public exploit code as a production test. Winning the race intentionally can crash or compromise the machine. It also provides little additional business value once the vendor has confirmed that the build is vulnerable. Safe configuration, package, exposure, and post-patch checks provide actionable evidence without weaponizing the flaw.
The seventh mistake is closing the ticket after installation without rebooting. The old kernel remains active until the system boots the new image unless a vendor-supported live-patch mechanism covers the CVE. Always record the runtime result.
MPTCP inventory is often less obvious than ordinary TCP inventory because administrators may know that the kernel supports the protocol without knowing which application binds an MPTCP socket. Start at the operating-system layer, then ask service owners whether they explicitly create MPTCP sockets or rely on a library or proxy that negotiates subflows. Review service units, container capabilities, socket activation, and deployment configuration. A host-level enabled flag is a clue, not a complete service map. Conversely, an application that can use MPTCP may fall back to ordinary TCP in one environment and actively listen with MPTCP in another.
For each candidate service, document the address families and interfaces where the listener is bound. A listener bound to a wildcard address may be reachable through more interfaces than its service configuration suggests. Host firewall rules, cloud security groups, network policy, and upstream load balancer behavior all contribute. A useful record says whether an untrusted client can complete a path to the host’s TCP stack, whether a proxy terminates the client connection first, and whether internal clients are in scope. This makes it possible to separate a truly isolated service from one that is merely absent from the public DNS zone.
Dual-stack deployments should be assessed as two connected but distinct paths. Inventory IPv4 and IPv6 routes, listeners, security groups, and translation devices independently. The upstream bug’s main ownership transfer is in IPv4 code, but a host with IPv6-only public ingress can still expose IPv4 through a management VLAN, cluster overlay, health-check network, or local peer. An IPv6 packet may also be translated or proxied into a separate IPv4 connection before reaching the vulnerable host. Network architecture, not a product label such as “IPv6-only,” determines what the kernel processes.
Do not disable a protocol across an entire fleet before identifying dependencies. MPTCP may be part of an intentional mobility or path-resilience design. A hasty change can cause throughput loss, break failover, or alter connection behavior in ways that make an incident harder to diagnose. Where MPTCP is not used, disabling it is a sensible temporary reduction in exposure, but record the change and verify that the service has not silently depended on it. Where it is used, prioritize a vendor kernel rollout and apply network restrictions compatible with the service objective.
Kernel maintenance on network endpoints has an availability dimension. A reboot interrupts established connections, resets connection-tracking state on some appliances, and may change routing or offload behavior. Before updating a load-balanced service, confirm that the remaining healthy nodes have enough capacity. Drain one node at a time, wait for long-lived sessions to close or reach an agreed timeout, update the kernel, reboot, and verify readiness before returning it to rotation. If the service uses MPTCP across multiple paths, include path failover behavior in the change test.
For stateful firewalls and gateways, confirm how the platform handles connection synchronization during rolling maintenance. A node may be healthy at the process level but not ready to accept traffic because routes, tunnel state, or conntrack synchronization has not converged. Include a check from a representative client network, not just a local health endpoint. Keep the previous image available according to the vendor’s supported rollback process, but make sure any rollback triggers the temporary exposure controls described in the risk record.
Coordinate patch windows with kernel extensions and out-of-tree modules. Storage, observability, security, and network agents can prevent a new kernel from booting or can lose functionality after an update. Verify that required modules have compatible builds and signatures. A failed reboot into the old image may leave the host vulnerable while monitoring shows only that the package manager completed successfully. Alert on a mismatch between the expected fixed build and the runtime kernel after maintenance.
In cloud fleets, update the source image before replacing instances. A one-time restart of running virtual machines is insufficient if autoscaling groups, instance templates, recovery plans, or managed node pools still refer to an old image. Test a newly launched replacement in the same network and confirm the vendor kernel is active. For immutable infrastructure, the remediation unit is often the image plus the rollout policy, rather than an individual host package.
For Kubernetes, coordinate node eviction with workload disruption budgets and persistent storage constraints. Update a canary node first, verify CNI and service routing, then proceed across zones. DaemonSets and privileged agents should be checked for kernel-version compatibility. The fact that a container restarts onto a patched node does not prove every replica moved; collect node-level evidence and tie each workload back to its current node. Managed Kubernetes customers should use the provider’s node image and maintenance guidance because the provider owns the kernel build.
A defensible remediation record ties the advisory to a specific artifact. Save the vendor’s CVE page or erratum, the package name and revision, the host or image identifier, the boot time after the update, and the running kernel string. Where the vendor publishes source-package status, include the exact kernel flavor and release. Where a product bundles a custom kernel, include the appliance firmware version and vendor statement. This prevents a later reviewer from having to infer whether a generic “Linux updated” note covered every system.
For organizations that generate SBOMs, connect the kernel package to the affected asset inventory and preserve a VEX statement when available. A VEX record can say that a product is affected, not affected, fixed, or under investigation, and can explain the basis for that status. It is particularly useful when an upstream CVE database shows a broad affected range while a distribution has backported the change. The statement should remain scoped to the exact product release; do not reuse a determination across a different kernel flavor without evidence.
Keep the original and updated scan results. A before-and-after comparison can show that the scanner recognized a vendor package revision, but it should not replace the vendor mapping. If a scanner continues to report the CVE after an update, record whether the finding is a stale inventory result, an unsupported kernel, a missing reboot, or a false positive due to backport handling. A closed finding with no explanation is difficult to defend and easy to reopen incorrectly.
Track exceptions with an owner, business reason, compensating controls, target date, and explicit re-evaluation condition. An exception for a temporarily unavailable appliance should identify the network paths it can receive, the services exposed, and whether MPTCP is active. Set an expiration rather than making the exception permanent. Reassess sooner if the vendor publishes a fix, new exploit evidence appears, or the appliance’s network boundary changes.
When the security team receives a CVE alert, the first decision is whether the organization owns a relevant kernel, not whether a vulnerability scanner has already produced a finding. Query endpoint management, cloud inventory, virtual machine images, Kubernetes node pools, network appliances, and embedded product records. Search for the kernel package and supported OS family. A source repository or runtime label can help locate systems, but confirm it against the actual running fleet.
The second decision is which assets can receive untrusted TCP traffic. Use cloud flow logs, load balancer configuration, firewall policy, service maps, and host listeners together. Distinguish direct internet traffic from traffic terminated by a managed proxy. Include trusted internal networks in the threat model because compromised workstations and workloads can become untrusted sources. A control-plane-only appliance may still have a data-plane interface reachable from customer networks.
The third decision is whether any condition elevates the priority. An MPTCP listener, request migration, reuseport BPF, public exposure, high-value network role, or lack of reliable host monitoring should move the system earlier in the queue. These conditions do not prove exploitation. They identify configurations that are closer to the known technical path or have higher business impact if compromised.
The fourth decision is how to validate closure. Identify the supported fixed package, deploy it, restart into it, test network services, and compare the final state against the advisory. Do not accept a planned maintenance ticket or a downloaded package as closure. The runtime state is the evidence that matters. If the patch cannot be applied, record a time-bounded exception and reduce reachable paths while the organization obtains a supported fix.
Finally, decide whether an incident investigation is needed. A vulnerable public MPTCP listener alone warrants urgent patching; it does not by itself prove compromise. Add incident response when there are relevant kernel faults, suspicious long-running connection attempts, unexplained root activity, integrity changes, or credible threat intelligence specific to the affected service. Keeping patch management and incident response linked but distinct avoids both complacency and unsupported breach declarations.
Executive updates should state the affected asset count, reachable service count, MPTCP exposure, fixed-build availability, rollout progress, and unresolved exceptions. Keep the Linux CNA’s CVSS 3.1 9.8, Ubuntu’s CVSS 4.0 8.3 and the current Red Hat product assessment attached to their sources and metric versions. Decision-makers need to know what their own environment runs and exposes, and whether a vendor-confirmed fix is actually available.
A concise technical statement can say: “The Linux IPv4 TCP request path can use IP-options memory after it has been freed. The upstream fix defers reclamation through RCU. Anthropic demonstrated remote root code execution against a vulnerable MPTCP listener in a controlled lab; this does not establish universal exploitability. We are patching internet-facing and MPTCP-enabled systems first and verifying the running vendor kernel after reboot.” This formulation communicates consequence, evidence, boundary, and action without overstating what is known.
Customer-facing communications should follow the organization’s incident and vulnerability disclosure policy. Do not claim a customer system is vulnerable solely because it runs Linux. Ask the platform or vendor for the exact kernel status and state whether a fixed build is available. If service interruption is required for a reboot, communicate the maintenance impact separately from exploit evidence.
Security teams should also preserve uncertainty. If a vendor has not yet assessed a custom image, say that status is under investigation and identify when it will be reviewed. If an MPTCP listener is not found, record the evidence and time of inspection. If the system is patched but a scanner has not recognized the backport, attach the vendor proof and keep the finding in a reviewable state until asset data converges.
The October 31, 2026 check did not confirm a CVE-specific Rocky Linux fixed package in the publicly accessible Rocky errata portal. Treat Rocky applicability and remediation as unresolved until the Rocky Linux errata service or Rocky support maps the exact release and kernel package to the upstream correction. Do not infer a Rocky fixed build from an RHEL version number, a compatible source package, or an older upstream kernel string.
On a Rocky host you administer, collect release identity, active kernel, and installed kernel packages:
cat /etc/os-release
uname -r
rpm -q kernel kernel-core kernel-modules
The DNF command reference documents advisory queries. If configured repositories expose CVE metadata, dnf updateinfo info --cves CVE-2026-98432 can help identify a matching advisory. It may refresh repository metadata and depends on repository coverage. No matching output is not proof that the installed kernel is safe; obtain an explicit vendor mapping before closing the item.
Also keep mitigation claims precise. The current Red Hat CVE page points to security bulletin RHSB-2026-016 for a detailed mitigation procedure. Read that product-specific procedure before acting. Disabling MPTCP, changing a Go listener preference, or filtering selected traffic is not a universal correction for the kernel memory-lifetime flaw. Prefer the vendor-supported fixed package, reboot into it, verify the active kernel, and retain post-change service checks.
No. The cited AWS bulletin says new tasks launched after November 1, 2026 at 09:00 PST / 17:00 UTC will use the patched platform. Existing tasks follow retirement settings unless replaced earlier. Verify each task\’s launch time, platform and replacement state; a scheduled rollout is not evidence that older tasks have already been replaced.
For EKS-optimized AL2023 managed or self-managed nodes and Karpenter, AWS identifies AMI release v20261031 or later. Verify the AMI and running kernel on the actual nodes. EKS Auto Mode replacement is AWS-managed and subject to NodePool disruption budgets; the expected global release date alone does not establish that every node has been replaced.
uname -r.uname -r, pveversion -v and the installed kernel package versions on the host.uname -r shows the corresponding running kernel after reboot.CVE-2026-98432 is a real kernel object-lifetime failure with a straightforward upstream correction and a demonstrated high-impact research outcome. Its risk should neither be reduced to a theoretical crash nor inflated into a claim that every Linux server is already remotely exploitable. The available evidence supports urgent, targeted action.
Prioritize exposed MPTCP listeners and internet-facing Linux TCP termination points. Use vendor package data rather than generic version matching. Apply the corrected kernel, reboot, validate service operation, update node and appliance templates, and preserve proof of the running fix. Where a change window cannot open immediately, disable unused MPTCP, narrow TCP exposure, and monitor relevant kernel and handshake behavior while scheduling the update.
The most important technical lesson is broader than this CVE: RCU protection is a contract between readers and reclaimers. A reader lock cannot protect an object that a writer returns directly to the allocator. The patch restores that contract by waiting for readers before freeing shared IP options. Verification should restore the operational contract as well: the organization knows which hosts were exposed, which fixed code they run, and whether the service still works after remediation.
Texto de penligent.ai tal como lo publicó, leído de su página y mostrado aquí con el formato de El Autómata. El original, en penligent.ai · Volver a la noticia de El Autómata