
By Javier Medina (X / LinkedIn / Web)
TL;DR
$ nc 127.0.0.1 5000whoamirootpwd/
If I were younger, and a bit more impressed with myself, this would probably have a name by now. CUPS4ROOT. CUPS2SHELL. Maybe CUPSKALYPSIS, which, to be honest, is a pretty good name. There would be a logo, a countdown, maybe a printer on fire and an overly dramatic website explaining why the internet is broken. Instead, I just looked at the terminal and wondered if anyone would even care.
I am not saying that out of false modesty. We spent two weekends in September looking for vulnerabilities in Linux components using Git, a few virtual machines, and a ChatGPT subscription to help us search for variants. Then we spent the next sixty days trying to disclose them properly. By the time we had everything ready to publish, it felt like half the industry was generating vulnerability reports by the dozen.
This post connects five things that are usually discussed separately, and mostly in the abstract:
- Variant analysis: Finding one bug doesn’t mean you’ve exhausted the bug family.
- Patching: Blocking a PoC isn’t the same as restoring the security invariant.
- LLM-assisted discovery: Exploring variants is getting cheaper for researchers and attackers alike; and it seems (to no one’s surprise) that many people using the same inputs may be generating similar outputs.
- Disclosure: The traditional 30-, 60-, and 90-day windows assume a pace of discovery and coordination that may no longer hold.
- The real-world mess: What actually happened with NVMe/TCP, CUPS, the variants, the patches, and the maintainers trying to handle them.
If you work in offensive security or vulnerability management, I think the story is worth reading.
0# First, the Evidence
We looked at three targets across different trust boundaries. We were not interested in memory corruption bugs; we wanted to look for design and logic flaws in how state and privileges move across components. Here is how each one worked in our lab.
NVMe/TCP: Storage Access without the Storage Secret
We started in the Linux kernel by looking at a commit that looked reasonable on paper: c91a20129185d5153cd845c857b4f9fce61e28d1 (nvmet-auth: authenticate on admin queue only).
In NVMe over Fabrics, a controller can authenticate hosts using DH-HMAC-CHAP. That commit moved authentication checks onto the Admin Queue (qid = 0) and skipped authentication on I/O queues (qid > 0), assuming I/O queues would simply inherit the controller’s authenticated state. From a performance standpoint, it seems to make sense. That split showed up in two places.
First, in drivers/nvme/target/fabrics-cmd.c:
/* Do not authenticate I/O queues */if (sq->qid) needs_auth = false;
Second, at the authorization check in drivers/nvme/target/auth.c:
bool nvmet_check_auth_status(struct nvmet_req *req){ if (req->sq->ctrl->host_key) { if (req->sq->qid > 0) return true; if (!req->sq->authenticated) return false; } return true;}
This shortcut only holds if there is no way for a controller to reach the READY state and accept I/O connections before the Admin Queue finishes authentication.
When we traced the target’s state machine at the wire level, that assumption broke down immediately. A standard NVMe/TCP session starts with an ICReq/ICResp PDU exchange (0x00/0x01), followed by a Fabrics Connect command (opcode 0x7f, fctype 0x01) on qid = 0. When a host key is configured for an authorized HostNQN, the target allocates a controller ID (CNTLID) and sets the ATR (Authentication Required, bit 17) flag in the completion queue result, expecting the client to run DH-HMAC-CHAP next.
However, the controller object already exists in memory with sq[0].authenticated = false, and the fabrics property handlers did not gate state transitions on that flag. By using an authorized HostNQN without knowing the DH-HMAC-CHAP secret, and sending raw NVMe/TCP PDUs instead of using nvme-cli, we walked the controller straight into an operational state:
- Admin Connect (
qid = 0): Target allocatesCNTLID=1and returnsATR=1, leaving admin authentication pending. - DH-HMAC-CHAP: Skipped entirely.
- Fabrics Property Set (
fctype 0x00): WritingNVME_CC_VALUE (0x00460001)to registerCC(offset0x14) is accepted on the unauthenticated Admin Queue. PollingCSTS(offset0x1c) confirmsCSTS.RDY = 1. - I/O Connect (
qid = 1): Connecting a second TCP socket and sending Fabrics Connect forqid = 1withCNTLID=1succeeds. Becauseqid > 0,nvmet_check_auth_status()returns true immediately and doesn’t even setATR=1in the I/O Connect response. - NVM Read (opcode
0x02): Sending a 512-byte READ command forNSID=1,LBA=2048onqid = 1returns the protected namespace data:
$ ./exploitNVMe/TCP lab client v2 -- read-only, fixed targetTarget: 10.0.2.4:4420Subsystem: nqn.2026-09.itres.lab:nvme-auth-testHostNQN: nqn.2026-09.itres.lab:host01NSID=1 LBA=2048 len=512[+] admin TCP connected[+] admin: ICReq/ICResp complete (no digests)[+] Admin Connect result=0x00020001 CNTLID=1 ATR(auth-required)=1 ASCR=0[+] Intentionally NOT performing DH-HMAC-CHAP; admin auth remains pending[+] Property Set CC=0x00460001 accepted on unauthenticated admin queue[+] Property Get CSTS=0x00000001 (RDY=1)[+] I/O TCP connected[+] io-q1: ICReq/ICResp complete (no digests)[+] I/O Connect result=0x00000001 CNTLID=1 ATR(auth-required)=0[+] Sending ONE read-only command: NSID=1 LBA=2048 (512 bytes)[+] READ payload (printable prefix): ITRES-NVME-LAB-MARKER-2026[+] C2H_DATA flags: LAST=1 SUCCESS=1[!!!] LAB RESULT: unauthenticated Admin Queue -> unauthenticated qid=1 -> READ succeeded.
A standard Linux nvme-cli client would never hit this because it sees ATR=1 and dutifully starts the DH-HMAC-CHAP handshake. With a minimal raw TCP client, we didn’t crack any secret or break cryptography—we just skipped a state transition the target forgot to enforce.
We sent the report to the NVMe maintainers and security@kernel.org on September 16 at 13:07. Forty-three minutes later, at 13:50, Hannes Reinecke replied with a proposed diff checking the authenticated state of queue 0:
--- a/drivers/nvme/target/auth.c+++ b/drivers/nvme/target/auth.c@@ -269,8 +269,10 @@ void nvmet_destroy_auth(struct nvmet_ctrl *ctrl) bool nvmet_check_auth_status(struct nvmet_req *req) { if (req->sq->ctrl->host_key) {- if (req->sq->qid > 0)- return true;+ if (req->sq->qid > 0) {+ struct nvmet_sq *sq0 = req->sq->ctrl->sqs[0];+ return sq0->authenticated;+ } if (!req->sq->authenticated) return false; }
That same afternoon, we rebuilt nvmet.ko against our Ubuntu 7.0.0-31-generic lab kernel, loaded the patched module, reset the target, and ran the exact same client unchanged. The connection still reached qid = 1, as expected, but the READ was now blocked:
[+] I/O Connect result=0x00000001 CNTLID=1 ATR(auth-required)=0[+] Sending ONE read-only command: NSID=1 LBA=2048 (512 bytes)[-] READ: NVMe status=0x4191 raw=0x8322 result=0x0000000000000000
Status 0x4191 (NVME_SC_AUTH_REQUIRED | NVME_STATUS_DNR), zero bytes returned, and an authenticated control client still worked normally. Fast turnaround from the maintainer, clean reproducer, perfect. At first glance, the bug looked completely solved. As we saw a few weeks later, it wasn’t.
CUPS: The Name survived the Fix
CVE-2026-34980 had already exposed an issue in CUPS involving options, control characters, and scheduler instructions. The patch for that vulnerability sanitized dangerous characters inside IPP option values. So we decided to look at option names.
IPP is a binary protocol where attributes carry explicit length-prefixed names and values… both coming directly from untrusted network clients. Inside CUPS, however, an attribute name was concatenated into a plain text option string before any value escaping took place:
cupsConcatString(optptr, attr->name, ...);cupsConcatString(optptr, "=", ...);/* value escaping happened later */
Because the text representation was assembled first, control characters smuggled inside attr->name survived into downstream components. Turning that into code execution required chaining two separate parser differentials across the printing pipeline:
- Differential 1 (IPP attribute name → pstops status line): Injecting line breaks inside a crafted
page-borderattribute name allowed us to smuggle a newline into the parsed option string. Whenpstopsprocessed the job and emitted diagnostic output,cupsdinterpreted the injected line as an internalPPD:status record. - Differential 2 (In-memory PPD update → disk reparsing): A carriage return (
\r) placed inside the value of an otherwise allowed PPD keyword passed the scheduler’s sensitive-keyword check in memory. However, oncecupsdserialized the updated PPD file to disk and parsed it back, that\racted as a line separator and created a fresh*cupsFilter2directive.
In short, the previous patch protected the data format the developers were looking at, and missed what happened when that same data was serialized to disk and parsed again under a different grammar. Part of this is the cost of legacy C plumbing: passing data back and forth through C strings, text options, and flat PPD files keeps turning untrusted bytes into syntax.
In our initial report, we pointed *cupsFilter2 to a filter path that did not exist on disk:
.../cups-lab-filter-THIS-MUST-NOT-EXISTNo such file or directory
That proved we could inject an arbitrary filter path into the queue’s PPD, even though it didn’t demonstrate command execution yet. The inert reproducer and full chain are documented in GHSA-w9hj-hq9p-m7f6. OpenPrinting accepted the report, published the advisory on September 16 with a Moderate score (4.6), and shipped a fix in CUPS 2.4.20 that validates IPP attribute names unconditionally.
On their side, the ticket was closed. On our side, we wanted to see if we could get reliable execution without dropping any files on disk.
The trick lies in how CUPS invokes every filter in its pipeline. Regardless of what binary is configured in *cupsFilter2, cupsd executes it with a fixed positional argv contract:
argv[1] -> job-idargv[2] -> requesting-user-nameargv[3] -> job-titleargv[4] -> copiesargv[5] -> optionsargv[6] -> document-filename
Instead of a nonexistent path, we injected /usr/bin/timeout as the filter in Stage 1. Then, in Stage 2, we sent a completely normal Print-Job IPP request where requesting-user-name was set to an interpreter binary already present on the system, and job-name carried the inline program to run. When CUPS spawned the filter, /usr/bin/timeout naturally parsed argv[1] (job-id) as the timeout duration in seconds, argv[2] (requesting-user-name) as the command to execute, and argv[3] (job-title) as its argument:
shell> whoamilpshell> uname -aLinux NVME-POC-SERVER 7.0.0-31-generic ...
This is remote code execution as the lp user. In our lab, it required a reachable scheduler, a shared legacy PostScript/PPD queue and permissions to submit a print job. Those preconditions matter. And mind you, I’m not saying it’s not exploitable. In fact, assigning an RCE a CVSS score of 4.6 seems reckless to me, because it turns it into the kind of thing that many people won’t patch, and then someone less well-intentioned than us will exploit it. Besides, there isn’t even a CVE (and we don’t plan on requesting one).
CUPS-Browsed: A Print Job Becomes a Root Process
At that point, looking for one more printer bug seemed like a reasonable way to spend an afternoon… especially if it could be linked to the previous one.
On an Ubuntu 26.04 lab VM running cups, cups-browsed, and avahi-daemon, we spun up an ippeveprinter emulator advertising an IPP Everywhere raster device (image/pwg-raster). As expected, cups-browsed discovered it automatically and created a local implicitclass:// queue. Any regular, unprivileged user on the system (outside lpadmin) could submit a PDF to that queue, triggering a conversion pipeline through libcupsfilters (cfFilterUniversal) and Ghostscript.
Here, the question wasn’t text turning into syntax, but whose privileges survived across process boundaries.
Some CUPS backends and filter chains start from a privileged scheduler context (UID=0). In this setup, that elevated identity was never dropped before handing execution down to the document conversion stage… a stage that still accepted job-level options controlled by the unprivileged user who submitted the PDF. By pointing a diagnostic helper into that conversion path, we confirmed what context the child process was running under UID 0.
[Job 119] Queued on "cups_vh_raster" by "vboxuser".[Job 119] cfFilterUniversal: Adding ghostscript to chain[Job 119] Fontmap entry for CUPS_VH_UID=0 ends prematurely! Giving up.
Audit logs independently confirmed that Ghostscript was executing with UID/EUID 0 under the cupsd//third_party AppArmor profile. Because a print conversion job is short-lived, we then tested a native helper that forked, called setsid() to detach from the filter process group, and bound a listener… giving us the root session shown at the beginning of this post.
We are not publishing the unpatched execution trigger or the helper code here. Explaining the architectural conditions is one thing; turning the post into a copy-paste LPE before there is a fix is another.
We reported this in September, and the ticket moved between CUPS, cups-filters, and cups-browsed. We followed up in writing to state that our investigation was still evolving. As of November 18; roughly sixty days later; there is still no confirmed patch for this path.
1# And Then They Taught Us Something
While we were writing reports, waiting for replies, and retesting patches, other people were looking at the exact same kernel code.
On October 13, Sung Byeongchan independently fixed our original NVMe/TCP issue in upstream commit 44512543ff04. Interestingly, the commit message credits AI-assisted source review and describes a raw network reproducer that reads namespace data without completing authentication; basically the same path we had reported in September. At first glance, it appears to be a collision. We don’t know, and we haven’t made any effort to get to the bottom of it.
Then, on October 28, Josef Bacik submitted another patch through Jens Axboe’s block tree (discussed on linux-nvme) that went even further. He noticed that a second, unauthenticated host didn’t even need to create its own controller. If it knew the right identifiers, it could attach an unused I/O queue directly to a controller that another legitimate client had already authenticated. Look back at Hannes’s proposed check (return sq0->authenticated;): if Client A had already authenticated sqs[0] on that controller, sq0->authenticated was true globally, so Client B’s unauthenticated qid = 1 passed the check anyway.
Obviously, we didn’t find this second-client variant ourselves, but we reproduced it on November 17 because it exposed that exact limitation in the earlier fix we had tested. We compiled three isolated versions of nvmet.ko and ran the same two-client test against all of them:
| Target module | Client A (authenticated) | Client B (no shared secret) |
| Ubuntu stock | READ succeeds | READ succeeds |
| Hannes’s proposed queue-0 check | READ succeeds | READ succeeds |
| Bacik’s per-I/O-queue authentication | READ succeeds | READ rejected (0x4191) |
Our September test wasn’t wrong and it proved that our specific exploit path was blocked. The mistake was assuming that blocking one path meant the underlying security boundary was fixed. A stupid mistake… doing what we do.
The real invariant wasn’t an unauthenticated client cannot enable its own controller via Property Set. It was no unauthenticated connection can perform I/O, even if it tries to reuse an already authenticated controller. Those are two very different things. One describes a specific exploit; the other describes the actual security requirement.
This is the most interesting takeaway from the kernel bug. Not the exploit, but the invariant.
2# What “Fixed” Means When Variant Hunting Is Cheap
In practice, vulnerability management historically works like a simple loop:
VULNERABILITY -> FIX -> TEST -> DONE
Experienced engineers know that passing one test doesn’t prove a codebase is bug-free. Still, limited time, release schedules, and ticket queues push everyone to work as if it did: patch the reported path, run the PoC, close the ticket, and move on.
Teams like Google Project Zero have talked about root-cause analysis and variant hunting for years. Although, judging by the result, I’m not sure the message really got through… maybe they should have included some memes.
What has changed recently is how cheap it has become to look for variants. Today, anyone (a researcher, a student, or an attacker) can take a patch diff and ask an LLM: “Hey! Show me another way through this code where the same assumption still fails.”
You don’t need a full proof that the software is broken. You just need one edge case. One reachable state, one controller authenticated by someone else, or one byte that is treated as data by the first parser and as syntax by the second.
There is another side effect to this. When hundreds of people point the same frontier models at the same recent commits and popular codebases, those models tend to flag the exact same suspicious patterns. Different models can still surface complementary bugs, as Unit 42 noted, so they won’t always find identical issues. Even so, shared training priors and similar prompts push everyone toward the same hot spots; which means independent collisions on the exact same bug become much more likely while a report sits in triage.
The asymmetry between both sides is obvious:
- Variant hunting: Find one single counterexample that works.
- Root-cause fixing: Rule out every reachable counterexample without breaking existing functionality.
In logic, that is the difference between finding one witness and proving a universal rule. In engineering, it is the difference between writing a PoC on a Friday afternoon and spending weeks reasoning about concurrency, legacy interfaces, and backward compatibility.
To be realistic, Rice’s theorem reminds us that there is no magic algorithm capable of automatically proving arbitrary semantic properties for every program. That doesn’t mean we should give up on bounded model checking, contracts, or better testing, but it does mean there will never be a universal button that guarantees a bug class is completely gone. Meanwhile, maintainers still have to figure out what the invariant actually is, which configurations are supported, and when a patch is safe enough to ship. An LLM can write a reproducer in seconds, but it doesn’t remove the human workload on the defensive side.
The data from the rest of the industry points in the same direction. In September, Trail of Bits reported that 283 of 2,265 initial fixes in their audits (12.5%) failed to fully resolve the reported issue. They were written by developers who had a detailed audit report in front of them. In October, Trail of Bits released tooling focused on invariant-guided repair and regression checks, which is a step in the right direction, though it also confirms that a single green test is no longer enough.
Then, in November, the Microsoft Security Response Center published numbers from their own scanning: 26,502 raw findings, 621 cases with working PoCs, and 59 upstream reports. Out of those 621 cases, 266 shared a root cause with another finding. One good root-cause fix could close several bugs at once, while a narrow patch leaves variants behind. Microsoft also noted that running the scans took around two weeks, while triaging, reporting, and fixing them took months of expert engineering time.
We don’t need Microsoft’s infrastructure to see the same pattern. A $20 subscription, Git, and a couple of VMs are enough to do serious variant hunting. You still need to understand the code, filter out hallucinations, and verify everything manually; but the entry barrier has dropped a lot, while maintainer capacity has stayed the same.
A Few Cheap Habits Before Hitting Merge
I don’t mean to sound like a guru. Mainly because I think there are no simple solutions to hard problems, and nothing here eliminates the asymmetry or replaces understanding your own codebase. Still, if you maintain software and receive a vulnerability report, a few low-cost habits can at least catch some variants before a patch goes out:
- Write down the invariant in one plain sentence before touching the code. Do not ask, “How do I block this PoC?” Ask, “What rule must always hold here?” In NVMe/TCP, the rule wasn’t “Queue 0 must finish authentication.” It was “No unauthenticated connection can perform I/O.” Writing that sentence down takes thirty seconds and often exposes narrow patches before you even compile.
- Break your own diff with the same LLM subscription. Or automate the whole thing. Put it in a CI pipeline, use a coding agent, run a local model or build whatever fits your workflow. The LLM subscription is just one example. But before merging a fix, test the patch and ask: “Assume this invariant must hold. How can an attacker still bypass this patch?”
- Run a quick
git grepon sibling inputs and callers. If a reporter found an injection inattr->value, checkattr->name. If a guard was added toqid == 0, check what happens whenqid > 0. Spending two minutes auditing the immediate neighborhood of a bug catches the most obvious sibling paths. - Enforce the check at the boundary, not just at the front door. Sanitizing input early breaks whenever data crosses another parser or serialization step later (like in-memory PPD updates being written to disk and reparsed in CUPS). Whenever practical, put the check right where the state transition happens or the privilege is actually used.
3# Sixty Days Is a Long Time Now
In our CUPS case, the report was accepted, scored, published, and closed on September 16. Closing the ticket was the maintainers’ workflow decision, even though our testing continued and led to the lp shell later on. For cups-browsed, the report moved between different components, and even though we kept updating the thread in writing, sixty days passed without a confirmed fix.
This isn’t a complaint against volunteer maintainers. Nobody expects them to work for free around the clock. The problem is structural. The math simply doesn’t work anymore, even when everyone acts in good faith.
Look at the queues right now. In January, curl shut down its bug-bounty program (as Daniel Stenberg documented) partly because of the flood of low-quality AI reports. At the same time, Microsoft is reporting hundreds of PoC-backed kernel bugs, Trail of Bits is automating variant checks… and independent researchers are digging through Git commits. Garbage reports and real vulnerabilities are all competing for the exact same pool of human attention.
Years ago, the bottleneck in security was finding the bug. Today, the bottleneck is finding someone who has the time to understand a bug family, define the proper invariant, fix the boundary, verify the patch, backport it, and coordinate disclosure. The bottleneck moved, but our disclosure and ticketing workflows stayed the same.
There’s also something those workflows don’t measure. Thirty, sixty, or ninety days may sound like reasonable administrative deadlines, but they are a very long time when discovery is getting cheaper. During that window, another researcher might find the same issue and help get it fixed. Or another researcher might find a variant. Or an attacker might get there first. A new commit can make an adjacent path obvious. These are not all bad collisions, but they are all possible, and the disclosure clock does nothing to stop them. We don’t even need to prove that the NVMe/TCP reports were a collision to see the problem.
Independent rediscovery isn’t new; RAND was studying zero-day collision rates back in 2017. What we cannot do is assume those historical rates still describe a world of cheap, repeatable, AI-assisted code review. On November 13, Google Project Zero explicitly argued that its traditional 90-day timeline is no longer sufficient, and announced a phased move to 60 and then 30 days. That’s a policy response, not a proof that any particular deadline is safe. The clock starts when someone files a report; the next discovery doesn’t wait for it.
4# Final Thoughts
I already know the obvious counterarguments to this post:
- The AI didn’t find the bugs on its own. True, for these specific scenarios, where for all intents and purposes, we had a $20 subscription to ChatGPT. We could have made it much more sophisticated; it wouldn’t have made much of a difference. So, yes, we picked the targets, traced the data flows, debugged the PoCs, and threw away plenty of wrong suggestions from the model. Anyway, LLM made exploration much faster.
- Three bugs are not a scientific sample. Agreed. These are lab notes, not a statistical study. We’ve said many times before that we don’t set out to do science; we’re content simply to make people think.
- You didn’t fight the 4.6 CVSS score (or push for a CVE) on the CUPS RCE. Fair, but OpenPrinting already closed the ticket, published the GHSA, and shipped the fix. We aren’t Google; we don’t have the headcount to spend weeks debating severity metrics or chasing every questionable maintainer decision.
- You missed the multi-client NVMe/TCP variant in your initial report. Completely true, which is why Section 1 is titled “And Then They Taught Us Something.” We took the lesson, and we’ll force us to checking the full security invariant before reporting is going straight into our workflow.
- You tested specific lab setups and withheld the exploit code. Also true. Parts of this chain aren’t even patched yet, so dropping weaponized reproducers right now would be irresponsible. Once the remaining fixes land, we plan to devote separate posts to CUPS and NVMe/TCP; both are serious bugs that deserve a proper technical breakdown and full visibility.
Even with those caveats, the three findings are real 0day vulnerabilites. We read protected NVMe storage without authenticating, bypassed two CUPS parsers to get execution as lp, and reached a root shell from an unprivileged print job. We reported all of them, watched one kernel bug get patched twice because the first fix was too narrow, and hit a sixty-day wall on another.
If this had happened a year ago, I probably would have bought the domain for CUPSKALYPSIS.IO.
Today, I am much more interested in what does “fixed” actually mean when finding the next variant is cheaper than fixing the previous one?
I think the answer isn’t to stop looking for bugs, but to stop assuming (we should never have agreed to it) that blocking one PoC means a security property has been restored. Right now, an attacker only needs one working edge case, but a defender needs confidence that no other edge cases remain… and our bug trackers still treat clicking “Close” as the end of the story.
References
Vulnerabilities and patches
- Linux NVMe/TCP: Original
nvmet-authcommit — c91a20129185; Sung Byeongchan’s upstream fix — 44512543ff04; Josef Bacik’s per-I/O-queue authentication patch, October 28. - CUPS prior option-value mitigation: CVE-2026-34980 / original security advisory.
- CUPS IPP attribute-name differential: GHSA-w9hj-hq9p-m7f6; fix commit 05fe6b0e848e, included in CUPS 2.4.20.
Protocols and components
- CUPS filter contract:
filter(7)manual. - IPP specifications: RFC 8010 — Encoding and Transport and RFC 8011 — Model and Semantics.
- Printing stack: cups-browsed / implicit-class backend; libcupsfilters /
cfFilterUniversal;ippeveprinter(1).
Research, disclosure, and methodology
- Google Project Zero: Root-cause and variant analysis; Policy and Disclosure: 2026 Edition.
- Trail of Bits: Incomplete first fixes — 283 / 2,265; Your AI agent fixed the bug, but what else did it change?.
- Microsoft Security Response Center: Lessons from 59 Linux Kernel Bug Reports.
- Daniel Stenberg / curl: The end of the curl bug-bounty.
- RAND: Zero Days, Thousands of Nights — historical zero-day collision research (PDF).
- Unit 42: The Frontier AI Vulnerability Burst — multi-model complementarity.
- Theory: Rice’s theorem and bounded model checking.
Disclosure Notes
The initial investigation across the three targets took roughly ten active hours over two weekends; debugging, reporting, and retesting continued over the following sixty days.
The NVMe/TCP follow-up reproduces Josef Bacik’s published second-client issue in isolated test builds; ITRES Labs does not claim credit for discovering that variant.
The lp shell was demonstrated in subsequent post-advisory testing.
Specific exploitation steps for the unpatched local privilege escalation path on cups-browsed are withheld pending a coordinated fix.
All findings apply to the described lab setups rather than default production configurations.
