Why this matters now
On November 13, 2026, CISA added CVE-2026-123039 to its Known Exploited Vulnerabilities catalog, with a federal remediation deadline of November 16 — today. The flaw is a local privilege escalation in the DynamicCLI service of Check Point Gaia OS: the daemon that runs extended command-line operations runs as root and listens on a local socket that any local user can write to, with no authentication at all. On its own it needs a foothold on the appliance. The reason it is on KEV, and the reason this hunt is urgent, is that attackers already had that foothold. Check Point Research documented a campaign that began October 30, 2026, in which the PHP2Shell flaws in the Mobile Access portal gave attackers code execution on unpatched Security Gateways, CVE-2026-123039 turned that into root, and the campaign then planted PHP webshells and the TSGA backdoor — and in the first wave, pivoted from the gateway to a VMware ESXi host and ran a wiper that destroyed data and left politically themed notes behind.
| CVE | CVE-2026-123039 — Incorrect Permission Assignment for Critical Resource in the Check Point Gaia OS DynamicCLI service |
|---|---|
| CVSS | 7.8 High (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), scored by Check Point as the CNA. NVD has not published its own assessment yet — the entry is still "Undergoing Enrichment" — so the vendor score is the only score, and this article leads with it and notes the gap. |
| Weakness | CWE-732 — Incorrect Permission Assignment for Critical Resource, and CWE-862 — Missing Authorization, both per the Check Point CNA on the NVD entry |
| Affected product | Check Point Quantum Security Gateways (Force Firewalls), Security Management and Log Servers, Multi-Domain Security Management and Multi-Domain Log Servers, and Maestro Orchestrator — Gaia R81, R81.10, R81.20, R82, R82.10, and R82.20. Spark Firewalls and Smart-1 Cloud are not affected. |
| Vendor | Check Point Software Technologies |
| Disclosure | Advisory sk1000362 created November 8, 2026; CVE published and Check Point Research report released November 12, 2026 |
| CISA KEV | Added November 13, 2026; federal remediation due November 16, 2026. Known ransomware use: Unknown. CISA's required action also invokes its BOD 26-04 forensics triage requirements. |
| Fixed in | November Jumbo Hotfix Accumulator: R82.20 Take 14 or later, R82.10 Take 52 or later, R82 Take 132 or later, R81.20 Take 174 or later. R81.10 and R81 are listed as affected and are end-of-support, with no Jumbo take listed for them — the path there is an upgrade, not a hotfix. |
| Exploitation | Confirmed — Check Point observed active exploitation against "a couple of dozen customers", running October 30 to November 4, 2026, chained with PHP2Shell (CVE-2026-109618 and CVE-2026-109619) on Mobile Access portals. The first wave on October 30 targeted Israeli organizations and included destructive activity; a broader second wave on November 2 hit organizations in several countries and sectors, with no destruction observed. |
This is the second half of the PHP2Shell story, and it is the half that turns a portal compromise into a root compromise of the firewall itself. The PHP2Shell hotfix had been available since October 23 — about a week before the first wave — and the November Jumbo Hotfix rolls up both the PHP2Shell fix and this one, so a single install closes the whole chain. But patching a gateway that was already entered does not evict the TSGA backdoor, and it does not restore the ESXi data the wiper destroyed. The hunts below follow the chain in order: the socket, the webshells, the backdoor, and the pivot.
The deadline is today, but the hunting window is the last three weeks: the first exploitation was October 30, so run these hunts back to at least October 23, the day the PHP2Shell hotfix shipped — any gateway that was unpatched after that date was in the target population.
The technique, in hunt terms
Gaia OS serves its Dynamic CLI through a root process, dynamic_server, which listens on a local Unix socket at /tmp/dynamic_socket. On affected releases the socket is created world-writable (0777) and the daemon never checks who connects. Any authenticated local user — including the portal service account an attacker lands as through PHP2Shell — can write a command string to the socket and have dynamic_server execute it as root. There is no privilege boundary to cross and no exploit payload to craft: it is a single write to a socket.
What makes this huntable is that the vulnerable daemon is also a chatty one. Check Point's advisory states that dynamic_server logs every command it receives to /var/log/dynamicCli.log, and legitimate requests all use the same Clish wrapper — a Received = #524288# line that sources /opt/CPshared/5.0/tmp/.CPprofile.sh and sets SP_DISTRIBUTE=0 before running a Gaia binary. Any command in that log that does not use the wrapper is a command that was executed as root through the socket by something other than the legitimate CLI. That one distinction is the highest-fidelity signal in this article, and Hunt 1 is built on it.
From root, the campaign Check Point Research documented follows a consistent chain. First, PHP webshells written into the portal's login-page templates, named zz<random>.tpl and gated by the hardcoded key zz2026. Second, the TSGA backdoor, launched as /tmp/CPconfigdaemon and relocating itself as slot_CPconfigdaemon, carrying an embedded TSProxy library written to /lib/libcpfwcommon.so and injected into appliance processes — encrypted remote access, configuration theft, backup and snapshot persistence, process injection, and tampering with the binary firewall logs. Third, the open-source gogo scanner run from the gateway to map internal hosts. Fourth, an SSH pivot to a VMware ESXi host using the vpxuser service account, where the destroy_v6 wiper was staged as /tmp/des and executed, recursively deleting files and leaving a DREAM_ANNEXATION.txt note in each processed directory.
In MITRE ATT&CK terms, the chain maps to T1190 (Exploit Public-Facing Application) for the PHP2Shell entry through the Mobile Access portal, T1068 (Exploitation for Privilege Escalation) for the DynamicCLI socket, T1505.003 (Server Software Component: Web Shell) for the zz*.tpl shells, T1055 (Process Injection) for TSProxy loaded into appliance processes, T1046 (Network Service Discovery) for the gogo scan from the gateway, T1021.004 (Remote Services: SSH) for the pivot to ESXi as vpxuser, T1071.001 (Web Protocols) for TSGA's encrypted channel on TCP 11072, and T1485 (Data Destruction) for the wiper. The same edge-appliance lesson from the Barracuda ESG hunt applies here — an unauthenticated flaw on the box, a chain to root, and a patch that does not evict an attacker who already got in — and the tooling lineage reaches back to the Ivanti edge exploitation campaign, where the same PhiliKit framework was seen against VPN appliances.
One honest framing note before the queries: the CrowdStrike Falcon sensor does not run on Gaia OS, so there is no Falcon process data from the gateway itself. The CrowdStrike sets below cover the two places Falcon does see this campaign — the same gateway logs forwarded into Falcon LogScale as third-party data, and Falcon endpoint telemetry on the internal estate the attacker pivots into, including the Linux systems around your ESXi hosts. If you do not forward /var/log/dynamicCli.log anywhere today, Hunt 1 is a reason to start: it is the only log that records the escalation itself.
A note on what is a hunting hypothesis and what is confirmed: the socket path and permissions, the Clish wrapper, the system() sink, the webshell names and key, the TSGA paths and port, the gogo scan, the vpxuser pivot, the wiper name and staging path, the two campaign waves, and the published file hashes are all documented in Check Point's advisory and research report. The attacker source IPs and hashes are campaign indicators, not a guarantee the same infrastructure was used against your gateway — so the hunts look for the behavior (the unwrapped command, the template webshell, the listening backdoor), and the hashes are a corroborating check, not the detection itself. Attribution is explicitly unconfirmed: TSGA and TSProxy share code and cryptographic material with the PhiliKit framework ESET tied to the China-nexus group UNC5221, but Check Point states the evidence does not allow a high-confidence assessment of the operation's true nature — an initial-access-broker role, a false flag, and a destructive smoke screen all remain plausible.
Hunt 1: The socket — DynamicCLI commands that skip the Clish wrapper
Every legitimate DynamicCLI request passes through the Clish wrapper, so the log check Check Point itself publishes is also the best hunt: any Received = line in /var/log/dynamicCli.log that does not contain the wrapper is a command executed as root by something other than the CLI. Forward that log into Splunk — via the Universal Forwarder or syslog — and this search surfaces exactly those lines. Run it back to October 23 at minimum; a single hit is a confirmed escalation, not a lead.
index=* sourcetype="checkpoint:dynamiccli" earliest=-30d
| search NOT "CPprofile.sh"
| table _time, host, _raw
| sort _time desc
Two more patterns from the same log, straight from the advisory. The system() sink — Received = #return_value# — is uncommon or absent in legitimate traffic, so any occurrence deserves the same treatment as a wrapper-less command. And the advisory lists the command strings commonly associated with exploitation attempts: reconnaissance (id;, whoami), credential access (/etc/shadow), outbound shells (ncat, nc -, /dev/tcp), downloads (curl, wget, base64), and persistence (useradd, authorized_keys).
index=* sourcetype="checkpoint:dynamiccli" earliest=-30d "Received = #return_value#"
| table _time, host, _raw
| sort _time desc
index=* sourcetype="checkpoint:dynamiccli" earliest=-30d
(" id;" OR " whoami" OR "/etc/shadow" OR "ncat" OR "nc -" OR "/dev/tcp" OR "curl " OR "wget " OR "base64" OR "useradd" OR "authorized_keys")
| table _time, host, _raw
| sort _time desc
If you have already applied the November Jumbo Hotfix, the same log becomes a record of blocked attempts: the fix blocks and logs unauthenticated calls, so a burst of rejected connections is evidence someone tried the socket after you patched — and a burst that predates your patch window is evidence the attempt may have succeeded. Replace the sourcetype with your own if your ingestion names it differently.
index=* sourcetype="checkpoint:dynamiccli" earliest=-30d "Rejected connection from unauthorized uid"
| rex field=_raw "uid (?<uid>\d+) \(pid (?<pid>\d+)\)"
| stats count as attempts, values(pid) as pids by host, uid
| sort - attempts
The LogScale equivalent, for the same forwarded log ingested as third-party data — adjust the raw-event field name to how the log lands in your repo. A non-zero UID in the rejected-connection lines (the advisory's example is uid 99, nobody) is the marker of an escalation attempt that was blocked.
sourcetype="checkpoint:dynamiccli" "Received =" NOT "CPprofile.sh"
| table([@timestamp, host, message])
| sort(@timestamp, order=desc)
Hunt 2: The webshells — zz*.tpl in the portal templates
With root, the attacker wrote PHP webshells into the directory the Mobile Access portal uses to build its login pages. Each shell starts as a small command-execution stub, then gets replaced with a more capable version gated by the hardcoded key zz2026, supporting OS commands, PHP evaluation, and file uploads saved to the fixed path /tmp/.up.tpl before being copied into the portal directory as challenge_render.tpl. A .tpl file with a zz prefix in the portal templates is not a template — it is the campaign's webshell, and any web request that reaches one is the attacker using it.
index=web earliest=-30d (uri_path="*zz*.tpl" OR uri_path="*challenge_render.tpl" OR uri_path="*/.up.tpl")
| stats count as hits, dc(clientip) as sources, values(clientip) as clients, earliest(_time) as first_seen, latest(_time) as last_seen by uri_path
| sort - hits
The entry that preceded the webshells also leaves traces on the gateway itself. Check Point Research reports PHP session artifacts created under /opt/CPcvpn-R81.20/tmp/ containing the upload_progress_pwn marker, and hundreds of segmentation faults in the portal's Apache/PHP workers during the exploitation window. If your gateway syslog is forwarded, search for the marker and the fault burst together — either alone is a lead, both in the same window is the PHP2Shell entry.
index=* sourcetype="checkpoint:syslog" earliest=-30d
("upload_progress_pwn" OR "/tmp/.up.tpl" OR "challenge_render.tpl" OR "CPconfigdaemon" OR "slot_CPconfigdaemon")
| table _time, host, _raw
| sort _time desc
index=* sourcetype="checkpoint:syslog" earliest=-30d "segmentation fault" (httpd OR apache OR php)
| bucket _time span=10m
| stats count as faults by _time, host
| where faults > 20
| sort - faults
On the CrowdStrike side, the campaign's published file hashes are the corroborating check across the estate — any host where the attacker staged tooling, not just the gateway. Check Point Research published SHA-256 hashes for the template webshell, both TSGA binaries, the gogo scanner, the wiper, and the ransom note. A hash hit anywhere is a confirmed artifact; treat the absence of a hash hit as absence of that exact file, not absence of compromise, since the attacker can recompile.
#event_simpleName=ProcessRollup2 OR #event_simpleName=FileWritten
| SHA256Hash=/edb3e92eb7bda7413a09edcc4b1ba3cbed4bcdf42808a8abce63b6e4c3fda2b3|4171b521fa6441382aa2fa014a08e18ff9a6e0ab6096c9144072bf46b37a2ec8|d7549671c7189979f0624ec52dad9ea6a707d23146e3585ab8f8c4720eca0c63|3b51080a909023f7d484e2443740b572307ce0054eb9e32d98f0a06bfcd2db90|c7d9477309fac6c638a1128442056a242de086996add8cb49cd6496c36003237|0522937c0c0337be54fe25493539e5f5f8ceb9742c980aaff1cfc9515f3a96f7/
| table([@timestamp, ComputerName, UserName, FileName, SHA256Hash, ImageFileName, CommandLine])
| sort(@timestamp, order=desc)
The same artifacts by name, for hosts where the hash field is not populated — the wiper's note file is the most distinctive of these, because no legitimate process writes a file called DREAM_ANNEXATION.txt.
#event_simpleName=FileWritten
| TargetFileName=/DREAM_ANNEXATION\.txt|destroy_v6|\/tmp\/des$|CPconfigdaemon|slot_CPconfigdaemon|\.up\.tpl|zz\d+\.tpl$/
| table([@timestamp, ComputerName, UserName, FileName, TargetFileName, ImageFileName])
| sort(@timestamp, order=desc)
Hunt 3: TSGA persistence — the backdoor that survives the patch
TSGA is the persistence layer, and it is built to survive exactly the response most teams reach for first. Launched as /tmp/CPconfigdaemon with output redirected to a hidden log at /tmp/.bd.log, it relocates itself and relaunches as slot_CPconfigdaemon in the boot persistence directory, so a reboot does not clear it. Its embedded TSProxy component writes /lib/libcpfwcommon.so and injects that library into selected appliance processes, intercepting networking functions so attacker connections are handled while ordinary traffic continues. Unlike the earlier PhiliKit build, which restricted its listener to loopback, TSGA listens on all IPv4 interfaces on TCP 11072, and communicates through the Unix socket /tmp/.p_sock. It also steals gateway configurations and tampers with the binary firewall logs — so a gateway that shows no suspicious firewall entries after October 30 is not necessarily clean; its logs may have been edited.
In firewall or proxy logs, TSGA is an inbound connection to the gateway on TCP 11072 from an address with no administrative history. Baseline the legitimate management sources first — anything else on that port is the backdoor answering.
index=firewall earliest=-30d dest_ip="<gateway-ip>" dest_port=11072
| stats count as connections, dc(src_ip) as sources, values(src_ip) as callers, earliest(_time) as first_seen, latest(_time) as last_seen by src_ip
| sort - connections
The campaign's known infrastructure is a second check in the same logs. Check Point Research attributes the first wave to 130.94.19.204, with 130.94.19.168 also listed as an indicator. A hit on either address in any direction is a campaign touch — but these are single-campaign IPs, so absence here proves nothing about the rest of the chain.
index=* earliest=-30d (src_ip="130.94.19.204" OR src_ip="130.94.19.168" OR dest_ip="130.94.19.204" OR dest_ip="130.94.19.168")
| table _time, src_ip, dest_ip, dest_port, _raw
| sort _time desc
The CrowdStrike equivalents, against Falcon network data on the internal estate and any LogScale-ingested firewall data: connections to TCP 11072, and the library write that marks TSProxy's installation.
#event_simpleName=NetworkConnectIP4
| RemotePort=11072
| table([@timestamp, ComputerName, UserName, ImageFileName, RemoteAddress, RemotePort])
| sort(@timestamp, order=desc)
#event_simpleName=FileWritten
| TargetFileName=/\/lib\/libcpfwcommon\.so$/
| table([@timestamp, ComputerName, UserName, FileName, TargetFileName, ImageFileName])
| sort(@timestamp, order=desc)
Hunt 4: The pivot and the wiper — from gateway to ESXi
The destructive half of the campaign is the part most teams will miss if they stop at the gateway. After establishing TSGA, the attacker ran the gogo scanner from the gateway to discover internal assets and services, then moved laterally to a VMware ESXi host over SSH, authenticating with the vpxuser service account. On the ESXi host the wiper was staged as /tmp/des and executed. destroy_v6 takes a target directory, recursively deletes files of any extension — overwriting them with zeros first unless the -f fast flag is used, and skipping directories named with -w — and writes a DREAM_ANNEXATION.txt note into each processed directory, with a timestamp and an explicit rejection of ransom negotiations.
A firewall doing its job does not scan your own network. The gogo signature is the gateway suddenly opening connections to dozens of internal hosts on many ports — the exact behavior this Splunk search measures. Replace the placeholder with your gateway's real IP and set the threshold from your own baseline; a gateway that normally talks to a handful of internal systems has no innocent reason to touch fifty.
index=firewall earliest=-30d src_ip="<gateway-ip>"
| stats dc(dest_ip) as internal_hosts, dc(dest_port) as ports, count as connections by src_ip
| where internal_hosts > 50
| sort - internal_hosts
The SSH pivot is the sharpest single signal in this hunt. Legitimate vpxuser logins come from vCenter, not from a firewall gateway — so an SSH session from the gateway's IP to an ESXi host, as vpxuser, is the campaign's lateral movement, and the ESXi authentication logs will show it even if the gateway's own logs were tampered with.
index=* earliest=-30d (sourcetype="vmware:esxi" OR sourcetype="linux:secure") "vpxuser"
| rex field=_raw "Accepted .* for (?<user>\S+) from (?<src>\S+)"
| where src="<gateway-ip>"
| table _time, host, user, src, _raw
| sort _time desc
The CrowdStrike side of the same pivot, for Falcon-monitored Linux hosts in the virtualization estate: the wiper executing, the staging path, and SSH as vpxuser from an unexpected source.
#event_simpleName=ProcessRollup2
| FileName=/destroy_v6/
| table([@timestamp, ComputerName, UserName, FileName, CommandLine])
| sort(@timestamp, order=desc)
#event_simpleName=ProcessRollup2
| FileName=/ssh/
| CommandLine=/vpxuser/
| table([@timestamp, ComputerName, UserName, FileName, CommandLine])
| sort(@timestamp, order=desc)
One more CrowdStrike query, for the wiper's effect rather than its name: mass file deletion followed by the note file is the behavior that survives a renamed binary. If your environment forwards ESXi or datastore events into LogScale, look for DREAM_ANNEXATION.txt writes there first — on the ESXi host itself, that file is the wiper's signature.
Triage: sorting real compromise from noise
First, run Check Point's own checks on the gateway before you trust any SIEM result. In Expert mode, the advisory's three greps against /var/log/dynamicCli.log are the triage: commands that skip the Clish wrapper, the system() sink, and the exploitation command strings. A wrapper-less command in that log is a confirmed root execution — do not tune it away, and do not treat the absence of entries as clean if the log was rotated or if TSGA's log tampering is in play; check the log file's own integrity and rotation history.
grep "Received =" /var/log/dynamicCli.log | grep -vF "CPprofile.sh >> /dev/null; export SP_DISTRIBUTE=0; set -o noglob;"
grep -F "Received = #return_value#" /var/log/dynamicCli.log
grep -EI "Received =.*( id;| whoami| /etc/shadow| ncat| nc -| /dev/tcp| curl | wget | base64| useradd| authorized_keys)" /var/log/dynamicCli.log
Second, confirm the patch state on the box itself, not in a spreadsheet. The fixed socket should show srw-rw---- root config (0660), not srwxrwxrwx (0777), and the installed Jumbo take should be at or above the fixed take for your release. A gateway that reports the right take but still shows a world-writable socket was not actually patched — verify both.
ls -l /tmp/dynamic_socket
cpinfo -y all | grep -i "jumbo\|take"
Third, separate the noise. Legitimate DynamicCLI use always carries the Clish wrapper — there is no legitimate unwrapped command, so Hunt 1 has no false-positive class to tune. Legitimate gateway outbound traffic goes to a short, stable list: management servers, update services, NTP, and DNS. A gateway scanning fifty internal hosts, opening SSH to an ESXi host, or receiving connections on TCP 11072 has no innocent explanation. The one place to be careful is the gogo hunt: a vulnerability scanner or an asset-discovery tool running from the gateway's network segment can produce the same shape, so confirm the source is the gateway itself, not a scanner sharing its subnet, before escalating.
Fourth, treat the gateway's configuration as compromised if any hunt hits. TSGA steals configurations — a map of the network, its rules, and its credentials — so a hit means rotating what that configuration protects, not just cleaning the box. And check the ESXi side independently of the gateway: the vpxuser login, the /tmp/des staging file, and the DREAM_ANNEXATION.txt notes are all visible in ESXi logs and datastores even if the gateway's logs were tampered with. If the wiper ran, the data is gone — it overwrites with zeros before deleting by default — so the recovery question is backups, not forensics.
Remediation and hardening
Install the November Jumbo Hotfix Accumulator for your release — R82.20 Take 14 or later, R82.10 Take 52 or later, R82 Take 132 or later, R81.20 Take 174 or later — on every Security Gateway, Management Server, Multi-Domain Server, and Log Server. The same takes also roll up the October PHP2Shell hotfix and the Gaia Portal privilege bug CVE-2026-107484, so one install closes the whole chain. If you cannot patch today and can live without Dynamic CLI, Check Point's interim step is to stop dynamic_server and prevent it from restarting — but note that this breaks the Dynamic CLI commands listed in sk144112, so confirm nothing in your operations depends on them first.
dbset process:dynamic_server
dbset :save
Patching closes the hole; it does not evict an attacker who already got in. If any hunt hits, assume the gateway is compromised and rebuild it from known-good media rather than cleaning in place — TSGA persists across reboots and tampers with the firewall logs, so a cleaned box cannot be trusted to report on itself. Rotate the gateway configuration and any credentials it held, rotate the ESXi vpxuser credentials, and review every ESXi host the gateway could reach for the wiper's staging path and note files. Restrict the Mobile Access portal's internet exposure permanently: the PHP2Shell entry point was a portal that should never have been reachable by the whole internet, and the November 2 wave showed the scanning is opportunistic, not targeted — any exposed portal is in the population.
Finally, make the socket log a standing feed. Forward /var/log/dynamicCli.log into your SIEM with an alert on any Received = line without the Clish wrapper and on any Rejected connection from unauthorized uid line — the first catches the escalation, the second catches the attempt after patching — and keep the Hunt 3 and Hunt 4 patterns (TCP 11072 to the gateway, gateway-initiated internal scanning, SSH from the gateway to ESXi) as standing detections. The next flaw in a perimeter appliance will arrive the same way: a foothold, a local escalation, and a backdoor that outlives the patch.
Sources
- NVD — CVE-2026-123039 (CNA score CVSS 3.1 7.8, vector CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H; CWE-732 and CWE-862; NVD assessment not yet published; KEV added November 13, 2026, due November 16, 2026)
- MITRE CVE record — CVE-2026-123039
- MITRE CWE-732 — Incorrect Permission Assignment for Critical Resource
- MITRE CWE-862 — Missing Authorization
- Check Point advisory sk1000362 — CVE-2026-123039: Local privilege escalation to root in the DynamicCLI process via local world-writable control socket (affected products and versions, fixed Jumbo Hotfix takes, dynamic_server mitigation, /var/log/dynamicCli.log indicators of compromise, blocked-connection logging)
- Check Point Research — PHP2Shell Exploitation on Check Point Gateway (campaign waves October 30 and November 2, 2026; PHP2Shell initial access; DynamicCLI escalation; zz*.tpl webshells; TSGA and TSProxy; gogo scanner; vpxuser SSH pivot to ESXi; destroy_v6 wiper; DREAM_ANNEXATION.txt notes; published IOC hashes and IPs; attribution assessment)
- CISA Known Exploited Vulnerabilities catalog (CVE-2026-123039 added November 13, 2026; due November 16, 2026; known ransomware use Unknown; BOD 26-04 forensics triage requirements)
- Security Affairs — U.S. CISA adds Check Point and UnrealIRCd flaws to its Known Exploited Vulnerabilities catalog (KEV additions of November 13, 2026, and the November 16 federal deadline)
- The Hacker News — Hackers Exploit PHP2Shell Flaws in Check Point Gateways to Deploy TSGA Backdoor and Wipe ESXi Files (campaign summary, TSGA capabilities, PhiliKit lineage, attribution caveats)
