Puppet Server Deserialization RCE, Exploited (CVE-2026-115731)
A CA-signed Puppet agent certificate lets an attacker run code on Puppet Server through a crafted report; fixed in Puppet Core 8.22.2 and 9.1.3.
TL;DR
- A crafted report event reaches Puppet's rich-data deserializer and runs Ruby on the Puppet Server as its service user. The flaw is CVE-2026-115731.
- Any client with a CA-signed agent certificate can send the report. Where the certificate authority autosigns without strong verification, an unauthenticated attacker can obtain that certificate first.
- CISA added CVE-2026-115731 to the KEV catalog on 2026-11-17, which records exploitation in the wild. The federal due date is 2026-12-01.
- Upgrade to Puppet Core 8.22.2 or 9.1.3, or Puppet Enterprise 2023.8.13, 2025.12.1 or 2026.0.1. Disable weak autosign and restrict the report endpoint if you cannot upgrade.
Am I affected?
You are affected when all of these hold:
- You run Puppet Core 8.x before 8.22.2, or 9.0.0 before 9.1.3.
- Or you run Puppet Enterprise 2023.8.0 before 2023.8.13, 2025.0.0 before 2025.12.1, or 2026.0.0 before 2026.0.1.
- The Puppet Server accepts agent reports on its HTTPS port, 8140 by default.
- An attacker can obtain a CA-signed agent certificate. A compromised agent provides one; an autosign policy that does not verify the request strongly provides one to anyone who asks.
The report endpoint is part of every Puppet Server, so the version is the main condition. Autosign turns the authenticated flaw into an unauthenticated one. Without it, the attacker needs a certificate the CA already issued.
| Branch | Affected versions | Fixed version |
|---|---|---|
| Puppet Core 9.x | 9.0.0 to 9.1.2 | 9.1.3 |
| Puppet Core 8.x | 8.0.0 to 8.22.1 | 8.22.2 |
| Puppet Enterprise 2026 | 2026.0.0 | 2026.0.1 |
| Puppet Enterprise 2025 | 2025.0.0 to 2025.12.0 | 2025.12.1 |
| Puppet Enterprise 2023.8 | 2023.8.0 to 2023.8.12 | 2023.8.13 |
| OpenVox Agent 9.x | before 9.3.0 | 9.3.0 |
| OpenVox Agent 8.x | before 8.32.0 | 8.32.0 |
| OpenVox Server 9.x | before 9.2.0 | 9.2.0 |
| OpenVox Server 8.x | before 8.18.0 | 8.18.0 |
Check the version on the server and on a sample of agents. Run the first command on the Puppet Server and the second on an agent host.
puppet --version
/opt/puppetlabs/bin/puppet --version
Puppet Enterprise installs under /opt/puppetlabs. An open-source package install also answers to the distribution package manager.
rpm -q puppetserver puppet-agent
dpkg -l puppetserver puppet-agent
Check whether the CA autosigns, and read the policy if it does.
puppet config print autosign
cat /etc/puppetlabs/puppet/autosign.conf
How do I fix it?
Upgrade the Puppet Server to a fixed build and disable weak autosign. Both steps matter: the upgrade closes the deserializer, and the autosign change removes the easiest way to get a certificate.
- Upgrade Puppet Core to 8.22.2 or 9.1.3 through the channel you installed it from.
- Upgrade Puppet Enterprise to 2023.8.13, 2025.12.1 or 2026.0.1 with the Puppet Enterprise installer.
- Restart
puppetserverand confirm the new version withpuppet --version. - Disable autosign, or replace it with policy-based autosign that verifies the request. Set
autosign = falseinpuppet.conffor the simple case. - Restrict TCP 8140 to the agents and consoles that need it. The report endpoint shares the port with catalog compilation.
# Open-source package install: upgrade both packages
sudo yum update puppetserver puppet-agent
# RubyGems install of Puppet Core
sudo gem install puppet -v 8.22.2
# 9.x line
sudo gem install puppet -v 9.1.3
OpenVox deployments must update both components: OpenVox Server to 9.2.0 or 8.18.0, and OpenVox Agent to 9.3.0 or 8.32.0, through the OpenVox package channel. Restart the server after updating its bundled Puppet library. Puppet Core release numbers are also distinct from puppetserver package versions; use the vendor channel rather than assuming identical version pins.
A deployment that cannot upgrade should disable autosign and restrict port 8140. That removes the unauthenticated path, but a stolen or forged agent certificate still reaches the deserializer. The workaround does not fix the flaw.
What is the root cause?
Puppet::Transaction::Event#initialize_from_hash read the event hash from an agent report with FromDataConverter, which reconstructs Puppet's rich data types from a reserved __ptype key. That key is attacker-controlled.
The method is in lib/puppet/transaction/event.rb:
def initialize_from_hash(data)
data = Puppet::Pops::Serialization::FromDataConverter.convert(data, {
:allow_unresolved => true,
:loader => Puppet::Pops::Loaders.static_loader
})
data is the event object from the report JSON. allow_unresolved lets a type name that the server cannot resolve pass through the converter. The converter reads __ptype and parses it as a Puppet type in lib/puppet/pops/serialization/from_data_converter.rb:
type = Types::TypeParser.singleton.parse(type_value, @loader)
...
pcore_type_hash_to_value(type, value)
For an Object[...] type, .create(value) reaches PObjectType#implementation_class. When no implementation is registered, the object type generates one with RubyGenerator:
@implementation_class = RubyGenerator.new.create_class(self)
RubyGenerator#create_class builds a class body from the type definition and evaluates it:
class_def = ''.dup
class_body(key, EMPTY_ARRAY, class_def)
cls = Class.new(parent_class)
cls.class_eval(class_def)
The RubyMethod annotation is part of that class body. class_eval therefore runs the attacker's Ruby during report processing.
How is it exploited?
The published proof of concept sends a report whose event carries an inline Object[...] type with a RubyMethod annotation. The annotation body contains the command, and the backticks run it when the class is evaluated.
- Obtain a CA-signed agent certificate. With autosign that does not verify the request, enroll a new agent and receive one. Otherwise use a compromised agent's certificate.
- Build a report for
PUT /puppet/v3/report. Put the payload inresource_statuses[...].events. - Set
__ptypeto anObject[...]definition with aRubyMethodannotation. The annotation body is Ruby that runs during class generation. - Send the report with the agent certificate.
- The server calls
Event.from_data_hash, the converter parses the type, andclass_evalruns the body as thepuppetuser.
The OpenVox advisory publishes this event fragment, which runs touch /tmp/pwned:
"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"
}
]
The report also needs the ordinary fields, such as host, time, transaction_uuid and report_format. The advisory's full JSON shows the complete request body.
How does the attack flow?
An agent certificate buys a report submission, the report's event type is deserialized, and Ruby runs on the Puppet Server as the service user.
or autosign enrollment"] --> B["PUT /puppet/v3/report
with a crafted event"] B --> C["Event.from_data_hash
calls FromDataConverter"] C --> D["__ptype is parsed
as an Object type"] D --> E["RubyGenerator class_eval
runs the RubyMethod body"] E --> F["Code execution as
the puppet user"] F --> G["CA signing key
and managed hosts"]
What can an attacker do?
An attacker who reaches the deserializer runs code as the Puppet Server's service user. The impact grows with what that account can read.
- The
puppetuser can read the certificate authority's private key on a Puppet Server that acts as its own CA. - With the CA key, the attacker can sign certificates with
EKU critical, serverAuth, clientAuth. The advisory notes that this can enable command execution on other hosts where orchestration trusts those certificates. - The attacker can read the reports, facts and configuration the server holds, and can change the catalogs it serves.
- The attack is unauthenticated when autosign does not verify requests; otherwise one CA-signed agent certificate is required.
- No user interaction is required.
The advisory demonstrates code execution with a file-creation command. It does not publish a victim list or a wider campaign.
Why does the fix work?
The fix stops reconstructing rich values from report data. It reads the event hash with ToStringifiedConverter, the same converter that writes it, so the result contains only plain 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')
ToStringifiedConverter renames the reserved keys and keeps the value as a hash. It never calls TypeParser.parse, so it never reaches RubyGenerator#create_class or class_eval. The regression tests in the same change assert that an inline Object[...] definition generates no class.
The change is complete for the event path. It does not remove other deserialization in Puppet, so apply the vendor's fixed release rather than only this method.
How do I check if I was compromised?
Start with the certificates the CA issued and the report requests the server accepted. A successful attack may leave no command output in the Puppet logs.
- List every certificate and look for names you do not recognise:
/opt/puppetlabs/bin/puppetserver ca list --all. - Check whether autosign was enabled:
puppet config print autosign, then read/etc/puppetlabs/puppet/autosign.conf. - Search the Puppet Server access log for
PUT /puppet/v3/reportfrom certificate names that are not agents you manage. - Look for files the proof of concept creates, such as
/tmp/pwned. A different command leaves a different file, so this is a lead, not a complete check. - Review the
puppetuser's processes and recent files for unexpected entries. - If you find an unknown certificate or evidence of code execution, treat the CA as compromised. Rebuild the server, rotate the CA and reissue every certificate.
No public indicators of compromise exist beyond the proof-of-concept marker. An attempt that failed validation may leave only a report request in the log.
Timeline
The fix and the CVE arrived together; the KEV listing followed two weeks later.
- 2026-11-03: Perforce publishes the advisory for CVE-2026-115731 and the fixed Puppet Core and Puppet Enterprise builds.
- 2026-11-03: The OpenVox project publishes GHSA-ffr6-rwpm-p5wq with the technical detail and releases 9.3.0 and 8.32.0.
- 2026-11-03: The CVE record and the GitHub advisory publish.
- 2026-11-17: CISA adds CVE-2026-115731 to the KEV catalog, with a federal due date of 2026-12-01.
- 2026-12-01: The federal remediation deadline.
FAQ
Is the flaw unauthenticated?
Only when the CA autosigns without strong verification. In that configuration, an attacker enrolls a new agent and receives a CA-signed certificate. Otherwise the attacker needs a certificate the CA already issued, such as one from a compromised agent.
Does it affect open-source Puppet or only Puppet Enterprise?
Both. Perforce lists Puppet Core 8.x and 9.x and three Puppet Enterprise lines. The OpenVox project documents the same code path in its fork and shipped 9.3.0 and 8.32.0.
Which versions fix it?
Puppet Core 8.22.2 and 9.1.3, and Puppet Enterprise 2023.8.13, 2025.12.1 and 2026.0.1. The vendor advisory lists each line and its fixed build.
Is there a public proof of concept?
Yes. The OpenVox advisory includes the full JSON report and the event fragment that runs a command. It is a working proof of concept against the affected code.
Is it exploited in the wild?
CISA added it to KEV on 2026-11-17, which records exploitation. No victim, campaign or indicator list is public.
Can I keep autosign and stay safe?
No. Disabling autosign removes the unauthenticated path, but a stolen agent certificate still reaches the deserializer. Upgrade to a fixed build, then review the autosign policy.
Find exposed Puppet Servers with Ostorlab
Ostorlab's attack surface discovery inventories the internet-facing hosts an organisation exposes, so you can find Puppet Server endpoints on port 8140 and patch them first. Start at https://ostorlab.co/product/attacksurface_discovery
References
- Perforce, "CVE: Report Deserialization Code Execution", 2026-11-03 (checked November 18, 2026). https://portal.perforce.com/s/cve/a91Qi000003IaHpIAK/report-deserialization-code-execution
- GitHub Advisory Database, "GHSA-4pxx-8frq-9r4j: Deserialization of untrusted data in the report-processing code of Puppet", 2026-11-03 (checked November 18, 2026). https://github.com/advisories/GHSA-4pxx-8frq-9r4j
- OpenVox project, "GHSA-ffr6-rwpm-p5wq: Authenticated RCE on OpenVox server via Event Deserialization", 2026-11-03 (checked November 18, 2026). https://github.com/OpenVoxProject/openvox/security/advisories/GHSA-ffr6-rwpm-p5wq
- OpenVox project, "Read event data hashes with the stringifying converter", pull request #765, 2026-11-03 (checked November 18, 2026). https://github.com/OpenVoxProject/openvox/pull/765
- OpenVox project, "9.3.0 release notes", 2026-11-03 (checked November 18, 2026). https://github.com/OpenVoxProject/openvox/releases/tag/9.3.0
- OpenVox project, vulnerable
event.rbat commit a80dfc2, 2026-11-03 (checked November 18, 2026). https://github.com/OpenVoxProject/openvox/blob/a80dfc2c8ea83a76908ca8b99507dfa18a09f01a/lib/puppet/transaction/event.rb#L69-L73 - CVE Program, "CVE-2026-115731", 2026-11-03 (checked November 18, 2026). https://www.cve.org/CVERecord?id=CVE-2026-115731
- CISA, "Known Exploited Vulnerabilities Catalog", 2026-11-17 (checked November 18, 2026). https://www.cisa.gov/known-exploited-vulnerabilities-catalog?field_cve=CVE-2026-115731