On Tuesday, the U.S. Cybersecurity and Infrastructure Security Agency (CISA) added CVE-2026-115731 to its Known Exploited Vulnerabilities (KEV) catalog — a critical remote code execution vulnerability in Perforce Puppet, the widely deployed enterprise infrastructure-as-code (IaC) and configuration management platform. The flaw carries a CVSS score of 9.4, placing it firmly in critical territory, and CISA's KEV inclusion confirms this is not theoretical: threat actors are actively exploiting this vulnerability in the wild.
For defenders, this should trigger immediate alarm. Puppet servers occupy a uniquely privileged position in enterprise environments. They hold the keys to your entire infrastructure — distributing configurations, managing credentials, and pushing code to thousands of endpoints. A compromised Puppet master is not just a single breached server; it is a potential enterprise-wide compromise with a built-in, trusted lateral movement mechanism that reaches every managed node in your environment. If an attacker gains code execution on your Puppet server, they effectively gain the ability to push arbitrary configurations, install persistent backdoors, and exfiltrate secrets from every system Puppet manages.
If your organization runs Perforce Puppet Enterprise or open-source Puppet Server, treat this as an emergency patch scenario. Federal agencies under CISA's Binding Operational Directive (BOD) 22-01 have a mandated remediation deadline. Private-sector organizations should adopt the same urgency.
Technical Analysis
Vulnerability Overview
| Attribute | Detail |
|---|---|
| CVE ID | CVE-2026-115731 |
| CVSS Score | 9.4 (Critical) |
| Affected Product | Perforce Puppet (Puppet Enterprise and open-source Puppet Server) |
| Vulnerability Type | Remote Code Execution (RCE) |
| Exploitation Status | Actively exploited in the wild; listed in CISA KEV |
| Attack Vector | Network-based; targets Puppet management server components |
| Component at Risk | Puppet Server / Puppet Master — the central management infrastructure |
Why Puppet Servers Are a High-Value Target
Puppet operates on a client-server architecture. The Puppet Server (historically called the Puppet Master) is the central authority that compiles configuration catalogs and distributes them to agent nodes across the environment. Agents check in regularly — typically every 30 minutes by default — to retrieve and apply their assigned configurations.
This architecture means that code execution on the Puppet Server gives an attacker several devastating capabilities:
- Catalog Poisoning: Modify Puppet manifests and modules to push malicious configurations, packages, or scripts to every managed node.
- Credential Theft: Puppet Servers frequently store sensitive data — API keys, database credentials, certificates, Hiera secrets, and in some configurations, SSH keys.
- Certificate Authority Abuse: The Puppet Server typically runs an integrated certificate authority (CA) that issues TLS certificates to agent nodes. An attacker controlling the CA can mint rogue certificates, impersonate legitimate nodes, and intercept agent communications.
- Persistent Access: By embedding malicious code into Puppet modules or manifests, attackers establish persistence that survives reboots and is re-applied on every agent check-in cycle.
Attack Chain Analysis
While specific exploitation details for CVE-2026-115731 have not been fully published, the CVSS 9.4 score and RCE classification strongly suggest a network-reachable vulnerability that can be exploited without authentication or with minimal authentication requirements. Based on the vulnerability class and Puppet's architecture, the likely attack chain follows this pattern:
- Initial Access: The attacker sends a crafted request to an exposed Puppet Server service — typically the Puppet Server API running on TCP port 8140, or potentially the Puppet Server's web-based console (Puppet Enterprise console on TCP 443).
- Code Execution: The vulnerability allows the attacker to execute arbitrary code in the context of the Puppet Server process, typically running as the
pe-puppetorpuppetservice account. - Privilege Escalation: The attacker leverages the Puppet service's file system access to read sensitive configuration files, Hiera data, and certificates.
- Lateral Movement: The attacker modifies Puppet manifests or modules to distribute payloads to managed agent nodes.
- Persistence: Malicious Puppet resources ensure that attacker's access mechanisms are maintained and re-applied across the infrastructure.
Exploitation Status
CVE-2026-115731 is listed in the CISA Known Exploited Vulnerabilities catalog. KEV inclusion requires confirmed evidence of active exploitation in the wild. This is not a proof-of-concept scenario — organizations should assume that exploitation attempts against internet-facing or internally accessible Puppet Servers are already underway.
Detection & Response
SIGMA Rules
---
title: Suspicious Process Spawned by Puppet Server
description: Detects unusual child processes spawned by the Puppet Server process (puppetserver or pe-puppetserver), which may indicate post-exploitation activity following CVE-2026-115731 exploitation. Legitimate Puppet Server operations rarely spawn interactive shells or system utilities directly.
references:
- https://thehackernews.com/2026/11/hackers-exploiting-critical-puppet-rce.html
- https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/11/04
id: a1b2c3d4-e5f6-7890-abcd-ef1234567890
status: experimental
tags:
- attack.execution
- attack.t1059
- attack.t1059.004
logsource:
category: process_creation
product: linux
detection:
selection_parent:
ParentImage|endswith:
- '/puppetserver'
- '/pe-puppetserver'
- '/java'
selection_parent_cmdline:
ParentCommandLine|contains:
- 'puppetserver'
- 'pe-puppetserver'
selection_child:
Image|endswith:
- '/bash'
- '/sh'
- '/dash'
- '/zsh'
- '/python'
- '/python3'
- '/perl'
- '/ruby'
- '/curl'
- '/wget'
- '/nc'
- '/ncat'
- '/socat'
- '/chmod'
- '/chown'
condition: selection_parent and selection_parent_cmdline and selection_child
falsepositives:
- Puppet exec resources that legitimately invoke shell commands during catalog application
- Custom Puppet modules that use exec or exec resource types
level: high
---
title: Suspicious File Modification in Puppet Code Directory
description: Detects unexpected file writes or modifications in Puppet environment directories (/etc/puppetlabs/code/, /etc/puppet/code/) by processes other than legitimate deployment tools. May indicate catalog poisoning or malicious module injection following Puppet Server compromise.
references:
- https://thehackernews.com/2026/11/hackers-exploiting-critical-puppet-rce.html
- https://attack.mitre.org/techniques/T1554/
author: Security Arsenal
date: 2026/11/04
id: b2c3d4e5-f6a7-8901-bcde-f12345678901
status: experimental
tags:
- attack.persistence
- attack.t1554
- attack.defense_evasion
logsource:
category: file_event
product: linux
detection:
selection_path:
TargetFilename|startswith:
- '/etc/puppetlabs/code/'
- '/etc/puppet/code/'
- '/opt/puppetlabs/server/data/'
selection_extension:
TargetFilename|endswith:
- '.pp'
- '.erb'
- '.epp'
- '.rb'
- '.yaml'
- '.eyaml'
filter_legitimate:
Image|endswith:
- '/puppet'
- '/r10k'
- '/git'
- '/rsync'
- '/vim'
- '/nano'
- '/code'
condition: selection_path and selection_extension and not filter_legitimate
falsepositives:
- System administrators manually editing Puppet manifests with non-standard editors
- CI/CD pipelines deploying code via custom scripts
level: high
---
title: Network Connection from Puppet Server to Suspicious Destination
description: Detects outbound network connections from the Puppet Server process to non-standard destinations. Puppet Server should primarily communicate with agent nodes on port 8140 and potentially with external repositories. Connections to unknown external IPs or uncommon ports may indicate C2 communication or data exfiltration.
references:
- https://thehackernews.com/2026/11/hackers-exploiting-critical-puppet-rce.html
- https://attack.mitre.org/techniques/T1071/
author: Security Arsenal
date: 2026/11/04
id: c3d4e5f6-a7b8-9012-cdef-123456789012
status: experimental
tags:
- attack.command_and_control
- attack.t1071
- attack.exfiltration
logsource:
category: network_connection
product: linux
detection:
selection_process:
Image|endswith:
- '/puppetserver'
- '/pe-puppetserver'
selection_process_cmdline:
CommandLine|contains:
- 'puppetserver'
- 'pe-puppetserver'
filter_known_ports:
DestinationPort:
- 8140
- 443
- 80
- 53
- 123
- 8081
- 8141
- 8142
- 8143
- 61613
- 5432
filter_internal:
DestinationIp|startswith:
- '10.'
- '172.16.'
- '172.17.'
- '172.18.'
- '172.19.'
- '172.20.'
- '172.21.'
- '172.22.'
- '172.23.'
- '172.24.'
- '172.25.'
- '172.26.'
- '172.27.'
- '172.28.'
- '172.29.'
- '172.30.'
- '172.31.'
- '192.168.'
- '127.'
condition: selection_process and selection_process_cmdline and not filter_known_ports and not filter_internal
falsepositives:
- Puppet Server connecting to external module repositories on non-standard ports
- Custom integrations with external monitoring or orchestration tools
level: medium
KQL — Microsoft Sentinel / Defender
The following KQL queries are designed for Microsoft Sentinel environments that ingest Linux Syslog and network data via the Syslog connector, CEF, or the Azure Monitor Agent. They also work with Defender for Endpoint data if your Puppet Servers are onboarded.
// Hunt 1: Detect suspicious child processes spawned by Puppet Server
// Looks for shells, interpreters, and network tools spawned by puppetserver/pe-puppetserver
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where InitiatingProcessCommandLine has_any ("puppetserver", "pe-puppetserver")
| where FileName in~ ("bash", "sh", "dash", "zsh", "python", "python3", "perl", "ruby", "curl", "wget", "nc", "ncat", "socat", "chmod", "chown")
| project TimeGenerated, DeviceName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, AccountName, InitiatingProcessId, ProcessId
| order by TimeGenerated desc
// Hunt 2: Detect inbound connections to Puppet Server on port 8140 from external or unexpected IPs
// Useful for identifying potential exploitation attempts against the Puppet Server API
DeviceNetworkEvents
| where TimeGenerated > ago(7d)
| where LocalPort == 8140
| where not (RemoteIP startswith "10." or RemoteIP startswith "192.168." or RemoteIP startswith "172.16.")
| project TimeGenerated, DeviceName, LocalPort, RemoteIP, RemotePort, InitiatingProcessFileName, InitiatingProcessCommandLine
| order by TimeGenerated desc
// Hunt 3: Syslog-based detection for Puppet Server exploitation artifacts
// Searches Syslog for suspicious process execution and file modification events related to Puppet
Syslog
| where TimeGenerated > ago(7d)
| where SyslogMessage has_any ("puppetserver", "pe-puppetserver")
| where SyslogMessage has_any ("bash", "sh -c", "python", "curl", "wget", "nc -", "chmod 777", "reverse", "shell")
| project TimeGenerated, Computer, Facility, SeverityLevel, SyslogMessage, ProcessName, ProcessID
| order by TimeGenerated desc
// Hunt 4: Detect file modifications in Puppet code directories
// Uses DeviceFileEvents from Defender for Endpoint on Linux
DeviceFileEvents
| where TimeGenerated > ago(7d)
| where FolderPath has_any ("/etc/puppetlabs/code/", "/etc/puppet/code/", "/opt/puppetlabs/server/data/")
| where ActionType in ("FileCreated", "FileModified", "FileRenamed")
| where not (InitiatingProcessFileName in~ ("puppet", "r10k", "git", "rsync", "vim", "nano"))
| project TimeGenerated, DeviceName, FolderPath, FileName, ActionType, InitiatingProcessFileName, InitiatingProcessCommandLine, InitiatingProcessAccountName
| order by TimeGenerated desc
Velociraptor VQL
The following VQL artifact hunts for indicators of Puppet Server compromise across your Linux fleet. Deploy this as a Velociraptor hunt targeting all systems with Puppet Server installed.
-- Hunt for Puppet Server post-exploitation indicators
-- Detects suspicious child processes, modified Puppet code files, and anomalous network connections
-- Deploy against all Linux endpoints running Puppet Server
-- Section 1: Suspicious child processes of puppetserver
SELECT Pid,
Ppid,
Name AS ProcessName,
Exe AS ProcessPath,
CommandLine,
Username,
CreateTime,
'Suspicious_Child_Process' AS IndicatorType
FROM pslist()
WHERE Ppid IN (
SELECT Pid FROM pslist()
WHERE CommandLine =~ 'puppetserver|pe-puppetserver'
)
AND (
Name =~ '(?i)bash|sh|dash|zsh|python|perl|ruby|curl|wget|nc|ncat|socat'
OR CommandLine =~ '(?i)reverse|shell|/dev/tcp|base64'
)
UNION ALL
-- Section 2: Recently modified Puppet manifest and module files
SELECT NULL AS Pid,
NULL AS Ppid,
'FILE_ARTIFACT' AS ProcessName,
FullPath AS ProcessPath,
NULL AS CommandLine,
NULL AS Username,
Mtime AS CreateTime,
'Modified_Puppet_Code' AS IndicatorType
FROM glob(globs=[
'/etc/puppetlabs/code/**/*.pp',
'/etc/puppetlabs/code/**/*.rb',
'/etc/puppetlabs/code/**/*.yaml',
'/etc/puppetlabs/code/**/*.eyaml',
'/etc/puppet/code/**/*.pp',
'/etc/puppet/code/**/*.rb',
'/etc/puppet/code/**/*.yaml'
])
WHERE Mtime > now() - 604800
UNION ALL
-- Section 3: Network connections from puppetserver process to non-standard destinations
SELECT Pid,
NULL AS Ppid,
Name AS ProcessName,
NULL AS ProcessPath,
NULL AS CommandLine,
NULL AS Username,
NULL AS CreateTime,
format(format='Suspicious_Network_Conn_%s:%s', args=[RemoteAddress.IP, RemoteAddress.Port]) AS IndicatorType
FROM netstat()
WHERE Name =~ '(?i)puppetserver|pe-puppetserver|java'
AND RemoteAddress.Port NOT IN (8140, 443, 80, 53, 123, 8081, 8141, 8142, 8143, 61613, 5432)
AND RemoteAddress.IP NOT =~ '^(10\\.|192\\.168\\.|172\\.(1[6-9]|2[0-9]|3[01])\\.|127\\.)'
Remediation and Hardening Script
The following Bash script performs immediate verification and hardening actions for Puppet Server systems. Run this on all Puppet Server hosts in your environment.
#!/bin/bash
# CVE-2026-115731 — Puppet Server Emergency Response Script
# Purpose: Verify Puppet Server version, check for compromise indicators, and apply hardening
# Run with root privileges on all Puppet Server hosts
# Author: Security Arsenal
set -euo pipefail
echo "=============================================="
echo "CVE-2026-115731 Puppet Server Response Script"
echo "Date: $(date -u)"
echo "=============================================="
# --- Step 1: Identify Puppet Server version ---
echo ""
echo "[STEP 1] Identifying Puppet Server version..."
if command -v puppetserver &> /dev/null; then
PUPPET_VERSION=$(puppetserver --version 2>/dev/null || echo "Unable to determine")
echo "Puppet Server version: $PUPPET_VERSION"
elif command -v pe-puppetserver &> /dev/null; then
PUPPET_VERSION=$(pe-puppetserver --version 2>/dev/null || echo "Unable to determine")
echo "Puppet Enterprise Server version: $PUPPET_VERSION"
else
echo "WARNING: Puppet Server binary not found. Verify installation path."
fi
# Check if Puppet Enterprise is installed
if [ -f /opt/puppetlabs/bin/puppet ]; then
PE_VERSION=$(/opt/puppetlabs/bin/puppet --version 2>/dev/null || echo "Unknown")
echo "Puppet agent version: $PE_VERSION"
fi
# --- Step 2: Check Puppet Server service status ---
echo ""
echo "[STEP 2] Checking Puppet Server service status..."
for service in puppetserver pe-puppetserver; do
if systemctl is-active --quiet "$service" 2>/dev/null; then
echo "Service $service is RUNNING"
systemctl status "$service" --no-pager -l | head -20
fi
done
# --- Step 3: Audit network listeners on Puppet ports ---
echo ""
echo "[STEP 3] Auditing network listeners on Puppet-related ports..."
echo "Active listeners on Puppet ports (8140, 8141, 8142, 8143, 61613):"
ss -tlnp | grep -E ':(8140|8141|8142|8143|61613)' || echo "No listeners found on standard Puppet ports"
echo ""
echo "All network connections involving puppetserver processes:"
ss -tnp | grep -i puppet || echo "No active puppetserver connections found"
# --- Step 4: Check for suspicious child processes ---
echo ""
echo "[STEP 4] Checking for suspicious child processes of puppetserver..."
PUPPET_PIDS=$(pgrep -f 'puppetserver|pe-puppetserver' 2>/dev/null || echo "")
if [ -n "$PUPPET_PIDS" ]; then
echo "Puppet Server PIDs: $PUPPET_PIDS"
for pid in $PUPPET_PIDS; do
echo "Child processes of PID $pid:"
ps --ppid "$pid" -o pid,ppid,user,comm,args --no-headers 2>/dev/null || echo " No child processes found"
done
else
echo "No puppetserver processes found running"
fi
# --- Step 5: Audit Puppet code directories for recent modifications ---
echo ""
echo "[STEP 5] Checking Puppet code directories for recent modifications (last 7 days)..."
for dir in /etc/puppetlabs/code /etc/puppet/code /opt/puppetlabs/server/data; do
if [ -d "$dir" ]; then
echo "Checking $dir:"
find "$dir" -type f \( -name '*.pp' -o -name '*.rb' -o -name '*.yaml' -o -name '*.eyaml' -o -name '*.erb' \) -mtime -7 -exec ls -la {} \; 2>/dev/null | head -50
echo "---"
fi
done
# --- Step 6: Review Puppet Server logs for anomalies ---
echo ""
echo "[STEP 6] Reviewing Puppet Server logs for anomalies..."
PUPPET_LOG_DIRS=("/var/log/puppetlabs/puppetserver" "/var/log/puppetserver")
for logdir in "${PUPPET_LOG_DIRS[@]}"; do
if [ -d "$logdir" ]; then
echo "Checking logs in $logdir:"
# Look for error patterns that may indicate exploitation attempts
grep -ril 'error\|exception\|unauthorized\|forbidden\|invalid' "$logdir" 2>/dev/null | head -10
echo ""
echo "Recent access log entries with non-2xx status codes:"
find "$logdir" -name '*access*' -mtime -1 -exec grep -h '" [45][0-9][0-9] ' {} \; 2>/dev/null | tail -20
echo "---"
fi
done
# --- Step 7: Check Puppet CA for unauthorized certificates ---
echo ""
echo "[STEP 7] Reviewing Puppet CA certificate inventory..."
if command -v puppetserver &> /dev/null; then
echo "Listing all signed certificates:"
puppetserver ca list --all 2>/dev/null || echo "Unable to list certificates"
fi
SSL_DIR="/etc/puppetlabs/puppet/ssl"
if [ -d "$SSL_DIR" ]; then
echo "Recently created/modified SSL certificates (last 7 days):"
find "$SSL_DIR" -name '*.pem' -mtime -7 -exec ls -la {} \; 2>/dev/null
fi
# --- Step 8: Apply network-level hardening (optional) ---
echo ""
echo "[STEP 8] Network hardening recommendations..."
echo "Consider applying the following firewall rules to restrict Puppet Server access:"
echo ""
echo " # Allow Puppet agent traffic only from internal subnets"
echo " iptables -A INPUT -p tcp --dport 8140 -s 10.0.0.0/8 -j ACCEPT"
echo " iptables -A INPUT -p tcp --dport 8140 -s 172.16.0.0/12 -j ACCEPT"
echo " iptables -A INPUT -p tcp --dport 8140 -s 192.168.0.0/16 -j ACCEPT"
echo " iptables -A INPUT -p tcp --dport 8140 -j DROP"
echo ""
echo " # Restrict Puppet Enterprise console (port 443) to admin subnets only"
echo " iptables -A INPUT -p tcp --dport 443 -s <ADMIN_SUBNET>/24 -j ACCEPT"
echo " iptables -A INPUT -p tcp --dport 443 -j DROP"
echo ""
echo "IMPORTANT: Adjust subnets to match your environment before applying."
# --- Step 9: Check for CISA KEV patch availability ---
echo ""
echo "[STEP 9] Patch status check..."
echo "CRITICAL: Check the Perforce Puppet advisory for CVE-2026-115731 patch availability."
echo "Visit: https://www.perforce.com/products/puppet"
echo "Visit: https://www.cisa.gov/known-exploited-vulnerabilities-catalog"
echo ""
echo "If a patch is available, update immediately:"
echo " # For Puppet Enterprise:"
echo " # Follow the Perforce upgrade documentation for your PE version"
echo " #"
echo " # For open-source Puppet Server (package-based):"
echo " # RHEL/CentOS:"
echo " # yum update puppetserver"
echo " # Debian/Ubuntu:"
echo " # apt-get update && apt-get install --only-upgrade puppetserver"
echo ""
echo "=============================================="
echo "Response script complete. Review all output above."
echo "Report findings to your security team immediately."
echo "=============================================="
Remediation
Immediate Actions (Within 24 Hours)
-
Patch Immediately. Check the Perforce Puppet advisory for CVE-2026-115731 and apply the vendor-supplied patch to all Puppet Server instances. This includes both Puppet Enterprise and open-source Puppet Server deployments. Monitor the Perforce Puppet product page and official release notes for patched version numbers.
-
Verify KEV Compliance Deadline. CISA KEV entries carry a remediation due date for federal civilian executive branch agencies under BOD 22-01. Check the CISA KEV catalog for the specific due date assigned to CVE-2026-115731. Private-sector organizations should adopt the same deadline as their internal SLA.
-
Network Segmentation. Ensure that Puppet Server ports — particularly TCP 8140 (agent communication) and TCP 443 (PE console) — are not exposed to the internet. Restrict access to these services to known internal IP ranges using firewall rules or network ACLs. If Puppet Server is currently internet-facing, take it offline or restrict access immediately while patching.
-
Audit Puppet Certificates. Review the Puppet CA for any unauthorized or unexpected certificates. Revoke any certificates that cannot be accounted for. An attacker who has compromised the CA can mint certificates to impersonate legitimate nodes.
Short-Term Actions (Within 72 Hours)
-
Audit Puppet Code and Modules. Review all Puppet manifests, modules, Hiera data files, and environment configurations for unauthorized modifications. Compare current production code against your version control system (Git) to identify any drift or unauthorized changes. Pay particular attention to
execresources,fileresources with unexpected sources, and any recently added classes or defined types. -
Review Puppet Server Logs. Examine Puppet Server access logs, application logs, and authentication logs for the past 30 days (or longer if log retention permits). Look for unusual request patterns, requests from unexpected source IPs, authentication failures, or error messages that could indicate exploitation attempts.
-
Rotate Secrets. If there is any suspicion that the Puppet Server was accessed by unauthorized parties, rotate all credentials stored in or accessible through Puppet — including Hiera secrets, API keys, database passwords, and service account credentials. The Puppet Server is a central credential repository, and compromise should be assumed to expose all stored secrets.
-
Deploy Detection Rules. Implement the Sigma rules, KQL queries, and Velociraptor VQL artifacts provided in this post across your detection stack. Tune the rules to your environment to reduce false positives from legitimate Puppet operations.
Medium-Term Actions (Within 30 Days)
-
Implement Code Integrity Monitoring. Establish file integrity monitoring (FIM) on Puppet code directories (
/etc/puppetlabs/code/,/etc/puppet/code/). Any modification outside of your approved CI/CD pipeline should generate an immediate alert. -
Enforce Code Signing and Review. Require that all Puppet code changes go through a formal pull request and code review process in version control. Deploy code to Puppet Server exclusively through automated CI/CD pipelines (e.g., r10k, Code Manager) — never through direct file system access.
-
Harden Puppet Server. Apply CIS Benchmark recommendations for Puppet Server. Disable unnecessary Puppet Server services and endpoints. Enable TLS certificate verification for all agent communications. Restrict Puppet Server API access to only required endpoints and authenticated clients.
-
Incident Response Preparedness. If you discover evidence of compromise, initiate your incident response plan immediately. A compromised Puppet Server requires a comprehensive response that extends to every managed node — not just the server itself. Consider engaging external DFIR support given the blast radius of a configuration management compromise.
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.