Jul 30, 2026·6 min read·64 visits
Flyto2 Core follows HTTP redirects to private internal subnets without revalidating intermediate URLs, leading to an SSRF vulnerability (CVSS 8.5).
An SSRF vulnerability exists in Flyto2 Core due to improper validation of intermediate HTTP redirect hops. While the initial request target is validated against an SSRF protection policy, the HTTP client library (aiohttp) transparently follows 30x redirects to local, internal, or cloud metadata endpoints without application-level revalidation.
The Flyto2 Core engine is designed to execute automation and artificial intelligence workflows by exposing dynamic orchestration modules. Under normal operational patterns, users utilize modules such as http.get, http.request, and http.batch to retrieve remote resources or execute webhooks. Because these execution runners operate on the internal network boundary of the host system, they expose a highly sensitive network attack surface.
To restrict access to internal infrastructure, the application uses an SSRF guard mechanism named validate_url_with_env_config(url). This validation tool resolves hostnames and asserts that target destinations do not lie within loopback addresses, local network subnets, or metadata addresses. If a user supplies a protected address directly, the application throws an exception and halts execution.
However, a severe design gap exists in how the engine processes downstream network redirections. While the initial request destination undergoes validation, intermediate HTTP redirection targets do not. This vulnerability allows an external, untrusted target to pivot the execution runner into restricted subnets by responding with standard redirection status codes.
The primary logical failure resides in the configuration of the Python aiohttp HTTP client library used by the request modules. When initializing execution sessions, the application relies on the default network client behavior where the redirect policy is configured with automatic redirection enabled (allow_redirects=True). Consequently, the socket handling layer resolves the redirection at the socket layer without returning control to the parent validation application.
The sequential flaw unfolds when an execution session resolves a public hostname that points to a legitimate external address. The application resolves the target host, verifies it does not match internal IP blocks, and initiates the socket connection. When the external server responds with a redirection status code (such as HTTP 301, 302, 303, 307, or 308) and a Location header, the underlying client immediately executes the subsequent request.
Because the redirection handling occurs transparently within the client library, the application-level validation layer is completely bypassed. If the Location header points to a private loopback target (such as http://127.0.0.1:8500) or cloud instance metadata endpoints (such as http://169.254.169.254/latest/meta-data), the client will establish the socket connection, retrieve the data, and expose internal configuration files or credential secrets.
The remediation committed in version 2.26.7 focuses on modifying the redirection behavior within src/core/utils.py. The patch explicitly disables automatic redirection on the HTTP client library and replaces it with a manual hop-by-hop checking loop.
# Patched implementation of aiohttp wrapper
_REDIRECT_STATUSES = frozenset({301, 302, 303, 307, 308})
async def guarded_aiohttp_request(session, method: str, url: str, *,
max_redirects: int = 5, **kwargs):
from urllib.parse import urljoin
# Explicitly remove allow_redirects if passed by the caller
kwargs.pop('allow_redirects', None)
guard = ssrf_protection_enabled()
if guard:
# Validate the initial URL input
validate_url_with_env_config(url)
method = method.upper()
for hop in range(max_redirects + 1):
# Execute request with automatic redirection disabled
response = await session.request(method, url, allow_redirects=False, **kwargs)
location = response.headers.get('Location')
# Manually intercept redirection status
if response.status in _REDIRECT_STATUSES and location and hop < max_redirects:
response.release() # Prevent connection socket leakage
url = urljoin(url, location)
if guard:
# REVALIDATE EACH INTERMEDIATE HOP AGAINST THE GUARD POLICY
validate_url_with_env_config(url)
if response.status == 303:
method = 'GET'
kwargs.pop('json', None)
kwargs.pop('data', None)
continue
return response
return responseBy disabling automatic redirects at the library layer via allow_redirects=False, the application intercepts every redirect. The code resolves relative URLs using urljoin and evaluates the resolved URL string against validate_url_with_env_config(url). If any redirect hop target maps to a restricted IP address range, the system raises an SSRFError, terminating the connection.
An attacker with privileges to configure or trigger a workflow block can exploit this vulnerability to extract confidential credentials from cloud environments. The target runner environment must have access to the internal network space or a cloud metadata endpoint.
To conduct the attack, the adversary registers an external domain and configures it to return redirection response headers pointing to the targeted internal service. For example, a redirect script running on an external server can respond with:
HTTP/1.1 302 Found
Location: http://169.254.169.254/latest/meta-data/iam/security-credentials/admin-roleWhen the Flyto2 Core engine initiates the execution of the workflow block containing the external URL, the initial validation check resolves the domain to a public IP. The request proceeds, gets redirected, and because of automatic redirect tracking, queries the cloud metadata endpoint, returning the administrative AWS credentials to the attacker inside the workflow output logs.
The impact of this SSRF bypass is rated high (CVSS v3.1 base score of 8.5). Successful exploitation allows authenticated users with execution privileges to read arbitrary internal configurations, network service responses, database details, and cloud metadata records.
By obtaining access to loopback interfaces, an attacker can exploit other unauthenticated services residing on the local host. For example, local microservices, caches, and queue systems that assume safety within the network perimeter can be read and manipulated. Furthermore, in containerized environments, attackers can pull access tokens belonging to the Kubernetes node or host instance, enabling lateral movement and escalating privileges across the broader cluster deployment.
The recommended remediation is to immediately update flyto-core to version 2.26.7 or later. This upgrade deploys the custom request handler that manually checks and isolates redirection hops.
In addition to upgrading, security operators should implement host-level network egress restrictions. Restricting runner instances from accessing local subnets (such as 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16) and blocklisting the cloud metadata address (169.254.169.254) via firewall rules (such as iptables or security groups) establishes a defense-in-depth model that prevents exploitation even in the presence of library-level validation bypasses.
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
flyto-core flytohub | < 2.26.7 | 2.26.7 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-918 |
| Attack Vector | Network |
| CVSS Base Score | 8.5 |
| EPSS Score | 0.00236 |
| EPSS Percentile | 14.80% |
| Exploit Status | poc |
| KEV Status | Not listed |
The application constructs an outbound HTTP request using a client-controlled URL destination without proper validation of intermediate redirects, allowing access to private resources.
A missing authorization and type validation vulnerability in Silverstripe Framework prior to version 6.2.13 allows authenticated CMS users to convert database records into arbitrary DataObject classes via user-controlled ClassName parameters in GridField detail forms.
CVE-2026-91115 (GHSA-c94f-87xg-65wf) is an unsafe reflection vulnerability in the Silverstripe Framework affecting versions 6.0.0 prior to 6.2.13. The built-in development task i18nTextCollectorTask passes the user-supplied 'writer' parameter directly to Silverstripe's dependency injection container (Injector::inst()->get()) without verifying that the requested class implements the expected Writer interface. Because the dependency injector supports instantiating arbitrary classes with attacker-supplied constructor arguments, and because nested task URLs bypassed interactive confirmation middleware, an attacker can achieve remote code execution via unauthenticated requests on development instances or via Cross-Site Request Forgery (CSRF) against authenticated administrators on production instances.
CVE-2026-129237 is a partial path traversal (Zip Slip) vulnerability in qbee-agent, the device agent for the qbee.io IoT device management platform. Prior to version 2026.41, the tar archive extraction routine in app/utils/tar.go used strings.HasPrefix without enforcing a directory separator boundary. When the Docker Compose bundle configuration has UseContext enabled, an authenticated user with delegated configuration or file management privileges can supply a crafted tar archive containing sibling-prefix traversal sequences, allowing directory creation and file writes into adjacent sibling directories outside the intended extraction root.
CVE-2026-128118 (GHSA-m9j8-jcmv-hp69) is an information disclosure vulnerability affecting the SvelteKit framework (@sveltejs/kit) from version 3.0.0 through 3.1.0. A design flaw in the build-time Vite module guard plugin (plugin_guard) failed to register src/params.js as a client entry point and implemented a fail-open validation model. Consequently, server-only modules and private environment variables imported directly or dynamically within parameter matchers were compiled into publicly accessible client-side JavaScript bundles without triggering a build error.
CVE-2026-128071 is a route-rule authorization bypass and security policy circumvention vulnerability in the Nuxt web framework, affecting `nuxt`, `@nuxt/nitro-server`, and `@nuxt/vite-server` prior to version 4.6.4. Serving as an incomplete fix for GHSA-6gq8-jgmh-3ffp, the flaw arises from an interpretation conflict between Nuxt's route-rule matching logic and Vue Router's catch-all route parameter decoding. When processing an incoming HTTP request containing percent-encoded forward slashes (`%2F` or `%2f`), the route-rule evaluation engine preserves the encoded sequence as a single path segment, failing to match prefix-based rules such as `/admin/**`. However, when the request is subsequently dispatched to a catch-all page route (`app/pages/[...slug].vue`) or a multi-segment parameter handler, the parameters are URL-decoded into literal slash delimiters. This discrepancy allows unauthenticated remote attackers to bypass route-level redirects, authentication middleware (`appMiddleware`), security headers, proxy configurations, and rendering constraints (`ssr: false`, `noScripts`), while the catch-all page resolves and renders the protected resource.
In Natural Language Toolkit (NLTK) versions prior to 3.10.4, the nltk.parse.dependencygraph.dot2img function resolves the Graphviz dot binary through the system PATH using find_binary('dot') and invokes it directly via subprocess.run() instead of routing execution through nltk.pathsec.spawn_trusted(). This omission bypasses file ownership validation, directory writability checks, and dynamic loader environment scrubbing. On multi-user POSIX systems where a victim's PATH contains a directory writable by a local low-privileged attacker, the attacker can plant a malicious dot binary that executes under the victim's privileges when dependency graphs are rendered.