A Type Name in a Report Body: Puppet Enterprise's CVE-2026-115731 Deserialization RCE
This is the English edition of a Korean report published on 18 November 2026. The original is at dohyeontech.github.io. On 17 November 2026, CISA added a report deserialization flaw in Perforce Puppet Enterprise (CVE-20
This is the English edition of a Korean report published on 18 November 2026. The original is at dohyeontech.github.io.
On 17 November 2026, CISA added a report deserialization flaw in Perforce Puppet Enterprise (CVE-2026-115731) to the KEV catalog. It is an entry in catalog version 2026.11.17, with a remediation deadline of 1 December, ransomware campaign use recorded as Unknown, and BOD 26-04 forensic triage as No. A KEV listing means attackers used the defect β and that this vulnerability reached real intrusion within a fortnight of being published on 3 November.
The sequence, in order. Alain RΓΆdel of Neodyme found two defects while preparing a red-team engagement against Puppet Enterprise 2025.11.2 (Puppet 8.20.0) and reported them to Perforce and OpenVox. At 17:00 UTC on 3 November both published patches and advisories simultaneously. The CVSS 4.0 score assigned that day by Perforce's CNA is 9.4 (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), Critical, classified as CWE-502 (deserialization of untrusted data) and CWE-94 (improper control of code generation). On 4 November, OpenVox's own advisory was published containing a working malicious report JSON β the exploit code did not arrive through a separate leak; it shipped with the patch instructions. On 13 November Red Hat released RHSA-2026:95652 and 95653 for Satellite 6 / Capsule 6 carrying openvox-server 8.18.0 and openvox-agent 8.32.0. Then the KEV listing on the 17th.
The advisory states the affected range. Puppet Core 8.x below 8.22.2, and Puppet Core 9.0.0 below 9.1.3, are vulnerable. Puppet Enterprise has three affected bands β 2023.8.0 to 2023.8.13, 2025.0.0 to 2025.12.1 and 2026.0.0 to 2026.0.1 β fixed in 2023.8.13 (Puppet Core 8.22.2), 2025.12.1 (8.22.2) and 2026.0.1 (9.1.3). In Neodyme's lab the same exploit worked on the open-source line at 6.24.0, released July 2021. One defect reaches five years of releases, and because the closed-source commercial product and the community fork shared the code, two CVEs were assigned across the two products.
What makes this far heavier than an ordinary "authenticated RCE" is where it sits. Puppet Server is the configuration management plane that distributes settings, packages and credentials to every managed node in the organization, and in Neodyme's lab, code execution as puppet was enough to read the CA signing key. Break one server and the root of trust (the CA) and the distribution channels (catalogs, PXP) fall with it. The CVSS 4.0 subsequent-system impacts all being High (SC:H/SI:H/SA:H) reflect that structure. Note that FIRST's EPSS is 0.366% (31st percentile), which looks low, but that is computed from pre-KEV data and is a weaker signal than observation. KEV is not a probability; it is a sighting.
1. The broken boundary: a report was treated as data the server produced
When a Puppet agent finishes a run it builds a report. The report is uploaded to PUT /puppet/v3/report/{agent_name}?environment={env}, and the server derives the node's identity from the mTLS client certificate. The report skeleton is resource_statuses, with per-resource status beneath it and an events array beneath that.
On the server the path runs like this. lib/puppet/transaction/report.rb:303 iterates resource_statuses and calls Puppet::Resource::Status.from_data_hash(rs); lib/puppet/resource/status.rb:200 passes each event to Puppet::Transaction::Event.from_data_hash(event). The problem is the next step, initialize_from_hash at lib/puppet/transaction/event.rb:69.
def initialize_from_hash(data)
data = Puppet::Pops::Serialization::FromDataConverter.convert(data, {
:allow_unresolved => true,
:loader => Puppet::Pops::Loaders.static_loader
})
FromDataConverter is a deserializer, as the name says. If a JSON hash has a __ptype key, the value is parsed as a type string, and __pvalue is restored as an instance of that type. It was built on the assumption of an internal round trip β the agent's to_data_hash into the server's from_data_hash. :allow_unresolved => true adds a tolerance on top: don't die with an exception when a type name the server doesn't know shows up, pass it along. The reason that tolerance was needed is realistic. Managed estates contain older agents, and a current server does not know every rich data type an older agent might send. The problem is that the tolerance was applied to data that arrived over the network. The trust boundary ended at certificate validation, and data inside it was treated as equivalent to what the server produced itself.
The restore path lives in lib/puppet/pops/serialization/from_data_converter.rb. Line 211, pcore_type_hash_to_value, builds an object when the value is a Hash and β when the value is a String β does this at line 223.
when String
build(pcore_type.create(value))
Here pcore_type is the result of parsing the string the attacker put in __ptype through Types::TypeParser.singleton.parse(type_value, @loader). That parser accepts more than primitive type names such as Integer and String; it also accepts inline type definitions of the form Object[{...}]. Meaning: a single field of a report can carry an entire type definition, saying "this value's type is the following." The report schema has no slot for a type definition. The converter trusted the data rather than the schema, and that created the slot.
2. From a type definition to class_eval in four steps
An inline Object type descends through create at pops/types/p_object_type.rb:863 into implementation_class.create(*args). implementation_class (line 551) first looks the class name up in the implementation registry and, failing that, builds a default implementation at line 557.
if class_name.nil?
# Use generator to create a default implementation
@implementation_class = RubyGenerator.new.create_class(self)
That branch favors the attacker. Use a type name that is not in the registry, a type that does not exist in the world (the advisory's PoC uses PEP), and execution always lands here. create_class in types/ruby_generator.rb:57 assembles a Ruby class body string out of the type definition and compiles it at line 66.
class_def = ''.dup
class_body(key, EMPTY_ARRAY, class_def)
cls = Class.new(parent_class)
cls.class_eval(class_def)
The body assembly is class_body (line 206), and the block at line 391 that emits function definitions is the decisive part.
code_annotation = RubyMethod.annotate(func)
if code_annotation
body = code_annotation.body
params = code_annotation.parameters
bld << "\n def " << rname(func.name)
...
bld << "\n " << body << "\n"
The body of a RubyMethod annotation is an arbitrary string carried inside the type definition, and it lands inside the def block with no escaping. The attacker puts a string in that body which closes the function early: 1 and end to end the method, a backticked shell command at the top level of the class body, then def d2 to open a new function. The assembled result:
def pwn
1
end
`/bin/sh -c 'touch /tmp/pwned'`
def d2
1
end
That class is never instantiated anywhere. class_eval compiles the string, though, and a backtick at the top level of a class body runs at compile time. The commands execute with the privileges of the Puppet Server service account: puppet. A normal report's events contain only scalars β name, status, message, elapsed time β and the server has no reason to build a class from that data. The difference between normal and attack traffic is not the request format. It is one semantic question: should this value be an object?
3. The unauthenticated path an autosigning CA creates
PR:L in the CVSS vector means one agent certificate is required. Without a certificate the report endpoint is closed, so strictly this is a post-authentication vulnerability. The catch is that obtaining that certificate is usually automated.
A new node without a certificate submits a CSR to /puppet-ca/v1/certificate_request/{name}. That endpoint has to be reachable without a certificate, so it does not require authentication. If an operator signs manually, the story ends there. In environments that auto-enroll tens to thousands of nodes through provisioning tools (Satellite, Ansible, Terraform), autosign is enabled, and a pattern such as *.lab.local in autosign.conf passes node names through without verification. This is why Perforce and CISA both state that when a CA autosigns without strong validation, an unauthenticated network attacker can obtain a valid certificate and exploit it. Under that condition the attack chain starts unauthenticated and ends in code execution as the server.
The report body OpenVox published in GHSA-ffr6-rwpm-p5wq keeps the shape of a normal report exactly: report_format 12, puppet_version 8.20.0, status changed, a Notify[x] entry under resource_statuses, matching what a real agent sends. One place differs β the events array.
"events": [
{
"__ptype": "Object[{name => 'PEP', functions => {'test' => {type => Callable, annotations => {RubyMethod => {'body' => \"1\\n end\\n `/bin/sh -c 'touch /tmp/pwned'`\\n def d2\\n 1\"}}}}}]",
"__pvalue": "x"
}
]
If the request succeeds, /tmp/pwned appears owned by puppet. From there the escalation follows the shape of the configuration management server. Neodyme's lab chain first copies the CA private key out through the Puppet file bucket (default /opt/puppetlabs/server/data/puppetserver/bucket), then uses that key to issue a server certificate offline with serverAuth and clientAuth in the EKU, attaches to the PXP (Puppet Execution Protocol) broker on port 8142, and pushes tasks to managed nodes for root execution. Estates without PXP configured still lose. In a non-standard install the puppet user can overwrite the catalog and distribute malicious configuration to every managed node from its next check-in, and in any configuration an attacker holding the CA signing key can forge the identity of other nodes.
The companion defect published the same day, CVE-2026-115732 (CVSS 9.0), makes that last stage far cheaper. It is a validation flaw where a certificate name passing as a partial match against an approved name was accepted, letting one node impersonate another. Neodyme reported fetching a specific host's catalog this way in a real customer environment, with PostgreSQL credentials and an admin API token sitting in it in plaintext. The RCE takes the server; the impersonation hands over the catalog's secrets. That is why the two CVEs came as a set.
For defenders there are observation points in the report body and in the aftermath. In report storage logs or proxy payloads, a __ptype value starting with Object[ or containing a RubyMethod string is a shape no normal agent can produce. Blocking __ptype wholesale would also catch legitimate rich data from Puppet 5 agents, so the filter has to target type definition expressions and RubyMethod annotations specifically. On the server, look for /bin/sh child processes spawned by puppet, PEM files newly appearing in the file bucket, newly signed certificates on the CA, PXP task execution history, and changes to catalog file ownership or mtime. forensicTriage: No in KEV is an administrative distinction that triage is not mandatory β not a statement that there is nothing to look for.
4. The patch: one line in the converter, with a compatibility price
The public-source fix is OpenVox commit 16920fe3a5a6ea887c5b261437269ae993094106 (21 October 2026, "Read event data hashes with the stringifying converter"). The change is a single converter swap in event.rb.
def initialize_from_hash(data)
- data = Puppet::Pops::Serialization::FromDataConverter.convert(data, {
- :allow_unresolved => true,
- :loader => Puppet::Pops::Loaders.static_loader
- })
+ # Read with the stringifying converter, the same one #to_data_hash writes with.
+ # Event values contain no rich data downstream, so there is nothing to reconstruct.
+ data = Puppet::Pops::Serialization::ToStringifiedConverter.convert(data, :message_prefix => 'Event')
The core idea is "read with the same converter you write with." Event#to_data_hash always used ToStringifiedConverter. The output was stringified plain data; only the input went through a deserializer. That asymmetry was the defect, and the fix removes it. The test in the same commit pins the regression condition explicitly: when an event carries a __ptype of Object[{name => 'Ev', attributes => {'a' => Integer}}], create_class in Puppet::Pops::Types::RubyGenerator must not be called. Tagged values stay hashes and the __ptype key disappears.
The cost is compatibility. The commit message notes that rich-typed values written by Puppet 5 agents are no longer restored as objects and arrive as tagged hashes with the reserved keys changed. Practically, values in reports left by agents from around 2021 may render differently when read on a current server, and report viewers or external report pipelines that expected __ptype-based objects should be checked after upgrading.
The Perforce fix is tracked as PA-9473 and landed in Puppet Server 9.0.24.1 and PuppetDB 9.0.26/8.10.16. Version coverage:
| Product | Vulnerable | Fixed | Note |
|---|---|---|---|
| Perforce Puppet Enterprise | 2026.0.0 to below 2026.0.1 | 2026.0.1 | includes Puppet Core 9.1.3 |
| Perforce Puppet Enterprise | 2025.0.0 to below 2025.12.1 | 2025.12.1 | includes Puppet Core 8.22.2 |
| Perforce Puppet Enterprise | 2023.8.0 to below 2023.8.13 | 2023.8.13 | includes Puppet Core 8.22.2 |
| Puppet Core | 9.0.0 to below 9.1.3 | 9.1.3 | Puppet Server 9.0.24.1 |
| Puppet Core | 8.x to below 8.22.2 | 8.22.2 | PuppetDB 8.10.16 |
| OpenVox (open-source fork) | server β€ 9.1.0 / β€ 8.17.0 | 9.2.0 / 8.18.0 | agents 9.3.0 / 8.32.0 |
| Red Hat Satellite 6 / Capsule 6 | bundled openvox | RHSA-2026:95652 / 95653 | shipped 2026-11-13 |
What matters in the order of application is that the vulnerable code runs on the server. Deserialization is performed by Puppet Server's JRuby in its own puppet code, so the first move is raising Puppet Core on the server and restarting pe-puppetserver so the fixed code loads. Agents on managed nodes are the attacker-side condition of this defect (the party sending the report), so raising only the server makes the server safe β but a PE release bundles both, so following the standard upgrade procedure costs less verification work.
Where a patch cannot go in immediately, three things reduce exposure. First, turn autosign off and move to manual signing or policy-based signing with strong validation (puppet config print autosign shows the current value; if autosign.conf exists, read it). Second, restrict port 8140 to the managed node range and remove internet exposure β there is almost never a legitimate reason to put a Puppet Server on the public internet. Third, reject report PUT bodies whose __ptype value starts with Object[ or contains RubyMethod, at a proxy or WAF in front of the server. All three buy time and remove none of the defect. If a breach is suspected, one more step goes into the order: if there are traces of the CA private key being read, the CA has to be rotated and every node certificate reissued along with the patch β until then no certificate can be trusted.
The lesson this case leaves is closer to boundary design than to version management. Puppet Server stands on a model where "a certificate means that node is trusted," and coupled with large-scale automatic provisioning that model turns certificates into something close to publicly issued documents. The assumption that data behind the certificate lives inside the trust boundary quietly stops holding on top of it. What remains after patching is the CA key and the issuance history, so the thing to check now is not only a version number.
Originally published in Korean at dohyeontech.github.io.
Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes β full credit and traffic to the original publisher.