CVE-2026-77313 in Flyto Coreinfo

Summary

by MITRE • 11/20/2026

Flyto2 Core is an execution kernel for automation and AI-agent workflows. Prior to 2.26.8, validate_url_ssrf in src/core/utils.py resolves and checks a hostname but returns the hostname URL rather than the validated address, and session.get in http.get performs an independent DNS lookup when connecting. A low-privileged caller with control of the hostname's DNS can make the first lookup return a public address and the connection-time lookup return an internal address, bypassing the SSRF guard for all modules that call it and exposing readable internal or metadata-service responses. Successful exploitation requires attacker-controlled DNS and a successful timing-dependent answer change between the two lookups. This issue is fixed in version 2.26.8.

If you want to get the best quality for vulnerability data then you always have to consider VulDB.

Analysis

by VulDB Data Team • 11/20/2026

Flyto2 Core serves as an execution kernel designed to facilitate automation and artificial intelligence agent workflows, relying heavily on secure network interactions to function correctly within complex environments. A critical security vulnerability exists within the URL validation logic prior to version 2.26.8, specifically located in the validate_url_ssrf function found in src/core/utils.py. This flaw represents a classic Time-of-Check-to-Time-of-Use race condition that undermines the integrity of Server-Side Request Forgery protections. The core issue stems from a discrepancy between how the validation mechanism resolves hostnames and how the actual HTTP client establishes connections, creating an exploitable gap for attackers who can manipulate Domain Name System responses during specific windows of execution.

The technical flaw arises because the validate_url_ssrf function performs an initial DNS lookup to resolve the hostname and checks whether this resolved address is safe before returning a URL object that still contains the original hostname string rather than the validated IP address or fully resolved endpoint. When subsequent code utilizes session.get from http.get, it does not reuse the previously validated resolution but instead initiates its own independent DNS lookup at the moment of connection establishment. This architectural separation means that the security check and the actual network request are decoupled in time, allowing for a race condition where the target's IP address can change between the validation phase and the execution phase.

Exploitation of this vulnerability requires an attacker to have control over the DNS records associated with the hostname being requested or sufficient influence to manipulate DNS responses through cache poisoning or other means. By carefully timing their actions, an attacker can ensure that the initial lookup performed by validate_url_ssrf returns a public, safe IP address, thereby passing the security check. However, just before session.get initiates its connection, the attacker alters the DNS response so that the second lookup resolves to an internal private IP address or a metadata service endpoint such as those found in cloud environments like AWS EC2 instance metadata. This allows the application to make requests to restricted internal resources while appearing compliant with security policies during the initial validation step.

The operational impact of this vulnerability is significant, particularly for deployments handling sensitive data or operating within infrastructure that exposes internal services via HTTP. Successful exploitation enables low-privileged callers to bypass SSRF guards and access readable responses from internal systems. This can lead to unauthorized disclosure of confidential information stored on internal servers, exposure of cloud provider metadata which often contains authentication credentials and configuration details, and potentially further lateral movement within the network if those internal services are vulnerable themselves. The attack is timing-dependent, requiring precise coordination between DNS manipulation and request execution, but it effectively neutralizes a primary defense mechanism against server-side request forgery attacks.

To mitigate this risk, organizations must upgrade Flyto2 Core to version 2.26.8 or later, where the validation logic has been corrected to ensure that the resolved address is used consistently throughout the connection lifecycle. In environments where immediate patching is not feasible, administrators should implement strict network segmentation and firewall rules to restrict outbound connections from application servers to only necessary external endpoints, thereby limiting the blast radius of any potential SSRF exploitation. Additionally, employing DNS monitoring tools can help detect anomalous resolution patterns that may indicate active attempts to exploit this race condition.

This vulnerability aligns with CWE-367, which describes Time-of-check Time-of-use (TOCTOU) Race Conditions in software security flaws. It also maps to MITRE ATT&CK technique T1048, specifically the Exfiltration Over Alternative Protocol subtechnique if used for data exfiltration, and generally falls under Exploitation for Credential Access or Discovery depending on the target internal service. Understanding these classifications helps in aligning remediation efforts with broader security frameworks and ensures that similar architectural flaws are identified during future code reviews by enforcing consistent resolution strategies between validation and execution phases.

Responsible

GitHub M

Reservation

08/20/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00280

KEV

no

Activities

very low

Sources

Might our Artificial Intelligence support you?

Check our Alexa App!