In Eclipse Mosquitto versions 2.1 through 2.1.2, a listener configured with `protocol websockets` mishandles empty WebSocket data frames. `net__read_ws()` in `lib/net_ws.c` returns the number of framing bytes consumed (the 4 masking-key bytes) for a data frame with a zero-length payload, without writing any bytes to the caller’s buffer. The MQTT packet reader in `packet__read_single()` (`lib/packet_mosq.c`) trusts that return value as a payload byte count. A remote client can therefore advance the read position over an uninitialised heap allocation, causing the broker to process and forward uninitialised heap memory (information disclosure, including heap and libc pointers), and can underflow the unsigned `to_process` counter so that subsequent attacker-controlled frame data is written past the end of the allocation (heap out-of-bounds write). The out-of-bounds write is reachable from the CONNECT packet before any authentication check, so an unauthenticated client can corrupt the heap and crash the broker even when `allow_anonymous false` is set. Combining the disclosure and the write allows remote code execution as the broker’s user by any client able to establish a session.
The WP Delicious – Recipe Plugin for Food Bloggers (formerly Delicious Recipes) plugin for WordPress is vulnerable to Stored Cross-Site Scripting via the 'recipeTitle' parameter in all versions up to, and including, 1.10.10 due to insufficient input sanitization and output escaping. This makes it possible for authenticated attackers, with contributor-level access and above, to inject arbitrary web scripts in pages that will execute whenever a user accesses an injected page. WordPress core's block-attribute kses pass strips HTML tags but preserves bare double-quote characters, allowing a payload such as x" onerror="alert(1) to survive both the save pipeline and the render-time strip_tags() call, breaking out of the alt attribute of the rendered img element.
The WP Delicious – Recipe Plugin for Food Bloggers (formerly Delicious Recipes) plugin for WordPress is vulnerable to Stored Cross-Site Scripting via the 'details[].icon' parameter in all versions up to, and including, 1.10.11 due to insufficient input sanitization and output escaping. This makes it possible for authenticated attackers, with contributor-level access and above, to inject arbitrary web scripts in pages that will execute whenever a user accesses an injected page. The payload bypasses wp_kses_post on save because Gutenberg serializes block attribute JSON with JSON_HEX_QUOT, encoding double-quotes as \u0022 so no raw quote or angle bracket appears in post_content; parse_blocks() restores the literal quote at render time, producing the HTML attribute breakout.
The BlockArt Blocks – Gutenberg Blocks, Page Builder Blocks ,WordPress Block Plugin, Sections & Template Library plugin for WordPress is vulnerable to authorization bypass in all versions up to, and including, 2.4.3. This is due to the plugin not properly verifying that a user is authorized to perform an action. This makes it possible for authenticated attackers, with contributor-level access and above, to view the title, excerpt, and full content of other users' draft, pending, and private posts, exposing that content to unauthenticated visitors on the published permalink. This is exploitable by an Author-level user because WordPress's wp_filter_post_kses preserves block-comment JSON in HTML comments, allowing the malicious queryArgs and query[post_status] attributes to survive post saving and execute on every unauthenticated request to the published URL. Exploitation by attackers with contributor-level access and above requires that attacker only needs to see the data themselves (not expose it to unauthenticated visitors) — satisfied by viewing their own preview URL. On a default installation, where that is not configured, the vulnerability requires attackers with author-level access and above.
In the Linux kernel, the following vulnerability has been resolved:
ALSA: hwdep: Serialize DSP load requests
The check of the loaded DSP indices and the call of the driver's
dsp_load callback in snd_hwdep_dsp_load() are not serialized. A hwdep
file descriptor can be shared among threads, or inherited across fork,
so two SNDRV_HWDEP_IOCTL_DSP_LOAD requests for the same index can both
observe the index as unloaded and enter the driver's callback
concurrently, even though the device itself is opened exclusively.
This breaks the assumption behind hw->dsp_loaded that a firmware index
is loaded only once. For example, snd-usb-usx2y hits
WARN_ON(usx2y->as04.buffer) in usx2y_async_seq04_init() and may
allocate the US-428 sequence URBs twice.
Serialize the check, the callback invocation and the bookkeeping with a
per-hwdep mutex, so that the second request returns -EBUSY.
Three distinct cyber campaigns are targeting the US trucking and logistics sector by exploiting routine workflows such as carrier verification, broker onboarding, and freight booking. These campaigns use fraudulent business portals and malicious documents to harvest sensitive information including credentials, Social Security Numbers, EINs, and fuel card data. The HelloFriends campaign uses fake FMCSA carrier verification portals for credential theft via phishing emails. NodeRemote distributes backdoors disguised as broker onboarding documents, establishing persistent access through scheduled tasks and rotating command-and-control infrastructure. Fake Freight Portals impersonate TIMOCOM and DAT platforms, delivering MeshCentral and CastleRAT malware through malicious WebDAV shortcuts and attempting to extract BitLocker recovery keys. These attacks combine sophisticated social engineering, infrastructure rotation, and multi-stage infection chains to achieve credential theft and persistent remote access.
CVE-2026-86805 is a local privilege escalation vulnerability in the GNU C Library (glibc) dynamic loader affecting versions prior to 2.39_2. It arises from a TOCTOU race condition when expanding $ORIGIN in DT_RPATH for setuid/setgid programs, allowing an attacker to load malicious code by exploiting path normalization and symbolic link manipulation. Major Linux distributions mitigate this by enabling fs.protected_hardlinks by default.
A vulnerability in GNU C Library (glibc) versions 2.3 up to but not including 2.39_2 allows crafted SHIFT_JISX0213 encoded input to cause the iconv conversion function to hang. This occurs because certain SHIFT_JISX0213 sequences decode into two code points, and if the output buffer is too small to hold both, the converter improperly handles the second code point, resulting in an infinite loop. This can cause the calling application to hang when processing attacker-controlled input.
CVE-2026-6791 is a critical vulnerability in the GNU C Library (glibc) affecting versions before 2.39_2. It involves a stack-based buffer clash triggered during tilde (~) expansion in the wordexp function when processing excessively long usernames. This occurs because the username is allocated on the stack without bounds checking, potentially exhausting stack space and causing a clash. The issue is fixed in glibc version 2.39_2.
A CRLF injection vulnerability was identified in GitHub Enterprise Server that allowed a user with write access to a repository to bypass branch protections and update branches or tags in that repository through specially crafted input when resolving pull request conflicts. This vulnerability affected all versions of GitHub Enterprise Server prior to 3.23 and was fixed in versions 3.19.16, 3.20.12, 3.21.10, and 3.22.5. This vulnerability was reported via the GitHub Bug Bounty program.
A vulnerability in GNU C Library version 2.3.3 and later involves converting crafted input from UCS-4 to IBM1390 or IBM1399 character encoding. The converter may read past the end of the input buffer, causing the application to crash due to improper bounds checking when handling combining base characters. Exploitation requires attacker control of input, encoding, and precise memory layout.
A vulnerability exists in Oracle Java SE, Oracle GraalVM for JDK, and Oracle GraalVM Enterprise Edition affecting core Java libraries. The flaw allows an unauthenticated attacker with network access via multiple protocols to potentially modify critical data without authorization. This vulnerability involves APIs that may be accessed through web services or sandboxed Java applications running untrusted code. The CVSS 3.1 base score is 5.9, indicating a medium severity with integrity impact only. Oracle has released a Critical Security Patch Update in November 2026 addressing this and many other vulnerabilities.
A vulnerability in Oracle Java SE and Oracle GraalVM for JDK libraries allows an unauthenticated attacker with network access to compromise the integrity of accessible data. The flaw affects specific versions of Oracle Java SE and Oracle GraalVM for JDK. Exploitation can result in unauthorized update, insert, or delete operations on data accessible via APIs, including sandboxed Java Web Start applications or applets running untrusted code. The CVSS 3.1 base score is 5.3, indicating a medium severity impact focused on integrity.
Oracle Construction and Engineering Suite contains multiple security vulnerabilities as part of a broader set of issues addressed in Oracle's November 2026 Critical Security Patch Update. The suite supports project management and collaboration for construction and engineering firms. Oracle has released patches covering versions 22.12.0 through 22.12.15 and 23.12.0 through 23.12.16. No specific CVSS score or detailed impact is provided. Oracle strongly recommends applying the available patches promptly to mitigate risks.
Converting crafted ISO-2022-CN-EXT input to UTF-8 character encoding, in the GNU C Library version 2.2 through 2.44 may result in the converter reading past the end of the input buffer, causing the calling application to crash.
When the ISO-2022-CN-EXT decoder encounters an invalid input byte sequence like '\x0e' it ends up advancing the pointer tracking the read buffer position twice. If this sequence is at the end of the input buffer, the decoder may then end up reading past the bounds of the input buffer. To exploit this, the input and encoding needs to be attacker controlled.
Converting crafted CP949 input to UTF-8 character encoding and ignoring invalid characters, in the GNU C Library version 2.1 or later may result in the converter reading past the end of the input buffer, causing the calling application to crash.
When the CP949 decoder encounters an invalid input byte sequence like '\xa2\xe8' it ends up advancing the pointer tracking the read buffer position twice. If //IGNORE is set on the destination encoding and this sequence is at the end of the input buffer, the decoder may then end up reading past the bounds of the input buffer. To exploit this, the target iconv function needs to set //IGNORE on the destination of the conversion and the input and encoding needs to be attacker controlled.
A use-after-free vulnerability exists in the HID component of Google Chrome versions prior to 158.0.8127.36. This flaw could allow a remote attacker, through social engineering and a crafted Chrome extension, to execute arbitrary code outside the browser sandbox. The vulnerability is classified with medium severity by Chromium security.
A use-after-free vulnerability exists in the Extensions component of Google Chrome versions prior to 158.0.8127.36. This flaw could allow a remote attacker, through social engineering and a crafted Chrome extension, to execute arbitrary code outside the browser sandbox. The Chromium project has assigned this vulnerability a medium severity rating. No public exploit or patch information is currently available.
A use-after-free vulnerability exists in the Views component of Google Chrome on Windows versions prior to 158.0.8127.36. This flaw allows a remote attacker, through social engineering and a crafted Chrome extension, to execute arbitrary code outside the browser sandbox. The vulnerability is classified with high severity by Chromium security.