A Check on One Path Is Not a Boundary on the Execution

An AI workflow platform added a command allowlist to the route through which users register tool servers. Other routes reached the same process launch without passing it. The final fix applied the same policy at the point every route shares: just before the process is spawned.

What is reported

Langflow is an open-source platform for building AI workflows. It can connect a workflow to tool servers that use the Model Context Protocol (MCP). One way to connect such a server is the “stdio” transport: Langflow launches the server as a local process, using a command and arguments taken from the server’s configuration.

On September 28, 2026, the Langflow project published a security advisory, GHSA-w794-rj3p-xv45 (CVE-2026-105697), rated critical. According to the advisory, before version 1.10.3 the stdio transport ran whatever command and arguments a configuration supplied, wrapped in a bash -c shell, with the privileges of the Langflow process. The advisory states that any user able to reach the MCP server settings could add such a configuration; with automatic login disabled, that included any authenticated non-admin user. With automatic login left at its default, which the project documents as a development-only setting, an exposed instance would issue a token without credentials. Affected versions run from 1.1.2 up to, but not including, 1.10.3.

This reading focuses on the fix history the advisory itself records.

  • In version 1.9.0, the project added a command allowlist and validation of arguments and environment variables to the model the REST interface uses when a user registers an MCP server. That closed the “Add MCP Server” route.
  • The code that actually launched the process still performed no validation. Configurations that did not pass through that model — those embedded in a flow, or supplied as run-time parameters the project calls tweaks — could still reach the launch with any command.
  • In version 1.10.3, the same policy was applied where the process is launched, covering embedded and run-time configurations, and the shell wrapper was removed. The project describes this as final pre-spawn enforcement: the same validator now runs at the API, at flow execution, and immediately before the process is spawned.
  • Version 1.11.0 added optional stricter modes for multi-tenant deployments.

The reporter also notes, in the advisory, that the command could run even when the interface reported that the server had failed to start.

The usual reading

Read as a vulnerability, this is command injection with a two-stage patch: the first fix was incomplete, the second closed the remaining routes, and the remedy is to upgrade. That reading is correct, and for anyone running an affected version it is the one that matters first.

This piece reads one structural detail within it: where the policy sat, and why the first placement was not enough.

A policy on a path, and a boundary on an execution

After version 1.9.0, the project had established a policy governing which commands could be launched. But its enforcement was attached to one route, the interface through which users register a server.

The execution the policy was meant to govern was something else: a process starting on the host with a given command. That execution could be reached by more than one route. A configuration registered through the interface was one. A configuration carried inside a flow was another. A value substituted at run time was a third. Each ended at the same place, the launch.

A check on the first route established that configurations entering by that route met the policy. It established nothing about configurations arriving by the others. The policy existed and was enforced, and the execution it concerned was still not bounded by it.

The decisive change, for this reading, was not a different command policy but where the existing one was enforced: at the point every route to the launch has to pass. (The same fix also removed the shell wrapper.) That is what made it a boundary on the execution rather than a check on a path. The earlier checks remained, and they still have value: rejecting a bad configuration at registration fails early, close to whoever submitted it. But the place where the policy binds the execution itself is the last one, where the process opens.

Where the record and the execution part

One further detail is small but worth noting. The reporter observed that a command could run while the interface reported that the server had failed to start. If so, what was displayed and what executed diverged: someone reading the interface could have concluded that nothing ran.

A status shown to a user describes what the system reported. It is not necessarily a description of what executed. Establishing what actually executed requires evidence of the launch itself, not merely the interface’s reported status.

What this does not show

This case does not show that the project’s maintainers were careless. Extending a check from one route to every route is a common second step once a bypass is found, and the project documented both stages openly.

It does not settle who was authorized to supply a configuration. The fixes govern which commands may be launched. Whether a particular user should have been able to place a configuration into a flow at all is a separate question the advisory does not address, and this reading does not attempt to.

It does not assess whether the policy itself is sufficient. The advisory notes that the default allowlist still lets npx and uvx run any package, which is how MCP servers are normally distributed, and it recommends further restrictions for multi-tenant deployments. This reading concerns where the policy was enforced, not what it permits.

Nor does it show that a check at the launch is the only check that matters, or that one enforcement point is sufficient in every system. In this case, the launch was the point every route shared. In other systems, that point may sit elsewhere, or there may be more than one.

Generalizing

When the same execution can be reached by more than one route, a policy enforced on one route governs that route. It does not yet govern the execution. Entry points tend to accumulate after a policy is first written — imports, templates, run-time parameters, automation — and each one is a route the original check may not see.

The useful question is therefore not only whether a policy exists, or whether it is enforced, but where. Is it enforced at the point every route to this execution must pass, at the moment execution opens?

A policy that guards one way in does not yet govern the execution. The boundary is where every way in must pass.


Source note. This piece draws on the Langflow security advisory GHSA-w794-rj3p-xv45 (CVE-2026-105697) and the corresponding OSV record. Version numbers, the fix sequence and the description of final pre-spawn enforcement are the project’s. The observation about failed-start reporting is the reporter’s, as recorded in the advisory. FO Lens has not tested any version of Langflow. The execution-boundary reading is FO Lens’s.

The essay as a webtoon

FO Lens Cases 35 webtoon: a panel-by-panel summary of this essay.
FO Lens Cases 35. A summary of the essay above, which remains the reference text. Select the image to open it at full size.

The same characters also star in a daily-life webtoon, Rurun Clocks In.