10.0

CVSS 3.1 score Siemens gave CVE-2026-58115

16

exploitation attempts from one address, 30 Oct to 1 Nov

3 days

from public detection to exploitation in the wild

1

HTTP request to deploy a flow and run a command

The CVE names one product. The exposure is a default.

CVE-2026-58115 is a Siemens CVE for a Siemens gateway, and attackers are using it. But the thing they are exploiting is not a coding mistake in one product. It is the way Node-RED ships: with an editor and an admin API that anyone who can reach the port is allowed to change.

That is the argument of this post. If you treat CVE-2026-58115 as a patch ticket for the SIMATIC IoT2050 Advanced, you will close it, and you will still have every other Node-RED install in your estate exposed in exactly the same way. The question to ask this week is not "do we run the affected Siemens build". It is "where do we run Node-RED, and can anyone reach its editor without logging in".

Node-RED is a flow based programming tool. People drag nodes onto a canvas, wire them together and press deploy. It reads sensors, moves data between industrial protocols and cloud services, and glues home and building automation together. It is also the reason the bug is so serious: one of the standard nodes runs operating system commands, by design. An editor with no login is a remote shell with a friendly user interface.

VulnCheck caught the first in the wild attempt on 30 Oct 2026, three days after it published its own detection for the CVE. The attacker sent one request that deployed a flow, downloaded a Linux bot and ran it. Later requests left web shells built out of Node-RED's own HTTP nodes, so the attacker could come back whenever it liked.

We have made a version of this point before. When a Brotli bug turned into Node2Shell, the copies that mattered were the ones a version scan could not see. Node-RED is a starker case. There is no vulnerable library to find at all on most hosts. There is only a setting that was never turned on.

What is Node-RED CVE-2026-58115?

Siemens ProductCERT published advisory SSA-834709 on 11 Aug 2026. Its title is plain: a missing authentication vulnerability in Node-RED on SIMATIC IoT2050 Advanced with Industrial OS. The advisory says affected devices "do not enforce authentication on the Node-RED HTTP interface, allowing unauthenticated access to programming nodes that are capable of executing system commands on the server."

Siemens scored it CVSS 3.1 10.0, the top of the scale and a critical on ours, with a vector of network reachable, low complexity, no privileges, no user interaction and a changed scope. It classed the weakness as CWE-306, missing authentication for a critical function. In the advisory's words, an unauthenticated remote attacker can "create malicious flows" and execute arbitrary code "with maximum privileges".

The fix is a firmware update: version 4.3.4.1 or later. Siemens also lists two mitigations for anyone who cannot update yet. One is to harden the Node-RED installation, pointing to the Node-RED user guide. The other is to uninstall Node-RED.

Read those mitigations again. The vendor's own workaround for a CVSS 10.0 is to configure Node-RED the way its documentation already tells everyone to configure it. That is the clearest sign the CVE describes a deployment, not a defect.

CVE-2026-58115 Critical
  • Product //

    SIMATIC IoT2050 Advanced with Node-RED installed
  • Affected //

    versions before V4.3.4.1
  • Fixed in //

    V4.3.4.1, per Siemens SSA-834709
  • CVSS //

    10.0 (3.1, Siemens), CWE-306
  • Exploited //

    Yes, per VulnCheck canaries from 30 Oct 2026
  • CISA KEV //

    Not listed when VulnCheck published

For more than two months the advisory sat quietly. Then, on 27 Oct, VulnCheck shipped detection material for its customers, including a proof of concept and scanner queries. On 30 Oct one of its canaries recorded the first exploitation attempt. VulnCheck moved the CVE into its own exploited catalog. It noted that the CVE was not in CISA's KEV at the time of writing, and Help Net Security reported the same on 3 Nov.

The scale of what VulnCheck saw is modest, and the company is careful about it. All of the Node-RED attempts came from one address, which sits in Microsoft's cloud network and geolocates to Brazil. That address hit the Node-RED CVE 16 times between 30 Oct and 1 Nov. Across VulnCheck's wider sensors the same address logged 125 hits against 8 different CVEs, old and new, in products such as Apache Solr, Gitea, MLflow and Joomla. VulnCheck reads that as opportunistic mass exploitation, not a targeted operation against industrial sites.

We agree with that reading, and we would not inflate it. No victim has been named. Nobody has published a count of compromised Node-RED servers. VulnCheck did not retrieve the bot binary, so it cannot say whether it is a miner, a DDoS bot or a remote access tool. What the data does show is that the exploit is automated, cheap and already in a toolkit that sprays the internet. Opportunistic attackers do not check whether you are a factory before they deploy.

How one request becomes a shell

The chain is short because Node-RED does most of the attacker's work. Every stage below uses a feature the product is meant to have. Nothing is corrupted and nothing crashes.

Figure 01

From an open port to a resident shell

  1. 01

    Find //

    A scanner finds an editor that answers without a login.

  2. 02

    Deploy //

    One request deploys a flow that runs a command.

  3. 03

    Implant //

    The command fetches and starts a Linux bot.

  4. 04

    Stay //

    A second flow publishes a web shell on the host.

Result //

The automation server now takes orders from the attacker.

Every stage is a documented Node-RED feature. The missing login is the whole bug.

VulnCheck's write up shows the attacker sending the complete exploit, the flow and the dropper, in a single POST to the admin API's flows endpoint. The flow joins an inject node, which fires on deploy, to an exec node, which runs a shell command. So the act of deploying is the act of executing. There is no second step to catch.

The first payloads downloaded a Linux bot, saved it under a hidden name in memory backed storage and started it detached. A later variant fetched a staged shell script instead, and a different server delivered a file named to look like a kernel worker thread. That disguise is aimed at whoever lists processes on the box later, and it tells you the attacker expects people to look.

The persistence step is the one we would worry about most. VulnCheck saw flows that expose an http in endpoint, at a path such as /cmd or a random string, which runs whatever command arrives in a query parameter. That is a web shell made entirely of Node-RED nodes. It survives a reboot because Node-RED saves its flows to disk and reloads them on start. It does not need a file on the web root, so a file integrity check on the usual places will not see it. And if the operator later turns on adminAuth without reviewing the flows, the shell keeps working, because adminAuth protects the editor, not the HTTP routes that flows create. Node-RED has a separate setting, httpNodeAuth, for those.

The impact depends on where Node-RED runs. On the Siemens gateway, Siemens says code runs with maximum privileges. On a Raspberry Pi in a plant room, it runs as whatever user started Node-RED, often with access to serial ports, PLC protocols and the credentials stored in flows for databases, MQTT brokers and cloud services. On a container in a data platform, it runs next to whatever that container can reach. In every case the attacker inherits the position Node-RED was trusted with, and Node-RED is usually trusted to talk to things that matter.

Why a CVE scan will not find your exposure

Here is the gap. A vulnerability scanner that keys on CVE-2026-58115 will look for a Siemens IoT2050 Advanced below V4.3.4.1. It will flag that device, someone will update it, and the dashboard will turn green. Everywhere else, the scanner has nothing to match. Node-RED on a Linux server, in a Docker container, on a Raspberry Pi or inside another vendor's appliance carries no CVE for this, because the upstream project documents the behaviour rather than treating it as a vulnerability.

Node-RED's security guide says it directly: by default the editor is not secured, anyone who can reach its address can access it and deploy changes, and that is only suitable on a trusted network. Its configuration reference adds the two defaults that turn that into an internet problem. The editor listens on port 1880, and on all IPv4 interfaces, unless someone sets uiHost to something narrower.

Put those together and the exposed population is not "IoT2050 gateways". It is every Node-RED instance where nobody uncommented adminAuth and the port is reachable from somewhere an attacker can stand. That includes instances behind a VPN that a contractor uses, instances on a flat OT network that one phished laptop can reach, and instances a vendor installed on an appliance you think of as a black box.

VulnCheck makes the vendor point too. Siemens assigned this CVE, which shows Node-RED is embedded in commercial industrial products, and VulnCheck notes that Emerson's documentation also highlights Node-RED, while saying plainly that it has not checked whether Emerson products are affected. We have not checked either, and we would not assume. The lesson is broader than any one vendor: an appliance can ship Node-RED, and your asset inventory may list the appliance without ever listing what runs inside it.

This is a pattern, not a one off. An exploited misconfiguration gets a CVE only when a vendor ships the misconfiguration inside a product and has to issue a fix. The CVE then becomes the thing security teams track, and the misconfiguration everywhere else stays invisible to every tool that works from CVE feeds. The Ivanti Connect Secure chain taught that a patch level says nothing about what already happened. This one teaches that a CVE number says nothing about where else the same door is open.

The test that matters is simple and does not need a vulnerability scanner at all. Ask the editor for its flows without credentials. If it answers, it is exposed, whatever product it sits in and whatever version it runs.

How to detect Node-RED flow tampering

Node-RED can log every admin API call, but the setting ships switched off. Its logging guide shows audit set to false in the default console logger. Set it to true and each deploy is recorded as a flows.set event with the path, the client address and a timestamp, plus the user when adminAuth is on. Do that first, then watch three places around it.

The first is the host. When an exec node runs, the Node-RED process spawns a shell. On most installs Node-RED never needs to start curl or wget through a shell, so a shell child of the Node-RED process that fetches something from the internet deserves an alert. The Sigma rule below is a starting point for Linux process creation telemetry, such as auditd or Sysmon for Linux.

Figure 02

Node-RED spawns a shell that downloads a file

Sigma

title: Shell spawned by Node-RED fetches a remote file
status: experimental
description: A shell started by the Node-RED Node.js process runs curl or wget, as an exec node deployed by an attacker would.
logsource:
  product: linux
  category: process_creation
detection:
  parent:
    ParentImage|endswith: '/node'
    ParentCommandLine|contains: 'node-red'
  shell:
    Image|endswith:
      - '/sh'
      - '/bash'
      - '/dash'
  fetch:
    CommandLine|contains:
      - 'curl '
      - 'wget '
  condition: parent and shell and fetch
falsepositives:
  - Flows that legitimately call curl or wget through an exec node
level: high
A starting point to tune against your own telemetry, not a production rule. Allow list the flows that genuinely shell out.

The second is the network. Deploys go to the admin API's flows endpoint. If a reverse proxy, load balancer or firewall sits in front of Node-RED, alert on any POST to /flows that does not come from the addresses your engineers use. Better still, block the admin API at that proxy for everyone else. VulnCheck saw the attacker use at least five different user agents, including curl, python-requests and browser strings, so do not build the rule on the user agent.

The third is the flows themselves, and this is the one that finds an attacker who already got in. Node-RED stores the deployed flows in a JSON file, by default named after the host, in its user directory, which also holds the credentials file. Export it on every instance and look for exec nodes and http in nodes that nobody on the team added. An http in node on a path like /cmd that feeds an exec node is the web shell pattern VulnCheck describes. Keep a known good copy of each flows file and compare against it, so the next unexpected change is a diff, not a hunt.

VulnCheck also publishes network indicators for this campaign, the source address and two payload servers, in its post. Block and search for them, but treat them as short lived. The source sits in a large cloud provider's range and VulnCheck reads it as shared infrastructure. The flow review will still work when those addresses have changed hands.

How we test Node-RED on an engagement

On an external test, we start by finding every host that answers like Node-RED, not just the ones in the asset register. Our external recon method maps host names from DNS, certificate transparency and the address ranges in scope, and our open source atarus-recon tool automates part of that work. We look for port 1880 on every address in scope, and for Node-RED answering on other ports behind a proxy.

When we find one, the check is the one described above, done within the rules of engagement: does the editor or the admin API answer without credentials? We do not deploy flows on a client's production automation server to prove a point. An editor that lists its flows to an anonymous request is the finding. If the client wants impact demonstrated, we agree a test instance or a harmless flow with them first, in writing.

Internally the question changes. On an assumed breach test we ask what Node-RED instances an ordinary workstation can reach, and what those instances hold. Our internal network first hour covers how we map that. A Node-RED editor reachable from the office network is often the shortest path from IT into OT, because it already holds working connections to the systems on the other side. The connections configured in its flows, for MQTT brokers, historians, databases and cloud APIs, show what an attacker on that host could reach next, and that map is usually worth more than the host itself.

We also check the HTTP routes the flows publish. Teams that do turn on adminAuth often leave httpNodeAuth off, so dashboards and API endpoints built in Node-RED stay open even when the editor is locked. That is not always wrong, but it should be a decision, and it should be written down.

And we look inside the appliances. When a vendor box exposes a web interface on an unusual port, we identify what serves it rather than accept the vendor's label, because this CVE exists only because one vendor shipped Node-RED inside a product.

What is still coming

Expect the attempts to grow. The exploit takes one request, VulnCheck shows it already sitting in a toolkit next to bugs in Solr and Gitea, and search engines that index internet services make Node-RED editors easy to list. Opportunistic actors add cheap exploits to their rotations and keep them there for years.

Expect more vendor CVEs of the same shape. Siemens issued this one because it shipped Node-RED inside a product and had to fix its own default. Other vendors who embed Node-RED face the same question, and some will answer it with an advisory. Each of those CVEs will cover one product. None of them will cover the copy an engineer installed on a spare server last spring.

CISA had not listed CVE-2026-58115 when VulnCheck published. If it does, federal teams will get a deadline for the Siemens device, and most organizations will read the listing as a Siemens problem. Read it as a prompt to find every Node-RED you run.

The fix that lasts is not a version number. It is a rule that no automation editor reaches a network it was not meant for without a login in front of it, and a habit of checking that rule against what is actually listening.

What to do today

  1. Find every Node-RED instance. Look for port 1880 and Node-RED responses on every network you own, including OT segments, containers and vendor appliances, not only the asset register.

  2. Test each one without credentials. If the editor or admin API answers anonymously, it is exposed, whatever version it runs.

  3. Turn on adminAuth or take the editor off the network. Set uiHost to a local interface where remote editing is not needed, and put httpNodeAuth on HTTP routes that should not be public.

  4. Update the Siemens IoT2050 Advanced to V4.3.4.1 or later. If you cannot, follow the advisory: harden Node-RED or uninstall it.

  5. Review deployed flows for exec and http in nodes nobody added. Turning on a login does not remove a web shell already saved in the flows file.

  6. Alert on Node-RED starting shells that download files. The Sigma rule above is a starting point; tune it to the flows that legitimately shell out.