NODE-RED / FROM EXPOSED WORKFLOW TO HOST COMMAND
You secured the Node-RED editor. Check the flows, too.
A login controls who can edit. The response also needs to establish what is already running.
A flow is an application. Treat an unfamiliar flow like unfamiliar code.
Node-RED lets people connect tasks in a browser: receive a reading, transform it, send a message, or run a command. That makes it useful in automation. It also means a reachable programming interface deserves the same scrutiny as a reachable server console.
VulnCheck's November 2 report describes requests designed to deploy automatically triggered shell commands through an exposed Node-RED interface. The practical response is to check access, the deployed workflow, and the host activity together.
BOUNDARY 01 / WHO MAY EDIT
The editor and Admin API
Control who can view or deploy flows. Review authentication, write permissions, and permitted management sources.
adminAuth · flows.writeBOUNDARY 02 / WHO MAY CALL
The routes a flow exposes
HTTP In nodes create their own endpoints. Review their authentication and every path from incoming data to a command.
httpNodeAuth · httpNodeMiddlewareFour checks that produce an answer
Begin with the system owner and existing evidence. On an industrial gateway, plan containment and changes with operations so the response does not interrupt a legitimate process.
Name it and contain exposure
Identify the instance, owner, embedded product, running version, management URL, and allowed clients. Restrict unexpected access with the operations owner before changing a production workflow.
Preserve the current flow
Save the active configuration, relevant audit/access logs, and timestamps before editing or redeploying. Flow exports can contain credentials; keep originals in restricted storage.
Review what can run
Compare with an approved baseline. Inspect unfamiliar Exec nodes, startup Inject nodes, and HTTP In paths that can pass data into commands. Ask what each branch is for and who approved it.
Correlate and recover
Join deployments to process events and egress. If unauthorized activity is confirmed, follow incident response, restore approved flows, and rotate exposed secrets after containment.
USE THIS WITH THE APPLICATION OR CONTROLS OWNER
Make the review a working record
The two-page worksheet captures the instance, active-flow baseline, authentication boundaries, and the evidence needed to distinguish a request from execution.
Download the worksheet PDFOpen the readable worksheetDownload the hunt packWhat changed, and which product is affected?
Siemens SSA-834709 covers SIMATIC IoT2050 Advanced, model 6ES7647-0BA00-1YA2, running Industrial OS with Node-RED installed. It lists versions below V4.3.4.1 as affected by CVE-2026-58115 and recommends V4.3.4.1 or later. The missing authentication can permit malicious flows to execute code with maximum privileges.
The advisory was published August 11. The new event is the reported exploitation attempt, not a newly released fix. Other Node-RED installations need an exposure and configuration review; this Siemens product scope should not be pasted onto every embedded product that uses Node-RED.
- Siemens publishes the advisory
Affected product conditions and the fixed version are available.
- A Telnet session submits a downloader
Similar filename and launch habits, using a different server.
- Malicious flow requests are reported
The published request shows the intended workflow-to-shell path.
- The reported payload-server IP sends GET /
A bare web request, separate from the malicious flow requests.
How a workflow becomes a command
REPORTED REQUEST DESIGN / NOT A LIVE EXPLOIT DEMO
- Submit a flow
A request changes the workflow running on the host.
POST /flows - Start automatically
An Inject node sends a message after deployment.
inject · once: true - Launch a command
An Exec node hands the command to the host operating system.
exec · shell command - Fetch and launch
The supplied command requests a Linux payload and tries to start it.
/dev/shm/.b
The important connection is the wiring. An Inject node can generate a message automatically. An Exec node can run an operating-system command. Review the command and its inputs, not just the node names. These are legitimate automation features, so an Exec node is a review point rather than a finding by itself.
Also trace HTTP In endpoints: which URL they expose, who can call it, and whether incoming data reaches an Exec node or other privileged action. A login on the editor is a different control from authentication on those endpoints.
Technical details worth checking
Do not stop at the browser UI
disableEditor: true hides the editor but leaves the Admin API active. httpAdminRoot can move the management path; include that prefix in access-log searches.
Keep deployment and execution separate
POST /flows sets the active configuration and requires flows.write. The API documents 200 for v2 success and 204 for v1 success. Check failed attempts too; a deployment response alone does not establish payload execution.
Where supported, enable and centrally retain Node-RED audit logging through logging.console.audit. The documented flows.set event helps establish deployment time and caller context. Preserve the flow file and approved change record as well: an audit event is not a complete record of what each flow did. Avoid collecting passwords or tokens in proxy request-body logging.
| Question | Ordinary source | What to compare |
|---|---|---|
| Who changed the flow? | Node-RED audit events and management access logs | Caller, time, method, management prefix, status, and approved change. |
| What is deployed? | Restricted active-flow export or configured flow file, plus a known-good version | Node types, wiring, commands, exposed endpoints, and the owner who approved them. |
| Did a command execute? | Linux EDR or process audit logs, where the device supports them | Node.js parentage, shell/downloader command line, host, account, and time. |
| What left the host? | Proxy, DNS, firewall, or network telemetry collected outside the gateway | Destination, port, request path when visible, process correlation, and response outcome. |
On embedded appliances, use vendor-supported logging and response methods. Do not install an endpoint agent or change runtime components unless the vendor supports that configuration.
What our decoys add to the picture
We checked our retained records against the reported infrastructure and downloader behavior. The useful connection is small and specific.
FIRST-PARTY OBSERVATION / OCTOBER 31, 2026
A reported download server also made a web request
- SOURCE ADDRESS
- 85.215.73[.]250
- RECORDED REQUEST
- 13:50:50 UTC · GET /
- RECORDED BODY AND USER-AGENT
- Empty body · no User-Agent
One request. No exploit in that recorded session.
A separate October 26 Telnet session submitted commands to fetch bot-linux-amd64 over port 8080 from a different host, save it as .bot, and launch it in the background. That is a useful behavioral comparison, not proof of common tooling or an operator. The decoy responses were simulated; the evidence is the submitted commands.
For defenders, the distinction matters: a host can appear as a caller in one record and a destination in another. Keep direction, time, and the actual request beside an indicator match.
Use the indicators with their direction attached
These are dated indicators from VulnCheck's report, not a list of proven operators. Search both incoming and outgoing records, then inspect the request or process behind each hit.
| Indicator | Reported role | Useful pivot |
|---|---|---|
| 4.201.105[.]116 | Reported request source | Review access to your Node-RED management routes. |
| 85.215.73[.]250 | Reported download server, port 8080 | Review outbound requests for bot-linux-amd64 or wget.sh. |
| 45.194.90[.]57 | Reported alternate download server, port 38472 | Review outbound requests for /.sys_update. |
An address can be reassigned or shared. Our October 31 source-IP match illustrates why a match needs its actual request and timestamp.
Research detection appendix
Start with Sigma, then choose the source you collect. These review hunts use ordinary web and Linux endpoint records, with no Deception Check schema. The companion documents prerequisites, false positives, and local checks; customer-tenant execution has not been performed.
Sigma
Sigma: review flow deployment requests
Webserver POST requests to a flows admin route, including unsuccessful attempts.
Known Node-RED admin route scope; Parsed HTTP method and path without query string; Sigma backend source and field mapping
title: Node-RED Flow Deployment Request for Review
id: c96120c9-2abd-4946-9f4d-76f87686f9c7
status: experimental
description: >-
Finds POST requests to a flows endpoint on known Node-RED admin hosts.
Includes an optional admin path prefix. This is a deployment review lead;
authorized deployments and rejected requests also match. It does not
identify an exploit, authentication bypass, or executed flow.
author: Deception Check
date: '2026-11-03'
references:
- https://nodered.org/docs/api/admin/methods/post/flows/
- https://nodered.org/docs/user-guide/runtime/configuration
logsource:
category: webserver
definition: >-
Scope to known Node-RED admin hosts or reverse-proxy routes. Map the
incoming HTTP method to cs-method and the URL path without query
string to cs-uri-stem. Preserve status as sc-status when available.
detection:
selection:
cs-method: POST
cs-uri-stem|re: '^(?:/[^/?]+)*/flows/?$'
condition: selection
fields:
- c-ip
- cs-username
- cs-method
- cs-uri-stem
- sc-status
falsepositives:
- Authorized editor deployments, CI jobs, API clients, and security tests
- Unrelated applications with a flows route if source scoping is omitted
level: informational
Sigma
Sigma: review Node.js shell and downloader children
Direct shell or download utility children of a Linux Node.js process.
Known Node-RED Linux server scope; Process-start events with full parent and child image paths
title: Linux Node.js Starts a Shell or Download Utility
id: 9d6f68db-a1bc-4c57-972e-5c0d4de52815
status: experimental
description: >-
Finds a direct shell or downloader child of a Node.js process. Scope to
known Node-RED Linux hosts and inspect the parent command line to establish
the application. This behavior is also legitimate and does not prove
exploitation, a completed download, or malware execution.
author: Deception Check
date: '2026-11-03'
references:
- https://www.vulncheck.com/blog/exploitation-targeting-node-red
- https://github.com/microsoft/Sysmon-Linux
- https://sigmahq.io/sigma-specification/specification/sigma-appendix-taxonomy.html
logsource:
category: process_creation
product: linux
definition: >-
Requires collected process start events with full executable paths for
Image and ParentImage, for example parsed Sysmon for Linux Event ID 1.
Raw auditd EXECVE records alone do not supply this parent image mapping.
detection:
selection_parent:
ParentImage|endswith:
- '/node'
- '/nodejs'
selection_child:
Image|endswith:
- '/sh'
- '/bash'
- '/dash'
- '/zsh'
- '/ksh'
- '/curl'
- '/wget'
condition: selection_parent and selection_child
fields:
- Computer
- User
- ParentImage
- ParentCommandLine
- Image
- CommandLine
- ProcessGuid
- ParentProcessGuid
falsepositives:
- Authorized Node-RED exec nodes, installation, maintenance, and deployment tasks
- Other Node.js applications, package managers, and build systems
level: low
CrowdStrike FDR
CrowdStrike FDR: Node.js child processes
Native ProcessRollup2 hunt for a verified Linux Node-RED host.
Falcon/FDR and LogScale access; FDR parser and retained process events; Verified Linux host aid
// Scope the time picker and repository to FDR events for known Node-RED Linux hosts.
// Replace the aid value with a verified Linux host agent ID. Add further IDs as needed.
#event_simpleName=ProcessRollup2 aid="REPLACE_WITH_LINUX_NODE_RED_AID"
| ParentBaseFileName=/^(node|nodejs)$/
| ImageFileName=/\/(sh|bash|dash|zsh|ksh|curl|wget)$/
| table([@timestamp, aid, TargetProcessId, ParentProcessId, ParentBaseFileName, ImageFileName, CommandLine], limit=2000)
Microsoft Defender
Microsoft Defender: Node.js child processes
DeviceProcessEvents hunt with native initiating-process semantics.
Onboarded Linux server with EDR; Advanced hunting entitlement and data; Verified DeviceId
// Replace DeviceId with a verified Linux Node-RED device ID.
DeviceProcessEvents
| where Timestamp >= ago(7d)
| where DeviceId in ("REPLACE_WITH_LINUX_NODE_RED_DEVICE_ID")
| where ActionType == "ProcessCreated"
| where InitiatingProcessFileName in ("node", "nodejs")
| where FileName in ("sh", "bash", "dash", "zsh", "ksh", "curl", "wget")
| project Timestamp, DeviceId, DeviceName, AccountName, InitiatingProcessId,
InitiatingProcessCreationTime, InitiatingProcessFileName, InitiatingProcessCommandLine,
ProcessId, ProcessCreationTime, FileName, ProcessCommandLine, ReportId
| order by Timestamp desc
Elastic ECS
Elastic ECS: Node.js child processes
Kibana Query Language filter for Linux process starts.
ECS-mapped Linux process starts; Parent and child process names; Verified host.id and data view access
host.os.type: "linux" AND
host.id: "REPLACE_WITH_LINUX_NODE_RED_HOST_ID" AND
event.category: "process" AND event.type: "start" AND
process.parent.name: ("node" OR "nodejs") AND
process.name: ("sh" OR "bash" OR "dash" OR "zsh" OR "ksh" OR "curl" OR "wget")
Sumo Logic
Sumo Logic: review flow deployment requests
Raw NCSA proxy-log hunt with explicit request extraction and optional status.
Collected NCSA access logs; Log Search access; Actual Node-RED proxy source category
_sourceCategory=REPLACE_WITH_NODE_RED_PROXY_CATEGORY
| parse regex "\"(?<method>[A-Z]+) (?<url>[^ ]+) HTTP/[0-9.]+\""
| where method = "POST"
| parse regex field=url "^(?<admin_path>(?:/[^/?]+)*/flows/?)(?:[?].*)?$"
| parse regex "HTTP/[0-9.]+\" (?<status_code>[0-9]{3})" nodrop
| fields _messagetime, _sourceHost, method, url, status_code, _raw
Splunk
Splunk: review flow deployment requests
Raw access_combined log hunt with explicit rex extraction.
Collected NCSA combined access logs; Search access; Actual Node-RED proxy index
index=REPLACE_WITH_NODE_RED_PROXY_INDEX sourcetype=access_combined earliest=-7d
| rex field=_raw "\"(?<request_method>[A-Z]+) (?<request_target>[^ ]+) HTTP/[0-9.]+\""
| where request_method="POST" AND match(request_target,"^(?:/[^/?]+)*/flows/?(?:[?].*)?$")
| rex field=_raw "HTTP/[0-9.]+\" (?<response_status>[0-9]{3})"
| table _time host source request_method request_target response_status _raw
Sophos XDR
Sophos XDR: verify Data Lake process coverage
Source-selection and investigation workflow; no runnable SQL or asserted Linux parent schema.
Live Discover entitlement; Data Lake uploads; Vendor query explicitly supporting Linux and Data Lake
# Sophos XDR: choose the verified Data Lake source
This is a practical hunt workflow, not a runnable SQL detection. A public, current Linux Data Lake process schema with verified parent identity fields was not established for this pack. The endpoint schema viewer and Live Endpoint tables cannot establish Data Lake coverage.
1. Open Threat Analysis Center > Live Discover > Data Lake Queries. Confirm the required EDR, XDR, or MDR entitlement and the Data Collection and Investigation policy's upload setting for the Linux server. Use a period containing a known legitimate Node-RED operation.
2. Select a vendor process query whose details explicitly support Linux and Data Lake. Inspect its SQL, returned event type, retention, and documented columns. Confirm that the results contain process starts, rather than only current processes, alerts, or detections.
3. Identify the server using its returned stable device identity. Inspect Node.js parents named `node` or `nodejs` and direct children named `sh`, `bash`, `dash`, `zsh`, `ksh`, `curl`, or `wget`. Use the documented parent process identity to establish each relationship. A shared time window or PID alone is insufficient: PIDs can be reused.
4. Inspect parent and child command lines, user, executable path, and start time. Match the parent to the Node-RED service. Compare activity with approved exec nodes and deployment records; then correlate with proxy requests using server identity and timestamps.
5. If the selected source lacks parent identity or process history, record that coverage gap. Preserve the useful proxy deployment-review hunt in another available log platform. Do not replace the missing history with a query of upstream findings and call it process detection.
Sophos documents distinct Endpoint and Data Lake query modes, supported OS details per query, upload prerequisites, and process pivots in [Live Discover](https://docs.sophos.com/central/customer/help/en-us/ManageYourProducts/ThreatAnalysisCenter/LiveDiscover/index.html). See [Data Lake queries](https://docs.sophos.com/central/customer/help/en-us/ManageYourProducts/ThreatAnalysisCenter/LiveDiscover/DataLakeQueries/index.html) for the cloud query workflow. No customer query was run for this pack.
What a completed response should leave behind
A named owner. A supported fix where the vendor advisory applies. Reviewed access to the editor and flow endpoints. An approved flow baseline. And independently retained records that can answer whether a command actually ran.
If a deployment looks suspicious, involve the application owner before removing nodes. Preserve the evidence, restrict the path, and follow the incident-response plan. The aim is to remove unauthorized behavior while keeping legitimate automation understandable and recoverable.
Which record would you check first?
The deployment, the running process, or the outbound request? Use the worksheet to find out which of those your team can answer today.
Take the worksheetTalk through the evidence pathSources and first-party method
- VulnCheck: reported request designs and infrastructure, November 2, 2026. Canary requests and responses are distinct; the bot binary was not analyzed.
- Siemens SSA-834709: affected product and remediation.
- Node-RED: editor and HTTP-node authentication; runtime settings and editor/API behavior; POST /flows request and response semantics; audit logging.
Our selected collector records cover October 23 through November 3, with collection gaps documented privately. First-party examples are incoming request or command records, not generated decoy output. Source locators, byte hashes, and collection gaps remain in the private research record. These examples do not establish captured Node-RED exploitation or complete fleet coverage.
