A security update for SUSE's python3 packages addresses multiple vulnerabilities including denial of service, stack buffer overflow, memory exhaustion, credential leakage, and file extraction flaws. These issues affect components such as xml.etree.ElementPath, zipfile decompression, urllib.request, CSV dialect sniffing, and tarfile extraction filters. The update also includes an upgrade to bundled setuptools wheels.
A code injection vulnerability exists in WongKinYiu yolov9 version 0.1 within the DetectMultiBackend.__init__ function in models/common.py, specifically in the ONNX Metadata Handler component. This vulnerability arises from manipulation of the argument names/stride. Remote exploitation is possible, and a public exploit disclosure exists. The project has been informed but has not yet responded or issued a fix. The CVSS 3.1 base score is 6.3, indicating a medium severity impact with low confidentiality, integrity, and availability impacts.
A vulnerability identified as CVE-2026-112006 affects specific versions of the Python OpenTelemetry exporter component (opentelemetry-exporter-otlp-proto-http). The affected versions include several builds around 1.38.0 through 1.44.0. The CVSS 3.1 base score is 6.5, indicating a medium severity issue with network attack vector, high attack complexity, no privileges required, and no user interaction. The impact includes high confidentiality loss, low integrity loss, and no availability impact.
CVE-2026-110666 is a path traversal vulnerability in cemtan sar2html version 4.0.0. The flaw exists in the updateDb function of the sar2html.py file related to file upload handling. This vulnerability allows remote attackers to manipulate file paths, potentially accessing unauthorized files. The issue was reported early to the project, but no response or fix has been provided yet. The vulnerability has a CVSS 4.0 base score of 6.9, indicating medium severity.
A double free vulnerability exists in the OpenSSH client used in Red Hat AI Base Images 3.3.6 (Spyre) when operating in FIPS mode during Diffie-Hellman Group Exchange (DH-GEX) key exchange. This flaw can be exploited by a malicious SSH server to cause client-side process termination, resulting in a denial of service. The impact is limited to availability of the SSH client process and does not lead to broader system compromise. Mitigation involves disabling the vulnerable key exchange algorithm in the SSH client configuration.
A security advisory from Red Hat addresses multiple vulnerabilities affecting Red Hat AI Base Images 3.2.5 (Spyre), including CVE-2026-8461 and several others. One notable flaw is an integer overflow in FFmpeg's processing of Common Encryption (CENC) subsample data, which can lead to out-of-bounds writes causing information disclosure, data corruption, or denial of service. This vulnerability requires local processing of specially crafted media files and is rated moderate by Red Hat. No fixes are currently available for these issues in the Red Hat AI Base Images 3.2.5. Red Hat OpenShift AI and related products that bundle FFmpeg are affected, but the cloud.redhat.com ffmpeg component is not vulnerable. Red Hat is pursuing fixes through product streams.
### 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
The Salty documentation repository builds and deploys the docs.saltbox.dev website. Prior to commit 649c9aea2daef1168eeb0415b44e65dbbde9f220, .github/workflows/trigger-pr-build.yml records an untrusted fork commit in the pr_info artifact, and the secret-bearing workflow_run job in .github/workflows/build-pr.yml checks out that commit before running pip install -r requirements.txt. A fork pull request can therefore supply attacker-authored setup.py or PEP 517 build hooks whose installation code executes in the privileged base-repository workflow with CF_API_TOKEN, GH_TOKEN, MKDOCS_GIT_COMMITTERS_APIKEY, and a write-capable GITHUB_TOKEN, allowing secret disclosure and follow-on compromise. The vulnerability is not caused by the repository-fork guard, and the demonstrated path requires attacker control of fork content rather than merely the artifact metadata. This vulnerability is fixed with commit 649c9aea2daef1168eeb0415b44e65dbbde9f220.
Virtualenvwrapper versions before 4.8.4_2 and 6.1.1_3 improperly handle line boundaries in the 'prompt' value written to pyvenv.cfg, allowing crafted prompts containing line breaks to inject or overwrite configuration keys such as 'home'. This can mislead tooling that relies on 'home' to locate the base interpreter. The vulnerability requires the prompt to be influenced by external, untrusted input, such as CI job templates or environment variables. A patch is available that sanitizes line boundaries by collapsing them to spaces during serialization.
CVE-2026-11940 is a vulnerability in the Python standard library tarfile.extractall() function. It allows a remote attacker to craft a malicious archive that bypasses security filters by using a hardlink referencing a symlink, enabling files to be read or written outside the intended extraction directory. This can lead to information disclosure or arbitrary file modification. The flaw affects Red Hat AI Base Images 3.5.3 (Gaudi) as shipped in Red Hat OpenShift AI. No fix is currently available from Red Hat for this issue.