CVE-2026-84389 is an open redirect vulnerability in Fortinet FortiSIEM versions 7.4.1 through 7.4.2 and 7.5.0 through 7.5.1. This flaw may allow an attacker to execute unauthorized code or commands by redirecting users to untrusted sites. The vulnerability has a low CVSS score of 2.8 and requires user interaction with a high attack complexity. An official fix is available from the vendor.
CVE-2026-76925 is a Time-of-check to Time-of-use (TOCTOU) race condition vulnerability in the Flatpak component org.freedesktop.Flatpak.SystemHelper used by Red Hat Enterprise Linux 10. The flaw arises because a privileged chmod operation occurs before OSTree repository validation in the Deploy() function. A local attacker with limited privileges who can win the timing race may redirect symlinks to arbitrary files, potentially causing unauthorized file manipulation or information disclosure. Exploitation requires local access and is difficult due to the narrow timing window. Red Hat has deferred the fix, citing limited residual risk and lack of suitable mitigations.
PassMark PerformanceTest before 11.1 build 1012, BurnInTest before 11.1 build 1000, and OSForensics before 11.1 build 1016 contain a privilege escalation vulnerability in DirectIo64.sys that allows local users to modify hardware configuration by exploiting exposed IOCTLs with no validation on device selection, register offset, or value. Attackers can obtain a device handle and issue arbitrary PCI configuration space read/write operations to enable Bus Master DMA on any PCI device, halt storage controller I/O by clearing command registers, or remap Base Address Registers to redirect DMA to an attacker-chosen physical address.
CVE-2026-85699 is a server-side request forgery (SSRF) vulnerability in the jina-ai reader component. The vulnerability arises because URL validation is only applied to the initial request and not to subsequent redirects. This allows attackers to craft URLs that redirect to internal network addresses or cloud metadata endpoints, causing the server to fetch and return sensitive internal responses to the attacker. The vulnerability has a high severity with a CVSS score of 8.7.
ms-swift 4.5.2 contains a server-side request forgery vulnerability in the swift deploy OpenAI-compatible API that fetches multimodal media URLs without validation or redirect filtering. Unauthenticated attackers can supply arbitrary image_url, audio_url, or video_url parameters to make the server issue requests to internal services and cloud metadata endpoints.
Allocation of Resources Without Limits or Throttling vulnerability in elixir-mint mint allows a remote HTTP server to exhaust memory on the client host and cause a denial of service.
Two HTTP/1 response-parser states accumulate server data without any cap. In lib/mint/http1.ex, decode_status_line/4 stores the unconsumed data in conn.buffer when the status line is incomplete, and decode_body/5 does the same for an unterminated chunk-extension line. Both wait for a CRLF the server never has to send, and conn.buffer is prepended to every subsequent socket message. The :max_header_list_size budget is wired only into decode_headers/5 and decode_trailer_headers/4, so neither of these states is covered by it. A malicious server, or one reached through an attacker-controlled redirect or a fetched URL, streams bytes indefinitely until the BEAM node is killed by the operating system out-of-memory handler. The chunk-extension variant is reached after a valid status line and a complete, valid header section, so an intermediary inspecting only headers sees an ordinary 200 response.
This issue affects mint: from 0.1.0 before 1.10.0.
### Summary
When decoding a compressed response body (`gzip`, `deflate`, `br`, or `zstd`), HTTPX2 fully decompressed each network read before yielding content to the application. A small compressed input could therefore cause a large intermediate memory allocation, even when the application streamed the response to keep memory usage bounded.
### Details
HTTPX2's default transport reads the socket in pieces of up to 64 KiB. Before `2.12.0`, each piece was inflated completely into one intermediate allocation before any decompressed bytes were yielded.
At DEFLATE's maximum compression ratio of roughly 1032:1, a 64 KiB compressed chunk can expand to about 64 MiB in one allocation. Brotli and Zstandard responses can cause similarly large amplification. Streaming the response did not prevent these transient allocations.
### Impact
Applications that fetch resources from untrusted or attacker-influenced servers - such as webhook receivers, link unfurlers, crawlers, SSRF-reachable fetchers, and redirect followers - can experience memory pressure or out-of-memory termination when processing a malicious compressed response. No authentication or user interaction is required beyond issuing a request to the server.
### Mitigation
Upgrade to HTTPX2 `2.12.0` or later. Patched versions decompress responses incrementally with bounded intermediate buffers, including responses with multiple content encodings.
LiteLLM is a proxy server (AI Gateway) to call LLM APIs in OpenAI (or native) format. Prior to versions 1.88.6 and 1.96.2, any authenticated LiteLLM proxy user could redirect an outbound provider call to a destination the user controls and cause the proxy to send its configured provider credentials to that destination. Request validation in litellm/proxy/auth/auth_utils.py, litellm/proxy/common_request_processing.py, litellm/proxy/health_endpoints/_health_endpoints.py, litellm/proxy/image_endpoints/endpoints.py, and litellm/proxy/litellm_pre_call_utils.py used incomplete checks that did not cover every sensitive parameter or inspect equivalent values across nested request fields, path values, and bracket-notation form data. Routing and credential parameters including api_base, base_url, model_list, fallbacks, and litellm_credential_name could therefore be applied without clearing the operator's stored key, exposing upstream provider credentials and other configured secrets and permitting server-side requests to internal services reachable by the proxy. This issue is fixed in versions 1.88.6 and 1.96.2.
Open edX Platform enables the authoring and delivery of online learning at any scale. Prior to commit 00b7c3c, the endpoint accepts user-supplied files[].url, performs a server-side fetch using "requests.get(url, allow_redirects=True)". The fetched bytes are then returned inside a ZIP response. This enables SSRF with response exfiltration. Redirect-following is enabled, and there is no timeout in the vulnerable fetch path. This issue has been patched via commit 00b7c3c.
The Yoast SEO Premium WordPress plugin before 27.6.1 does not sanitize control characters from redirect origins before writing them to the site's Apache configuration file when the file-based redirect mode is enabled, and the redirect-creation endpoint is reachable by users with only Author-level access. This allows such users to inject arbitrary newline-delimited Apache directives into the root .htaccess file. On Apache servers that honour PHP directives, the injection can be chained with the user's own media upload (a polyglot image carrying a PHP payload) and an auto_prepend_file directive to achieve Remote Code Execution.
The Broken Link Checker plugin for WordPress is vulnerable to Stored Cross-Site Scripting via Comment Author URL / Link Log in all versions up to, and including, 2.4.13 due to insufficient input sanitization and output escaping. This makes it possible for unauthenticated attackers to inject arbitrary web scripts in pages that will execute whenever a user accesses an injected page. Exploitation requires an administrator to perform the plugin's standard dismiss-and-recheck workflow on a link submitted by the attacker via the WordPress comment author URL field, after which the attacker's HTTP server issues a redirect to a URL containing an HTML/JavaScript payload that is stored verbatim in the link log.
A vulnerability in the web-based management interface of HPE Networking Fabric Composer could allow an unauthenticated remote attacker to redirect users to an arbitrary URL.
URL Redirection to Untrusted Site ('Open Redirect') vulnerability in ash-project ash_typescript allows an attacker who controls a path-parameter value to redirect a generated client's request, and the credentials attached to it, to an unintended route or an external origin.
The URL builders in lib/ash_typescript/typed_controller/codegen/route_renderer.ex replace each :param placeholder with a bare template interpolation and never call encodeURIComponent, so the value reaches executeTypedControllerRequest raw. A value containing ../ is normalised away by the fetch URL resolver and reaches a different route, while ? or # truncates the path and can smuggle or override query parameters. For a route whose path begins with a parameter, a value such as /evil.example.com/x yields the protocol-relative URL //evil.example.com/x, sending the request and the credentials from TypedControllerConfig to an attacker-controlled host. Nothing constrains the value at runtime: get_path_param_type/2 emits only a TypeScript type, which is erased.
The query-string path is unaffected, since URLSearchParams.set encodes its own values.
This issue affects ash_typescript: from 0.15.0 before 0.18.0.
Joomla Extension - joomshaper.com - Open Redirect via Base64 Return Parameter in Helix Ultimate < 2.2.10 - Return redirect parameters accepted arbitrary Base64 strings without verifying whether the resolved target was an internal site URL via Uri::isInternal.
CVE-2026-16947 is a critical Server-Side Request Forgery (SSRF) vulnerability in the Total processing card payments for WooCommerce WordPress plugin up to version 7.3. The plugin fails to validate user-supplied paths before using them to build server-side verification requests and does not verify the authenticity of responses. This allows unauthenticated attackers to redirect verification requests to arbitrary hosts, potentially disclosing merchant payment-gateway credentials and forging success responses that mark arbitrary WooCommerce orders as paid.
CVE-2026-33604 is a medium-severity vulnerability affecting Dovecot mail servers that can be exploited when an attacker causes Dovecot to relay a message, such as via Sieve redirect or submission relay. The attacker crafts a message body line ending that bypasses outbound protections designed to prevent message content from being interpreted as SMTP commands. This can lead to SMTP smuggling on downstream mail servers that have not patched the underlying SMTP vulnerability, allowing injection of spoofed email commands. No public exploits are known, and mitigation involves updating to a non-vulnerable version and ensuring receiving mail servers reject bare carriage returns in message data.
CVE-2026-82247 is a high-severity vulnerability in GitoxideLabs' gitoxide project affecting the gix-url crate (<= 0.32.0) and gix-transport (<= 0.49.0). The issue arises from a non-compliant URL parser that mishandles the authority component, allowing an attacker to craft malicious HTTP redirect responses. This flaw causes gitoxide to send HTTP Basic Authorization credentials to an unintended host, potentially exposing sensitive credentials. Fixes are available in gix-url 0.37.1 and gix-transport 0.58.1.
WWBN AVideo versions through 30.0 (and master up to commit 4cb576e) contain a cross-site request forgery (CSRF) vulnerability in the plugin/Live/myLiveControls.save.json.php endpoint. This endpoint processes certain parameters via a GET request without enforcing CSRF tokens or origin checks, relying only on user login status. An attacker can exploit this by tricking a logged-in streamer into visiting a malicious page, which silently changes live-channel viewer redirect settings to redirect viewers to phishing sites or display spoofed messages.
A Server-Side Request Forgery (SSRF) vulnerability (CVE-2026-75871) was found in the GitLab AI Gateway component affecting multiple versions from 18.10 through 19.2.2. This flaw allowed an authenticated user with Duo Agent Platform access to redirect outbound model requests to attacker-controlled endpoints by manipulating the HTTP Host header in inline flow configurations. Exploitation could lead to disclosure of sensitive Google Cloud Vertex service credentials and private signing keys. The vulnerability has a high severity score of 8.2 and affects the cloud-hosted GitLab AI Gateway service. GitLab has remediated this issue in their cloud environment.