← Blog
CVE-2026-115731Puppet EnterpriseDeserialization RCECISA KEV

Puppet Enterprise CVE-2026-115731: deserialization RCE, PoC public, exploited

CVE-2026-115731: a crafted Puppet report runs code on the Puppet Server as the puppet user. CVSS 9.4, public PoC, now on CISA KEV. Patch and rotate the CA key.

Zero Hunt Research··8 min read

Published by Zero Hunt, an autonomous AI red team on an on-premise appliance running private AI: automated penetration testing for networks and infrastructure, black-box or gray-box, with a human approving every step that matters.

A Puppet Server is the most privileged box in a lot of estates: it hands out certificates, pushes configuration, and runs code on every node it manages. CVE-2026-115731 lets an attacker turn that trust inward. A single crafted agent report — the routine JSON a Puppet agent sends back after each run — is enough to execute arbitrary code on the server as the puppet user, which is enough to steal the CA signing key and impersonate the whole fleet. The bug was disclosed on 2026-11-03 with a working proof-of-concept; on 2026-11-17 CISA added it to the Known Exploited Vulnerabilities catalog, which by the catalog's own standard means there is reliable evidence of exploitation in the wild.

Developing story — first published 19:38 CET (18:38 UTC), 17 November 2026. Updated as the vendor and CISA publish more.

At a glance

CVE CVE-2026-115731
Product / affected versions Perforce Puppet Enterprise before 2023.8.13 · 2025.12.1 · 2026.0.1; OpenVox Server ≤ 9.1.0 and ≤ 8.17.0; open-source Puppet (unsupported, no fix). The flaw dates back to code in Puppet 6.x (2021)
Fixed in Puppet Enterprise 2023.8.13 · 2025.12.1 · 2026.0.1; OpenVox Server 9.2.0 · 8.18.0; OpenVox Agent 9.3.0 · 8.32.0. Restart the Puppet Server service after upgrading so the fixed code loads
CVSS 9.4 Critical (CVSS 4.0) by Puppet/Perforce (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); NVD 9.9 Critical (CVSS 3.1, CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H)
Exploited in the wild Yes — added to CISA KEV 2026-11-17
CISA KEV Added 2026-11-17; federal due date 2026-12-01 (BOD 26-04)
Public PoC Yes — a working sample report ships in the OpenVox advisory (GHSA-ffr6-rwpm-p5wq) and the Neodyme write-up, both published 2026-11-03
Official advisory Perforce — Report Deserialization Code Execution

Update — 2026-11-18 01:51 CET

NVD finished its analysis of CVE-2026-115731 — the record now reads Analyzed rather than Awaiting Analysis — and added its own 9.9 Critical score on CVSS 3.1 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H), alongside the vendor's 9.4 on CVSS 4.0. NVD's SSVC decision point now reads exploitation: active, matching the CISA KEV listing. No new indicators, named actor, or victim count has been published, and the fixed versions and the 2026-12-01 federal due date are unchanged.

How the deserialization bug works

A Puppet agent finishes a run and sends a report back to the server at PUT /puppet/v3/report. That report is JSON, and inside it the agent lists the events that happened during the run. The server deserializes those events through Puppet's rich-data layer so that native types (timestamps, binaries, resource references) survive the round trip.

The problem is that the rich-data layer trusts a type name the client supplies. The Neodyme research traces the path: the event body reaches FromDataConverter.convert(data, {:allow_unresolved => true, ...}), the attacker-controlled __ptype field is parsed by Types::TypeParser, and .create(value) is called on the resulting type. When no implementation class is registered for that type, Puppet generates one — RubyGenerator.new.create_class(self) builds a Ruby class body from the type's declared functions and runs it through cls.class_eval(class_def).

That is the sink. The attacker declares an Object type with a function whose RubyMethod annotation carries an arbitrary body, and the body contains Ruby backticks:

__ptype → Object[{ … functions => { test => { … RubyMethod => { body => "… + `/bin/sh -c id` + …" }}}}]

Because the backticks fire while the class is being defined, the command runs the moment the server evaluates the generated class — the object never has to be instantiated. The OpenVox advisory ships the exact payload and says plainly: "Send the above JSON event with a valid client certificate authentication to PUT /puppet/v3/report." Code runs as the puppet service user, which owns the CA signing key.

Why autosign turns it into an unauthenticated RCE

On paper this is authenticated: the attacker needs a CA-signed Puppet agent certificate, which is why the vector reads PR:L. In practice most large Puppet deployments run autosign — new agents enroll and the CA signs their certificate requests automatically, without manual approval or strong verification. Where that is true, an unauthenticated attacker who can reach the enrollment endpoint simply requests a certificate, receives a signed one, and then uses it to fire the report payload. The precondition evaporates.

That is also why the blast radius is worse than one server. Code execution as puppet yields the CA private key. With it, the attacker mints certificates bearing serverAuth and clientAuth extended key usages, impersonates any node, and — because Puppet is a configuration-management tool — can push commands to every managed node in the estate. One crafted report becomes fleet-wide code execution. The companion flaw disclosed the same day, CVE-2026-115732 (CVSS 9.0, a certificate-name authorization bypass in trapperkeeper-authorization), compounds the impersonation story and is fixed in the same releases, so treat the two as one patch.

Am I running an affected Puppet Server?

Check the server build and, just as important, whether autosign is enabled:

# Puppet Enterprise / Puppet Server version
puppetserver --version
# OpenVox
rpm -q openvox-server 2>/dev/null || dpkg -l | grep openvox-server

# Is autosign on? (any of these indicates automatic signing)
puppet config print autosign --section master
ls -l $(puppet config print confdir)/autosign.conf 2>/dev/null

If the version is below the fixed release and autosign signs requests without strong verification, assume the unauthenticated path is reachable from anywhere that can hit port 8140.

Remediation

  1. Am I affected? Run the checks above. Treat any internet-reachable or broadly-reachable Puppet Server below the fixed version as actively at risk — this is on CISA KEV with a 2026-12-01 federal due date under BOD 26-04, and the same risk-based clock is the right default for everyone, not just federal agencies.
  2. Patch — exact fixed versions. Puppet Enterprise 2023.8.13, 2025.12.1, or 2026.0.1; OpenVox Server 9.2.0 or 8.18.0 (agents 9.3.0 or 8.32.0). Restart the Puppet Server service after upgrading — the fixed code is not live until the JVM reloads. Open-source Puppet receives no fix; migrate to OpenVox or Puppet Enterprise.
  3. Can't patch now? Compensating controls. Disable autosign, or tighten it to a policy that strongly verifies each request, so an attacker cannot self-enroll a certificate. Restrict network access to port 8140 and to PUT /puppet/v3/report to known agent ranges only. These shrink the attack surface; they do not fully close the bug for an attacker who already holds a signed certificate.
  4. Hunt for compromise. No vendor IOCs (IPs, hashes) have been published, so hunt on behavior, not indicators. Look for: report submissions to /puppet/v3/report whose body contains an __ptype encoding an Object[...] with a RubyMethod/body field (T1190); the puppetserver/puppet process spawning a shell or unexpected child processes running as the puppet user (T1059); certificate signing requests from agents you do not recognize, clustered in time (T1649); and any read or copy of the CA signing key (ssl/ca/ca_key.pem). Fleet-wide command pushes shortly afterwards (T1072, Puppet used as a deployment tool) are the sign the server became a launch point.
  5. Eradicate + verify. If you find any sign of execution, assume the CA key is compromised: a patch does not un-leak a private key. Regenerate the CA, re-issue agent certificates, and revoke the old chain. Remove any attacker-planted manifests or scheduled tasks on managed nodes, rotate credentials the server could reach, and then confirm clean — re-run the crafted-report test against the patched server and verify it is rejected rather than evaluated. Validating the fix is a different thing from reading the version string.

What is not known yet

  • CISA's KEV entry asserts exploitation but names no actor, campaign, or victim count, and publishes no indicators. At disclosure two weeks earlier, the vendors and NVD's SSVC record (2026-11-06) stated no confirmed in-the-wild use — the window between a public PoC and real-world exploitation has since closed, as it usually does.
  • NVD has now analyzed the CVE and scored it 9.9 on CVSS 3.1 (see the Update above); the vendor's 9.4 is on CVSS 4.0. The two scales are not directly comparable — both land in Critical.
  • The precise Puppet Enterprise fixed-version mapping is taken from the vendor advisory and coverage; the public OpenVox GHSA states the open-source fork's fixed versions directly and notes only that "this vulnerability also affects Puppet Enterprise." Confirm your exact PE build against Perforce's advisory before planning the upgrade.

Patch first, then prove it is closed

When a KEV-listed RCE lands with a public PoC and a messy multi-branch fix, the hard part is not knowing that you should patch — it is sequencing the work and proving it worked. Zero Hunt's AI Remediation Advisor ranks what to fix by real exploitability — CISA KEV first, then what was proven reachable in the campaign, then CVSS, then EPSS — and returns the exact fixed version with rollout and rollback notes plus a compensating control (here: disable autosign, restrict the report endpoint) for the hours before you can patch, through an autonomous AI red team that runs on-premise on private AI with a human approving every action that matters.

The follow-up is where the version string stops being the answer. Whether CVE-2026-115731 is actually drivable against your server depends on your build, whether autosign is on, and whether the report endpoint is reachable — not on the number alone. Zero Hunt's generative engine settles it the way the attacker would: in a gray-box campaign it enrolls a certificate through your CA, sends a crafted report against your exact installed version, and shows whether code runs — every exploit written per target by local models and executed in an ephemeral, hardened container that never touches the appliance host. It is the same proof used to re-verify the fix afterwards, so "patched" means demonstrated closed, not version bumped. And because the real damage here is the CA key becoming a key to the whole fleet, the appliance's traffic model flags the aftermath — a Puppet Server suddenly pushing commands across nodes it never drove before is loud on the wire while it happens, not in the next morning's log review. For how continuous, automated validation fits a KEV cadence, see our guide to automated penetration testing.

Every vulnerability CISA lists as exploited, with federal due dates: CISA KEV tracker →

Patching one CVE at a time? A CTEM program validates which exposures are actually exploitable before the next advisory: what CTEM is →

Is this exploitable in your environment?

Zero Hunt answers that on your own network: an autonomous AI red team on an on-premise appliance, running on private AI, black-box or gray-box, with a human approving every step that matters. Proof of what is exploitable, the fix, and signed evidence — no data leaves your perimeter.