CVE-2026-74049 is an Execution After Redirect (EAR) vulnerability in Apache Tomcat affecting multiple versions from 7.0.0 through 11.0.26. The flaw allows execution of code after an HTTP redirect, potentially leading to partial compromise of confidentiality and integrity. The issue is fixed in Apache Tomcat versions 11.0.27, 10.1.61, and 9.0.123.
Between April and July 2026, attackers compromised AOMEI's update servers to distribute malware via brief modifications to configuration files used by AOMEI Backupper's built-in promotional and notification features. The attackers altered two configuration files to redirect software updates to malicious payloads, delivering a downloader named CROSSROAD and a backdoor called SHINYROAD. These changes were short-lived, lasting only minutes, making detection difficult. The malware established persistence and enabled remote control of infected systems. Additionally, a technique to steal Windows authentication hashes was observed during one attack window. Affected organizations spanned multiple countries and sectors. AOMEI has since upgraded its servers, patched vulnerabilities, and taken corrective actions, though details on the initial breach vector remain undisclosed.
CVE-2026-112251 is an open redirect vulnerability in the antoinersx clawhost product up to version 0.0.45. The flaw exists in the handleRequest function of the Reverse Proxy component, where manipulation of the token argument can cause an open redirect. The vulnerability can be exploited remotely and public exploit code is available. The vendor has not responded to disclosure attempts and no patch information is provided.
Bulletin ID: 2026-054-AWS Scope: AWS Content Type: Important (requires attention) Publication Date: 07/14/2026 13:00 PM PDT Description: AWS HealthLake MCP Server (awslabs.healthlake-mcp-server) is a Model Context Protocol server that enables AI assistants to interact with AWS HealthLake FHIR datastores. We identified CVE-2026-15643, a server-side request forgery in the pagination handling component in AWS awslabs.healthlake-mcp-server before 0.0.14 on all platforms might allow a remote authenticated user to exfiltrate AWS temporary security credentials to an arbitrary endpoint via a crafted next_token parameter. The server does not validate that pagination URLs point back to the expected HealthLake endpoint, allowing an actor to redirect subsequent requests to an actor-controlled server. Impacted versions: < 0.0.14 Please refer to the article below for the most up-to-date and complete information related to this AWS Security Bulletin.
Exposure of Sensitive Information to an Unauthorized Actor vulnerability in Apache Camel HTTP component.
This issue affects Apache Camel: from 4.0.0 before 4.18.5, from 4.19.0 before 4.22.1.
Two paths handed credentials to a redirect target, which is a host chosen by the remote server rather than by the route, once followRedirects=true. OAuth2ClientConfigurer registers its interceptor with addRequestInterceptorFirst, and HttpClient runs protocol-level request interceptors inside ProtocolExec, which sits below RedirectExec in the exec chain; the interceptor therefore ran again for every redirect hop and re-attached Authorization: Bearer to whatever host the Location header named. Separately, credentials were registered against an AuthScope matching any host, so basic and digest credentials were presented to a redirect target as well. A remote endpoint - or anyone who can influence its responses - could therefore collect the bearer token or the configured credentials simply by answering with a redirect to a host it controls.
Upgrade to Apache Camel 4.23.0, which fixes the issue. Users on the 4.18.x LTS releases stream should upgrade to 4.18.5. Users on the 4.22.x LTS releases stream should upgrade to 4.22.1. Credentials are now sent only to the authority the endpoint was configured with, and are not re-attached when a redirect crosses to another host. For deployments that cannot upgrade immediately, set followRedirects=false on endpoints that carry credentials, and handle any redirect explicitly in the route so that the destination is chosen by the route rather than by the remote server.
CVE-2026-84178 is a Cross-Site Request Forgery (CSRF) vulnerability in the Apache Camel OAuth component affecting versions from 4.11.0 before 4.18.5 and from 4.19.0 before 4.22.1. The flaw allows an attacker to redeem an authorization code obtained in any browser at the callback, associating it with the victim's session, which can silently sign the victim in as the attacker-controlled identity. This also enables an open redirect from a trusted origin due to unvalidated post-authentication redirect targets. The issue is fixed in Apache Camel versions 4.18.5 and 4.22.1 and later.
A vulnerability was determined in diem-project diem up to 116974edfb9a5b8bd69cb13586dc62bcdbb485ad. This affects an unknown part of the file dmCorePlugin/plugins/dmUserPlugin/modules/dmUser/lib/BasedmUserActions.class.php of the component Sign-In. This manipulation of the argument Referer causes open redirect. The attack is possible to be carried out remotely. The exploit has been publicly disclosed and may be utilized. This product adopts a rolling release strategy to maintain continuous delivery. Therefore, version details for affected or updated releases cannot be specified. The project was informed of the problem early through an issue report but has not responded yet.
CVE-2026-109937 is an open redirect vulnerability in the Otter Blocks WordPress plugin versions before 3.2.3. The plugin fails to validate that a user-supplied return URL belongs to the site when building the return destination of a Stripe Checkout session. This allows unauthenticated attackers to redirect users who complete or cancel checkout to arbitrary external URLs.
CVE-2026-111555 is a vulnerability in the luksmeta component of Red Hat Enterprise Linux 10 involving improper boundary validation of metadata slots. This flaw allows an attacker with the capability to supply or modify a disk header to redirect wipe or load operations outside the intended metadata area. Exploitation requires privileged access to raw block devices or tricking an administrator into processing a crafted disk image. Successful exploitation can cause persistent data loss and corrupted storage by overwriting or zeroing encrypted payload data.
Nezha versions from 2.1.0 up to but not including 2.3.15 contain a host header injection vulnerability in the mintTransferTool component. This vulnerability allows attackers who can control the Host header in a victim's MCP request to manipulate file upload and download URLs. Exploitation could enable redirection of file uploads or capture and replay of one-time download tokens to exfiltrate files. The vulnerability has a medium severity with a CVSS 4.0 score of 6.3.
Node.js HTTP client library undici versions 7.0.0 through 7.30.0 and 8.0.0 through 8.12.1 have a cache poisoning vulnerability when an originless Agent uses redirect and cache interceptors composed in a specific order with a shared cache store. This flaw allows an attacker controlling a redirect target to poison the cache under a trusted URL or disclose private data by serving cached responses to unauthorized users. The issue is fixed in versions 7.30.1 and 8.12.2 by verifying origin consistency and preserving cache-control policies. Users should upgrade or apply recommended workarounds to mitigate the risk.
Scoold is a Q&A and a knowledge sharing platform for teams. Prior to 1.69.1, the getBackToUrl() method in src/main/java/com/erudika/scoold/utils/HttpUtils.java validates the backto and returnto parameters with Strings.CI.startsWith against the configured server URL. An attacker can supply an absolute URL whose hostname begins with the legitimate hostname, causing URI.resolve() to retain the attacker URL and the prefix check to accept it. A victim who follows the crafted sign-in link can be redirected to an attacker-controlled domain after authentication, enabling phishing and possible credential or token theft. This issue is fixed in version 1.69.1.
CVE-2026-79825 is a heap-based buffer overflow vulnerability in Hewlett Packard Enterprise's HPE NonStop NDSREST component. This flaw could corrupt the resume-execution address, potentially allowing an attacker to redirect execution flow. The vulnerability has a CVSS 3.1 score of 7.1, indicating high severity. No specific affected versions or patch information are provided. There are no known exploits in the wild at this time.
Roo Code versions up to 3.54.0 have a command approval bypass vulnerability in the getCommandDecision() function. This flaw allows attackers to prefix denied shell commands with a bare >& redirect, causing the commands to be auto-approved and executed. Indirect prompt injection can be used to manipulate the allowlist to match a redirect target such as echo, while the shell executes the originally denied command on the developer's machine. The vulnerability has a high severity score of 7.7.
### Summary
`dio_http2_adapter` follows HTTP `Location` redirects without stripping sensitive request headers when the redirect target is a different origin. An attacker who can cause any origin server to return a cross-origin `302` redirect receives the victim's `Authorization`, `Cookie`, and `Proxy-Authorization` headers verbatim. This vulnerability has a CVSS v3.1 base score of **7.5 (High)** because `followRedirects` is enabled by default, no authentication is required to exploit it, and the confidentiality impact is high.
### Details
When `Dio` is configured to use `Http2Adapter`, the adapter's internal `_fetch` method constructs HTTP/2 request headers by unconditionally copying all entries from `options.headers`:
```dart
// plugins/http2_adapter/lib/src/http2_adapter.dart:111
headers.addAll(
options.headers.entries.map((entry) {
...
return Header.ascii(entry.key.toLowerCase(), v);
}).toList(),
);
```
On receiving a `3xx` response, the adapter reads the `Location` header and resolves the redirect target URI:
```dart
// plugins/http2_adapter/lib/src/http2_adapter.dart:254-263
final url = responseHeaders.value('location');
final uri = Uri.parse(url ?? '');
final String path = resolveRedirectUri(options.uri, uri).toString();
return _fetch(options.copyWith(path: path, maxRedirects: --options.maxRedirects), ...);
```
`options.copyWith` is called without an explicit `headers` argument; `dio/lib/src/options.dart:629` therefore preserves the full original header map via `headers ?? Map.from(this.headers)`. `resolveRedirectUri` (`http2_adapter.dart:290`) returns an attacker-controlled cross-origin URI without any origin comparison. The combination means that on every redirect, the full set of original sensitive headers — including `Authorization`, `Cookie`, and `Proxy-Authorization` — is forwarded to the new authority with no sanitization.
**Data flow (source → sink):**
1. `dio/lib/src/dio_mixin.dart:383` — public `Dio.request<T>(String path, ...)` entry point.
2. `dio/lib/src/options.dart:331` — base and per-request headers merged into `RequestOptions`.
3. `dio/lib/src/dio_mixin.dart:596` — `httpClientAdapter.fetch(reqOpt, ...)` dispatches to `Http2Adapter`.
4. `plugins/http2_adapter/lib/src/http2_adapter.dart:254` — `Location` header is read from the network response (attacker-controlled source).
5. `plugins/http2_adapter/lib/src/http2_adapter.dart:258` — redirect target URI resolved; cross-origin check absent.
6. `plugins/http2_adapter/lib/src/http2_adapter.dart:260` — `options.copyWith(path: path, ...)` called without `headers` override.
7. `dio/lib/src/options.dart:629` — `copyWith` preserves `Map.from(this.headers)` — all sensitive headers retained.
8. `plugins/http2_adapter/lib/src/http2_adapter.dart:111` — preserved headers emitted verbatim to the cross-origin HTTP/2 request (sink).
**Suggested patch** — strip sensitive headers before following a cross-origin redirect:
```diff
--- a/plugins/http2_adapter/lib/src/http2_adapter.dart
+++ b/plugins/http2_adapter/lib/src/http2_adapter.dart
+ static const _sensitiveRedirectHeaders = {
+ 'authorization',
+ 'cookie',
+ 'proxy-authorization',
+ };
+
- final String path = resolveRedirectUri(options.uri, uri).toString();
+ final redirectUri = resolveRedirectUri(options.uri, uri);
+ final redirectOptions = options.copyWith(
+ path: redirectUri.toString(),
+ maxRedirects: --options.maxRedirects,
+ );
+ if (!_sameOrigin(options.uri, redirectUri)) {
+ redirectOptions.headers.removeWhere(
+ (name, _) => _sensitiveRedirectHeaders.contains(name.toLowerCase()),
+ );
+ }
return _fetch(
- options.copyWith(path: path, maxRedirects: --options.maxRedirects),
+ redirectOptions,
list != null ? Stream.fromIterable(list) : null,
cancelFuture,
redirects,
);
+
+ static bool _sameOrigin(Uri a, Uri b) =>
+ a.scheme == b.scheme && a.host == b.host && a.port == b.port;
```
### PoC
The following steps reproduce the vulnerability using two local HTTP/2 cleartext (h2c) servers inside an isolated Docker container (no external network required).
**Prerequisites:**
- Docker installed and accessible.
- Repository checked out at the path used as the build context.
**Build and run:**
```bash
# From the repository root (github_web_81_cfug__dio/)
docker build -f vuln-001/Dockerfile -t dio-vuln-001:poc .
docker run --rm --network none dio-vuln-001:poc
```
**What the container does:**
1. Starts an *origin* h2c server on `127.0.0.1:18081` that immediately returns `302 Location: http://127.0.0.1:18082/capture`.
2. Starts an *attacker* h2c server on `127.0.0.1:18082` that logs every received header.
3. Executes the following Dart exploit:
```dart
final dio = Dio()
..httpClientAdapter = Http2Adapter(ConnectionManager());
await dio.get(
'http://127.0.0.1:18081/start',
options: Options(headers: {
'Authorization': 'Bearer SECRET
CVE-2026-109160 is an open redirect vulnerability in PublicCMS version 5.202608.a. The issue exists in the SafeConfigComponent.getSafeUrl function within the pay Endpoint component. Manipulating the returnUrl argument can cause an open redirect, which can be triggered remotely. The vulnerability has a medium severity rating with a CVSS score of 5.3. The vendor has not responded to the disclosure, and no patch or remediation is currently confirmed.
Admidio versions 4.0.12 through 4.3.17 and 5.0.0 before 5.0.15 contain a reflected cross-site scripting (XSS) vulnerability in the system/redirect.php component. This vulnerability allows unauthenticated attackers to inject JavaScript code via the url GET parameter due to an incomplete fix of a previous vulnerability (CVE-2021-43810). The attack involves crafting a javascript: URL with a decoy http:// segment that bypasses validation and executes script in the context of the Admidio origin when a victim clicks the redirect link.
Open WebUI versions from 0.7.0 up to but not including 0.11.4 have a cross-origin message handling vulnerability in the SyncStatsModal component. This flaw allows any website to steal a signed-in user's session token by sending unvalidated verify:chat messages. Attackers can exploit a path traversal in the chat ID to redirect authenticated requests to the authentication endpoint, thereby obtaining the victim's JWT token and gaining full API access. The vulnerability is fixed in version 0.11.4.