Back to Intelligence

CVE-2026-115731: Perforce Puppet Enterprise Deserialization Vulnerability — Detection and Remediation Guide

SA
Security Arsenal Team
November 17, 2026
12 min read

On November 17, 2026, CISA added CVE-2026-115731 to the Known Exploited Vulnerabilities (KEV) catalog, confirming active in-the-wild exploitation of a critical deserialization vulnerability in Perforce Puppet Enterprise. This vulnerability enables remote code execution on Puppet Server infrastructure, threatening configuration management pipelines that control enterprise infrastructure.

Puppet Server is the central nervous system for infrastructure automation in thousands of organizations. Compromise of a Puppet Server grants attackers the ability to push malicious configurations across entire managed estates—servers, network devices, cloud workloads, and security controls. The confirmed exploitation status elevates this from theoretical risk to immediate operational threat.

Why this matters now: CISA KEV listing indicates federal agencies must remediate within specified timeframes, and private sector organizations face identical threat actor attention. The vulnerability's exploitation requires only a valid CA-signed agent certificate—a barrier that collapses entirely if certificate auto-signing is enabled without strong verification.


Technical Analysis

Affected Products and Versions

ProductAffected VersionsComponent
Perforce Puppet EnterpriseAll versions prior to 2025.3.1Puppet Server report-processing
Perforce Puppet Server (open source)All versions prior to 8.7.1Report handler rich-data processing

The vulnerability resides specifically in Puppet's report-processing code, which handles agent-submitted reports via PUT requests to the Puppet Server API.

Vulnerability Classification

  • CVE ID: CVE-2026-115731
  • CWE: CWE-502 (Deserialization of Untrusted Data)
  • Attack Vector: Network
  • Attack Complexity: Low (when certificate auto-signing enabled)
  • Privileges Required: Low (valid agent certificate) or None (if auto-signing enabled)
  • User Interaction: None
  • Scope: Changed (Puppet Server compromise enables infrastructure-wide impact)

Root Cause: Rich-Data Type Deserialization

Puppet's report-processing subsystem accepts reports from managed nodes containing rich-data types—serialized Ruby objects that preserve complex data structures. The vulnerability exists because the report handler fails to properly validate or sanitize these rich-data types before deserialization.

When a Puppet agent submits a report via HTTP PUT to /puppet/v3/report/[node-name], the server deserializes the report content. A crafted report containing a malicious rich-data type triggers arbitrary code execution within the Puppet Server's Ruby runtime, executing with the privileges of the pe-puppetserver or puppetserver service account.

Exploitation Chain

Prerequisites for exploitation:

  1. Network access to Puppet Server's API port (default 8140/TCP)
  2. A valid CA-signed agent certificate from the Puppet CA

Attack sequence:

  1. Attacker obtains valid agent certificate (compromised node, rogue enrollment, or auto-signing abuse)
  2. Crafts malicious report containing serialized Ruby object payload in rich-data format
  3. Submits PUT request to /puppet/v3/report/[attacker-controlled-node]
  4. Puppet Server deserializes report, executing embedded code as service user
  5. Attacker gains shell access, pivots to certificate authority, or modifies catalog compilation

Critical Risk: Certificate Auto-Signing

The most dangerous deployment pattern involves CA auto-signing without strong verification. Organizations frequently enable autosign.conf with permissive patterns (e.g., *.example.com or even *) to streamline node provisioning. In such environments:

  • Any network-adjacent attacker can request a certificate with a matching hostname
  • Puppet CA automatically signs the request
  • Attacker immediately possesses valid credentials for exploitation
  • No prior compromise required—true unauthenticated remote code execution

Exploitation Status

IndicatorStatus
Public PoCNot publicly disclosed as of publication
Active ExploitationConfirmed (CISA KEV listing)
CISA KEV Date Added2026-11-17
Federal Remediation Deadline2026-12-08 (21 days from KEV listing)
Known Exploitation CampaignsUnder investigation by CISA and Perforce

The absence of public PoC code does not indicate safety—KEV listing confirms threat actors possess working exploitation capability. The 21-day federal remediation window reflects the severity of active exploitation.


Detection and Response

Behavioral Indicators

Effective detection focuses on anomalous Puppet Server behavior rather than specific exploit strings, which may vary across payloads:

  1. Report submission anomalies: PUT requests with unexpected Content-Type, oversized bodies, or from unfamiliar source IPs
  2. Puppet Server process behavior: Unexpected child processes, network connections, or file system modifications
  3. Certificate authority events: Autosigning of unexpected hostnames or certificate requests from atypical network segments
  4. Post-exploitation artifacts: New files in Puppet Server directories, modified configuration, or unauthorized certificate operations

Sigma Detection Rules

YAML
---
title: Puppet Server Suspicious Child Process Execution
id: 7f8e9a1b-2c3d-4e5f-8a9b-0c1d2e3f4a5b
status: experimental
description: Detects suspicious child process spawning from Puppet Server process, indicative of successful deserialization exploitation and post-exploitation activity.
references:
  - https://www.cisa.gov/known-exploited-vulnerabilities-catalog
  - CVE-2026-115731
author: Security Arsenal
date: 2026/11/17
tags:
  - attack.execution
  - attack.t1059
  - attack.t1059.004
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentImage|endswith:
      - '/puppetserver'
      - '/java'
  selection_suspicious:
    Image|endswith:
      - '/bash'
      - '/sh'
      - '/python'
      - '/python3'
      - '/perl'
      - '/ruby'
      - '/curl'
      - '/wget'
      - '/nc'
      - '/netcat'
      - '/socat'
  condition: selection_parent and selection_suspicious
falsepositives:
  - Legitimate Puppet Server management operations
  - Administrative troubleshooting with shell access
  - Monitoring or backup scripts executed by Puppet Server
level: high
---
title: Puppet Report API Abnormal Request Pattern
id: 8g9f0b2c-3d4e-5f6a-9b0c-1d2e3f4a5b6c
status: experimental
description: Detects anomalous HTTP PUT requests to Puppet report endpoint with suspicious characteristics potentially indicating exploitation attempts.
references:
  - https://www.cisa.gov/known-exploited-vulnerabilities-catalog
  - CVE-2026-115731
author: Security Arsenal
date: 2026/11/17
tags:
  - attack.initial_access
  - attack.t1190
logsource:
  category: webserver
  product: apache
detection:
  selection_uri:
    cs-uri-stem|contains: '/puppet/v3/report/'
  selection_method:
    cs-method: 'PUT'
  selection_anomalies:
    cs-bytes|gt: 1048576
    sc-status:
      - 200
      - 500
  condition: all of selection_*
falsepositives:
  - Large legitimate reports from complex Puppet runs
  - Failed report submissions due to Puppet Server errors
level: medium
---
title: Puppet CA Autosigning Suspicious Certificate
id: 9h0g1c3d-4e5f-6a7b-0c1d-2e3f4a5b6c7d
status: experimental
description: Detects certificate autosigning events for hostnames with suspicious patterns or from unexpected network sources, indicating potential certificate-based attack preparation.
references:
  - https://www.cisa.gov/known-exploited-vulnerabilities-catalog
  - CVE-2026-115731
author: Security Arsenal
date: 2026/11/17
tags:
  - attack.persistence
  - attack.t1553
  - attack.t1553.004
logsource:
  category: file_event
  product: linux
detection:
  selection:
    TargetFilename|contains:
      - '/etc/puppetlabs/puppet/autosign.conf'
      - '/etc/puppet/autosign.conf'
    Image|endswith:
      - '/puppet'
      - '/puppetserver'
  condition: selection
falsepositives:
  - Legitimate autosign configuration updates
  - Infrastructure automation modifying certificate policies
level: medium

Microsoft Sentinel KQL Hunt Queries

KQL — Microsoft Sentinel / Defender
// Hunt for suspicious Puppet Server process behavior
// Look for Puppet Server spawning unexpected child processes
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where InitiatingProcessFileName =~ "java" or InitiatingProcessFileName =~ "puppetserver"
| where FileName in~ ("bash", "sh", "python", "python3", "perl", "ruby", "curl", "wget", "nc", "netcat", "socat")
| project TimeGenerated, DeviceName, InitiatingProcessFileName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, AccountName
| order by TimeGenerated desc

// Hunt for Puppet report API access anomalies from network logs
// Requires Puppet Server access logs forwarded to Sentinel
CommonSecurityLog
| where TimeGenerated > ago(7d)
| where RequestURL contains "/puppet/v3/report/"
| where RequestMethod == "PUT"
| extend ReportSize = toint(RequestBytes)
| where ReportSize > 1000000 or SourceIP !in ("10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16")
| project TimeGenerated, SourceIP, RequestURL, RequestMethod, ReportSize, ResponseCode
| order by ReportSize desc

// Hunt for Puppet certificate authority operations
Syslog
| where TimeGenerated > ago(7d)
| where SyslogMessage contains "puppet-ca" or SyslogMessage contains "certificate"
| where SyslogMessage contains "sign" or SyslogMessage contains "autosign"
| where SyslogMessage contains_regex @"(external|unknown|untrusted|192\.168|10\.|172\.(1[6-9]|2[0-9]|3[01]))"
| project TimeGenerated, Computer, SyslogMessage
| order by TimeGenerated desc

Velociraptor VQL Hunt Artifact

VQL — Velociraptor
-- Hunt for Puppet Server compromise indicators
-- Focus: process execution, file artifacts, and certificate operations

SELECT Pid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE Name =~ '(?i)(puppetserver|java)'
   AND (CommandLine =~ '(?i)(bash|sh|python|perl|ruby|curl|wget|nc|socat)'
        OR CommandLine =~ '(?i)(/tmp|/var/tmp|/dev/shm)')

UNION

SELECT 
  '0' as Pid,
  'FileArtifact' as Name,
  FullPath as CommandLine,
  FullPath as Exe,
  'System' as Username,
  ModificationTime as CreateTime
FROM glob(globs='/opt/puppetlabs/server/data/puppetserver/**/*.jar')
WHERE ModificationTime > ago(24h)

UNION

SELECT 
  '0' as Pid,
  'CertificateLog' as Name,
  Data as CommandLine,
  Source as Exe,
  'PuppetCA' as Username,
  TimeGenerated as CreateTime
FROM parse_evtx(filename='/var/log/puppetlabs/puppetserver/puppetserver.log.json')
WHERE Message =~ '(?i)(sign|certificate|autosign)'
  AND Message =~ '(?i)(external|unknown|reject)'

Immediate Containment Script

Bash / Shell
#!/bin/bash
# CVE-2026-115731 Emergency Containment and Verification Script
# Run on Puppet Server and Puppet CA systems

set -e

echo "=== CVE-2026-115731 Containment Script ==="
echo "Timestamp: $(date -u +%Y-%m-%dT%H:%M:%SZ)"

# Check for vulnerable Puppet Server version
echo -e "\n[*] Checking Puppet Server version..."
if command -v puppetserver &> /dev/null; then
    PUPPET_VERSION=$(puppetserver --version 2>/dev/null | head -1 || echo "unknown")
    echo "Detected: $PUPPET_VERSION"
    
    # Version comparison (simplified - production should use proper semver)
    if [[ "$PUPPET_VERSION" =~ 2025\.3\.1 ]] || [[ "$PUPPET_VERSION" =~ 2025\.([4-9]|[1-9][0-9]) ]]; then
        echo "[+] PATCHED version detected"
    else
        echo "[!] VULNERABLE version detected - immediate patching required"
    fi
else
    echo "[-] Puppet Server not found or not in PATH"
fi

# Check for suspicious child processes of Puppet Server
echo -e "\n[*] Checking for suspicious Puppet Server child processes..."
SUSPICIOUS_PROCS=$(pgrep -P $(pgrep -f "puppetserver" | head -1) 2>/dev/null | xargs -I {} ps -o comm= -p {} 2>/dev/null | grep -E "(bash|sh|python|perl|ruby|curl|wget|nc|socat)" || true)
if [ -n "$SUSPICIOUS_PROCS" ]; then
    echo "[!] ALERT: Suspicious child processes detected:"
    echo "$SUSPICIOUS_PROCS"
    echo "[!] IMMEDIATE INVESTIGATION REQUIRED"
else
    echo "[+] No suspicious child processes detected"
fi

# Check autosign.conf for dangerous patterns
echo -e "\n[*] Checking certificate autosigning configuration..."
AUTOSIGN_PATHS=("/etc/puppetlabs/puppet/autosign.conf" "/etc/puppet/autosign.conf")
for path in "${AUTOSIGN_PATHS[@]}"; do
    if [ -f "$path" ]; then
        echo "Found autosign.conf at: $path"
        DANGEROUS_PATTERNS=$(grep -E "^(\*|.*\*.*|\.)" "$path" 2>/dev/null || true)
        if [ -n "$DANGEROUS_PATTERNS" ]; then
            echo "[!] WARNING: Dangerous autosign patterns detected:"
            echo "$DANGEROUS_PATTERNS"
            echo "[!] Consider disabling autosigning or restricting to specific hostnames"
        else
            echo "[+] No wildcard autosign patterns detected"
        fi
    fi
done

# Check for recent report submissions with large sizes
echo -e "\n[*] Checking recent report submissions..."
REPORT_DIR="/opt/puppetlabs/server/data/puppetserver/reports"
if [ -d "$REPORT_DIR" ]; then
    LARGE_REPORTS=$(find "$REPORT_DIR" -name "*.yaml" -mtime -1 -size +1M 2>/dev/null | wc -l)
    if [ "$LARGE_REPORTS" -gt 10 ]; then
        echo "[!] WARNING: $LARGE_REPORTS large reports in last 24 hours (potential DoS or exploitation)"
    else
        echo "[+] Report submission volume appears normal"
    fi
fi

# Network connections from Puppet Server
echo -e "\n[*] Checking active network connections from Puppet Server..."
PUPPET_PID=$(pgrep -f "puppetserver" | head -1 || echo "")
if [ -n "$PUPPET_PID" ]; then
    OUTBOUND_CONNS=$(ss -tnp 2>/dev/null | grep "pid=$PUPPET_PID" | grep -v "127.0.0.1\|::1" | wc -l || echo "0")
    if [ "$OUTBOUND_CONNS" -gt 5 ]; then
        echo "[!] WARNING: $OUTBOUND_CONNS outbound connections from Puppet Server"
        ss -tnp 2>/dev/null | grep "pid=$PUPPET_PID" | head -10
    else
        echo "[+] Outbound connection count appears normal"
    fi
fi

echo -e "\n=== Containment Actions ==="
echo "If compromise is suspected:"
echo "1. Isolate Puppet Server from network"
echo "2. Preserve forensic evidence: tar czf /tmp/puppetserver-forensics-$(date +%s).tar.gz /var/log/puppetlabs /opt/puppetlabs/server/data"
echo "3. Review certificate authority for unauthorized certificates"
echo "4. Reset all agent certificates if CA compromise suspected"
echo "5. Apply patches immediately: https://puppet.com/security/cve/CVE-2026-115731"

echo -e "\n=== Script Complete ==="

Remediation

Primary Action: Apply Vendor Patches Immediately

ProductFixed VersionAvailability
Perforce Puppet Enterprise2025.3.12026-11-10
Perforce Puppet Server (open source)8.7.12026-11-10

Patch URLs:

CISA KEV Deadline

  • Federal Civilian Executive Branch Agencies: 2026-12-08 (21 days from 2026-11-17)
  • All Other Organizations: Treat with equivalent urgency given confirmed active exploitation

Temporary Mitigations (If Immediate Patching Impossible)

If patching cannot occur immediately, implement these compensating controls:

1. Disable Certificate Autosigning

Bash / Shell
# On Puppet CA server - immediate action required
# Remove or comment out autosign.conf entries
cp /etc/puppetlabs/puppet/autosign.conf /etc/puppetlabs/puppet/autosign.conf.backup.$(date +%s)
echo "" > /etc/puppetlabs/puppet/autosign.conf

# Restart Puppet Server to apply
systemctl restart pe-puppetserver  # Puppet Enterprise
# OR
systemctl restart puppetserver     # Open source

2. Implement Certificate Allowlisting

Bash / Shell
# Replace autosign.conf with explicit hostname allowlist only
cat > /etc/puppetlabs/puppet/autosign.conf << 'EOF'
# Explicit allowlist - CVE-2026-115731 mitigation
# Only add hostnames that require immediate provisioning
# monitor01.example.com
# db-server-02.example.com
EOF

3. Network Segmentation

Restrict Puppet Server API access (8140/TCP) to known agent networks:

Bash / Shell
# Example iptables rules - adjust for your environment
iptables -A INPUT -p tcp --dport 8140 -s 10.10.0.0/16 -j ACCEPT
iptables -A INPUT -p tcp --dport 8140 -s 10.20.0.0/16 -j ACCEPT
iptables -A INPUT -p tcp --dport 8140 -j DROP

4. Report Submission Size Limits

Configure Puppet Server to reject oversized reports:

Bash / Shell
# In /etc/puppetlabs/puppetserver/conf.d/webserver.conf
# Add or modify:
# max-request-body-size: 1048576  # 1MB limit

Verification Steps

After patching:

Bash / Shell
# Verify Puppet Server version
puppetserver --version

# Confirm patch level includes CVE-2026-115731 fix
# Expected: 2025.3.1 or higher for PE, 8.7.1 or higher for open source

# Test report submission functionality
puppet agent --test --noop

# Verify certificate autosigning is properly configured
puppet config print autosign

Post-Incident Actions

If exploitation is suspected or confirmed:

  1. Forensic preservation: Capture Puppet Server logs, process memory, and disk images before remediation
  2. Certificate revocation: Revoke and reissue all agent certificates if CA integrity is uncertain
  3. Infrastructure validation: Review all deployed configurations for unauthorized modifications
  4. Credential rotation: Reset any credentials stored in Puppet manifests or Hiera data
  5. Threat hunting: Search for persistence mechanisms, lateral movement, and data exfiltration

Defensive Recommendations

Immediate (24-48 Hours)

  • Inventory all Puppet Enterprise and open source Puppet Server deployments
  • Apply vendor patches to all identified systems
  • Disable certificate autosigning if not business-critical
  • Implement network segmentation restricting Puppet Server API access
  • Review certificate authority logs for unauthorized certificate issuance

Short-Term (1-2 Weeks)

  • Deploy Sigma detection rules to SIEM infrastructure
  • Configure Sentinel KQL hunting queries for continuous monitoring
  • Conduct Velociraptor hunts for compromise indicators
  • Review and harden Puppet Server configuration per CIS benchmarks
  • Implement certificate pinning for Puppet agents where feasible

Long-Term (30-90 Days)

  • Migrate to certificate-based mutual TLS with short-lived certificates
  • Implement just-in-time certificate provisioning eliminating standing autosigning
  • Deploy Puppet Server behind additional authentication layer (VPN, zero-trust proxy)
  • Establish Puppet-specific incident response playbooks
  • Conduct purple team exercise simulating Puppet Server 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.