Apache CXF contains a vulnerability in the STSTokenValidator component where the validation result of a SAML assertion signed by a trusted certificate is stored in a shared object accessible by all requests. This allows a remote, unauthenticated attacker to send a forged assertion signed with an untrusted certificate that could be mistakenly accepted as trusted during concurrent request processing. The issue affects services using STSTokenValidator without the alwaysValidateToSts setting enabled. Fixed versions 4.2.4, 4.1.9, and 3.6.13 address this vulnerability.
Apache CXF versions prior to 4.2.4, 4.1.9, and 3.6.13 contain a vulnerability in the STSTokenValidator and Security Token Service (STS) where validated security tokens are cached using a non-cryptographic 32-bit hash. This allows an attacker to craft a token that collides with a cached hash, bypassing password validation and signature verification, potentially authenticating as another user and obtaining STS-signed tokens for that identity. The issue is fixed in versions 4.2.4, 4.1.9, and 3.6.13.
Apache CXF's FIQL query parser has a vulnerability where it can consume excessive CPU resources when processing long strings without operators. This can lead to denial of service by slowing or stopping other requests. The issue is fixed by limiting FIQL expressions to 4 KiB by default. Users should upgrade to versions 4.2.4, 4.1.9, or 3.6.13 or later to mitigate this risk.
Apache CXF contains an open redirect vulnerability in its OIDC relying-party component that allows redirection to attacker-controlled URLs after authentication. This occurs because state parameters controlled by an attacker are used as redirect targets without proper validation. Both directly and double-encoded URLs can exploit this issue. Fixed versions 4.2.4, 4.1.9, and 3.6.13 address this vulnerability.
CVE-2026-78384 is a high-severity vulnerability in Apache CXF where the CompressionUtils.inflate() method decompresses attacker-controlled DEFLATE data without limiting the output size. This can cause a small crafted payload to expand to gigabytes on the heap, potentially leading to resource exhaustion. The flaw is exploitable via JWE decryption with zip=DEF and SAML redirect/POST binding token inflation, both occurring before trust validation. Fixed versions include 4.2.4, 4.1.9, and 3.6.13, which introduce a configurable maximum inflated-size cap to prevent excessive memory usage.
CVE-2026-73179 is a high-severity race condition vulnerability in Apache CXF's JPA OAuth2 authorization code grant provider. It allows a remote attacker to obtain multiple valid access tokens from a single authorization code by exploiting a time-of-check to time-of-use (TOCTOU) flaw in the non-atomic find-then-delete operation under READ_COMMITTED isolation. This issue is fixed in Apache CXF versions 4.2.4, 4.1.9, and 3.6.13.
CVE-2026-71575 is a critical vulnerability in Apache CXF affecting the OidcClientCodeRequestFilter component. Due to a milliseconds/seconds unit mismatch and inverted comparison polarity, the max_age authentication freshness check was ineffective. This flaw allows relying parties using setMaxAgeOffset to enforce re-authentication to bypass step-up authentication policies, accepting sessions of any age. The issue is fixed in Apache CXF versions 4.2.4, 4.1.9, and 3.6.13.
CVE-2026-71884 is a vulnerability in Legion of the Bouncy Castle Inc.'s BC-LTS-JAVA library versions 2.73.4 up to but not including 2.73.13. The native one-shot CTR packet cipher implementation did not validate that the input length fit within the counter space derived from the IV, causing the counter to wrap and the keystream to repeat. This results in two segments of the ciphertext being encrypted under the same keystream, allowing plaintext recovery without the key. The issue affects the native one-shot path only; other implementations validate the counter range properly. The vulnerability has a high severity with a CVSS 4.0 score of 8.2.
Memory overflow vulnerability leading to Remote Code Execution or Denial of Service Vulnerability in NetScaler ADC.
NetScaler ADC or NetScaler Gateway must be configured as a SAML SP or SAML IdP, subject to the following version-specific requirements:
* For the following versions: Applicable only when configured as a SAML IdP:
* NetScaler ADC and NetScaler Gateway between 14.1-73.37 and 14.1-73.41, inclusive
* NetScaler ADC 14.1-FIPS between 14.1-73.37 FIPS and 14.1-73.41 FIPS, inclusive
* NetScaler ADC and NetScaler Gateway between 13.1-64.23 and 13.1-64.28, inclusive
* NetScaler ADC 13.1-FIPS between 13.1-NDcPP 13.1-37.279 and 13.1- 37.282, inclusive
For the following versions: Applicable only when configured as a SAML SP or SAML IdP:
* NetScaler ADC and NetScaler Gateway before 14.1-73.37
* NetScaler ADC 14.1-FIPS before 14.1-73.37 FIPS
* NetScaler ADC and NetScaler Gateway before 13.1-64.23
* NetScaler ADC 13.1-FIPS before13.1-NDcPP 13.1-37.279
GnuTLS version 3.8.13 has an incomplete X.509 implementation that allows attackers who control a subordinate Certificate Authority to bypass cross-domain PKI restrictions and issue unauthorized certificates. This vulnerability affects specific Ubuntu package versions of gnutls26. The CVSS score is 3.7, indicating a low severity impact primarily on confidentiality. There are no known exploits in the wild and no patch information is provided in the source data.
amqp091-go is a Go AMQP 0.9.1 client. From 1.13.0 until 1.14.0, the frame-size mitigation from the prior allocation advisory can be bypassed before connection.tune completes because Connection.maxFrameSize uses zero for both the not-yet-negotiated and negotiated-unlimited states. A malicious or compromised AMQP peer can send a short body-frame header with a large declared payload length, causing ReadFrame and the body-frame parser to allocate attacker-selected memory before the payload is received or the frame's protocol state is rejected. The condition is reachable through public Open even when Config.FrameSize is set to the protocol minimum and can cause severe memory pressure, out-of-memory termination, or loss of the client process before authentication completes. This issue is fixed in version 1.14.0.
CVE-2026-106431 is an off-by-one out-of-bounds write vulnerability in the BSON bulk document writer component of the MongoDB C Driver. The flaw occurs when a document ends exactly at a specific buffer boundary, causing a single zero byte to be written just beyond the allocated heap memory. This can result in adjacent memory corruption or process termination if an attacker controls the size of serialized documents via the BSON bulk-writer API. The vulnerability affects MongoDB C Driver versions from 0.5.0 up to but not including 1.30.13, and from 2.0.0 up to but not including 2.5.6. The CVSS 4.0 base score is 5.9, indicating medium severity. No known exploits are reported in the wild, and no official patch links are provided in the data.
GnuTLS version 3.8.13 contains a vulnerability due to improper certificate validation that causes the application to accept certificates with invalid extensions. This flaw affects multiple specific versions of the gnutls26 package. The vulnerability has a high CVSS score of 9.1, indicating a critical impact on confidentiality and integrity. No vendor advisory or patch information is provided, so patch status is not confirmed.
GnuTLS version 3.8.13 contains a vulnerability where improper certificate validation causes the application to reject legitimate certificates. This results in a Denial of Service (DoS) condition affecting valid users. The issue does not impact confidentiality or integrity but causes availability disruption.
## Summary
When processing an attacker-controlled Protobuf schema, vulnerable versions of
`datamodel-code-generator` could write a generated weak-import stub outside the
intended `__weak_imports__` temporary directory. Absolute import paths and relative
paths containing `..` could escape this directory.
An attacker could create directories and new files at locations writable by the
process. Relative path traversal could also overwrite existing writable files
because the existence check and the stub write used different base directories.
An existing absolute target was skipped by the existence check.
Written content was limited to a generated Protobuf syntax declaration,
`syntax = "proto2";` or `syntax = "proto3";`, followed by a newline. This issue did
not provide fully attacker-controlled file contents, and direct arbitrary code
execution has not been demonstrated.
These filesystem side effects occurred before `protoc` ran. A subsequent
compilation error did not undo them. A user or CI job must process the
attacker-controlled schema for the issue to be triggered, whether the schema is
supplied as a local file or fetched via `--url`.
The fix has been merged into the parent repository's `main` branch in
[5e94b8f](https://github.com/datamodel-code-generator/datamodel-code-generator/commit/5e94b8f4203198798ec66b8e48217f70af69a0dc). A patched package release is not yet available.
The technical details and PoC below describe the vulnerable implementation before
that fix.
## Affected component
- Repository: `datamodel-code-generator/datamodel-code-generator` (formerly `koxudaxi/datamodel-code-generator`).
- Analyzed at: released **0.80.0** (`pip install datamodel-code-generator==0.80.0`) and `main` @ commit `834731d56c0a90c182a0919f316069cf5ff0659a` (2026-09-13). Both contained the identical vulnerable sink.
- Sink / entry point (`src/datamodel_code_generator/parser/protobuf.py`, line numbers from 0.80.0):
- Source: `WEAK_IMPORT_PATTERN` (`protobuf.py:37`) — attacker-controlled capture group.
- Sink: `_write_missing_weak_imports` (`protobuf.py:391-393`) — `weak_import_dir / import_path` + `mkdir(parents=True)` + `write_text`.
- Timing: called from `_ProtoInputPreparer.__enter__` (`protobuf.py:333`), before `protoc.main(...)` runs inside the `with` body.
- Preconditions: victim runs the tool (CLI or Python API) with `--input-file-type protobuf` on an attacker-controlled `.proto`, supplied as a local file (`--input`) or a remote URL (`--url`). Requires the `grpcio-tools` package (Protobuf support). The attacker does not need privileges on the affected system; filesystem effects are limited to locations writable by the code-generation process.
## Severity
Proposed: **High**. `CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N` = **7.5**.
- Scored to match the project's own rating of the sibling path-traversal advisories CVE-2026-55389 / CVE-2026-55390, both `AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N` = 7.5. This finding is the same attack surface (unvalidated path from a processed schema) with the impact moved from confidentiality (read) to **integrity (write)**, hence `C:N/I:H`.
- `AV:N`: the malicious schema can be fetched over the network via `--url`, consistent with how the siblings were scored.
- `I:H`: attacker fully controls the write path and can create arbitrary directory trees and overwrite existing files; only the file *content* is constrained (a fixed `syntax = "proto{2,3}";` line).
- `A:N` chosen conservatively; overwriting build-critical files (lock files, `__init__.py`, entry points) can cause availability loss, which would argue `A:L`.
- Honest alternative: if the reviewer treats "the victim must run the tool on the file" as user interaction (`UI:R`), the score is **6.5 (Moderate)**. The project used `UI:N` for the identical read-path siblings, so `UI:N` is used here for consistency.
## Details
Source pattern — the imported path is captured with no character restriction:
```python
# protobuf.py:37
WEAK_IMPORT_PATTERN = re.compile(r'^\s*import\s+weak\s+"([^"]+)"\s*;', re.MULTILINE)
```
Sink — the captured path is joined and written with no boundary check:
```python
# protobuf.py:383-393 (_write_missing_weak_imports)
for import_path in WEAK_IMPORT_PATTERN.findall(text):
if any((include_path / import_path).exists() for include_path in include_paths):
continue
stub = self.weak_import_dir / import_path # no resolve(), no is_relative_to()
stub.parent.mkdir(parents=True, exist_ok=True) # arbitrary directory tree
stub.write_text(syntax, encoding=self.parser.encoding)
```
Two escape mechanisms, both from `pathlib`'s `/` semantics:
- **Absolute path**: `Path(".../__weak_imports__") / "/etc/x"` == `/etc/x` (an absolute
right operand replaces the base). Creates new files anywhere the process can write.
- **`../` traversal**: `Path(".../__weak_imports__") / "../../x"` climbs out of the
temp directory.
Why the existence guard (line 389) does not protect the write:
Integrics Enswitch 3.13 through 4.4 contains an authentication bypass vulnerability in /api/json/user/password/update/ that allows unauthenticated attackers to change account passwords by omitting the reset parameter. Attackers can target accounts with no pending reset, whose empty reset_key matches the defaulted empty value, to take over administrator accounts after enumerating valid usernames.
The npm package albert-anitabaileys version 1.1.13 is part of a large family of malicious forks of the Baileys WhatsApp Web library. These forks inject code that silently subscribes the victim's WhatsApp account to attacker-controlled channels without user consent by issuing an authenticated FOLLOW query using the victim's own WhatsApp session. The target channels are obfuscated or dynamically fetched to evade detection. This behavior does not involve credential theft, persistence, or arbitrary code execution.
The cantarella-baileys npm package, versions 1.1.11 through 1.1.13, contains malicious code that silently subscribes the victim's WhatsApp account to attacker-controlled channels without user consent. This is done by injecting a covert channel-subscription action into the WhatsApp socket layer, issuing an authenticated FOLLOW query using the victim's own WhatsApp session. The targeted channels are obfuscated or fetched dynamically to evade detection. The malicious code does not steal credentials, maintain persistence, or execute arbitrary code.
Eclipse Ditto Explorer UI versions 3.6.0 to 3.8.13 and 3.9.0 to 3.9.7 have a vulnerability where the UI loads environment configuration from an attacker-controlled URL without user confirmation. This allows an attacker to set malicious OpenID Connect (OIDC) provider settings or API URIs, leading to theft of access and refresh tokens or bearer credentials. The vulnerability is fixed in versions 3.8.14 and 3.9.8.
A vulnerability in the PostgreSQL JDBC Driver (pgjdbc) versions 42.7.4 through 42.7.13 causes padding of values shorter than their declared length with leftover bytes from the driver's send buffer instead of zeros. These leftover bytes include SQL text and parameter values from previous statements on the same connection, potentially exposing sensitive data from other requests. This occurs when applications use certain methods to set data with declared lengths larger than the actual data. Versions 42.7.3 and earlier do not exhibit this behavior.