Back to Intelligence

CVE-2026-111497: Siemens Industrial Software Vulnerable to Node2Shell RCE — Detection and Remediation Guide

SA
Security Arsenal Team
November 17, 2026
13 min read

On October 21, 2026, the Node.js project released security updates addressing CVE-2026-111497, a critical out-of-bounds write vulnerability in the Brotli decoder bundled with Node.js. Dubbed "Node2Shell," this vulnerability allows a remote attacker to cause memory corruption and potentially execute arbitrary code. Siemens has now confirmed that multiple industrial software products — including Teamcenter, Polarion, and Manufacturing Operations Center (Opcenter) — are affected. For security teams operating in manufacturing, energy, and critical infrastructure environments, this advisory demands immediate attention. The affected Siemens products often serve as the backbone of product lifecycle management (PLM), application lifecycle management (ALM), and manufacturing operations — meaning a compromise here could cascade into production environments, intellectual property theft, or disruption of physical processes.

Technical Analysis

Affected Products

Siemens has published Software Field Bulletins confirming impact across the following product lines:

  • Teamcenter — Siemens' flagship PLM platform used for product data management, engineering collaboration, and manufacturing planning
  • Polarion — ALM platform for requirements management, QA, and regulatory compliance tracking
  • Manufacturing Operations Center (Opcenter) and Process Preparation X — MES and process planning tools that interface directly with shop-floor operations

The exact affected version ranges are detailed in each product-specific bulletin. Security teams must consult the Siemens support portal to determine their exposure based on deployed versions.

Vulnerability Details

AttributeValue
CVE IDCVE-2026-111497
Common NameNode2Shell
Vulnerability TypeOut-of-bounds write (CWE-787)
Affected ComponentBrotli decoder bundled with Node.js
ImpactMemory corruption, arbitrary code execution
Attack VectorRemote (network-based exploitation)

The vulnerability resides in the Brotli decompression library that Node.js bundles for HTTP content-encoding support. When a Node.js application processes a maliciously crafted Brotli-compressed payload, the out-of-bounds write corrupts adjacent memory structures. Depending on heap layout and application architecture, this corruption can be leveraged to achieve arbitrary code execution in the context of the Node.js process.

Siemens products that embed Node.js runtime components — whether for embedded web servers, REST API layers, or microservices architectures — inherit this vulnerability. Teamcenter, Polarion, and Opcenter all use Node.js-based components in their web-tier and integration-layer services.

Exploitation Requirements and Attack Chain

From a defender's perspective, the attack chain unfolds as follows:

  1. Reconnaissance: The attacker identifies internet-facing or internally exposed Siemens application endpoints that accept Brotli-encoded HTTP requests (via Content-Encoding: br headers).
  2. Payload Delivery: A crafted Brotli-compressed HTTP body is sent to a Node.js-powered endpoint. No authentication is necessarily required if the endpoint processes compressed payloads before auth validation.
  3. Memory Corruption: The OOB write triggers during decompression, corrupting heap metadata or adjacent objects.
  4. Code Execution: Under favorable heap conditions, the attacker achieves remote code execution as the Node.js service account.

In industrial environments, this service account often runs with elevated privileges on Windows servers hosting the application tier, and it may have network-level access to OT segments through integrated manufacturing workflows.

Exploitation Status

As of the advisory publication date, the Node.js project released patches on October 21, 2026. Siemens has published product-specific impact assessments and field bulletins. While active in-the-wild exploitation has not been confirmed at the time of this writing, the vulnerability's characteristics — remote, unauthenticated, affecting a ubiquitous decompression library — make it a prime candidate for rapid exploit development. Security teams should treat this as an imminent threat and prioritize remediation accordingly. Monitor CISA's Known Exploited Vulnerabilities (KEV) catalog for any updates indicating confirmed exploitation.

Detection & Response

Sigma Rules

YAML
---
title: Node2Shell Exploitation Attempt — Brotli Decompression Anomaly
id: 8f3b2c41-7a1e-4d59-b3f6-2c8e1a5d9b04
status: experimental
description: Detects HTTP requests with Brotli content-encoding targeting known Siemens application endpoints. May indicate attempted exploitation of CVE-2026-111497 in Node.js Brotli decoder.
references:
  - https://www.cisa.gov/news-events/ics-advisories/icsa-26-321-04
  - https://attack.mitre.org/techniques/T1190/
author: Security Arsenal
date: 2026/11/15
tags:
  - attack.initial_access
  - attack.t1190
logsource:
  category: webserver
  product: generic
detection:
  selection:
    c-http-content-encoding|contains: 'br'
    cs-uri|contains:
      - '/teamcenter'
      - '/polarion'
      - '/opcenter'
      - '/tc/'
      - '/siemens/'
  condition: selection
falsepositives:
  - Legitimate Brotli-compressed API traffic to Siemens applications
level: high
---
title: Node.js Child Process Spawned by Siemens Web Service
id: 2d7e5a19-4b8c-4f61-a9d3-6e1c8b5f0a72
status: experimental
description: Detects Node.js processes spawning unexpected child processes (cmd.exe, powershell.exe, bash, sh) on systems running Siemens industrial software. This behavior is consistent with post-exploitation following successful Node2Shell RCE.
references:
  - https://www.cisa.gov/news-events/ics-advisories/icsa-26-321-04
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/11/15
tags:
  - attack.execution
  - attack.t1059
logsource:
  category: process_creation
  product: windows
detection:
  selection:
    ParentImage|endswith:
      - '\node.exe'
      - '\nodejs.exe'
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\mshta.exe'
      - '\rundll32.exe'
      - '\certutil.exe'
      - '\bitsadmin.exe'
  condition: selection
falsepositives:
  - Legitimate Siemens application maintenance scripts or health checks that invoke system utilities from Node.js services
level: critical
---
title: Node.js Unexpected Network Connection from Siemens Server
id: 5c1a9f83-3e7d-4b26-a8c4-9f2e6d1b3a58
status: experimental
description: Detects Node.js processes establishing outbound network connections to suspicious ports or external destinations from servers hosting Siemens industrial software. Post-exploitation C2 or data exfiltration indicator.
references:
  - https://www.cisa.gov/news-events/ics-advisories/icsa-26-321-04
  - https://attack.mitre.org/techniques/T1071/
author: Security Arsenal
date: 2026/11/15
tags:
  - attack.command_and_control
  - attack.t1071
logsource:
  category: network_connection
  product: windows
detection:
  selection:
    Image|endswith:
      - '\node.exe'
      - '\nodejs.exe'
    DestinationPort:
      - 4444
      - 5555
      - 6666
      - 7777
      - 8888
      - 9999
      - 1337
      - 31337
  filter_known_cdn:
    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.'
  condition: selection and not filter_known_cdn
falsepositives:
  - Legitimate Node.js microservices communicating on non-standard ports within the Siemens application stack
level: high

KQL (Microsoft Sentinel / Defender)

KQL — Microsoft Sentinel / Defender
// Hunt for Node.js processes spawning suspicious child processes on Siemens application servers
// This detects post-exploitation activity consistent with Node2Shell (CVE-2026-111497)
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where InitiatingProcessFileName =~ "node.exe" or InitiatingProcessFileName =~ "nodejs.exe"
| where FileName in~ ("cmd.exe", "powershell.exe", "pwsh.exe", "wscript.exe", "cscript.exe", "mshta.exe", "rundll32.exe", "certutil.exe", "bitsadmin.exe", "whoami.exe", "net.exe", "nltest.exe", "ipconfig.exe")
| extend SuspiciousCommand = ProcessCommandLine
| project TimeGenerated, DeviceName, InitiatingProcessFileName, InitiatingProcessCommandLine, FileName, SuspiciousCommand, AccountName, InitiatingProcessId, ProcessId
| order by TimeGenerated desc

// Hunt for anomalous Brotli-encoded HTTP requests to Siemens endpoints via proxy/firewall logs
CommonSecurityLog
| where TimeGenerated > ago(7d)
| where RequestURL contains "teamcenter" or RequestURL contains "polarion" or RequestURL contains "opcenter"
| where AdditionalExtensions has "br" or Message has "content-encoding: br" or Message has "Content-Encoding: br"
| project TimeGenerated, SourceIP, DestinationIP, DestinationPort, RequestURL, RequestMethod, AdditionalExtensions
| order by TimeGenerated desc

// Hunt for Node.js processes making outbound connections on suspicious ports
DeviceNetworkEvents
| where TimeGenerated > ago(7d)
| where InitiatingProcessFileName =~ "node.exe" or InitiatingProcessFileName =~ "nodejs.exe"
| where RemotePort in (4444, 5555, 6666, 7777, 8888, 9999, 1337, 31337, 12345, 54321)
| where not(RemoteIP startswith "10." or RemoteIP startswith "192.168." or RemoteIP startswith "172.16.")
| project TimeGenerated, DeviceName, InitiatingProcessFileName, InitiatingProcessCommandLine, RemoteIP, RemotePort, RemoteUrl
| order by TimeGenerated desc

Velociraptor VQL

VQL — Velociraptor
-- Hunt for Node.js processes with suspicious child processes or command lines
-- Targets post-exploitation behavior following Node2Shell (CVE-2026-111497) RCE
SELECT Pid,
       Ppid,
       Name,
       Exe,
       CommandLine,
       Username,
       CreateTime
FROM pslist()
WHERE (Name =~ 'node' OR Exe =~ 'node')
  AND (CommandLine =~ 'cmd|powershell|pwsh|wscript|cscript|mshta|rundll32|certutil|bitsadmin|bash|sh -c|nc |ncat|curl|wget')
ORDER BY CreateTime DESC
VQL — Velociraptor
-- Enumerate network connections from Node.js processes on Siemens servers
SELECT Pid,
       Name,
       Status,
       Laddr,
       Lport,
       Raddr,
       Rport,
       Fqdn
FROM netstat()
WHERE Name =~ 'node'
  AND Status =~ 'ESTABLISHED'
  AND Rport IN (4444, 5555, 6666, 7777, 8888, 9999, 1337, 31337)
ORDER BY Pid

Remediation Script

PowerShell
# CVE-2026-111497 Node2Shell Remediation and Verification Script
# Run as Administrator on servers hosting Siemens industrial software with Node.js components
# This script checks Node.js versions, identifies vulnerable installations, and verifies patch status

Write-Output "=== CVE-2026-111497 Node2Shell Detection and Remediation ==="
Write-Output "Scan Date: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')"
Write-Output "Hostname: $env:COMPUTERNAME"
Write-Output ""

# --- Step 1: Identify all Node.js installations on the system ---
Write-Output "[STEP 1] Identifying Node.js installations..."
$nodeInstallations = @()

# Check common installation paths
$commonPaths = @(
    "$env:ProgramFiles\nodejs\node.exe",
    "${env:ProgramFiles(x86)}\nodejs\node.exe",
    "$env:LOCALAPPDATA\Programs\nodejs\node.exe",
    "$env:APPDATA\npm\node.exe"
)

foreach ($path in $commonPaths) {
    if (Test-Path $path) {
        $version = & $path --version 2>$null
        $nodeInstallations += [PSCustomObject]@{
            Path = $path
            Version = $version
            Source = "Common Path"
        }
    }
}

# Search for node.exe in Siemens installation directories
$siemensPaths = @(
    "$env:ProgramFiles\Siemens",
    "${env:ProgramFiles(x86)}\Siemens",
    "C:\Siemens",
    "D:\Siemens"
)

foreach ($basePath in $siemensPaths) {
    if (Test-Path $basePath) {
        $found = Get-ChildItem -Path $basePath -Recurse -Filter "node.exe" -ErrorAction SilentlyContinue | Select-Object -First 10
        foreach ($exe in $found) {
            $version = & $exe.FullName --version 2>$null
            $nodeInstallations += [PSCustomObject]@{
                Path = $exe.FullName
                Version = $version
                Source = "Siemens Install"
            }
        }
    }
}

# Also check running Node.js processes
$runningNode = Get-Process -Name "node" -ErrorAction SilentlyContinue | Select-Object Path -Unique
foreach ($proc in $runningNode) {
    if ($proc.Path -and ($nodeInstallations.Path -notcontains $proc.Path)) {
        $version = & $proc.Path --version 2>$null
        $nodeInstallations += [PSCustomObject]@{
            Path = $proc.Path
            Version = $version
            Source = "Running Process"
        }
    }
}

if ($nodeInstallations.Count -eq 0) {
    Write-Output "  No Node.js installations found on this system."
} else {
    Write-Output "  Found $($nodeInstallations.Count) Node.js installation(s):"
    foreach ($install in $nodeInstallations) {
        Write-Output "    - Path: $($install.Path)"
        Write-Output "      Version: $($install.Version)"
        Write-Output "      Source: $($install.Source)"
    }
}
Write-Output ""

# --- Step 2: Check if installed versions are vulnerable ---
Write-Output "[STEP 2] Assessing vulnerability status (CVE-2026-111497)..."
Write-Output "  NOTE: Node.js patches were released October 21, 2026."
Write-Output "  Refer to https://nodejs.org/en/blog/vulnerability/october-2026-security-releases for patched versions."
Write-Output ""

# Patch verification: Check for Node.js versions released after Oct 21 2026
# Vulnerable: All Node.js versions prior to the October 2026 security release
# Patched: LTS and Current releases with the Brotli fix applied
$vulnerable = $false
foreach ($install in $nodeInstallations) {
    $versionStr = $install.Version -replace 'v',''
    Write-Output "  Checking: $($install.Path) (v$versionStr)"
    # Attempt to get file modification date as a proxy for patch status
    $fileInfo = Get-Item $install.Path -ErrorAction SilentlyContinue
    if ($fileInfo) {
        $buildDate = $fileInfo.LastWriteTime
        Write-Output "    File Date: $buildDate"
        $patchDate = Get-Date "2026-10-21"
        if ($buildDate -lt $patchDate) {
            Write-Output "    STATUS: POTENTIALLY VULNERABLE — Node.js binary predates October 2026 security release"
            $vulnerable = $true
        } else {
            Write-Output "    STATUS: Potentially patched (verify against official Node.js release notes)"
        }
    }
}
Write-Output ""

# --- Step 3: Check for suspicious Node.js child processes ---
Write-Output "[STEP 3] Checking for suspicious Node.js child process activity..."
$suspiciousChildren = Get-CimInstance Win32_Process -ErrorAction SilentlyContinue | Where-Object {
    $_.ParentProcessId -ne 0
} | ForEach-Object {
    $parent = Get-Process -Id $_.ParentProcessId -ErrorAction SilentlyContinue
    if ($parent -and $parent.Name -match "node") {
        if ($_.Name -match "cmd|powershell|pwsh|wscript|cscript|mshta|rundll32|certutil|bitsadmin") {
            [PSCustomObject]@{
                ChildProcess = $_.Name
                ChildPID = $_.ProcessId
                ChildCmdLine = $_.CommandLine
                ParentName = $parent.Name
                ParentPID = $parent.Id
                ParentPath = $parent.Path
            }
        }
    }
}

if ($suspiciousChildren) {
    Write-Output "  WARNING: Suspicious child processes detected under Node.js:"
    $suspiciousChildren | Format-Table -AutoSize
    Write-Output "  ACTION REQUIRED: Investigate these processes immediately."
} else {
    Write-Output "  No suspicious Node.js child processes detected at this time."
}
Write-Output ""

# --- Step 4: Apply network-level mitigations (firewall rules) ---
Write-Output "[STEP 4] Applying defensive firewall rules..."
Write-Output "  Blocking Node.js from establishing outbound connections on common C2 ports..."
$c2Ports = @(4444, 5555, 6666, 7777, 8888, 9999, 1337, 31337)
foreach ($port in $c2Ports) {
    $ruleName = "Block-Node2Shell-C2-Outbound-$port"
    $existingRule = Get-NetFirewallRule -DisplayName $ruleName -ErrorAction SilentlyContinue
    if (-not $existingRule) {
        New-NetFirewallRule -DisplayName $ruleName `
            -Direction Outbound `
            -Protocol TCP `
            -RemotePort $port `
            -Program "C:\Program Files\nodejs\node.exe" `
            -Action Block `
            -Description "Temporary mitigation for CVE-2026-111497 Node2Shell — block Node.js C2 on port $port" `
            -ErrorAction SilentlyContinue | Out-Null
        Write-Output "    Created rule: $ruleName"
    } else {
        Write-Output "    Rule already exists: $ruleName"
    }
}
Write-Output ""

# --- Step 5: Summary and recommendations ---
Write-Output "=== REMEDIATION SUMMARY ==="
if ($vulnerable) {
    Write-Output "[CRITICAL] This system has Node.js installations that may be vulnerable to CVE-2026-111497."
    Write-Output ""
    Write-Output "IMMEDIATE ACTIONS:"
    Write-Output "  1. Update Node.js to the latest patched version released October 21, 2026"
    Write-Output "  2. Apply Siemens product-specific patches per field bulletins:"
    Write-Output "     - Teamcenter: https://support.sw.siemens.com/en-US/knowledge-base/PL8869204"
    Write-Output "     - Polarion: https://support.sw.siemens.com/en-US/knowledge-base/PL8869197"
    Write-Output "     - Opcenter/Process Preparation X: https://support.sw.siemens.com/en-US/knowledge-base/PL8869211"
    Write-Output "  3. Review the CISA ICS Advisory: https://www.cisa.gov/news-events/ics-advisories/icsa-26-321-04"
    Write-Output "  4. If patching is not immediately possible, restrict network access to affected endpoints"
    Write-Output "  5. Disable Brotli compression (Content-Encoding: br) at the reverse proxy / WAF level"
} else {
    Write-Output "[INFO] No vulnerable Node.js installations detected. Continue monitoring."
}
Write-Output ""
Write-Output "=== Script Complete ==="

Remediation

Immediate Actions (Within 24-48 Hours)

  1. Update Node.js: Apply the security updates released by the Node.js project on October 21, 2026. Consult the official Node.js security release page for the exact patched version numbers for your release line (LTS or Current).

  2. Apply Siemens Product Patches: Siemens has published product-specific Software Field Bulletins. Follow the guidance in each bulletin:

  3. Review CISA ICS Advisory: Read the full advisory at ICSA-26-321-04 for the authoritative list of affected Siemens product versions and recommended mitigations.

Interim Mitigations (If Patching Is Delayed)

  1. Disable Brotli at the Edge: Configure your reverse proxy, WAF, or load balancer to strip or reject Content-Encoding: br headers from inbound requests to Siemens application endpoints. This prevents the malicious payload from reaching the vulnerable Node.js Brotli decoder.

  2. Network Segmentation: Restrict network access to Siemens application servers. Ensure these systems are not directly exposed to the internet. Apply strict ACLs limiting inbound connections to authorized subnets only. For OT environments, enforce Purdue Model segmentation between IT and OT zones.

  3. Egress Filtering: Block outbound connections from Node.js processes on non-standard ports using host-based firewalls or network security groups. The remediation script above includes PowerShell commands to create these rules.

Ongoing Monitoring

  1. Deploy Detection Rules: Implement the Sigma, KQL, and VQL rules provided in this post in your SIEM and EDR platforms. Tune for your environment — pay particular attention to false positives from legitimate Siemens application health checks.

  2. Monitor CISA KEV: Track CISA's Known Exploited Vulnerabilities catalog for any addition of CVE-2026-111497, which would indicate confirmed active exploitation and trigger mandatory remediation timelines for federal agencies and strongly recommended deadlines for private organizations.

  3. Threat Hunt: Proactively hunt for signs of compromise using the KQL queries and VQL artifacts provided. Focus on Node.js process anomalies, unexpected child processes, and unusual outbound network connections from Siemens application servers over the past 30 days.

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.