Deception Check

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.write

BOUNDARY 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 · httpNodeMiddleware
Node-RED documents these controls separately. Securing the editor does not remove an existing flow or automatically secure its HTTP endpoints.

Four 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.

KEEP: Owner, version evidence, approved access path

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.

KEEP: Flow version, collection time, evidence custodian

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.

KEEP: Changed nodes, wiring, command, approval

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.

KEEP: Host evidence, outbound destination, recovery owner

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 pack

What 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.

  1. Siemens publishes the advisory

    Affected product conditions and the fixed version are available.

  2. A Telnet session submits a downloader

    Similar filename and launch habits, using a different server.

  3. Malicious flow requests are reported

    The published request shows the intended workflow-to-shell path.

  4. 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

  1. Submit a flow

    A request changes the workflow running on the host.

    POST /flows
  2. Start automatically

    An Inject node sends a message after deployment.

    inject · once: true
  3. Launch a command

    An Exec node hands the command to the host operating system.

    exec · shell command
  4. Fetch and launch

    The supplied command requests a Linux payload and tries to start it.

    /dev/shm/.b
Conceptual reconstruction of the request VulnCheck reported. It illustrates intended steps; a canary response is not evidence that the payload ran.

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.

Node-RED runtime configuration

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.

Node-RED deployment API

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.

QuestionOrdinary sourceWhat to compare
Who changed the flow?Node-RED audit events and management access logsCaller, time, method, management prefix, status, and approved change.
What is deployed?Restricted active-flow export or configured flow file, plus a known-good versionNode 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 themNode.js parentage, shell/downloader command line, host, account, and time.
What left the host?Proxy, DNS, firewall, or network telemetry collected outside the gatewayDestination, 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.

The address VulnCheck listed as a payload server sent this bare request to an ICS-themed web decoy. The shared address does not establish who operated it or connect this request to the reported exploit.

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.

IndicatorReported roleUseful pivot
4.201.105[.]116Reported request sourceReview access to your Node-RED management routes.
85.215.73[.]250Reported download server, port 8080Review outbound requests for bot-linux-amd64 or wget.sh.
45.194.90[.]57Reported alternate download server, port 38472Review 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 path

Sources and first-party method

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.