Seven case files, one habit: Linux writes the rule in one file and the exception in another, and the composition has no reviewer. The fixes are two lines. The wait is years.
The Nefarious Plan of Linux
Two destructors opted out of a convention their own file had already written down.
That is the diagnosis of CVE-2026-98432: Two Destructors in net/ipv4 Used kfree(). The Sibling Writers Already Used kfree_rcu()., in the words of the file. It is also the diagnosis of every other case file I have filed on Linux this year. The sentence works verbatim on six of them.
The charge is not that Linux writes bad code. The code is fine. The charge is that Linux ships local correctness, and the CVEs land in the space between two local correctnesses that nobody is paid to read side by side. The fix is small, every time. The wait is years, every time. The reason it waits is that the kernel's review process runs on files, and the bugs run on compositions.
The convention is in the file next to the bug
CVE-2026-31431: authencesn Has Been Writing Those Four Bytes for Nine Years. The Patch Is Not in authencesn. is nine years old. The template writes four bytes of scratch into its destination buffer. That is correct behavior under its contract. In 2017 a different file, algif_aead, made the destination buffer the user's scatterlist. Years later, splice let page cache into that scatterlist. The template never changed. The destination did:
The algorithm did not change. The destination did.
Three subsystems. Three correct decisions. One primitive that overwrites /usr/bin/su in cache. The patch is not in authencesn. The patch reverts the 2017 in-place optimization in a file the authencesn maintainer did not touch. The template was never wrong. The file around it was.
TCP wrote the flag down, UDP did not read it
CVE-2026-43284 + CVE-2026-43500: The Flag Was on TCP. UDP Did Not Set It. is the same shape at the network layer. The kernel has a bit called SKBFL_SHARED_FRAG that means "this skb carries pages the kernel does not own." TCP set it. ESP's fast path checked it. UDP's append path did not set it. RxRPC's fast path checked a different bit entirely and missed every paged-frag skb. Two receive paths. One trust boundary. One flag. The boundary existed as a convention in the skb layer's head.
The kernel had the metadata. One transport was setting it.
The follow-up, Dirty Frag: the patched half is the half Ubuntu already mitigated, stops hedging and names the mechanism out loud:
There is no review process in the kernel that runs against
esp_inputevery time someone touches__ip_append_data.
That is the whole story of the Linux CVE pipeline this year in one sentence. The 2017 fast-path commit was correct. The 2023 MSG_SPLICE_PAGES commit was correct. The composition is what shipped. Nothing in the kernel's workflow pairs the two files for one human to read in sequence.
The patch was on LKML for five years and seven months
CVE-2026-46333: The Dumpability Check Needs an mm. exit_mm() Runs Before exit_files(). is the clearest version. __ptrace_may_access denies a file-descriptor steal when the target is not user-dumpable. The deny clause is gated on mm &&. The kernel's do_exit() calls exit_mm() before exit_files(). During the interval, the task has no mm and the deny falls open. pidfd_getfd walks out with the open descriptors of a dying SUID binary. The exploit is a for loop.
The patch Linus committed on May 14, 2026 is the patch Jann Horn posted to LKML in October 2020.
Five years, seven months. Posted. Public. Archived. Every kernel from 5.6 onward shipped the primitive. Linus's commit does not reference the 2020 thread. Nobody who has to merge a security patch is obligated to read every prior thread that proposed one. That is the charge. It is not a code quality charge. It is a review-graph charge.
MS-SMB2 said MUST, ksmbd did not, Namjae Jeon wrote both commits
CVE-2026-31717: ksmbd's Durable Handle Was Not an Authorization, It Was a Credential is the only file where the rule was not in another kernel file. The rule was in Microsoft's protocol specification, the one ksmbd implements. The fix commit quotes it:
According to MS-SMB2, the server MUST verify that the SecurityContext of the reconnect request matches the SecurityContext associated with the existing open.
MUST. The implementation shipped for two years without the check. An unprivileged user guessed a 64-bit integer allocated from zero and inherited the victim's f_cred, with which the kernel then read /etc/shadow on their behalf. The author of the feature and the author of the fix are the same person. Nothing in two years of production shipping made Namjae Jeon reread §3.3.5.9.7, because nothing in the kernel's review workflow was going to make him. That is the fucking charge. It is not that ksmbd was written by one person. It is that one person is still, in 2026, the review graph for ksmbd's compliance with its own specification.
The destructor and the reader were in the same file
The 98432 file I opened with. net/ipv4/af_inet.c. Readers of inet_opt hold rcu_read_lock and call rcu_dereference. The destructor in the same file calls plain kfree. The reader convention and the destructor exception are in one compilation unit.
Both protocols were visible in the same file.
Not a different subsystem. Not a different year. Not a different maintainer. One file. The mismatch is a scroll. Nobody scrolled. The bug shipped in Linux 4.4. The fix is kfree_rcu in two places, dated 2026-10-05, six lines of commit message.
I have read a lot of bad patches. I had not read one that was a paragraph.
Where the vendor is right
The fixes are honest. Every one. Two lines of RCU for 98432. One skb_unshare for RxRPC. One strcmp in ksmbd's new durable_owner struct. One cached dumpability field in task_struct. One SKBFL_SHARED_FRAG set in UDP append and read in esp_input. A revert of the 2017 in-place optimization for Copy Fail. The maintainers who merge these patches understand the invariant the moment a researcher points at it. Linus's commit message for the dumpability fix reads like someone who gets it: "the concept comes from whether it can core dump or not, and makes no sense when you don't have an associated mm."
The algorithms are not wrong. authencesn's scratch write is correct under its own ownership contract. ESP's fast path is correct when the frags belong to the kernel. The pre-2017 esp_input was correct. The 2017 optimization was correct in 2017. UDP's MSG_SPLICE_PAGES is correct against receivers that read the flag. The dumpability check is correct on any process that still has an mm. ksmbd's lease branch does check the ClientGUID. None of these is slop. Every one is a correct local decision that composes wrong because the composition has no reviewer.
The bugs are not in the primitives the vendor wrote. The bugs are in the graph of files the vendor's workflow does not pair.
The next one is visible in the files above
Open a kernel commit whose subject line contains "avoid" or "whenever possible" or "fast path" applied to a defensive copy, a defensive check, a defensive unshare, a defensive free-with-grace-period. skb_cow_data replaced with skb_unshare. kfree_rcu replaced with kfree. rcu_dereference_protected swapped for a read with no reader-side changes. A branch added to a destructor that skips a step the destructor used to always take. The commit's reasoning is local and sound inside its own file. That is the first file.
Then open the file next door. The file that produces the input the first file consumes. Look for a bit, a flag, a field that signals "this input is foreign," "this credential belongs to someone else," "this pointer is live for RCU readers." SKBFL_SHARED_FRAG. f_cred. ireq_opt inherited through a child socket. The high 32 bits of an XFRM sequence number read from a netlink attribute. A persistent_id allocated from zero. Any field one subsystem sets and another subsystem reads to decide whether what follows is safe to modify.
Ask whether every producer sets the field. Ask whether every consumer checks it. Ask it across subsystems, because none of the maintainers will. Where producer and consumer disagree, the CVE is already in the tree. The files above are the ones where somebody finally wrote the question down.
What the next advisory looks like
The next Linux advisory of this shape will land in a net/ receive or teardown path that runs in-place work on an object whose ownership crossed a subsystem boundary. The boundary will be splice, io_uring fixed buffers, GUP-pinned pages, or an SCM_RIGHTS-passed struct file carrying a stale f_cred the receiver trusts. The fix will add a check on a flag or a field that already exists in the kernel's data structures. The Fixes: tag will cite a commit older than four years whose subject line contains "avoid," "whenever possible," or "fast path." The patch will be under twenty lines. The CVSS will be above 7. The window between report and merge will be short. The window between merge and Ubuntu's advisory will be longer. The researcher will be at a team that has published this year.
Mark that called or missed.
To Eric Dumazet, Steffen Klassert, Namjae Jeon, Linus: you do not have a code quality problem, you have a composition problem, and your own commit messages this year wrote it down. The next one is already in the tree, in two files reviewed by two people, neither of whom has read the other's file.