Back to Intelligence

CVE-2026-115731: Perforce Puppet Server RCE Exploited in the Wild — Detection, Hardening, and Remediation Guide

SA
Security Arsenal Team
November 19, 2026
11 min read

Perforce Puppet — the configuration management backbone sitting at the center of thousands of enterprise infrastructures — has a critical remote code execution vulnerability that is actively being exploited in attacks. Tracked as CVE-2026-115731, the flaw allows any client that holds a CA-signed agent certificate to execute arbitrary code on the Puppet server itself.

If you run Puppet (open source or Puppet Enterprise), understand the gravity of this immediately: your Puppet server is one of the most privileged assets in your environment. It holds root-equivalent control over every managed node, stores credentials and secrets in catalogs and Hiera data, and pushes code to your entire fleet. An attacker who executes code on the Puppet server doesn't just own one box — they own your configuration management plane, which is functionally the keys to the kingdom.

The attack surface here is insidious. This is not an unauthenticated zero-day in the traditional sense — but in any large environment, there are hundreds or thousands of signed agent certificates floating around. Every managed node, every decommissioned-but-never-cleaned VM image, every compromised workstation with an agent installed, every cert that leaked into a backup or a Git repo represents a potential exploitation path. Active exploitation is confirmed. The time to act is now.

Technical Analysis

What CVE-2026-115731 Actually Is

Based on the disclosure, the vulnerability exists in the way the Puppet server (the puppetserver process — a JRuby application running inside a JVM, typically fronted by its embedded web server on TCP/8140) processes requests from clients presenting valid CA-signed agent certificates.

Key mechanics defenders must internalize:

  • Authentication barrier: low in practice. The attacker needs a certificate signed by your Puppet CA. In a mature environment, that includes every agent cert ever issued — including certs on compromised endpoints, certs embedded in old VM templates and AMIs, certs that were never revoked after node decommissioning, and any cert an attacker obtains through a prior foothold on any managed node.
  • Impact: code execution on the server. Successful exploitation yields command execution in the context of the puppetserver process (commonly running as the puppet user, but with read access to the CA private key, signed certs, catalogs, Hiera secrets, and the ability to modify manifests pushed to every node).
  • Blast radius: total fleet compromise. Post-exploitation, an attacker can modify Puppet code/modules in the environment directories (e.g., /etc/puppetlabs/code/environments/), poison catalogs, extract secrets, and push malicious configurations to every agent on the next run cycle (default: every 30 minutes).

Affected Products

  • Perforce Puppet (open source) — puppetserver installations
  • Perforce Puppet Enterprise (PE) — primary/compile master infrastructure nodes

Any deployment where the Puppet CA has issued agent certificates and the server is reachable from those agents over TCP/8140 is in scope. Air-gapped or tightly segmented deployments have a smaller — but not zero — exposure surface.

Exploitation Status

  • Confirmed active exploitation in the wild per the SecurityWeek reporting. This is not theoretical.
  • Given the confirmed exploitation, treat this with CISA KEV-level urgency even while monitoring for formal KEV listing. Do not wait for a catalog entry to act.

Why This Attack Chain Is So Dangerous

The classic post-exploitation path we've seen in configuration-management compromises (and what your IR plan should assume) looks like this:

  1. Attacker compromises any single managed endpoint and harvests its agent certificate and private key (/etc/puppetlabs/puppet/ssl/certs/<fqdn>.pem and /etc/puppetlabs/puppet/ssl/private_keys/<fqdn>.pem).
  2. Attacker presents that cert to the Puppet server over 8140 and exploits CVE-2026-115731 to achieve code execution as the puppet user.
  3. Attacker reads the CA private key, Hiera-encrypted secrets (or the eyaml keys), and writes malicious code into environment module paths.
  4. Within one run interval, the attacker's payload executes as root on every managed node in the fleet.

Steps 1–4 can complete in under an hour. Detection windows are measured in minutes.

Detection & Response

The strongest behavioral signal available: the puppetserver JVM process should essentially never spawn interactive shells, download tools, or scripting interpreters. Any child process of the puppetserver JVM that is a shell, curl/wget, python, nc, or a base64-decoding pipeline is an emergency-grade alert. Below are production-ready detections.

Sigma Rules

YAML
---
title: Puppet Server Process Spawning Shell or Interpreter
description: Detects the puppetserver JVM or wrapper processes spawning shells, scripting interpreters, or network download tools — a strong indicator of post-exploitation activity following CVE-2026-115731 RCE on the Puppet server.
author: Security Arsenal
id: 3b8f2e91-7c4a-4d2e-9f1a-5e6b7c8d9e0f
date: 2026/04/06
status: experimental
references:
  - https://www.securityweek.com/critical-perforce-puppet-rce-exploited-in-attacks/
  - https://attack.mitre.org/techniques/T1059/
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentCommandLine|contains:
      - 'puppetserver'
      - 'puppet-server'
  selection_parent_img:
    ParentImage|endswith:
      - '/java'
  selection_child:
    Image|endswith:
      - '/sh'
      - '/bash'
      - '/dash'
      - '/zsh'
      - '/python'
      - '/python3'
      - '/perl'
      - '/curl'
      - '/wget'
      - '/nc'
      - '/ncat'
      - '/socat'
      - '/base64'
  condition: (selection_parent or selection_parent_img) and selection_child
falsepositives:
  - Rare; legitimate puppetserver JVM child processes are typically limited to puppet subcommands (e.g., puppetserver ca). Validate any java-parent matches against known Java service children in your environment before broad deployment.
level: critical
---
title: Unauthorized Modification of Puppet Code or Environment Directories
description: Detects file writes to Puppet environment/module paths by processes other than the expected deployment toolchain (r10k, code-manager, CI pipelines), consistent with an attacker poisoning manifests after compromising the Puppet server via CVE-2026-115731.
author: Security Arsenal
id: 9c1d4a72-2e5f-4b8a-a3c6-7d8e9f0a1b2c
date: 2026/04/06
status: experimental
references:
  - https://www.securityweek.com/critical-perforce-puppet-rce-exploited-in-attacks/
  - https://attack.mitre.org/techniques/T1554/
logsource:
  category: file_event
  product: linux
detection:
  selection_paths:
    TargetFilename|contains:
      - '/etc/puppetlabs/code/environments/'
      - '/etc/puppetlabs/puppetserver/'
      - '/opt/puppetlabs/server/data/'
      - '/etc/puppetlabs/puppet/hiera.yaml'
      - '/etc/puppetlabs/puppet/ssl/'
  filter_deployers:
    Image|endswith:
      - '/r10k'
      - '/git'
      - '/rsync'
  condition: selection_paths and not filter_deployers
falsepositives:
  - Administrators editing modules directly on the server (a practice that should be eliminated — enforce r10k/Code Manager-only deployments)
level: high
---
title: Suspicious Connections to Puppet Server Port 8140 from Non-Agent Systems
description: Detects inbound TLS connections to the Puppet server on TCP/8140 from source hosts outside the managed-agent population, which may indicate an attacker replaying a harvested agent certificate to exploit CVE-2026-115731.
author: Security Arsenal
id: 5f7a9c1d-3b6e-4f2a-b8d4-9e0f1a2b3c4d
date: 2026/04/06
status: experimental
references:
  - https://www.securityweek.com/critical-perforce-puppet-rce-exploited-in-attacks/
  - https://attack.mitre.org/techniques/T1190/
logsource:
  category: network_connection
  product: linux
detection:
  selection:
    DestinationPort: 8140
    Image|endswith:
      - '/curl'
      - '/wget'
      - '/python'
      - '/python3'
      - '/openssl'
      - '/nc'
      - '/ncat'
  condition: selection
falsepositives:
  - Manual puppet agent --test invocations wrapped in scripts; infrastructure health checks using openssl s_client (tune to known monitoring hosts)
level: high

KQL — Microsoft Sentinel / Defender

Hunt for the puppetserver process spawning unexpected children (requires Syslog/auditd ingestion from your Puppet servers, or MDE Linux coverage):

KQL — Microsoft Sentinel / Defender
// Hunt: puppetserver spawning shells/interpreters — post-CVE-2026-115731 exploitation
union isfuzzy=true
    (Syslog
    | where Facility =~ "user" or Facility =~ "audit"
    | where SyslogMessage has "puppetserver"
    | where SyslogMessage has_any ("/bin/sh", "/bin/bash", "curl", "wget", "python", "nc ", "ncat", "base64")
    | project TimeGenerated, Computer, SyslogMessage),
    (DeviceProcessEvents
    | where InitiatingProcessCommandLine has_any ("puppetserver", "puppet-server")
    | where FileName in~ ("sh", "bash", "dash", "zsh", "python", "python3", "perl", "curl", "wget", "nc", "ncat", "socat", "base64")
    | project TimeGenerated, DeviceName, FileName, ProcessCommandLine, InitiatingProcessCommandLine, AccountName
    )
| order by TimeGenerated desc
KQL — Microsoft Sentinel / Defender
// Hunt: connections to Puppet server 8140 from unusual sources (CEF/Syslog firewall or netflow)
CommonSecurityLog
| where DestinationPort == 8140
| summarize ConnectionCount = count(), FirstSeen = min(TimeGenerated), LastSeen = max(TimeGenerated)
    by SourceIP, SourceHostName, DestinationHostName
| order by ConnectionCount asc
// Investigate low-frequency sources not present in your managed-node inventory

Velociraptor VQL

Deploy this hunt across your Puppet server(s) to identify suspicious child processes of the puppetserver JVM and enumerate active listeners/connections on 8140:

VQL — Velociraptor
-- Hunt: CVE-2026-115731 post-exploitation artifacts on Puppet servers
-- Suspicious children of puppetserver JVM + established 8140 connections
SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE (
        CommandLine =~ '(?i)(/bin/(ba)?sh|curl|wget|python|perl|ncat|socat|base64)'
        AND (
            Ppid IN (SELECT Pid FROM pslist() WHERE CommandLine =~ '(?i)puppetserver|puppet-server')
        )
      )
   OR Name =~ '(?i)puppetserver'
VQL — Velociraptor
-- Enumerate established connections to the Puppet server port 8140 for source triage
SELECT Pid, Name, Status, LocalAddr, LocalPort, RemoteAddr, RemotePort
FROM netstat()
WHERE LocalPort = 8140 AND Status =~ 'ESTABLISHED'
ORDER BY RemoteAddr

Remediation / Verification Script (Bash)

Run on your Puppet server(s) to inventory signed certificates, check versions, identify unexpected recent CA activity, and apply network-level compensating controls while you patch:

Bash / Shell
#!/usr/bin/env bash
# CVE-2026-115731 — Puppet Server triage & compensating controls
# Run as root on the Puppet server / PE primary. Review before executing firewall changes.

set -euo pipefail

echo "=== [1] Installed puppetserver version ==="
if command -v puppetserver >/dev/null 2>&1; then
  puppetserver --version || true
fi
rpm -qa 2>/dev/null | grep -iE 'puppetserver|puppet-agent|pe-puppetserver' || \
dpkg -l 2>/dev/null | grep -iE 'puppetserver|puppet-agent|pe-puppetserver' || true

echo "=== [2] Full inventory of CA-signed agent certificates ==="
puppetserver ca list --all 2>/dev/null | tee /tmp/puppet_ca_inventory.txt

echo "=== [3] Certificates signed in the last 30 days (unexpected signings = investigate) ==="
find /etc/puppetlabs/puppet/ssl/ca/signed -name '*.pem' -mtime -30 -ls 2>/dev/null || \
find /etc/puppetlabs/puppetserver/ca/signed -name '*.pem' -mtime -30 -ls 2>/dev/null || true

echo "=== [4] Recent puppetserver access log entries hitting suspicious endpoints ==="
for log in /var/log/puppetlabs/puppetserver/puppetserver-access.log \
           /var/log/puppetlabs/puppetserver/puppetserver.log; do
  [ -f "$log" ] && tail -n 5000 "$log" | grep -viE '\"(GET|PUT|POST|HEAD) /puppet/v3/(catalog|node|file_|report|status)' | tail -n 50 || true
done

echo "=== [5] Child processes of puppetserver (should be near-empty) ==="
PSERVER_PID=$(pgrep -f 'puppetserver' | head -n1 || true)
if [ -n "${PSERVER_PID:-}" ]; then
  ps --ppid "$PSERVER_PID" -o pid,ppid,user,comm,args || true
fi

echo "=== [6] COMPENSATING CONTROL: restrict 8140 to known agent subnets ==="
echo "# Example (adjust subnets to your managed-node ranges; test before enforcing):"
echo "# firewall-cmd --permanent --new-zone=puppet-agents"
echo "# firewall-cmd --permanent --zone=puppet-agents --add-source=10.20.0.0/16"
echo "# firewall-cmd --permanent --zone=puppet-agents --add-port=8140/tcp"
echo "# firewall-cmd --permanent --zone=public --remove-port=8140/tcp"
echo "# firewall-cmd --reload"

echo "=== [7] OPTIONAL IR action: revoke a suspected compromised agent cert ==="
echo "# puppetserver ca clean --certname <compromised-node-fqdn>"

echo "Triage complete. Preserve /tmp/puppet_ca_inventory.txt and logs for forensics."

Remediation

  1. Patch immediately. Apply the fixed puppetserver/Puppet Enterprise release referenced in the official Perforce security advisory for CVE-2026-115731. Pull the advisory and exact fixed version numbers directly from Perforce's security advisories page (https://www.perforce.com/support/security-advisories) and the Puppet release notes — do not rely on secondary sources for version specifics, and verify your installed build against the advisory before declaring remediation complete. Given confirmed in-the-wild exploitation, this is an emergency-change candidate, not a next-maintenance-window candidate.
  2. Audit the CA — this is as important as patching. Export the full signed-certificate inventory (puppetserver ca list --all) and reconcile it against your CMDB/asset inventory. Revoke (puppetserver ca clean --certname) every certificate that maps to a decommissioned, unknown, duplicated, or unverifiable node. Every orphaned cert is a pre-staged exploitation credential.
  3. Restrict network reachability of TCP/8140. The Puppet server should be reachable only from managed-node subnets. Block 8140 from user VLANs, guest networks, server-adjacent DMZs that aren't managed, and especially the internet. If 8140 is currently exposed beyond agent subnets, treat that as an incident to investigate, not just a misconfiguration.
  4. Hunt before you patch, not after. Patching closes the hole; it does not evict an attacker. Run the Sigma/KQL/VQL detections above, review the puppetserver access logs for anomalous endpoints or client certnames, diff your environment module directories against your Git source of truth (r10k deploy roots vs. repo HEAD), and check the CA for recently signed certs you didn't authorize.
  5. Assume secret exposure if compromise is suspected. The puppet user context can read the CA private key and Hiera/eyaml key material. If you find evidence of exploitation: rotate the Puppet CA (full re-issue of agent certs), rotate every secret stored in Hiera, rotate any credentials present in catalogs, and audit Puppet code changes going back to earliest suspicious log entries. Engage your IR retainer — this is a full-scope incident.
  6. Harden the trust model going forward. Disable CA autosigning (or restrict it to tightly-scoped, time-boxed policy-based autosign with challenge passwords); enforce cert clean-up in your decommissioning runbooks; monitor for cert signing events as a high-fidelity alert; and move all module deployments exclusively through r10k/Code Manager so any direct file write to environment paths becomes a high-severity anomaly.
  7. Fleet integrity check. Because post-exploitation commonly means poisoned catalogs, validate a sample of managed nodes for unexpected packages, cron entries, systemd units, and new local accounts — and confirm your EDR coverage includes both the Puppet servers and a representative slice of agents.

The Bottom Line

CVE-2026-115731 collapses the entire trust model of Puppet into a single condition: hold any signed agent certificate, own the server. With exploitation already confirmed, every hour of delay extends the window in which a single compromised laptop's agent cert can be converted into fleet-wide root access. Patch the server, prune the CA, lock down 8140, and hunt aggressively — in that order, starting today.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.