Why this matters now
On November 17, 2026, CISA added CVE-2026-115731 to its Known Exploited Vulnerabilities catalog, with a federal remediation deadline of December 1. The flaw is a deserialization remote code execution bug in the report-processing code of Puppet Server: any client holding a CA-signed agent certificate can run arbitrary code on the Puppet Server as its service user by submitting a crafted report. And the certificate is a lower bar than it sounds — where the Puppet certificate authority autosigns requests without strong verification, an unauthenticated network attacker can simply enrol, obtain a valid certificate, and exploit the flaw. The researchers who found it, Neodyme, confirmed the bug is exploitable on open-source Puppet back to version 6.24.0, from July 2021 — five years of vulnerable releases, in the tool that provisions and patches your servers.
What makes this one worth hunting today, rather than just patching, is what code execution on a Puppet Server buys. The Puppet Server service account can read the certificate authority's private signing key. With that key, an attacker mints certificates the whole fleet trusts — including certificates with server and client authentication that let them drive Puppet Enterprise's PXP orchestration broker and run commands as root on managed hosts. The Puppet Server is not just another server in your estate: it is the machine that tells every other machine what software to run. A compromise there is a compromise of the fleet, and the window between the public proof of concept on November 3 and the KEV listing on November 17 means attackers have had two weeks with a working exploit and, as of yesterday, confirmation from CISA that it is being used.
| CVE | CVE-2026-115731 — Deserialization of Untrusted Data in Puppet Server report processing (CWE-502, CWE-94) |
|---|---|
| CVSS | 9.4 Critical (CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H), scored by Perforce as the CNA. NVD and Red Hat both score it 9.9 Critical under CVSS 3.1 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H). This article leads with the vendor CNA score of 9.4 and notes the difference; the two scores disagree on the scale, not on the severity — both are Critical, both agree the scope changes. |
| Affected product | Puppet Enterprise 2023.8.0 to before 2023.8.13, 2025.0.0 to before 2025.12.1, and 2026.0.0 to before 2026.0.1. The vulnerable code is upstream in Puppet itself, so Puppet Core, OpenVox Server, and Red Hat Satellite are affected too — see the remediation section for their fixed releases. Open-source Puppet receives no fix on that line. |
| Vendor | Perforce (Puppet); reported by Alain at Neodyme |
| Disclosure date | November 3, 2026 (fixes released 17:00 UTC; CVE published 21:17 UTC) |
| CISA KEV | Added November 17, 2026; federal remediation due December 1, 2026; known ransomware campaign use: Unknown |
| Fixed version | Puppet Enterprise 2023.8.13, 2025.12.1, or 2026.0.1; Puppet Core 9.1.3 or 8.22.2; OpenVox Server 9.2.0 / 8.18.0 (agent 9.3.0 / 8.32.0); Red Hat Satellite 6.17 (RHSA-2026:95656) and 6.16 (RHSA-2026:95655) |
| Exploitation status | Confirmed exploited in the wild — CISA KEV listing, November 17, 2026. CISA gives no first-seen date, no actor, and no victim count, so the scale of exploitation is unclear. A working proof of concept shipped with the OpenVox advisory on November 3. Perforce and Vox Pupuli have issued no exploitation statement of their own. |
The technique, in hunt terms
Puppet agents report the results of each run back to the server: after every enforcement run, the agent sends a JSON report to PUT /puppet/v3/report/{certname}?environment={env} on TCP 8140, authenticated with its client certificate over TLS. Each report carries resource statuses, and each status carries a list of events. On the server, those events are rebuilt from the JSON by Puppet::Transaction::Event.from_data_hash, which hands the data to Puppet::Pops::Serialization::FromDataConverter.convert with unresolved types allowed.
That converter is the vulnerability. When it meets a __ptype key in an event, it parses the supplied value as a Puppet type and calls .create(value) on it. If the type has no registered implementation, the code falls through to RubyGenerator, which generates a Ruby class from the attacker-supplied type definition — including any RubyMethod annotation, whose body string is pasted verbatim into the generated class — and then calls cls.class_eval on it. Ruby executes backticks at class-definition time, so a method body that closes its function, drops in a backticked shell command, and re-opens a function runs that command the moment the server parses the report. Neodyme's published proof-of-concept event does exactly this with a single shell command in the annotation body. No user interaction, no second request, no agent binary on the attacker's machine — just a report with a crafted event.
The code runs as the Puppet Server service account (puppet on open-source and OpenVox installs, pe-puppet on Puppet Enterprise). From there, the attack branches three ways, and each branch is a hunt in this article:
- The CA key. The service account can read the certificate authority's private signing key. Neodyme's lab proof of concept exfiltrated that key, minted a certificate for the Puppet Server itself with
serverAuthandclientAuthextended key usage, and used it against the PXP orchestration broker on TCP 8142 to run commands as root on managed hosts. A stolen CA key also lets the attacker sign certificates for any hostname, impersonating any agent in the fleet. - The catalog. Where the Puppet Server's file ownership is not hardened, the service account can tamper with compiled catalogs, so the next agent check-in pulls attacker-chosen configuration — the configuration-management equivalent of a supply-chain compromise. Catalogs frequently carry secrets: in Neodyme's engagement, one host's catalog contained PostgreSQL credentials and admin API tokens.
- The companion flaw. The same November 3 release fixed CVE-2026-115732, a certificate-name authorization bypass in the
trapperkeeper-authorizationlibrary (CVSS 4.0 9.0). A hostname comparison that stopped at the shorter of two names meant a certificate issued forevil.target.lab.localwas accepted astarget.lab.local. With that certificate, an attacker pulls another host's catalog, pushes false facts, and adds exported resources that other hosts then realise. It is not KEV-listed, but it is the same advisory, the same fix window, and the same impersonation story — hunt it alongside the RCE.
MITRE ATT&CK mapping for the exploitation behaviour: T1190 Exploit Public-Facing Application for the report-endpoint entry, T1059.004 Unix Shell for the backticked command, T1552.004 Private Keys for the CA signing-key theft, T1078 Valid Accounts for the minted certificates, and T1072 Software Deployment Tools for the PXP and catalog push onto managed hosts.
Two honest framing notes before the queries. First, the telemetry below assumes the Puppet Server logs are forwarded somewhere searchable — the access log and the main server log live at /var/log/puppetlabs/puppetserver/puppetserver-access.log and puppetserver.log, and the endpoint telemetry assumes a sensor (Falcon, or Defender for Servers) on the Puppet Server host. If neither is in place, Hunt 1 is the reason to start forwarding the access log today: it is the only record of who submitted reports. Second, a successful exploit may leave no error in puppetserver.log at all — the crafted report parses cleanly, by design. The hunts below therefore look for the behaviour around the exploit (the report, the shell, the key), not for an error message, and the absence of errors is not evidence of safety.
Hunt 1: The report endpoint — who is PUTting reports, and from where
Every legitimate agent submits reports to /puppet/v3/report, so this hunt is not about the endpoint existing — it is about reports that do not fit the fleet. A report from a source IP that has never submitted one, a certname seen from two different IPs, or a certname that appears for the first time days after your last provisioning run are all worth pulling. Start with volume by source IP over the last 30 days, and run it back to at least October 23 — the KEV listing on November 17 only confirms exploitation, it does not date its start.
source="/var/log/puppetlabs/puppetserver/puppetserver-access.log" earliest=-30d "PUT /puppet/v3/report"
| rex field=_raw "^(?<src_ip>\d+\.\d+\.\d+\.\d+)"
| stats count as report_puts, earliest(_time) as first_seen, latest(_time) as last_seen by src_ip
| sort - report_puts
Then the sharper test: a certname reporting from more than one source IP. Agents do move and do get re-IP'd, so triage each hit against your provisioning records — but a certname that has always reported from one address and suddenly appears from another, especially an address outside your agent networks, is the impersonation pattern, and it is also the shape a stolen certificate takes when it is used.
source="/var/log/puppetlabs/puppetserver/puppetserver-access.log" earliest=-30d "PUT /puppet/v3/report"
| rex field=_raw "/puppet/v3/report/(?<certname>[^/?\s]+)"
| rex field=_raw "^(?<src_ip>\d+\.\d+\.\d+\.\d+)"
| stats count as reports, dc(src_ip) as source_ips, values(src_ip) as ips, earliest(_time) as first_seen by certname
| where source_ips > 1
| sort - reports
Third, the enrolment angle. The whole attack starts with obtaining a CA-signed certificate, and in autosigning environments that means a certificate request nobody approved by hand. Pull first-seen certnames from the last seven days and compare them against your provisioning system — a certname with no matching ticket, VM, or onboarding record is an attacker-enrolled agent until proven otherwise.
source="/var/log/puppetlabs/puppetserver/puppetserver-access.log" earliest=-30d "PUT /puppet/v3/report"
| rex field=_raw "/puppet/v3/report/(?<certname>[^/?\s]+)"
| stats earliest(_time) as first_report by certname
| where first_report > relative_time(now(), "-7d")
| sort first_report desc
Corroborate on the server itself: the Puppet Server CA logs certificate signing in puppetserver.log. Pull every signing line and match it against the first-seen list above — a signed certificate for a host your provisioning system never created is the enrolment, and the report that follows it is the exploit.
source="/var/log/puppetlabs/puppetserver/puppetserver.log" earliest=-30d certificate
| search signed OR autosign OR "certificate request"
| table _time, host, _raw
| sort _time desc
Hunt 2: The shell — child processes of the Puppet Server JVM
Code execution as the service account means the Puppet Server's Java process spawns a shell. That is the single most reliable post-exploitation signal in this hunt, because nothing in normal Puppet Server operation shells out: the JVM compiles catalogs, serves files, and processes reports. Any child process of the java process running Puppet Server is suspicious; a shell, a downloader, or openssl reading a key file is a confirmed compromise, not a lead.
In Splunk, against Linux process telemetry (Sysmon for Linux fields shown — map Image, ParentImage, and CommandLine to your own source if you collect process events with auditd instead):
index=os earliest=-30d (sourcetype="sysmon:linux" OR sourcetype="linux:audit")
ParentImage="*java*" (Image="*/sh" OR Image="*/bash" OR Image="*/dash" OR Image="*/curl" OR Image="*/wget" OR Image="*/nc" OR Image="*/ncat" OR Image="*/openssl" OR Image="*/python*" OR Image="*/perl" OR Image="*/ruby" OR Image="*/ssh" OR Image="*/socat")
| table _time, host, User, ParentImage, Image, CommandLine
| sort _time desc
The CrowdStrike equivalent, against Falcon process data on the Puppet Server host. Scope it to the Puppet Server JVM by its command line first — if that returns nothing, widen it to any java parent on the host and filter by the service account (puppet or pe-puppet) in the results:
#event_simpleName=ProcessRollup2
| ParentCommandLine=/puppetserver/
| FileName=/^(sh|bash|dash|curl|wget|nc|ncat|openssl|python3?|perl|ruby|ssh|socat)$/
| table([@timestamp, ComputerName, UserName, FileName, CommandLine, ParentBaseFileName, ImageFileName])
| sort(@timestamp, order=desc)
And the Defender for Servers (Linux) version, for fleets running Microsoft Defender for Endpoint on their Linux estate — the same parent-child shape in KQL:
DeviceProcessEvents
| where InitiatingProcessFileName == "java"
| where InitiatingProcessCommandLine contains "puppetserver"
| where FileName in~ ("sh", "bash", "curl", "wget", "nc", "openssl", "python3", "perl")
| project Timestamp, DeviceName, AccountName, FileName, ProcessCommandLine, InitiatingProcessCommandLine
| order by Timestamp desc
One more Splunk check from the server log, labelled as a hunting hypothesis: a malformed or partial exploitation attempt may leave deserialization errors behind even when a clean one does not. Search puppetserver.log for the converter's own vocabulary and treat any hit as a lead to correlate with Hunt 1, not as a standalone detection.
source="/var/log/puppetlabs/puppetserver/puppetserver.log" earliest=-30d
("SerializationError" OR "RubyGenerator" OR "FromDataConverter" OR "class_eval")
| table _time, host, _raw
| sort _time desc
Hunt 3: The CA key — reads, copies, and the PXP pivot
If Hunt 2 finds the shell, Hunt 3 answers the question that decides the incident's size: did the attacker reach the CA signing key? The key file is ca_key.pem, under /etc/puppetlabs/puppetserver/ca/ on current installs. In CrowdStrike, look for any process whose command line touches it, and for the file itself being written anywhere it does not belong — Neodyme's proof of concept copied the key into a Puppet file bucket to fetch it, so a ca_key.pem landing in a bucket directory, /tmp, or a home directory is the exfiltration in progress:
#event_simpleName=ProcessRollup2
| CommandLine=/ca_key\.pem/
| table([@timestamp, ComputerName, UserName, FileName, CommandLine, ImageFileName])
| sort(@timestamp, order=desc)
#event_simpleName=FileWritten
| TargetFileName=/ca_key\.pem$/
| table([@timestamp, ComputerName, UserName, FileName, TargetFileName, ImageFileName])
| sort(@timestamp, order=desc)
The Defender equivalent, for the same command-line shape:
DeviceProcessEvents
| where ProcessCommandLine contains "ca_key.pem"
| project Timestamp, DeviceName, AccountName, FileName, ProcessCommandLine
| order by Timestamp desc
Then the pivot. A minted certificate with server and client authentication lets the attacker speak to the PXP orchestration broker on TCP 8142 and push tasks to agents, which execute them as root. Legitimate PXP traffic flows between the Puppet Server or orchestrator and the agents; a connection to 8142 from a host that is neither, or a sudden burst of orchestration jobs outside a change window, is the pivot. In CrowdStrike, against Falcon network data:
#event_simpleName=NetworkConnectIP4
| RemotePort=8142
| table([@timestamp, ComputerName, UserName, ImageFileName, RemoteAddress, RemotePort])
| sort(@timestamp, order=desc)
And in Splunk, the same port against firewall or proxy logs, grouped by source so a single host hammering the broker stands out:
index=firewall earliest=-30d dest_port=8142
| stats count as connections, dc(dest_ip) as agents_reached, earliest(_time) as first_seen by src_ip
| sort - connections
Hunt 4: The impersonation twin — CVE-2026-115732 catalog grabs
The companion flaw needs its own hunt because its telemetry is different: no report, no shell — just a certificate that is not what it claims to be, used to pull another host's catalog. The tell is the same shape as Hunt 1's second query, applied to the catalog endpoint instead of the report endpoint: one certname's catalog requested from more than one source IP, or a catalog pulled for a host from an address that host has never used.
source="/var/log/puppetlabs/puppetserver/puppetserver-access.log" earliest=-30d "GET /puppet/v3/catalog"
| rex field=_raw "/puppet/v3/catalog/(?<certname>[^/?\s]+)"
| rex field=_raw "^(?<src_ip>\d+\.\d+\.\d+\.\d+)"
| stats count as catalog_requests, dc(src_ip) as source_ips, values(src_ip) as ips, earliest(_time) as first_seen by certname
| where source_ips > 1
| sort - catalog_requests
Triage these against the same provisioning records as Hunt 1. A host that was rebuilt or re-IP'd will show two addresses legitimately; a host whose catalog was pulled from an address in a different network, or from an address that has never submitted a report for that certname, is an impersonation until proven otherwise — and remember what a catalog can contain. In Neodyme's engagement the catalog they pulled for a single host carried database credentials and admin API tokens, so a confirmed impersonation is a secrets exposure, not just a spoofed identity: rotate the secrets that host's catalog carries.
Triage: sorting real compromise from noise
Run the vendor's own checks on the Puppet Server before you trust any SIEM result. First, confirm the patch state on the box itself, not in a spreadsheet: the installed Puppet Enterprise release against the fixed list (2023.8.13, 2025.12.1, 2026.0.1), or Puppet Core 9.1.3 / 8.22.2, or the OpenVox and Satellite takes in the remediation section. A server that reports the right release but was never restarted after the upgrade is still running the vulnerable code — restart the Puppet Server service so the fixed code loads.
Second, check how certificates are being issued, because that decides whether the attacker could even reach the flaw. The Perforce advisory's own check, run on the CA primary:
puppet config print autosign --section server
A value of true is naive autosigning: every certificate request is signed automatically, and any unauthenticated network attacker could have obtained a certificate. A file path means basic or policy-based autosigning — inspect the allowlist or the policy executable to see which names it signs. If it is empty or missing, the effective allowlist is empty and nothing is autosigned. Cross-check the result against Hunt 1's first-seen certnames: autosigning plus an unexplained certname is the full attack path, already walked.
Third, list the certificates the CA has actually signed and look for anything your provisioning system does not recognise:
puppetserver ca list --all
Any certname on that list with no matching host is a certificate to revoke immediately — and if Hunt 2 or Hunt 3 has fired, revocation is not enough, because the attacker may hold the CA key itself (see the remediation section).
Fourth, respect the log retention trap. Puppet Server's Logback configuration archives logs at 200 MB and deletes the oldest once all server logs exceed 1 GB, so the access log may not reach back to November 3 on a busy primary. If your window is shorter than the exposure, say so in the incident record and lean on the endpoint telemetry in Hunts 2 and 3, which does not rotate the same way. And do not treat a clean access log as a clean server if the log was ever rotated, truncated, or forwarded late — verify the log's own continuity before you clear the host.
Remediation and hardening
Upgrade first, and upgrade the whole chain. The fixed releases are Puppet Enterprise 2023.8.13, 2025.12.1, or 2026.0.1 (which bundle Puppet Core 9.1.3 or 8.22.2), OpenVox Server 9.2.0 / 8.18.0 with agent 9.3.0 / 8.32.0, and Red Hat Satellite 6.17 via RHSA-2026:95656 and 6.16 via RHSA-2026:95655. Open-source Puppet has no fix on its line — Vox Pupuli's position is that all known Puppet implementations are vulnerable and open-source users should migrate to OpenVox. After upgrading, restart the Puppet Server so the fixed code loads, and re-check the autosigning configuration from the triage section.
If you cannot upgrade immediately, the Perforce advisory's temporary mitigations are: turn off autosigning, or enforce strong validation in autosign scripts so only trusted nodes receive certificates; and apply strong access controls to Puppet agent hosts so unauthorised users cannot reach signed certificates or private keys. Restrict network access to TCP 8140 to your agent networks — the report endpoint should never be reachable from an untrusted network — and do the same for TCP 8142, the PXP broker. If you run the companion CVE-2026-115732 fix, note the behaviour change the advisory flags: after upgrading, wildcard matching in auth.conf is stricter — a rule for *.example.com matches a subdomain such as web.example.com but no longer matches the base name example.com, so review and test custom wildcard rules and add explicit authorisation where a rule must cover both.
If Hunt 2 or Hunt 3 fired, treat the incident as a CA compromise, not a single-host compromise. A confirmed or suspected read of ca_key.pem means every certificate the CA has ever signed is untrusted: revoke the certificates the attacker used, reissue the CA itself, and re-enrol the fleet — a painful operation, and the reason the key hunt comes before the patch in the triage order. Rotate every secret carried in any catalog the attacker could have pulled, and review PXP job history and the orchestrator's audit log for tasks pushed outside change windows. Finally, verify the fix the way the attacker would: after the upgrade and restart, confirm the installed release, confirm autosigning is off or strictly validated, and confirm that a report containing a __ptype event no longer reaches the converter — the fixed builds restrict report-event deserialization to safe expected types.
Related hunts in this series: the same KEV-driven, chain-to-root shape appears in the Check Point Gaia DynamicCLI hunt (CVE-2026-123039), where a second flaw turned a foothold into root; in the Barracuda ESG hunt (CVE-2026-116606 and CVE-2026-111560), another KEV-listed pair chained to root on an edge appliance; and in the Cisco BroadWorks XXE hunt (CVE-2026-20320), where a single crafted request to a collaboration platform exposed its identity material.
Sources
- NVD — CVE-2026-115731 (CVSS 3.1 9.9 Critical, CWE-502 and CWE-94, affected versions)
- MITRE CVE Record — CVE-2026-115731 (canonical record)
- Perforce — Puppet security vulnerabilities: CVE-2026-115731 and CVE-2026-115732 (vendor advisory: impact, fixed releases, autosigning mitigations)
- Neodyme — Pulling the right strings for RCE on a Puppet (original research: deserialization chain, proof of concept, CA-key and PXP impact)
- OpenVox — GHSA-ffr6-rwpm-p5wq, Authenticated RCE on OpenVox Server via Event Deserialization (CVSS 4.0 9.4, fixed versions, proof of concept)
- Red Hat — CVE-2026-115731 (Critical impact, CVSS 3.1 9.9, Satellite RHSA-2026:95655 and RHSA-2026:95656)
- CISA Known Exploited Vulnerabilities Catalog (added November 17, 2026; due December 1, 2026)
- CWE-502: Deserialization of Untrusted Data and CWE-94: Improper Control of Generation of Code
