Jul 31, 2026·6 min read·22 visits
A vulnerability in linuxfabrik-lib prior to 6.0.0 forwards custom authentication headers (such as X-Auth-Token or X-Api-Key) during cross-origin redirects, allowing remote attackers to exfiltrate administrative credentials.
CVE-2026-67435 is a security vulnerability in the linuxfabrik-lib Python library prior to version 6.0.0. When performing HTTP requests with follow_redirects enabled, custom authentication headers (such as X-Auth-Token or X-Api-Key) are forwarded during cross-origin redirects. A malicious or compromised server can leverage this behavior to capture sensitive monitoring and administrative credentials, leading to potential unauthorized access and Server-Side Request Forgery (SSRF).
The component linuxfabrik-lib is a utility library developed by Linuxfabrik GmbH, primarily used to support enterprise monitoring plugins. Within this library, the HTTP client utility lib.url.fetch() streamlines network interactions by wrapping the HTTP client library httpx. These utilities are routinely deployed within automation scripts and infrastructure monitoring frameworks to query internal networks and device endpoints.
By default, lib.url.fetch() configures the HTTP client with automatic redirection capabilities (follow_redirects=True). Because monitoring configurations frequently rely on persistent authentication mechanisms to query endpoints, sensitive tokens are passed via HTTP headers. This exposure creates a broad attack surface if a monitored endpoint is compromised or misconfigured to yield redirection paths.
The vulnerability belongs to the CWE-200 (Exposure of Sensitive Information) and CWE-918 (Server-Side Request Forgery) classes. Under certain conditions, a target device can coerce the client library into leaking critical administrative credentials to arbitrary external domains. This bypasses the security zone separation established within monitoring environments.
The underlying flaw arises from how the HTTP client engine manages cross-origin redirects. While standard HTTP libraries, including httpx, strip default authentication headers such as Authorization or Cookie upon encountering cross-origin HTTP 3xx redirects, they lack context regarding proprietary or application-specific headers. Consequently, custom headers remain attached to the redirected request.
In infrastructure monitoring contexts, plugins frequently query out-of-band management platforms, such as Redfish APIs. These APIs rely on proprietary authentication schemes, using custom headers like X-Auth-Token or vendor-specific API keys like X-Api-Key. Because these headers do not match the standardized standard list of credential headers, the client continues to transmit them when executing cross-origin redirection hops.
An attacker who can influence the destination of the HTTP query can manipulate the host to return a 302 Found or 307 Temporary Redirect response. If the client automatically follows the redirect, the custom authentication header is dispatched directly to the target system controlled by the attacker. This configuration results in direct credential exposure without requiring complex exploit payloads or privilege escalations.
The vulnerability was remediated in commit 6573ff9347e541200305d278d2663d2e54e052ff by implementing custom header filtering on redirect events. The patch introduces a static list of trusted transport headers, designated as _REDIRECT_SAFE_HEADERS. These headers are deemed safe for transfer across security domains because they do not carry user-specific credentials.
# Safe headers to keep when redirecting across origins
_REDIRECT_SAFE_HEADERS = frozenset({
'accept',
'accept-encoding',
'accept-language',
'connection',
'content-length',
'content-type',
'host',
'transfer-encoding',
'user-agent',
})To determine whether a redirection hop represents a cross-origin boundary crossing, the developers implemented origin-matching logic. The function evaluates if the scheme, host, or port changes during transit, excluding standard HTTP-to-HTTPS upgrades on the same host.
def _leaks_credentials_on_redirect(src, dst):
# Compare source and destination origins
same_origin = (
src.scheme == dst.scheme
and src.host == dst.host
and _default_port(src) == _default_port(dst)
)
if same_origin:
return False
# Allow standard http to https upgrades
https_upgrade = (
src.host == dst.host
and src.scheme == 'http'
and _default_port(src) == 80
and dst.scheme == 'https'
and _default_port(dst) == 443
)
return not https_upgradeTo apply this logic to the httpx.Client without modifying the global package namespace, the patching code interceptively shadows the private _redirect_headers method of the instance. If a cross-origin transfer is detected, non-whitelisted headers are explicitly deleted.
def _install_safe_redirect_stripping(client):
original = getattr(client, '_redirect_headers', None)
if original is None:
return client
def _redirect_headers(request, url, method):
headers = original(request, url, method)
if _leaks_credentials_on_redirect(request.url, url):
for name in list(headers.keys()):
if name.lower() not in _REDIRECT_SAFE_HEADERS:
del headers[name]
return headers
client._redirect_headers = _redirect_headers
return client> [!WARNING]
> While this patch effectively closes the vulnerability, it exhibits potential robustness issues. It monkey-patches _redirect_headers, a private internal method of the httpx module. Because private methods are subject to change in minor version updates of httpx, future modifications to the internal signature of httpx could disable the security wrapper without causing standard execution runtime errors.
An execution scenario involves an attacker targeting internal monitoring infrastructure. The attacker identifies a monitored target device or service that has been compromised, or whose DNS records can be spoofed. Alternatively, the target endpoint may allow user-supplied URI injection, permitting an attacker to manipulate the redirect destinations.
In the first stage, the monitoring agent initiates a routine poll to the target device using the vulnerable library. The request includes custom credentials, such as an X-Auth-Token header containing administrative session data. Because the device is compromised or configured to act maliciously, it responds with an HTTP redirect code pointing to http://evil.local.
The vulnerable lib.url.fetch() utility intercepts the redirect and processes the redirection automatically. It instantiates a new HTTP request targeting http://evil.local but fails to strip the custom header. Upon receipt, the attacker-controlled server extracts the X-Auth-Token value from the request headers, granting the attacker administrative privileges over the monitored system.
The potential consequences of CVE-2026-67435 are severe, particularly because it directly exposes out-of-band management endpoints. These platforms control server hardware, firmware updates, and core hypervisor systems. If an administrative Redfish token is leaked, attackers can gain console access or modify hardware configurations.
The vulnerability is assigned a CVSS v4.0 base score of 6.0, indicating a Medium severity issue. While the attack is relatively simple once a redirect path is established, the exploitation is bounded by the need to intercept or manipulate target network responses. The Confidentiality vector is rated High because complete session tokens are exposed.
Because this vulnerability is not currently listed in the CISA KEV catalog and lacks weaponized exploitation scripts, the immediate exploitation threat remains low. However, custom automation scripts that interact with third-party APIs represent an overlooked vector for silent credential harvest.
The primary remediation path requires upgrading linuxfabrik-lib to version 6.0.0 or higher. This version contains the dynamic patching wrapper that intercepts and filters redirected request headers, safeguarding custom security context during origin crossings.
If patching cannot be executed immediately, administrators must secure their execution environment using secondary controls. Egress firewalls on monitoring agent hosts should be restricted to prevent outgoing traffic to unauthorized IP addresses and domains. Monitoring agents should only communicate with known, whitelisted internal resources.
Additionally, developers can configure the library to disable redirection parsing globally when executing authenticated HTTP queries. Passing follow_redirects=False within calling functions prevents the client library from automatically navigating redirect pathways, neutralizing the primary attack vector.
CVSS:4.0/AV:N/AC:L/AT:P/PR:L/UI:N/VC:H/VI:L/VA:N/SC:N/SI:N/SA:N| Product | Affected Versions | Fixed Version |
|---|---|---|
linuxfabrik-lib Linuxfabrik GmbH | < 6.0.0 | 6.0.0 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-200, CWE-918 |
| Attack Vector | Network |
| CVSS v4.0 Score | 6.0 |
| EPSS Score | 0.00286 (Percentile: 20.87%) |
| Impact | Credential Exposure |
| Exploit Status | None |
| KEV Status | Not Listed |
The product exposes sensitive information to an actor who is not authorized to have access to that information.
CVE-2026-126295 (also tracked as GHSA-fg9w-wfp5-j933) is a path confinement bypass vulnerability in the Natural Language Toolkit (NLTK) affecting versions 3.10.0 prior to 3.10.4. The flaw resides in nltk/parse/bllip.py within the BllipParser class and its factory method BllipParser.from_unified_model_dir(). Unlike sibling tool wrappers in NLTK that enforce data-root confinement via the nltk.pathsec module, BllipParser passes caller-supplied filesystem paths directly into the third-party bllipparser native C extension without validation. When an application passes untrusted input as model paths or directories to BllipParser, an attacker can force the native extension to open arbitrary files on the local filesystem. This leads to information disclosure through parser diagnostic oracles, local model tampering via shared directories, and denial of service by hanging worker threads on blocking special files (such as FIFOs or device nodes) or exhausting memory via oversized files.
CVE-2026-126300 (GHSA-ffr9-mgrr-wcvr) is an inefficient algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) Python library affecting versions 3.2.5 prior to 3.10.4. The flaw resides in the quote-restoration routine of TreebankWordTokenizer.span_tokenize and NLTKWordTokenizer.span_tokenize, where repeated calls to list.pop(0) over matched quote tokens introduce quadratic O(n^2) time complexity. An unauthenticated remote attacker who supplies input containing long sequences of double-quote characters can exhaust CPU resources and degrade service availability.
The Natural Language Toolkit (NLTK) versions 3.6 through 3.10.3 contain an algorithmic complexity vulnerability in the LegalitySyllableTokenizer.tokenize method. When processing tokens composed of continuous runs of vowels, an unguarded string reversal and set membership lookup loop executes in quadratic time relative to the input token length. Remote attackers capable of submitting arbitrary text to applications utilizing this tokenizer can trigger sustained single-core CPU exhaustion and application-level denial of service.
CVE-2026-126304 is a symlink path traversal vulnerability (CWE-59) in the Natural Language Toolkit (NLTK) versions 3.10.0 prior to 3.10.4. The YCOECorpusReader class constructs internal sub-readers for the 'psd' and 'pos' subdirectories using FileSystemPathPointer.join(), which relies exclusively on lexical string-prefix validation rather than canonical path resolution. An attacker who supplies a crafted YCOE corpus containing symbolic links in place of the 'psd' or 'pos' subdirectories can bypass directory confinement and read arbitrary files from sibling corpora or sensitive directories within the NLTK data sandbox.
CVE-2026-128077 (GHSA-r99w-jh2x-3mg9) is an authorization bypass and interpretation conflict vulnerability affecting Nuxt and its underlying @nuxt/nitro-server package in versions 4.6.0 through 4.6.3. When an incoming HTTP request path begins with a double forward slash (e.g., //x/admin), the WHATWG URL parser within the Nuxt server-side page renderer interprets the initial segment as a network host/authority and resolves the remaining path (/admin) against the application's page router. Because Nitro server middleware, route-scoped serverHandlers, and Nitro routeRules evaluate the unparsed request path (//x/admin), path-based access controls, redirects, and security header policies configured for /admin fail to match and are bypassed.
Prior to version 2.10.2, the sqlite3-ruby gem explicitly cast 64-bit Ruby string lengths (long) to 32-bit signed integers (int) when invoking the underlying SQLite C API. On 64-bit platforms, providing a string of 4 GiB (2^32 bytes) or larger causes integer truncation, instructing SQLite to process only a prefix of the string. This flaw affects SQL query preparation, bound parameter values, and return values from custom Ruby-defined SQL functions and aggregates, allowing trailing SQL clauses such as WHERE restrictions to be silently dropped under specific conditions.