Back to Intelligence

PaperCut NG/MF Mass Exploitation: AI-Orchestrated Campaign Compromises 440+ Instances — Detection and Remediation Guide

SA
Security Arsenal Team
September 10, 2026
12 min read

Independent reporting from Blackpoint Cyber and GreyNoise attributes an ongoing mass-exploitation campaign against PaperCut NG/MF print management servers to a suspected Russian-speaking threat actor — and the operational model should concern every defender reading this. Rather than manually working through target lists, the actor reportedly used artificial intelligence to develop the exploit chain against a recently disclosed pair of PaperCut NG/MF vulnerabilities, then deployed hundreds of AI agents to execute the campaign, ultimately compromising more than 440 instances.

The activity has been traced to source IP 45.142.193[.]132, which both vendors have linked to the scanning and exploitation traffic.

This is the industrialization of exploitation. The bottleneck that used to protect you — human operator time — is gone. When an actor can parallelize reconnaissance, exploit delivery, and post-exploitation across hundreds of autonomous agents, your exposure window shrinks from weeks to hours. If your organization runs PaperCut NG/MF anywhere on-prem (common in education, healthcare, legal, and managed print environments), you need to treat this as an active incident until proven otherwise.

Technical Analysis

What We Know

  • Target: PaperCut NG and PaperCut MF print management application servers
  • Vulnerabilities: A pair of recently disclosed security flaws in PaperCut NG/MF (vendor advisories and CVE identifiers were not named in the initial reporting — do not assume your version is safe; verify against the latest PaperCut security bulletin)
  • Attribution: Suspected Russian-speaking cyber actor
  • Infrastructure: 45.142.193[.]132 (scanning/exploitation source)
  • Scale: 440+ confirmed compromised instances
  • Novel element: AI used both to develop the exploit and to operate the campaign via hundreds of autonomous agents

Why PaperCut Is a High-Value Target

PaperCut's application server (pc-app.exe on Windows, Java-based on Linux) almost universally runs with elevated privileges — frequently SYSTEM or root — because it must interact with print spoolers, directory services, and user databases. It is also commonly:

  • Exposed to large network segments (every workstation prints)
  • Integrated with Active Directory / LDAP, making it a credential and identity pivot
  • Managed by IT generalists rather than security teams, meaning patching lags
  • Rarely covered by EDR policy tuning — print servers are a notorious blind spot

A compromise of the PaperCut application server is not a "print problem." It is a SYSTEM-level foothold on a domain-integrated server with legitimate network reach into your fleet. Historically, PaperCut exploitation has been followed by ransomware deployment (notably the Cl0p and Bl00dy campaigns against CVE-2023-27350-era flaws), and there is no reason to expect different economics here.

Attack Chain (Defender's View)

Based on the reported technique and how PaperCut exploitation typically manifests:

  1. Reconnaissance: Internet-facing scan for PaperCut NG/MF login portals (default ports 9191/9192 HTTP/S) from 45.142.193[.]132
  2. Exploitation: Weaponized requests against the vulnerable PaperCut components — typically abusing the application server's scripting/configuration functionality to achieve remote code execution
  3. Code execution: The PaperCut application process spawns child processes (cmd.exe, powershell.exe, /bin/sh) — this is the single most reliable detection signal for PaperCut RCE
  4. Post-exploitation: AI agents automate enumeration, persistence checks, and data staging across hundreds of victims in parallel

Exploitation Status

Confirmed active, in-the-wild exploitation at scale — 440+ compromised instances. This is not theoretical. Treat any unpatched, internet-reachable PaperCut NG/MF instance as breached and initiate incident response.

Detection & Response

Sigma Rules

The highest-fidelity signal for PaperCut exploitation is the application server process spawning command interpreters. This should be near-zero in a healthy environment.

YAML
---
title: PaperCut Application Server Spawning Command Shell
title_note: Detects pc-app.exe spawning cmd/powershell — primary indicator of PaperCut NG/MF RCE
id: 3f8c1a92-7b4d-4e61-9c05-2a7d8f1b3e44
status: experimental
description: Detects the PaperCut application server process spawning command interpreters or scripting engines, consistent with remote code execution against PaperCut NG/MF. This behavior is near-zero in healthy environments and was the hallmark of prior PaperCut exploitation campaigns.
references:
  - https://thehackernews.com/2026/09/papercut-attacker-uses-hundreds-of-ai.html
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/09/15
tags:
  - attack.execution
  - attack.t1059
  - attack.exploit_public_facing_application
  - attack.t1190
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith:
      - '\pc-app.exe'
      - '\pc-app-service.exe'
  selection_child:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\mshta.exe'
      - '\rundll32.exe'
      - '\certutil.exe'
      - '\bitsadmin.exe'
      - '\curl.exe'
      - '\wget.exe'
  condition: selection_parent and selection_child
falsepositives:
  - Rare administrative scripting legitimately invoked by PaperCut print scripting — validate against change records
level: critical
---
title: Outbound Connection to PaperCut Campaign Infrastructure
id: 8d2e5b17-4c6a-4f39-a1d8-6e9b2c4a5f77
status: experimental
description: Detects network connections to 45.142.193.132, the IP attributed by Blackpoint Cyber and GreyNoise to the mass PaperCut NG/MF exploitation campaign. Any hit warrants immediate incident response.
references:
  - https://thehackernews.com/2026/09/papercut-attacker-uses-hundreds-of-ai.html
  - https://attack.mitre.org/techniques/T1190/
author: Security Arsenal
date: 2026/09/15
tags:
  - attack.exploit_public_facing_application
  - attack.t1190
  - attack.command_and_control
logsource:
  category: network_connection
detection:
  selection:
    DestinationIp: '45.142.193.132'
  condition: selection
falsepositives:
  - None expected — this IP has no legitimate business purpose in typical environments
level: critical
---
title: PaperCut Server Anomalous Child Process on Linux
id: 1b7a9d34-8e2f-4c55-b3a1-9f4c6d8e2a10
status: experimental
description: Detects the PaperCut Java application process on Linux spawning shells or download tools, indicating post-exploitation activity consistent with the AI-orchestrated PaperCut campaign.
references:
  - https://thehackernews.com/2026/09/papercut-attacker-uses-hundreds-of-ai.html
  - https://attack.mitre.org/techniques/T1059.004/
author: Security Arsenal
date: 2026/09/15
tags:
  - attack.execution
  - attack.t1059.004
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentCommandLine|contains:
      - 'papercut'
      - 'pc-app'
  selection_child:
    Image|endswith:
      - '/sh'
      - '/bash'
      - '/dash'
      - '/curl'
      - '/wget'
      - '/python'
      - '/python3'
      - '/perl'
      - '/nc'
      - '/ncat'
  condition: selection_parent and selection_child
falsepositives:
  - Custom PaperCut print scripting hooks invoking shell commands — review configured scripts
level: high

KQL — Microsoft Sentinel / Defender

Two hunts: process lineage on the PaperCut host, and any network touch of the known campaign IP. The network query works against firewall/CEF ingestion as well as Defender endpoint data.

KQL — Microsoft Sentinel / Defender
// Hunt 1: PaperCut application server spawning suspicious child processes
DeviceProcessEvents
| where TimeGenerated > ago(30d)
| where InitiatingProcessFileName in~ ("pc-app.exe", "pc-app-service.exe", "java.exe")
| where InitiatingProcessCommandLine has_any ("papercut", "pc-app") or InitiatingProcessFileName has "pc-app"
| where FileName in~ ("cmd.exe", "powershell.exe", "pwsh.exe", "mshta.exe", "wscript.exe", "cscript.exe", "rundll32.exe", "certutil.exe", "bitsadmin.exe", "curl.exe", "wget.exe")
| project TimeGenerated, DeviceName, AccountName, InitiatingProcessFileName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, SHA256, ReportId
| order by TimeGenerated desc

// Hunt 2: Any endpoint or network device communicating with campaign infrastructure
let CampaignIP = "45.142.193.132";
union isfuzzy=true
    (DeviceNetworkEvents
     | where TimeGenerated > ago(30d)
     | where RemoteIP == CampaignIP
     | project TimeGenerated, DeviceName, LocalIP, RemoteIP, RemotePort, InitiatingProcessFileName, InitiatingProcessCommandLine),
    (CommonSecurityLog
     | where TimeGenerated > ago(30d)
     | where DestinationIP == CampaignIP or SourceIP == CampaignIP
     | project TimeGenerated, DeviceVendor, DeviceProduct, SourceIP, DestinationIP, DestinationPort, Protocol, Message),
    (Syslog
     | where TimeGenerated > ago(30d)
     | where SyslogMessage has CampaignIP
     | project TimeGenerated, Computer, ProcessName, SyslogMessage)
| order by TimeGenerated desc

Velociraptor VQL

Deploy this hunt across your PaperCut servers. It surfaces suspicious children of the PaperCut process and any live/recent connections to the campaign IP in a single sweep.

VQL — Velociraptor
-- Security Arsenal: PaperCut NG/MF exploitation hunt
-- Surfaces suspicious child processes of the PaperCut app server and connections to campaign infrastructure

SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE CommandLine =~ '(?i)(cmd|powershell|pwsh|mshta|wscript|cscript|rundll32|certutil|bitsadmin|curl|wget|/bin/(ba)?sh)'
  AND (
    Ppid IN (SELECT Pid FROM pslist() WHERE Exe =~ '(?i)(pc-app|papercut)')
    OR Exe =~ '(?i)(pc-app|papercut)'
  )

// Separately, check live network connections for the campaign IP
SELECT Pid, Name, LocalAddr, LocalPort, RemoteAddr, RemotePort, Status
FROM netstat()
WHERE RemoteAddr =~ '45\\.142\\.193\\.132'

Verification & Hardening Script

For Windows-hosted PaperCut servers (the majority of deployments). Run this on every PaperCut application server to inventory version, check for suspicious child processes and connections, and pull relevant logs.

PowerShell
# Security Arsenal - PaperCut NG/MF compromise assessment & IOC check
# Run elevated on each PaperCut application server

Write-Host "=== PaperCut Version Check ===" -ForegroundColor Cyan
$pcPath = "C:\Program Files\PaperCut NG" , "C:\Program Files\PaperCut MF"
foreach ($p in $pcPath) {
    if (Test-Path $p) {
        Write-Host "Install found: $p"
        Get-ChildItem $p -Filter "*.version" -ErrorAction SilentlyContinue | Get-Content
        # Also pull product version from the main binary
        $exe = Join-Path $p "server\bin\win\pc-app.exe"
        if (Test-Path $exe) { (Get-Item $exe).VersionInfo | Select-Object ProductVersion, FileVersion }
    }
}

Write-Host "`n=== Suspicious child processes of pc-app.exe (live) ===" -ForegroundColor Cyan
$pcPids = Get-CimInstance Win32_Process -Filter "Name='pc-app.exe'" | Select-Object -ExpandProperty ProcessId
if ($pcPids) {
    Get-CimInstance Win32_Process | Where-Object { $pcPids -contains $_.ParentProcessId } |
        Select-Object ProcessId, Name, CommandLine, CreationDate | Format-List
} else { Write-Host "pc-app.exe not currently running." }

Write-Host "`n=== Connections to campaign IP 45.142.193.132 ===" -ForegroundColor Cyan
Get-NetTCPConnection | Where-Object { $_.RemoteAddress -eq "45.142.193.132" } | Format-Table -AutoSize
$fwHit = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=5156} -MaxEvents 5000 -ErrorAction SilentlyContinue |
    Where-Object { $_.Message -match '45\.142\.193\.132' }
if ($fwHit) { $fwHit | Select-Object TimeCreated, Message -First 20 } else { Write-Host "No firewall log hits (or logging disabled)." }

Write-Host "`n=== Recent PaperCut server log anomalies ===" -ForegroundColor Cyan
$logDir = "$p\server\logs"
if (Test-Path $logDir) {
    Get-ChildItem $logDir -Filter "server.log*" | Sort-Object LastWriteTime -Descending | Select-Object -First 2 |
        ForEach-Object {
            Write-Host "Scanning $($_.Name) for error/exploit patterns..."
            Select-String -Path $_.FullName -Pattern "(?i)(error|exception|unauthor|script|exec|\.jsp|\.aspx|webshell)" |
                Select-Object -First 30 | ForEach-Object { $_.Line }
        }
}

Write-Host "`n=== Block campaign IP at host firewall (defense-in-depth) ===" -ForegroundColor Cyan
New-NetFirewallRule -DisplayName "BLOCK - PaperCut Campaign C2 45.142.193.132" `
    -Direction Outbound -RemoteAddress 45.142.193.132 -Action Block -ErrorAction SilentlyContinue
New-NetFirewallRule -DisplayName "BLOCK - PaperCut Campaign C2 45.142.193.132 Inbound" `
    -Direction Inbound -RemoteAddress 45.142.193.132 -Action Block -ErrorAction SilentlyContinue
Write-Host "Firewall block rules created."

For Linux-hosted PaperCut:

Bash / Shell
# Security Arsenal - Linux PaperCut assessment
set -euo pipefail

echo "=== PaperCut version ==="
cat /opt/papercut/server/VERSION 2>/dev/null || ls /opt/papercut/server/

echo "=== PaperCut process tree (look for shell children) ==="
PC_PID=$(pgrep -f "papercut" | head -5 || true)
if [ -n "$PC_PID" ]; then
  for pid in $PC_PID; do
    echo "--- children of $pid ---"
    ps --ppid "$pid" -o pid,ppid,user,cmd 2>/dev/null || true
  done
fi

echo "=== Connections to campaign IP ==="
ss -tnp | grep "45.142.193.132" || echo "No live connections."
grep -r "45.142.193.132" /var/log/ 2>/dev/null | head -20 || echo "No log hits."

echo "=== Block campaign IP ==="
iptables -C INPUT -s 45.142.193.132 -j DROP 2>/dev/null || iptables -A INPUT -s 45.142.193.132 -j DROP
iptables -C OUTPUT -d 45.142.193.132 -j DROP 2>/dev/null || iptables -A OUTPUT -d 45.142.193.132 -j DROP
echo "iptables rules applied (persist with iptables-save / netfilter-persistent)."

echo "=== Recent PaperCut server.log anomalies ==="
tail -5000 /opt/papercut/server/logs/server.log 2>/dev/null | \
  grep -iE "error|exception|unauthor|script|exec" | tail -30 || echo "No server.log found."

Remediation

Prioritize in this order — do not skip step 1 to jump to patching:

  1. Assume breach on internet-exposed instances. Any PaperCut NG/MF server reachable from the internet that has not been patched against the current flaw pair should be treated as compromised. Isolate it from the network (do not power off — preserve volatile evidence) and initiate IR: image memory, collect server.log, review process lineage back 30+ days, and hunt for lateral movement from the print server into AD. Reset any credentials stored on or accessible from that host, including the LDAP/service accounts PaperCut uses for directory sync.

  2. Patch immediately. Apply the latest PaperCut NG/MF release that remediates the currently exploited flaw pair. Pull the current fixed-version numbers directly from PaperCut's security bulletins page (papercut.com/kb/Main/SecurityBulletins) and their known-vulnerability advisory — do not rely on secondhand version references, as PaperCut ships fixes in specific maintenance releases. Verify post-patch by confirming the build number in the admin console matches the bulletin.

  3. Remove PaperCut from the internet. There is almost no legitimate reason for the PaperCut application server (ports 9191/9192) to be internet-facing. Put it behind VPN/ZTNA access for remote administration. This single architectural change would have removed most of the 440+ victims from the target set.

  4. Block campaign infrastructure. Add 45.142.193[.]132 to perimeter block lists, but treat this as temporary containment — AI-orchestrated campaigns rotate infrastructure trivially. The behavioral detections above (child process lineage) will outlive the IP.

  5. Restrict the PaperCut service account. Audit what the PaperCut service runs as. If it's SYSTEM, that's the default — but ensure the host itself is tiered appropriately, can't be used to reach DCs, and has no cached domain admin credentials. Apply LSA protection and credential guard on the host.

  6. Deploy and test the detections above. The pc-app.exe → shell Sigma rule should be near-zero noise. Test it in your environment now, before you need it during an incident.

  7. Shorten your patch SLA for edge-reachable services. The strategic lesson here is temporal: when exploit development and campaign execution are AI-accelerated, the gap between disclosure and mass compromise compresses to days. Internet-facing and high-privilege applications like PaperCut belong in a 72-hour (or faster) patch tier, with emergency change processes to match.

The Bigger Picture

This campaign is a milestone, not an anomaly. The actor didn't just use AI to write an exploit — they used it to operate at a scale that previously required a large human crew or a botnet. Defenders should internalize two things: first, your exposure management speed is now the primary control against commodity mass exploitation; second, behavioral detection on high-value application servers (print, MDM, remote access, backup) is no longer optional, because you will not always have an IOC feed faster than the attacker's agents.

If you run PaperCut NG/MF and have not validated patch status and process lineage on those hosts this week, that is your Monday morning task.

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.