-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 NEFARIOUSPLAN-CANONICAL-V1 {"body_md":"> Two destructors opted out of a convention their own file had already written down.\n\nThat is the diagnosis of [CVE-2026-98432: Two Destructors in net/ipv4 Used kfree(). The Sibling Writers Already Used kfree_rcu().](/posts/cve-2026-98432-two-destructors-skipped-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.\n\nThe 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.\n\n## The convention is in the file next to the bug\n\n[CVE-2026-31431: authencesn Has Been Writing Those Four Bytes for Nine Years. The Patch Is Not in authencesn.](/posts/linux-copyfail-cve-2026-31431-the-bug-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:\n\n> The algorithm did not change. The destination did.\n\nThree 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.\n\n## TCP wrote the flag down, UDP did not read it\n\n[CVE-2026-43284 + CVE-2026-43500: The Flag Was on TCP. UDP Did Not Set It.](/posts/dirty-frag-tcp-set-the-flag-udp-did-not) 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.\n\n> The kernel had the metadata. One transport was setting it.\n\nThe follow-up, [Dirty Frag: the patched half is the half Ubuntu already mitigated](/posts/dirty-frag-patched-half-ubuntu-already-mitigates), stops hedging and names the mechanism out loud:\n\n> There is no review process in the kernel that runs against `esp_input` every time someone touches `__ip_append_data`.\n\nThat 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.\n\n## The patch was on LKML for five years and seven months\n\n[CVE-2026-46333: The Dumpability Check Needs an mm. exit_mm() Runs Before exit_files().](/posts/linux-cve-2026-46333-dumpability-needs-an-mm) 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.\n\n> The patch Linus committed on May 14, 2026 is the patch Jann Horn posted to LKML in October 2020.\n\nFive 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.\n\n## MS-SMB2 said MUST, ksmbd did not, Namjae Jeon wrote both commits\n\n[CVE-2026-31717: ksmbd's Durable Handle Was Not an Authorization, It Was a Credential](/posts/ksmbd-durable-handle-was-the-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:\n\n> According to MS-SMB2, the server MUST verify that the SecurityContext of the reconnect request matches the SecurityContext associated with the existing open.\n\nMUST. 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.\n\n## The destructor and the reader were in the same file\n\nThe 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.\n\n> Both protocols were visible in the same file.\n\nNot 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.\n\nI have read a lot of bad patches. I had not read one that was a paragraph.\n\n## Where the vendor is right\n\nThe 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.\"\n\nThe 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.\n\nThe bugs are not in the primitives the vendor wrote. The bugs are in the graph of files the vendor's workflow does not pair.\n\n## The next one is visible in the files above\n\nOpen 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.\n\nThen 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.\n\nAsk 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.\n\n## What the next advisory looks like\n\nThe 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.\n\nMark that called or missed.","closing_line":"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.","hook_md":"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.","post_id":863,"slug":"the-nefarious-plan-of-linux","title":"The Nefarious Plan of Linux","type":"editorial","unreadable_sentence":"The 2017 fast-path commit was correct, the 2023 MSG_SPLICE_PAGES commit was correct, and nothing in the kernel's workflow pairs the two files for one human to read in sequence."} -----BEGIN PGP SIGNATURE----- iHUEARYIAB0WIQRf0htP5+SjynlxywneZjl4jgkQJgUCavqL7wAKCRDeZjl4jgkQ JhW0AP4m4MId7kyPMpB3IYlI5lNomPgLc8Zn80IbuQt3swz1UwEA1MJggoSqiCK6 ILXWKOFscpVuyMK7b1md0LeiSIDnyAA= =0og8 -----END PGP SIGNATURE-----