The Approval Button Was Not a Security Boundary

The Approval Button Was Not a Security Boundary

A human approval button is not a security boundary if an unauthenticated API can press it.

That is the architectural failure described in CVE-2026-111322, a critical missing-authentication vulnerability in Archon, an open-source workflow engine for AI coding. The VulnCheck advisory says Archon versions 0.2.13 through 0.11.1 expose the /api/* control API without authentication and bind it to 0.0.0.0 by default.

The advisory rates the issue CVSS 4.0 9.3 Critical. Its description says a network attacker can send messages to the coding agent, which runs with bypassPermissions, and execute commands on the host as the Archon user.

The interesting part is not just the missing login. It is what the missing login reaches: the control loop itself.

The control plane is the capability

The vulnerable path is short:

network-reachable client
        |
        v
unauthenticated /api/* control API
        |
        v
message the coding agent
        |
        v
agent runs with bypassPermissions
        |
        v
commands execute as the Archon user

This is not a prompt-injection story in the narrow sense. The attacker does not first need to persuade a normal user to paste an instruction into a chat window. The attacker reaches the service that manages the workflow and sends the agent a message through its control surface.

The NVD record describes the same boundary failure: unauthenticated access to the control API, a default all-interface bind, and command execution through the coding agent’s permissions.

That composition matters. An agent with command execution is already a privileged service. Its orchestration API is therefore an authorization endpoint, even when the product presents it as a convenient local dashboard or workflow controller.

Why the approval step does not save it

Archon workflows can pause for human approval. That sounds like a useful safety gate until the approval action itself travels through the same control plane.

If an attacker can call the API without proving who they are, the system has no reliable way to distinguish these two requests:

legitimate operator -> approve this action
unauthenticated caller -> approve this action

The interface may show a human approval button. The server still needs an authenticated principal, an authorization decision, and an audit record tied to that principal. Without those, the click is only a user-interface event. It is not proof that the right person approved the right action.

This is the same mistake that appears in many agent products: treating the visible checkpoint as the boundary while leaving the backend command that implements the checkpoint open.

The version boundary is not the trust boundary

VulnCheck lists Archon versions 0.2.13 through 0.11.1 as affected. The NVD entry records the issue under CWE-306, Missing Authentication for a Critical Function, with the vector AV:N/AC:L/AT:N/PR:N/UI:N.

The Archon repository currently lists a v0.12.1 release, but the advisory does not identify that release as a fix for this CVE. Its description also does not establish that upgrading to the latest tag closes the control-plane issue. Operators should not infer remediation from a version number alone.

That is an important operational distinction:

  • Observed fact: the advisory names the affected range through 0.11.1.
  • Observed fact: the repository lists v0.12.1 as its latest release at the time of writing.
  • Open question: whether a later release fixes this specific missing-authentication path.

Until the project documents a fix, treat the exposed API as hostile infrastructure, not as a feature that can be made safe by moving to a newer tag without checking the implementation.

What operators should do now

The advisory’s failure mode is network access to an agent control API. The first response is therefore containment and identity, not a prompt rewrite.

  • Bind the control API to a trusted local interface where possible, and do not expose it on a LAN, public address, container bridge, or reverse proxy without an authenticated front door.
  • Add network controls that restrict who can reach the port. This reduces exposure, but it does not replace authentication.
  • Inspect the actual route and authentication configuration in the deployed version. Do not rely on the dashboard showing a login screen.
  • Run the agent as a dedicated low-privilege user with a disposable workspace and no unnecessary SSH keys, cloud credentials, production repositories, or Docker socket.
  • Review workflow and host logs for unexpected API requests, agent messages, approvals, and command execution.
  • If an affected instance was reachable by an untrusted network, rotate secrets available to the Archon user and investigate the host before restoring it.
  • Require the project to document the specific fixed version and the authentication behavior before treating an upgrade as remediation.

Blocklists alone are not enough. A firewall can shrink the set of callers, but the service still needs to authenticate and authorize every privileged control action. Isolation limits the blast radius when that control fails. Auditability makes the failure discoverable.

The broader agent lesson

The agent is not the only security boundary. The gateway, workflow engine, approval mechanism, tool runner, operating-system account, and deployment network all participate in the trust model.

A model can refuse a dangerous instruction. That is useful, but it is not authorization. A dashboard can display an approval request. That is useful, but it is not identity. A service can bind to localhost. That is useful, but it is not proof that a browser, plugin, or local process is trusted.

The uncomfortable truth is simple: once an API can make an agent run commands, that API is a privileged control plane. It needs authentication, authorization, isolation, and an audit trail before the agent gets anywhere near production data.

The approval button is not the boundary. The authenticated control loop is.

Sources

Keep reading