Trending now
Top 10 CVEs trending on social media within the last 24 hours.
Updated 41 minutes ago
FeedsHypemeter
Current score
Soft-boiled
Trending
Hype score
Published
Description
Last 24 hours
- show more detail1CVE-2026-123007
critical 9.2
31
Nov 18, 2026
CVE-2026-123007 is an integer underflow vulnerability in NGINX's HTTP/2 flow-control implementation, disclosed in November 2026 as part of a group of flaws dubbed "NGINX2Root". The issue arises when a remote, unauthenticated client cancels queued response data. NGINX fails to verify the HTTP/2 maximum limit when refunding queued bytes to the connection's send window, resulting in an integer underflow. This miscalculation allows invalid window values to propagate, causing NGINX to use an incorrect length during subsequent memory-copy operations and leading to a heap-based out-of-bounds write. Exploiting this memory corruption can crash NGINX worker processes, leading to a denial of service, or potentially allow remote code execution (RCE) with the privileges of the worker process. However, achieving RCE is complex and requires transmitting a massive volume of HTTP/2 traffic (approximately 128 GB) over a direct connection, as well as bypassing memory protection mechanisms like Address Space Layout Randomization (ASLR). The vulnerability affects NGINX configurations where HTTP/2 is enabled. Organizations can address the issue by upgrading to a patched version of NGINX and restarting the service, or temporarily mitigate it by disabling HTTP/2 on exposed listeners.
NGINX PlusNGINX Open Source - show more detail2CVE-2026-123633
critical 9.2
26
Nov 18, 2026
CVE-2026-123633 is a use-after-free vulnerability affecting NGINX Plus and NGINX Open Source when configured to use HTTP/2 with requests forwarded to an upstream backend server. The flaw stems from a connection-lifecycle issue where an active HTTP/2 connection can remain incorrectly marked as reusable. Specifically, a connection that has only received a partial HEADERS frame is marked reusable, and this status is not consistently cleared when a new request stream begins processing. Under connection-resource pressure—such as when the server is running low on worker connections—NGINX may reclaim and release the memory of the active connection while it is still being used to connect to an upstream server, resulting in a use-after-free condition. This vulnerability can allow an unauthenticated remote attacker to cause a denial-of-service (DoS) or potentially execute arbitrary code with the privileges of the NGINX worker process. The bug dates back to NGINX version 1.19.7 (released in 2021) and was patched in November 2026 in NGINX Open Source versions 1.31.9 and 1.30.7, as well as NGINX Plus versions 37.2.0.1 and 37.0.7.1. For systems where immediate patching is not possible, disabling HTTP/2 on exposed listeners serves as a temporary mitigation.
NGINX PlusNGINX Open Source - show more detail3CVE-2026-123634
critical 9.2
25
Nov 18, 2026
CVE-2026-123634 is a use-after-free vulnerability affecting NGINX Open Source and NGINX Plus when configured as a proxy. The flaw resides in the DNS resolver's waiting list processing and is triggered under specific configuration conditions. Specifically, it occurs when the proxied server name is built using variables (request-time DNS) and a Server Side Includes (SSI) or mirror directive sends a subrequest to a location that resolves that same server name. When a request and its mirror subrequest wait for the same lookup, a specially crafted HTTP request can trigger the use-after-free condition in the NGINX worker process. Exploitation of this vulnerability can allow an unauthenticated remote attacker to crash the NGINX worker process, corrupt its memory, or potentially achieve remote code execution (RCE) if Address Space Layout Randomization (ASLR) is disabled or bypassed. To address the issue, F5 released patches in NGINX Open Source versions 1.31.9 and 1.30.7, as well as NGINX Plus versions 37.3.0.1 and 37.0.8.1. Temporary workarounds include avoiding the use of SSI and mirror directives, or pointing the `proxy_pass` directive to a fixed upstream group to eliminate request-time DNS lookups.
NGINX PlusNGINX Open Source - show more detail4CVE-2026-121810
critical 9.2
24
Nov 18, 2026
CVE-2026-121810 is a use-after-free vulnerability affecting NGINX Plus and NGINX Open Source configurations that have HTTP/3 (QUIC) enabled and forward requests to an upstream backend server. Disclosed in November 2026 as part of a group of NGINX vulnerabilities dubbed "nginx2root," the flaw occurs when a QUIC connection is drained during stream creation and upstream connection. Specifically, NGINX closes an HTTP/3 connection and frees a request while it is still attempting to open a connection to the upstream server. An unauthenticated remote attacker can exploit this vulnerability to trigger a use-after-free condition in the NGINX worker process. This can result in a denial-of-service (DoS) through a process restart, or potentially allow the execution of arbitrary code with the privileges of the NGINX worker process if Address Space Layout Randomization (ASLR) is disabled or bypassed. To mitigate the issue, administrators are advised to update NGINX to a patched version (such as 1.31.9 or 1.30.7) or temporarily disable HTTP/3 by removing QUIC listeners and setting `http3 off;` in the configuration.
NGINX PlusNGINX Open Source - show more detail5CVE-2026-113425
critical 9.2
24
Nov 18, 2026
CVE-2026-113425 is a use-after-free vulnerability affecting NGINX Open Source and NGINX Plus when configured as a mail proxy using the `proxy` and `auth_http` directives. The flaw is triggered when a client abruptly resets or closes its connection during an active `auth_http` authentication lookup. This action causes NGINX to reference memory that has already been freed, leading to a use-after-free condition within the NGINX worker process. An unauthenticated remote attacker can exploit this vulnerability by sending specific traffic to crash the worker process, corrupt its memory, or potentially execute arbitrary code, particularly on systems where Address Space Layout Randomization (ASLR) is disabled or can be bypassed. To address the issue, administrators are advised to upgrade to patched versions of NGINX, such as NGINX Open Source 1.31.9 or 1.30.7. If immediate patching is not possible, temporary mitigations include restricting mail proxy listeners to trusted networks or binding them to a loopback address.
NGINX PlusNGINX Open Source - show more detail6CVE-2026-98432
critical 9.8
19
Oct 15, 2026
CVE-2026-98432 is a use-after-free vulnerability in the Linux kernel's IPv4 TCP handshake path, affecting kernels dating back to version 4.4. The flaw stems from a race condition involving the ownership and reclamation of IPv4 option data (such as Timestamp or Record Route options) associated with a TCP request socket. When a connection progresses, two processors can act on related request and child sockets while referencing the same IP options object. This allows one path to free the object while another continues to use it, resulting in a stale kernel pointer that can be reached through network traffic. The vulnerability gained significant attention after Anthropic demonstrated that its AI model, Claude, could generate a proof-of-concept exploit for it. The exploit targets Linux servers running a multipath TCP (MPTCP) listener, allowing a remote, unauthenticated attacker to execute arbitrary commands as root. It achieves this in two stages: first, by exploiting the race condition to leak a kernel pointer and bypass Kernel Address Space Layout Randomization (KASLR), and second, by triggering the use-after-free to overflow a buffer and overwrite a callback pointer with a staged payload. The vulnerability has since been patched upstream and backported to all maintained stable kernel branches.
Ubuntu - show more detail7CVE-2026-99288
high 7.5
19
Nov 10, 2026
CVE-2026-99288, also known as "NoisyTCP," is a race condition vulnerability in the Linux kernel's TCP networking subsystem that was introduced in October 2015 and remained latent for 11 years. Discovered by security researcher Hyunwoo Kim, the flaw resides in the lockless socket lookup mechanism used during TCP connection handling. Because the lookup process does not use locks, recycled socket memory can be accessed before it is properly initialized and hashed. An attacker can exploit this timing window by sending a crafted sequence of TCP packets, causing a stale lookup to return an unhashed request socket (such as one reconstructed via a SYN cookie). This results in a NULL pointer dereference and a subsequent kernel panic, taking the host and any hosted containers offline. To trigger the vulnerability, the target server must process incoming packets concurrently across multiple CPUs, which requires a network configuration with two or more receive (RX) queues or Receive Packet Steering (RPS) enabled. The exploit can be launched remotely and without authentication against standard services with default configurations, such as SSH, Apache, or Nginx. While the flaw allows attackers to cause a denial of service, it does not facilitate data alteration or arbitrary code execution. Upstream Linux kernel developers have resolved the issue in versions 6.12.117, 6.18.63, and 7.3.4 by ensuring that lookups reject unhashed sockets.
Linux Kernel - show more detail8
8
-
CVE-2026-46675 is a use-after-free vulnerability in the sequential reader of the `libpng` library, affecting versions 1.6.0 through 1.6.58. The issue arises when an application calls the `png_read_end` function after `png_read_info` without first reading the image rows. A specially crafted `zTXt`, `iTXt`, or `iCCP` chunk can cause `libpng` to halt decompression prematurely while the underlying `zlib` library still expects input. Because the chunk handlers release the `zlib` stream without clearing its input pointer and count, `png_read_end` resumes decompression using a stale pointer instead of reading the expected IDAT data. Depending on the chunk type, this stale pointer can lead to different memory safety issues: for `zTXt` and `iTXt` chunks, it results in a heap use-after-free, while for `iCCP` chunks, it causes a stack use-after-return. The primary impact of this vulnerability is a denial of service (DoS). Because the dangling pointer is only read and the decompressed bytes are sent to a discarded scratch buffer, the vulnerability does not result in data disclosure or corruption. The issue has been resolved in `libpng` version 1.6.59.
- show more detail9
1
Nov 17, 2026
CVE-2026-114938, also known as "Java4Shell," is an integer underflow vulnerability in OpenJDK's Base64 decoder that leads to an out-of-bounds heap write. Discovered by the security research firm Calif, the flaw resides in the HotSpot AVX-512 Base64 decode intrinsic (`generate_base64_decodeBlock`), which is used to speed up decoding on compatible processors. When a specially crafted Base64 string ending with a short padded tail is processed, the decoder's padding handler decrements a decoded-size counter below zero, causing a heap overflow of approximately 62 bytes. This vulnerability affects OpenJDK versions 17, 21, 25, and 27 running on x86-64 systems with CPUs that support the AVX-512 VBMI instruction set, such as certain Intel Xeon and AMD EPYC processors. Because Base64 decoding is commonly used to process authentication headers, tokens, and file uploads before user verification, unauthenticated remote attackers can exploit this flaw to achieve arbitrary code execution or cause a denial of service (JVM crash). Researchers demonstrated pre-authentication remote code execution on default installations of several enterprise applications, including Atlassian Jira, Confluence, Jenkins, Keycloak, JFrog Artifactory, and PingFederate. Oracle and the OpenJDK project released security patches to address the vulnerability on November 17, 2026, alongside alternative JVM flag mitigations for systems where immediate patching is not feasible.
JavaOpenJDK - show more detail10CVE-2026-50811
medium 6.5
1
Jul 7, 2026
CVE-2026-50811 is an out-of-bounds read vulnerability affecting the FreeType font rendering library, specifically version 2.14.3 and earlier builds prior to commit 5a280ecde6f324de0d226261036e736e0cb49a71. The flaw resides in the `TT_Get_Var_Design` implementation within `src/truetype/ttgxvar.c`, which is utilized by `FT_Get_Var_Design_Coordinates` when processing TrueType GX variable fonts. An attacker can trigger this vulnerability by supplying a specially crafted TrueType variable font file, causing the library to read memory outside of its allocated buffers. Because FreeType is invoked whenever an application renders fonts, this vulnerable path can be reached when a system opens a document, visits a web page, or loads an application resource containing the malicious font. The primary impact of this out-of-bounds read is the potential disclosure of sensitive process memory, though it can also result in application crashes or denial of service if the read operation touches unmapped memory pages. The issue has been addressed in FreeType version 2.15.0, and users are advised to update their installations or apply vendor-provided patches.
FreeType