Red Hat has issued an important security advisory for Red Hat AMQ Clients 2026.Q3 addressing multiple vulnerabilities in components such as Apache Qpid Proton-J, Jackson-databind, Netty, Spring Boot, and others. The vulnerabilities include denial of service, authentication bypass, arbitrary code execution, information disclosure, and HTTP request smuggling. These flaws affect message sending and receiving capabilities with AMQ Broker 7. The update also includes numerous bug fixes and enhancements. Users are advised to apply this update after ensuring all previous errata are applied.
A security update for httpcomponents-client addresses CVE-2026-64607, which involves improper release of underlying connections back to the connection manager when an invalid or unsupported Content-Encoding header is present in a response message.
CVE-2026-90234 is a vulnerability in the Linux kernel's NFS implementation where the client fails to properly return a delegation to the server in certain error flows. This causes the server to believe the client still holds the delegation, leading to repeated recall attempts and a state management loop on the client. The issue arises because the client drops the delegation silently instead of sending the required DELEGRETURN message as specified in RFC 8881. This flaw has been fixed in specific Linux kernel commits.
RabbitMQ amqp091-go is a Go AMQP 0.9.1 client. Prior to 1.13.0, readField in read.go reads the length of an AMQP byte-array field with type tag x into a signed int32 and passes the value directly to make when allocating the field buffer. A malicious or compromised broker can encode a value such as 0xFFFFFFFF, which becomes -1 and causes a len out of range runtime panic. The panic escapes the network reader goroutine and terminates the client process, including during connection.start server properties or message header table parsing. This issue is fixed in version 1.13.0.
RabbitMQ amqp091-go is a Go AMQP 0.9.1 client. Prior to 1.13.0, Channel.recvContent in channel.go preallocates the message body slice with the uint64 ch.header.Size value supplied by an AMQP content header without capping the allocation to the negotiated Connection.Config.FrameSize value. A malicious or compromised broker can send an extreme declared body size and cause the Go runtime to attempt a correspondingly large allocation before body data is received. The allocation can exhaust memory and terminate the client process. This issue is fixed in version 1.13.0.
OpenBMC's IPMI implementation, phosphor-net-ipmid, contains a logic flaw in which an unauthenticated client can force the RAKP Message 1 handler to return before it overwrites the authentication object's constructor defaults. The IPMI service then accepts a RAKP Message 3 whose HMAC is computed with the constant 20-byte 'userKey' initialized from the string '0penBmc' and an often-predictable 'bmcRandomNum'. Several downstream vendors implement phosphor-net-ipmid as their IPMI stack, such as NVIDIA and H3C.
A critical vulnerability in the Linux kernel's Ceph client was resolved involving improper bounds checking in the handle_session() function. The flaw allows a malicious or compromised Metadata Server (MDS) to cause an out-of-bounds read of up to 4 GiB during session setup, potentially crashing the client kernel. This occurs because certain byte string copies lack proper bounds checks, unlike other fields in the same message. The issue is fixed by switching to safe decode functions that enforce bounds checking.
A vulnerability in the Linux kernel's libceph component allows a malicious or compromised authenticated Ceph OSD peer to crash a kernel Ceph client by sending a malformed sparse-read reply. The issue arises because the client does not properly validate that each OSD-supplied extent is monotonic and within the original request range, which can cause the client to advance the message-data cursor beyond the request buffer and trigger a kernel crash.
An information leakage vulnerability exists in the Endpoint DLP component (epdlpdrv.sys) of Netskope Client for Windows prior to version R141. An internal communication channel used by the user-space hook DLL to pass messages through the kernel driver to the daemon lacked proper token-based message validation, allowing local unprivileged processes to send unauthorized queries. Additionally, a reply buffer used by the port message handler was not properly initialized before returning data, leaking residual kernel pool memory from prior allocations. A local unprivileged attacker could exploit this vulnerability to enumerate DLP configuration and feature flags, extract live session tokens, and read kernel memory fragments from other users' operations.
Red Hat AMQ Broker 7.14.1 is a high-performance messaging implementation based on ActiveMQ Artemis. The 7.14.1 release includes multiple security fixes addressing a wide range of vulnerabilities such as authentication bypass, denial of service, arbitrary code execution, information disclosure, cross-site scripting, and prototype pollution across various components and dependencies. These vulnerabilities affect components like bcprov-jdk18on, Eclipse Jetty, undici, Netty, Apache ActiveMQ, Axios, and others. The update is rated as important by Red Hat Product Security and addresses critical security issues that could impact message broker operations and client interactions.
A vulnerability in Fortinet's fortimon3_74.sys kernel driver allows any local administrator to terminate protected processes, including Windows Defender and lsass.exe, by sending an 8-byte message to an unauthenticated communication port. This bypasses Protected Process Light (PPL) protections without requiring complex exploitation techniques. Additionally, a handle leak issue may enable credential theft by duplicating a handle to a protected process. The vulnerability requires local administrator privileges and affects the FortiClient anti-exploit minifilter driver.
When the broker is processing message-based management requests, sent by an authenticated messaging client that is authorized with MANAGE permission to perform management-via-messaging, the parameter processing can trigger Java deserialization of certain method parameters that the broker will not utilise. The permitted types allow to craft a payload causing excessive computation and pinning the processing thread, leading to denial of service.
This issue affects Apache Artemis: from 2.50.0 through 2.56.0; Apache ActiveMQ Artemis: from 1.3.0 through 2.44.0.
Users are recommended to upgrade to version 2.57.0, which fixes the issue.
An authenticated client could attach a consumer with a selector containing crafted wildcard usage that results in excessive evaluation during message delivery attempts, occupying a shared broker thread and leading to denial of service.
This issue affects Apache Artemis: from 2.50.0 through 2.56.0; Apache ActiveMQ Artemis: from 1.0.0 through 2.44.0.
Users are recommended to upgrade to version 2.57.0, which fixes this issue.
GitPython versions up to 3.1.58 contain a vulnerability in the TagReference.create() method where a positional 'reference' argument bypasses the unsafe option guard for '--file', enabling an attacker to read arbitrary local files. This occurs because the guard only inspects keyword arguments, allowing '--file=<path>' passed positionally to reach the underlying git tag command and return file contents as the annotated tag message. The vulnerability requires the embedding application to forward user-controlled input to this method. A fix is available in version 0.7.2_7.
WWBN AVideo through commit e01e41ecc (no patched version available) exposes get_api_preauthorize in plugin/API/API.php as a second, undocumented login path. Unlike get_api_signIn, which enforces a rate limit of 10 attempts per 5 minutes via checkRateLimit(), get_api_preauthorize performs the same credential check with no throttling for any client, allowing unlimited remote password guessing against arbitrary accounts, including admin. The endpoint also acts as a credential oracle: it returns the message "Invalid credentials" for both correct and incorrect passwords, while the users_id field in the response body discloses the authenticated identity (users_id:1 on success, users_id:0 on failure), and a correct password establishes a session cookie that remains usable for authenticated API requests. Together these issues permit unauthenticated brute-force account takeover.
This is the official web site of tcpdump, a powerful command-line packet analyzer; and libpcap, a portable C/C++ library for network traffic capture.
Security Fix(es):
In BPF instructions that load/store a value from/to a scratch memory register the register index is an unsigned 32-bit integer and must not exceed 15, but libpcap BPF interpreter does not validate the value. In particular uncommon use cases a crafted filter program can cause the interpreter to try reading and writing the OS process memory in the 16GiB starting at the current stack frame on 64-bit architectures and in the entire address space on 32-bit architectures.(CVE-2026-0799)
The rpcap client code that processes a RPCAP_MSG_PACKET message received from the server incorrectly validates its headers. A malicious server can send a crafted message and cause the client to treat up to 20 bytes of the client process memory beyond the end of the buffer as if it was a part of the captured packet.(CVE-2026-18238)
rpcapd can allocate up to 65536 bytes per each RPCAP_MSG_UPDATEFILTER_REQ or RPCAP_MSG_STARTCAP_REQ message received from the client, but it never frees the memory, so it leaks memory even under normal use. A malicious client can cause the server to leak memory substantially faster.(CVE-2026-18313)
libpcap BPF interpreter calls abort() if it encounters a BPF instruction that has an invalid opcode. In particular uncommon use cases a crafted filter program can terminate the OS process.(CVE-2026-31911)
libpcap BPF interpreter detects neither reaching the end of the filter program buffer due to lack of a return instruction nor executing a jump instruction with an offset that translates to a pointer outside of the buffer. In particular uncommon use cases a crafted filter program can cause the interpreter to try reading the OS process memory in the 32GiB around the buffer on 64-bit architectures and in the entire address space on 32-bit architectures.(CVE-2026-31912)
libpcap BPF interpreter for the 'div #k' and 'mod #k' ALU instructions does not check whether the immediate value is zero. In particular uncommon use cases a crafted filter program can cause a division by zero.(CVE-2026-6244)
libpcap BPF interpreter treats the offset in the 'ja L' BPF instruction as a signed integer to implement looping via backward jumps, but it does not limit the number of loop iterations. In particular uncommon use cases a crafted filter program can cause the interpreter to loop infinitely.(CVE-2026-6554)
A vulnerability in the undici WebSocket client for Node.js causes the process to crash when processing a specially crafted permessage-deflate compressed message that exceeds the decompressed payload size limit and contains a malformed DEFLATE block. This triggers an unhandled error in the internal zlib InflateRaw stream, leading to process termination. The issue affects undici versions 6.25.0 through before 6.28.1, 7.28.0 through before 7.29.1, and 8.1.0 through before 8.10.2. No workaround is available, but patched versions have been released.
Allocation of Resources Without Limits or Throttling vulnerability in elixir-mint mint allows a remote HTTP server to exhaust memory on the client host and cause a denial of service.
Two HTTP/1 response-parser states accumulate server data without any cap. In lib/mint/http1.ex, decode_status_line/4 stores the unconsumed data in conn.buffer when the status line is incomplete, and decode_body/5 does the same for an unterminated chunk-extension line. Both wait for a CRLF the server never has to send, and conn.buffer is prepended to every subsequent socket message. The :max_header_list_size budget is wired only into decode_headers/5 and decode_trailer_headers/4, so neither of these states is covered by it. A malicious server, or one reached through an attacker-controlled redirect or a fetched URL, streams bytes indefinitely until the BEAM node is killed by the operating system out-of-memory handler. The chunk-extension variant is reached after a valid status line and a complete, valid header section, so an intermediary inspecting only headers sees an ordinary 200 response.
This issue affects mint: from 0.1.0 before 1.10.0.
Inefficient Algorithmic Complexity vulnerability in elixir-mint mint allows a remote HTTP server to exhaust CPU on the client host and cause a denial of service.
parse_hex_prefix/2 in lib/mint/http1/parse.ex folds each hex digit of a chunked response's chunk-size field into an arbitrary-precision accumulator with acc * 16 + digit and imposes no limit on the digit count. Because the accumulator grows without bound, the multiplication is not constant time and one pass over N digits costs O(N squared). handle_data/2 prepends conn.buffer and re-parses from the start on every socket message, so a server that dribbles the digits out in small packets makes the client pay that cost repeatedly. A run of roughly 512,000 hex digits costs over ten seconds of CPU in a single pass, measured on stock defaults. The parser reaches this state after a valid status line and a complete, valid header section, so an intermediary inspecting only headers sees an ordinary 200 response.
This issue affects mint: from 1.9.3 before 1.10.0.