Twisted's DNS client UDP transport (twisted.names.dns.DNSDatagramProtocol) accepts DNS responses based solely on matching the 16-bit transaction ID without validating the source address. This allows an attacker able to send UDP packets to the resolver's port to inject forged DNS responses, enabling off-path DNS response spoofing or cache poisoning. The standard client mitigates this risk by using per-query random source ports, increasing entropy, but the missing source address validation remains a security gap. This affects all versions prior to 26.10.0rc1, where the issue is fixed.
### Summary
`qs.stringify` with `allowEmptyArrays: true` writes the key of an empty array without encoding it, even though keys are encoded by default. A key that contains `&` (or the configured `delimiter`), `=`, or `#` therefore becomes query string syntax instead of data, so a caller-supplied key name can add parameters to the serialized query string, or cut it short.
### Details
In `lib/stringify.js`, the `allowEmptyArrays` branch returns `adjustedPrefix + '[]'` early, before the code that passes every other key through `encoder` and `formatter`. So `{ "x&k=v": ["1"] }` serializes as `x%26k%3Dv%5B0%5D=1`, but `{ "x&k=v": [] }` serializes as `x&k=v[]`. The early return applies at any depth (`{ "a": { "b&k=v": [] } }` gives `a[b&k=v][]`), under every `arrayFormat`, with `allowDots`, and with a custom `encoder`, which is never called for that key. With `encode: false` or `encodeValuesOnly: true`, keys are intentionally left unencoded on every path; those configurations are not affected.
#### PoC
```js
var qs = require("qs");
var query = qs.stringify({ q: "hi", "x&apiKey=evil&y": [] }, { allowEmptyArrays: true });
// "q=hi&x&apiKey=evil&y[]"
qs.parse(query);
// { q: "hi", x: "", apiKey: "evil", y: [""] }
qs.stringify({ "x#": [], z: "1" }, { allowEmptyArrays: true });
// "x#[]&z=1": in a URL, everything after "#" becomes the fragment
```
#### Fix
Applied in 234d505 on `main` and released as v6.17.0, and backported to v6.16.2, v6.15.4, v6.14.3, v6.13.4, and v6.12.6: the key of an empty array goes through `encoder` and `formatter` exactly as the key of any other value does, so `{ "x&apiKey=evil&y": [] }` now serializes as `x%26apiKey%3Devil%26y[]`. Keys that need no encoding serialize as before, with two exceptions that match every other path: the brackets of a nested key are now encoded (`a[b][]` becomes `a%5Bb%5D[]`, which `qs.parse` reads identically), and with `encodeDotInKeys`, a dot in the key becomes `%252E` instead of `%2E` (which `decodeDotInKeys` previously misread as nesting).
### Affected versions
- `>=6.12.0 <6.12.6`, fixed in v6.12.6
- `>=6.13.0 <6.13.4`, fixed in v6.13.4
- `>=6.14.0 <6.14.3`, fixed in v6.14.3
- `>=6.15.0 <6.15.4`, fixed in v6.15.4
- `>=6.16.0 <6.16.2`, fixed in v6.16.2
v6.17.0 and later are not affected.
`allowEmptyArrays` was introduced in f22b2bc and first shipped in v6.12.0, with this early return. Earlier versions have no `allowEmptyArrays` option and are not affected.
### Impact
An application that passes an object whose key names come from untrusted input to `qs.stringify` with `allowEmptyArrays: true` (for example, to forward a parsed JSON body or user-selected fields to an upstream service) can have parameters injected into the resulting query string. The injected parameters are not keys of the object, so deleting or overwriting a key on the object (such as setting a trusted `apiKey` after copying the user's fields) does not remove them; whether the attacker's value or the application's wins depends on how the receiving side handles a duplicate parameter. A `#` in such a key ends the query string early when the result is placed in a URL. `allowEmptyArrays` is off by default, and only keys whose value (after any `filter`) is an empty array are affected.
A double free vulnerability exists in libyal libmsiecf through version 20260525 in the function libmsiecf_url_values_read_data(). This flaw allows attackers to corrupt heap memory by supplying a crafted MSIE cache index.dat file with an oversized unknown_offset in a partial URL record. The vulnerability can cause forensic tools processing such files to crash. The CVSS 3.1 base score is 5.5, indicating a medium severity impact primarily affecting availability.
libpff versions up to 20260926 contain an off-by-one bounds check vulnerability in the function libpff_table_read_6c_record_entries. This flaw allows attackers to trigger a heap out-of-bounds read by supplying crafted 6c table record entries in PST, OST, or PAB files. Applications using libpff, such as pffexport or pypff, may read adjacent heap memory or crash when processing malicious files.
gbsplay versions up to 0.0.103 contain an out-of-bounds read vulnerability in the mapper_map() function. This flaw allows crafted game files to cause the player to read beyond the allocated ROM buffer, resulting in a crash. The vulnerability arises from improper validation of ROM bank indexes, leading to an underflowed bank length and heap buffer overread.
A vulnerability in snappy-java prior to version 1.1.10.9 allows out-of-bounds memory access due to improper validation of array ranges passed to native memcpy. This can cause JVM crashes. The issue is fixed in version 1.1.10.9.
A vulnerability has been identified in the RDSEED instruction on AMD Zen 5 (Turin) processors. The 16- and 32-bit versions of the RDSEED instruction can silently fail under certain system load conditions, potentially compromising applications that rely on these instructions for cryptographic random number generation. The 64-bit version of RDSEED is not affected and remains safe. AMD is currently investigating this issue. The 64-bit Linux kernel uses the safe 64-bit RDSEED instruction for /dev/[u]random, so those random numbers are not impacted. Applications that synthesize random numbers using the 16- or 32-bit RDSEED instructions should be aware of this insecurity.
A vulnerability (CVE-2026-6726, also known as TCGVRT0010) has been identified in the Trusted Computing Group's TPM 2.0 reference implementation code, affecting all published revisions of the code (v1.16, v1.38, v1.59, v1.83, v184). This flaw could allow a privileged local attacker to obtain credentials from a TPM-aware Certificate Authority for a falsified TPM key, enabling the creation of fraudulent TPM 2.0 attestations. Google will proactively update affected systems during standard maintenance windows, and no customer action is required.
CVE-2026-116576 is an OS command injection vulnerability in the systeminformation Node.js library prior to version 5.33.16. The issue arises from improper sanitization of service names used in PowerShell commands on Windows, allowing an attacker to inject arbitrary PowerShell expressions. Exploitation requires local or forwarded attacker-controlled input to the vulnerable services() or getDynamicData() functions. The vulnerability is fixed in version 5.33.16.
libosmocore versions through 1.14.1 contain an out-of-bounds read vulnerability in the iuup_rx_initialization() function located in src/gsm/iuup.c. This flaw allows a remote attacker to read memory beyond intended boundaries, potentially exposing sensitive information. The vulnerability affects multiple specific package versions of libosmocore. No CVSS score or public exploit code is available, and there is no indication of active exploitation in the wild.
libosmocore versions through 1.14.1 contain out-of-bounds read vulnerabilities in the GSM 04.80 supplementary-service component parsers located in src/gsm/gsm0480.c. This flaw allows a remote attacker to read memory beyond intended boundaries, potentially exposing sensitive information. The vulnerability affects multiple specific versions of libosmocore, including various builds from 0.9.0 through 1.11.0. There is no information provided about available patches or fixes.
Asterisk versions prior to 20.20.1, 21.12.3, 22.10.1, 23.4.1 and certain Certified Asterisk versions contain a reflected cross-site scripting vulnerability in phone provisioning HTTP error pages. This flaw allows an unauthenticated attacker to potentially steal an authorized user's AMI session cookie and impersonate that user if the res_phoneprov module and related HTTP services are enabled. The HTTP server binds to 127.0.0.1 by default, limiting exposure. The vulnerability is fixed in the specified versions.
A vulnerability in Asterisk's LDAP realtime driver (res_config_ldap) prior to versions 20.20.1, 21.12.3, 22.10.1, 23.4.1 and certain Certified Asterisk releases allows unauthenticated attackers to perform LDAP filter injection via crafted SIP usernames. This can lead to arbitrary LDAP queries and information disclosure. The module is not loaded by default and must be configured to access an LDAP server. The issue is fixed in the specified versions.
A heap-use-after-free vulnerability exists in Asterisk's PJSIP TCP/SDP handling when an authenticated attacker sends a SIP INVITE over a connection-oriented transport and disconnects before receiving a 200 OK response. This issue has been observed only when Asterisk is built with Address Sanitizer, a development tool not used in production. The vulnerability is fixed in Asterisk versions 20.20.1, 21.12.3, 22.10.1, 23.4.1, and Certified Asterisk 20.7-cert11 and 22.8-cert3.
A vulnerability in Asterisk's chan_ooh323 addon channel driver allows an unauthenticated attacker to cause an out-of-bounds read, potentially crashing the system. This issue affects versions prior to 20.20.1, 21.12.3, 22.10.1, 23.4.1 and certain Certified Asterisk releases. The chan_ooh323 driver is not installed by default and requires explicit compilation and a publicly reachable port. The vulnerability is fixed in the specified versions.
libosmocore versions up to 1.14.1 contain out-of-bounds read vulnerabilities in the IPA CCM identity-tag parsers located in src/gsm/ipa.c. This flaw allows remote attackers to read sensitive information from memory. The issue affects multiple specific versions of libosmocore, including several Debian and Ubuntu package builds. No public exploit code or active exploitation is reported. The severity is assessed as medium based on the impact of information disclosure.
libosmocore versions through 1.14.1 contain an out-of-bounds read vulnerability in the CBSP WRITE-REPLACE decoder located in src/gsm/cbsp.c. This flaw can be exploited by a remote attacker to cause a denial of service condition.
A buffer overflow vulnerability exists in libosmocore through version 1.14.1 in the function osmo_iuup_compute_payload_crc() located in src/gsm/iuup.c. This flaw allows a remote attacker to cause a denial of service. Multiple specific versions of libosmocore are affected. No public exploit code or active exploitation in the wild is currently known.
vLLM versions from 0.16.0 up to but not including 0.32.0 contain a vulnerability in the /v1/responses endpoint that allows an authenticated user to supply a malicious template in chat_template_kwargs[chat_template]. This bypasses the intended trust policy and can lead to uncontrolled CPU or memory consumption during Jinja template rendering. The issue is resolved in version 0.32.0.