//nefariousplan

The Nefarious Plan of Ivanti

Three Ivanti case files on this blog, in two products, over thirteen months. Read side by side, they stop looking like three bugs. They start looking like a vendor that keeps editing the documents around the engine, and an actor that keeps reading those documents to find the next one.

The integrity checker attests that the host is clean. The host is not clean.

That line is from Ivanti: The Vulnerability Subscription, published in January, when PHASEJAM was patching Ivanti's Integrity Checker Tool so the tool returned a clean verdict while the implants persisted. ICT, the Integrity Checker Tool, is Ivanti's own answer to the question of whether an appliance has been tampered with. ICT produces a document. The document says clean. The document is the only thing an operator has to read, because the appliance will not let them look at anything else.

This is the Ivanti security model, and I did not see it in one sentence until I had all three files open. Every defense Ivanti ships in these files is a document about the system. The Apache configuration that promises which URLs cannot be reached. The CVSS rating that promises a bug cannot be exploited. The end-of-life page that promises a branch is retired. The factory reset procedure that promises a clean baseline. The system does not read any of these documents. The attacker reads all of them.

The primitive stays, the regex changes

Open CVE-2026-10520: Ivanti Patched The Argument To handleMessage, Not The Call.

Both versions of the handler call CommonUtilities.executeNativeCommand. Both versions return the shell's stdout to the HTTP caller.

Pre-patch, the HTTP caller picked which shell command to run. Post-patch, Ivanti hardcoded the shell command inside the controller. The controller still calls configService.handleMessage. The dispatcher still parses the string as the MICS wire protocol, Ivanti's internal protocol for one management node to invoke an admin action on another. The protocol still has a commandexec module. The module still runs /bin/cat through a shell. The patch is one argument.

The companion CVE, 2026-10523, is not in the Java at all. It is in the bundled Apache HTTPD configuration. Ivanti added two regex rules that promise the path cannot be reached without authentication. The 2023 fix for the same product, credited to Horizon3.ai, was the same shape: one regex, different path. Three years. Two research teams. One fence layer. Two more promises added to a document.

The character set was the rating

Open CVE-2025-22457: Ivanti's End-of-Life Branch Was UNC5221's Lab.

The filter is on the bytes you can write. The bug is on how many of them you write.

Ivanti's February 11, 2025 advisory on this stack overflow said the input was constrained to periods and numbers, "evaluated and determined not to be exploitable as remote code execution." That sentence was the public risk rating, baked into a binary diff and shipped without an embargo. Five weeks later UNC5221 was exploiting it as remote code execution against the production fleet. Ivanti raised the rating to CVSS 9.0 on April 3. CISA added it to the Known Exploited Vulnerabilities catalog on April 4.

Ivanti rated the bug by the character filter. The character filter was on the source bytes. The destination was a fixed-size stack buffer. strlcpy copies a string with a length cap, and its third argument is the size of the destination. The code passed a size derived from the source. Nothing about restricting the input to [0-9.] tells a copy function the size of the thing it is writing to. The filter was never the bug. The rating was the filter.

The 22.7R2.6 patch rewrote WebRequest::dispatchRequest. It also turned on stack canaries, PIE, and FORTIFY_SOURCE, the compiler-level protections the previous binary had shipped without. One function change is a fix. The compiler-flag changes are an admission. A customer fleet of approximately four thousand internet-exposed appliances was running the unmitigated build at the moment of disclosure.

The 9.x branch of the same product, under end of life, had neither the patch nor the mitigations. Same bug. Same web process. Mandiant observed UNC5221 on both branches at the same time. End of life is a document. The actor read it as a published statement of which branch would not get the fix, and developed the exploit on the one the vendor had already written off.

The appliance is the attestation

Back to Ivanti: The Vulnerability Subscription and CVE-2025-0282, the pre-authentication stack overflow in the IKEv2 handler of Ivanti Connect Secure, disclosed January 8, 2025, exploited by December 2024 per Mandiant. Twelve days of pre-patch exposure on the box whose job is to be the VPN gateway.

PHASEJAM patches ICT to return clean results while the implants persist.

Connect Secure is a closed Linux box Ivanti ships. You cannot run your own EDR on it. You cannot patch the OS independently of Ivanti's release cycle. You cannot inspect the runtime without Ivanti's tooling. Ivanti's tooling is ICT. ICT runs in the same environment it attests about. That is not a hardening deficiency. That is the fucking architecture.

SPAWNSNAIL, the SSH backdoor in that campaign, survives factory reset. Factory reset is a document promising a clean baseline. Factory reset restores components from that baseline. The components in the baseline have been patched by SPAWNSNAIL. The restore procedure restores the backdoor. Every defense Ivanti ships on this appliance runs inside the thing it is defending. The attestation is a document produced by a tool the attacker has modified. The management traffic the attacker's C2 blends into is the traffic Ivanti needs on the box. The only lever a defender has is to not run the product.

This is the charge, and this is what it is not

The charge is that Ivanti's defenses are documents and Ivanti's fixes are edits to those documents. The Apache regex entries are a document. The CVSS rating is a document. The advisory language is a document. The ICT output is a document. The end-of-life page is a document. In three unrelated bugs across two different products over thirteen months, Ivanti's response pattern is the same shape: identify the document that got the system wrong, edit the document, ship. The MICS dispatcher still runs shell commands. The web process still parses untrusted HTTP into stack buffers in C++. ICT still attests from inside the environment it attests about.

That is what the files say. What they do not say, and what I will not charge, is that Ivanti knows a specific bug is being exploited and sits on it, or that any of this is unique to Ivanti in an industry that is not also guilty. Delegating URL authorization to a frontend web server is common. End of life is standard. In-process attestation is how most embedded appliances answer the question of self-inspection. The IKEv2 handler has to accept internet traffic because the appliance is the VPN. The strlcpy bug in dispatchRequest is a genuine C programmer error, and the rewrite in 22.7R2.6 is a real fix for that error, with the mitigation flags on alongside it.

What is Ivanti's, and only Ivanti's, is the repetition and the vocabulary. "Not exploitable as remote code execution" is in the advisory for a bug that was exploited as remote code execution five weeks later. "Integrity Checker Tool" is the name of a tool the attacker patched. Three years between two Sentry patches, and the second one adds two more regex entries to Apache. The vendor keeps picking the document as the layer to edit.

The next one is already in these files

Read the section titled "The MICS admin plane is the primitive" in the Sentry file. The MICS wire protocol is a vocabulary. commandexec is one module in that vocabulary. The file states there are others. Each module is a reflection-dispatched Java method the protocol's parser can reach. The Apache filter now denies unauthenticated callers to the specific path watchTowr found. It does not deny authenticated callers. It does not enumerate paths the deny list has not been told about. The JAR servlet still has no opinion about who is allowed to call handleMessage.

The next Sentry case file comes from a different URL that reaches the same dispatcher. A URL-encoding differential between Apache and the Tomcat behind it. An internal alias the deny list did not enumerate. A sibling route in another controller that also invokes ConfigServiceHandler.handleMessage. Or an authenticated session of a low-privilege role on a multi-tenant deployment. The dispatcher is the target. The fence is the regex.

The next Connect Secure case file comes from the web process. The pattern is a C or C++ copy into a fixed-size buffer with a length derived from the input, in a function other than dispatchRequest. The shared codebase that ships to ICS, IPS, ZTA, and Pulse Connect Secure contains others. UNC5221's post-exploitation kit already runs inside /home/bin/web. The implant family is designed for the process. The process is the substrate. The next bug in that process delivers code execution into infrastructure the operator already built for the last one.

I am calling the next advisory

The next Ivanti advisory in this class will be a pre-authentication buffer handling bug in the Connect Secure web process, in a function other than WebRequest::dispatchRequest, reachable on the public HTTPS listener before any endpoint is selected, attributed by Mandiant to UNC5221 or a cluster described as overlapping with it, with evidence of exploitation before the disclosure date, and patched in a release whose binary turns on one more compiler protection the previous build did not have. The advisory will describe the bug narrowly. The patch will rewrite the function. The next function in the shared codebase will still be there.

Or it will be in Sentry. A POST that reaches MICS through a path Apache's current regex set does not match, with an authenticated session of any role, invoking a module in the wire protocol's catalog other than commandexec. The fix will be more regex entries in the Apache configuration.

I am not calling which of the two it is. Either one is called by the pattern in these three files. A later reader can mark it against the next Ivanti advisory and say whether I got it right.

And to you, Ivanti. Your advisories, your commit messages, your rating text, your Apache configs, your end-of-life page, and your factory reset documentation all say the same thing when they are read side by side: you ship documents, and the next researcher is already reading them.