← cd ../blog

CVE-2026-115731: Puppet Server report deserialization RCE, now exploited in the wild

A rich-data deserialization flaw in Puppet's report processing (CVSS 4.0 9.4, CISA KEV) lets any CA-signed agent run code on Puppet Server and reach its CA key. Exposure checks, hunting and fixes.

CISA added CVE-2026-115731 to the KEV catalog today, with a federal due date of 1 December. The bug is in Puppet Server, and that’s what worries me. Puppet is the system that tells every managed server what to look like. Get code execution on the primary server and you have the CA signing key, the catalogs every agent applies, and often an orchestration channel to run commands as root across the fleet. The patch came out on 3 November, so if you haven’t applied it yet, start today. For context on where this sits among this year’s RCEs, see my 2026 RCE field guide.

Scope and ethics. This post covers architecture, exposure checks, detection and remediation for Puppet infrastructure you own or are authorized to assess. It contains no crafted reports, serialized type payloads or exploit code. Lab validation here means confirming versions and config on a VM you control, not firing a PoC.

At a glance

   
CVE CVE-2026-115731, “Report Deserialization Code Execution”
Severity CVSS 4.0 9.4 Critical, AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H (Puppet/Perforce CNA). NVD’s own CVSS 3.1 score is 9.9 (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H)
CWE CWE-502 Deserialization of Untrusted Data, CWE-94 Code Injection
Affected Puppet Enterprise 2023.8.0–2023.8.12, 2025.0.0–2025.12.0, 2026.0.0. Puppet Core 8.x before 8.22.2, 9.0.0–9.1.2. OpenVox Server before 8.18.0 / 9.2.0 (agent before 8.32.0 / 9.3.0)
Fixed in PE 2023.8.13, 2025.12.1, 2026.0.1. Puppet Core 8.22.2, 9.1.3. OpenVox Server 8.18.0 / 9.2.0, Agent 8.32.0 / 9.3.0 (all 3 Nov 2026)
Exploited? Yes. CISA KEV, added 17 Nov 2026 (federal due date 1 Dec). A public PoC is in the OpenVox advisory
Auth / interaction Any CA-signed agent certificate / none. With weak autosigning, that means effectively unauthenticated

Description: how the bug works

After every run, a Puppet agent sends a report back to the server: what changed, what failed, and a list of per-resource events. Agents submit it with an HTTP PUT to /puppet/v3/report/<certname>, authenticated by their TLS client certificate.

Puppet supports “rich data”, a serialization format (Pcore) that can carry typed values and not just strings and numbers. A rich-data value can include a type descriptor, and the receiving side rebuilds an object of that type. According to the OpenVox advisory and Neodyme’s write-up, event values in a report go through Puppet’s Pcore FromDataConverter. It parses the attacker-supplied type descriptor and asks that type to create the value. Puppet’s type system can define object types whose methods are implemented in Ruby, and building such a type generates a Ruby class at runtime with class_eval. So the report doesn’t just carry data. It can carry a type definition, and building that type on the server runs Ruby code the attacker supplied.

Alain Rödel of Neodyme found the issue. That’s the textbook CWE-502 pattern: the deserializer trusts the type information in the message. It’s also why NVD lists CWE-94 too: the end result is code generation from untrusted input.

The code runs inside Puppet Server’s JRuby runtime, as the server’s service user (pe-puppet on PE, puppet on open-source and OpenVox servers).

Why the certificate requirement isn’t much of a barrier

The report endpoint requires a client certificate signed by the Puppet CA. That sounds like strong authentication until you look at autosigning. Many enterprises autosign new agents (everything, a domain glob, or a weak policy script) so that auto-scaled hosts can enroll without someone approving them. With autosign on, an attacker who can reach port 8140 can request a certificate through the normal enrollment endpoint, get it signed, and then submit a malicious report. The OpenVox maintainers state plainly that with autosign “this is an unauthenticated attack chain”. CISA’s KEV entry says the same.

Neodyme reported a companion bug at the same time, CVE-2026-115732, a certificate-name authorization bypass in trapperkeeper-authorization. A cert for evil.target.example.com can match rules meant for target.example.com. Patch both.

Impact: why it’s fleet-wide

  • Code execution on the primary server as the Puppet Server service user, with no user interaction.
  • CA compromise. The OpenVox advisory and Neodyme both note that the service user can read the CA signing key. With it, an attacker can mint certificates (including server certificates) and impersonate the Puppet server or any node.
  • Configuration of every managed node. Neodyme points out that if the server process can write the catalogs or code it serves, an attacker can change what agents apply at their next check-in. Agents apply catalogs as root.
  • Orchestration. On Puppet Enterprise, the orchestrator (PXP) can run tasks and commands on agents. OpenVox users often have Choria. Neodyme flags both as ways to escalate to direct command execution across the fleet.
  • Secrets. Catalogs, Hiera data and reports routinely contain database passwords, API tokens and service credentials.

Neodyme sums it up as ransomware, mass exfiltration and lateral movement in the worst case, and says how bad it gets “highly depends on the Puppet server configuration”.

Prerequisites: network reachability to Puppet Server (default TCP 8140), a pre-fix build, and a CA-signed agent certificate, either stolen from an existing node or obtained through autosign.

Identifying affected systems

Run these on Puppet servers you administer. The fix lands in the Puppet Ruby code that Puppet Server loads, so check the primary server and every compiler, not just your agents.

# 1) Puppet Enterprise release on the primary / compilers
cat /opt/puppetlabs/server/pe_version          # fixed: 2023.8.13, 2025.12.1, 2026.0.1 or later

# 2) Puppet core version the server runs (puppet-agent package on the server)
/opt/puppetlabs/puppet/bin/puppet --version    # fixed: 8.22.2+ (8.x) or 9.1.3+ (9.x)
/opt/puppetlabs/bin/puppetserver --version

# 3) Package view (OpenVox: openvox-server >= 8.18.0 / 9.2.0)
rpm -qa | grep -Ei '^(pe-)?puppet(server|-agent)|^openvox' 2>/dev/null \
  || dpkg -l | grep -Ei 'puppet(server|-agent)|openvox'

# 4) Is autosign on, and how? (true / glob file / policy script)
/opt/puppetlabs/bin/puppet config print autosign --section server
cat /etc/puppetlabs/puppet/autosign.conf 2>/dev/null

# 5) Who can reach 8140? Check from a segment that should NOT be able to
nc -zv puppet.example.com 8140

An autosign value of true, or an autosign.conf with broad globs like * or *.example.com, moves you from “an attacker needs a stolen node cert” to “an attacker needs network access”. A policy-based autosign script that checks a pre-shared challenge password or a cloud instance identity document is much stronger.

Open-source Puppet: Vox Pupuli says that all known Puppet implementations are affected, including distro packages. Open-source Puppet won’t get a fix. Neodyme confirmed that versions as old as Puppet 6.24.0 are affected. If you run community Puppet 7/8 packages, your options are Perforce’s Puppet Core or OpenVox. Older, out-of-support PE streams aren’t on Perforce’s affected list, but given Neodyme’s results, don’t assume they’re safe.

Safe validation in an isolated lab

  1. Build a throwaway primary server on an isolated network with a pre-fix release and a second one on the fixed release. Run the version checks above and your vulnerability scanner against both. Only the old one should be flagged. If neither is, your scanner is reading the agent package on endpoints and not the server.
  2. Test your autosign policy: from an unapproved lab VM, run puppet ssl bootstrap against the lab server and confirm the CSR stays pending (puppetserver ca list) and doesn’t get signed automatically.
  3. Test your process-lineage detection with a legitimate feature. Compile a lab catalog that uses the built-in generate('/usr/bin/id') function, which makes Puppet Server run a command during compilation. Your EDR should show the java puppetserver process spawning a child as puppet/pe-puppet. If it doesn’t, you won’t see real exploitation either.

Detection and threat hunting

Details of the in-the-wild attacks haven’t been published yet, so there are no vendor IOCs. Hunt for the behaviors the bug requires:

  • Process lineage. Puppet Server is a JVM (java ... puppetserver). Look for it spawning sh, bash, curl, wget, python, perl, nc or base64, or writing executables to /tmp, /var/tmp or /dev/shm. Baseline first: catalogs that use generate() and some report processors or ENC scripts legitimately start processes.
    for p in $(pgrep -f 'puppetserver'); do ps --ppid "$p" -o pid=,user=,lstart=,cmd= ; done
    
  • Certificate inventory. Compare every signed certificate with your CMDB, and look for certnames you don’t recognize, especially recent ones, ones that look like subdomains of real hosts (the CVE-2026-115732 pattern), or ones that carry unusual extended key usages.
    /opt/puppetlabs/bin/puppetserver ca list --all | sort > /tmp/signed-certs.txt
    
  • Report traffic. In /var/log/puppetlabs/puppetserver/puppetserver-access.log, look for PUT /puppet/v3/report/ from certnames that aren’t in inventory, from source IPs outside your agent subnets, or from nodes that submit reports without fetching a catalog first.
  • Stored reports. If the store report processor is on, the public PoC puts an object type definition inside a __ptype field of an event. Normal agent reports don’t define new object types, so treat any hit as a lead to investigate, not proof:
    grep -rlE '__ptype.{0,40}Object\[' /opt/puppetlabs/server/data/puppetserver/reports/ 2>/dev/null
    
  • Integrity of CA and code. Check for unexpected reads or changes under the CA directory (/etc/puppetlabs/puppetserver/ca/), new files in /etc/puppetlabs/code/ that didn’t come from your control repo or Code Manager, and orchestrator jobs or tasks that no one in your team launched.
  • Network. Watch for outbound connections from the Puppet Server host to the internet, which it normally has no reason to make beyond package and module repos.

Remediation

  1. Upgrade the primary server and all compilers to PE 2026.0.1, 2025.12.1 or 2023.8.13, or to Puppet Core 9.1.3 / 8.22.2, or to OpenVox Server 9.2.0 / 8.18.0 (plus the matching agent and openvoxdb releases).
  2. Restart Puppet Server after upgrading. Perforce explicitly says to restart so the fixed code actually loads.
  3. Lock down autosign. Turn it off, or replace globs with a policy executable that verifies something the attacker can’t forge. Vox Pupuli points to their autosign tool for this.
  4. Recheck auth.conf after upgrading. The CVE-2026-115732 fix changes how hostname rules match, and Vox Pupuli warns that custom rules may have depended on the old, buggy wildcard behavior.
  5. If you find signs of compromise, patching isn’t enough. Code execution as the service user exposes the CA key, so treat the CA as compromised. Rebuild it, re-issue agent certificates, rotate secrets in Hiera and catalogs, and review code and orchestration history for changes pushed to agents.

Interim mitigations (if you truly can’t patch today)

  • Restrict network access to 8140 to the subnets your agents actually live in. Vox Pupuli lists this first, since both server bugs need network access.
  • Disable or tighten autosign right away. This removes the unauthenticated path, though any holder of an existing node certificate can still exploit the bug.
  • Revoke certificates for decommissioned nodes so stolen certs from old hosts stop working.
  • Vox Pupuli offers standalone patch scripts for OpenVox. They warn these may not apply cleanly to old versions, and you take responsibility if you use them. Treat them as a stopgap.

References

Verify every version against the vendor advisory before acting. Published 17 Nov 2026.