Apache Shiro versions from 2.0.0-alpha through 3.0.1, when used with the Jakarta EE integration module and form saving enabled, have a security weakness in the automatic form resubmission feature. This weakness can cause cookies set during form resubmission to lose security attributes like Secure and SameSite, and may send form data and cookies to untrusted hosts. The issue is resolved in version 3.0.2 and later.
Apache Shiro versions through 3.0.1 have a vulnerability where authorization annotations like @RequiresRoles and @RequiresPermissions are not consistently enforced in certain class or interface hierarchies. This affects modules such as shiro-guice, shiro-aspectj, shiro-cdi, and shiro-jakarta-ee, potentially allowing unauthorized method invocations. The issue is fixed in version 3.0.2 and later, where the annotation closest to the invoked method takes precedence.
Apache Shiro versions through 3.0.0 are vulnerable to session fixation when the "Remember me" feature is enabled. The vulnerability occurs because the existing session is not invalidated nor is a new session created with a new ID when a user is restored from a "Remember me" cookie. Additionally, session IDs in the request URL are accepted even if URL rewriting is disabled. This issue is fixed in version 3.0.1, which properly invalidates the old session and ignores URL session IDs when URL rewriting is disabled.
@fastify/busboy is a streaming parser for multipart form data used by Fastify. In versions 1.0.0 through 3.2.5, when a request reaches the configured limit on the number of multipart parts, each further part is skipped without attaching an error listener to the skipped part stream. If the request body ends in the middle of such a skipped part, the vendored Dicer parser emits an error on that stream, and because nothing is listening Node.js raises an unhandled error event and the process exits. A single crafted unauthenticated request is therefore enough to crash the server. The bug is latent in the parser on its own and was first demonstrated through @fastify/multipart versions 10.1.2 through 10.1.4, which keep feeding the request body to the parser after a limit error, and it affects any consumer that sets a finite parts limit and parses request bodies that can be terminated early. The issue is fixed in @fastify/busboy 3.2.6, and users should upgrade to 3.2.6 or later. There is no complete application level workaround because the crash happens inside the parser before application code runs, though consumers that set a finite parts limit should also attach an error listener to the parser stream.
@fastify/proxy-addr versions 3.0.0 through 5.1.2 have a vulnerability where the trustProxy setting incorrectly handles zoned IPv6 link-local addresses. This causes the system to trust network hops on different links that share the same link-local address but different zone identifiers. An attacker on another link of a multi-homed server can spoof forwarded headers such as X-Forwarded-For, bypassing IP allowlists, rate limiting, and audit logging. The issue is fixed in version 5.1.3.
@fastify/multipart is the official Fastify plugin for handling multipart/form-data uploads. In versions 7.4.0 through 10.1.8, when the plugin is registered with the attachFieldsToBody option, the saveRequestFiles helper treats any object in the parsed request body that carries truthy file and buffer properties as an uploaded file. An unauthenticated client can forge such an object through a plain JSON request or a JSON-typed multipart field, so attacker-chosen bytes are written to the temporary directory while upload hooks and the file count and size limits are skipped, and the saved entry keeps the attacker's filename verbatim instead of being reduced to its basename. Because that filename can contain parent directory segments, applications that use it as a write destination, as the project README example does, are exposed to an arbitrary relative-path file write from a single request. The issue is fixed in @fastify/multipart 10.1.9, and users should upgrade to 10.1.9 or later. As a workaround, call saveRequestFiles only after confirming the request is multipart, and reduce each returned filename to its basename or validate it against an allowlist before using it as a destination.
@fastify/multipart is the official Fastify plugin for handling multipart/form-data uploads. In versions 3.0.0 through 10.1.3, temporary files written by the saveRequestFiles helper are removed only by a response hook that runs when the response finishes or errors. When a client completes an upload and then disconnects before the handler writes the reply, for example while the handler scans, hashes or forwards the file, the response only emits a close event, the cleanup hook never runs, and the saved files are left on disk. An unauthenticated client can repeat this cheaply to exhaust disk space and deny service to applications that save uploaded files to disk. The issue is fixed in @fastify/multipart 10.1.4, and users should upgrade to 10.1.4 or later. As a workaround, avoid saving request files for untrusted clients, or clean the saved files from a close handler on the raw response so removal also happens when the client disconnects.
The Ruby httpx gem versions 1.7.6-1, 1.8.0-1, and 1.8.1-1 contain a vulnerability in their JSON response parsing via the transcoder layer. When the oj gem is loaded and multi_json is absent, the decoder uses Oj.load in :object mode, allowing attacker-controlled JSON to instantiate arbitrary Ruby objects. This can lead to remote code execution if a suitable gadget chain is present. The issue is fixed in version 1.9.1.
A vulnerability in the Linux kernel's UDF filesystem handling allows a specially crafted corrupted UDF filesystem with a symlink containing an unexpected extent type to cause a kernel crash (general protection fault). This occurs due to an incorrect return value handling in udf_map_block(), leading to a wild memory access in __page_get_link().
A use-after-free vulnerability exists in the Linux kernel's NFS server code (nfsd) in the client_has_openowners() function. The flaw occurs because the function reads state information without holding the necessary lock, leading to a potential race condition where freed memory can be accessed concurrently. This issue has been resolved by ensuring the lock is held while walking the openowner list.
CVE-2026-99309 is a vulnerability in the Linux kernel's ksmbd component affecting 32-bit builds. It involves an integer overflow in the dacloffset bounds check within the build_sec_desc() function, which can lead to an out-of-bounds read of up to 8 bytes preceding the allocated memory. This occurs when a large dacl_offset value in the range [0xFFFFFFF8, 0xFFFFFFFF] is provided. The issue has been fixed by adding an overflow check.
A buffer overflow vulnerability in the Linux kernel's xHCI USB driver was fixed. The issue occurs with high-speed USB devices that have out-of-spec 1024-byte bulk endpoints. The driver allocates a 512-byte bounce buffer but may write up to 1024 bytes, causing overflow. This affects only out-of-spec devices and has been corrected by aligning transfer ring buffers to the packet size chosen by the driver.
CVE-2026-99307 is a vulnerability in the Linux kernel's Ceph filesystem client where the dentry lease record parsing does not properly verify the size of the ceph_mds_reply_lease structure. This allows a malicious Metadata Server (MDS) to send a shorter record than expected, causing an out-of-bounds read in kernel memory during lookup operations on a mounted CephFS. The issue leads to a slab-out-of-bounds read detected by Kernel Address Sanitizer (KASAN).
CVE-2026-99306 is a vulnerability in the Linux kernel's Ceph filesystem client where malformed MDS maps claiming more ranks than the protocol constant CEPH_MAX_MDS can cause out-of-bounds memory access. This occurs because the code does not properly bound the size of the bitmap used to track ranks, leading to a stack out-of-bounds read. The flaw is triggered when a monitor connection, which can be unauthenticated in legacy mode, sends a corrupted map. The issue has been resolved by rejecting MDS maps that claim more ranks than allowed at the point where rank space is established.
CVE-2026-99305 is a use-after-free vulnerability in the Linux kernel's framebuffer device (fbdev) udlfb driver. It occurs because the mode list is rebuilt and freed while the framebuffer is still in use, leaving dangling pointers that can cause kernel memory corruption. This issue is triggered by an unprivileged write to the edid sysfs attribute, leading to a kernel slab-use-after-free error during console switching.
CVE-2026-99304 is a vulnerability in the Linux kernel's Ceph filesystem component where an integer overflow in the snap trace bounds check can lead to out-of-bounds memory reads. This occurs because the addition of two counts from network data wraps around due to improper integer handling, causing a bounds check to incorrectly pass and allowing reads beyond allocated memory. The flaw is triggered by malicious or compromised Metadata Servers (MDS) sending crafted messages, potentially causing kernel memory corruption.
A vulnerability in the Linux kernel's speakup component causes a NULL pointer dereference when switching virtual terminals (VT) and quickly selecting or pasting text. This occurs because the tty is not yet set during rapid VT switches, leading to a NULL dereference which is aborted to prevent a crash.
CVE-2026-99302 is a vulnerability in the Linux kernel's nvmet-rdma component where short RDMA connection requests are improperly handled. The function nvmet_rdma_parse_cm_connect_req() accepts any nonzero private_data_len but treats the data as a fixed structure, leading to out-of-bounds reads when the private data is shorter than expected. This flaw causes a slab-out-of-bounds read, as confirmed by a Kernel Address Sanitizer (KASAN) report. The issue arises because the iWARP path allocates memory exactly matching the peer-provided length, allowing a six-byte MPA request to trigger the out-of-bounds read. The vulnerability has been addressed by requiring the complete request structure before accessing its fields.
CVE-2026-99301 is a vulnerability in the Linux kernel's virtio_net driver where the mechanism to disable receive mode work during device teardown is not atomic. This can lead to use-after-free errors when work is enqueued after the device has been freed during probe failure or teardown. The issue has been addressed by using the workqueue disable mechanism to atomically reject new work and drain running work before resource teardown.
A vulnerability in the Linux kernel's go7007 media driver occurs because the audio_enabled flag is set before confirming successful initialization of the ALSA sound context. If initialization fails, audio_enabled remains set while snd_context is NULL, leading to a null pointer dereference during device disconnect. This can cause a kernel panic and system crash.