CVE-2026-87849

Remote command injection vulnerability in heap profiler builtin service in Apache bRPC (all versions < 1.15.0) on all platforms allows attacker to inject remote command. Root Cause: The bRPC heap profiler built-in service (/pprof/heap) does not validate the user-provided extra_options parameter and executes it as a command-line argument. Attackers can execute remote commands using the extra_options parameter. Affected scenarios: Use the built-in bRPC heap profiler service to perform jemalloc memory profiling. How to Fix: we provide two methods, you can choose one of them: 1. Upgrade bRPC to version 1.15.0. 2. Apply this patch ( https://github.com/apache/brpc/pull/3101 ) manually.

The MySQL client response parser in Apache bRPC dereferences a null pointer when the server peer sends a zero-payload-length response packet. A packet with declared zero payload length passes the frame-length check, after which the parser reads the response type byte via an unbounded 5-byte fetch that returns nullptr, causing type = p[4] to dereference it and crash the client process.

On a brpc::Server that sets both ServerOptions.auth and ServerOptions.internal_port, the HTTP built-in service exemption on internal_port can be abused to bypass authentication entirely. Verification runs only for the first message of a connection and the result latches the connection, so a request such as GET /status to internal_port authenticates the whole connection.

Apache bRPC versions before 1.18.0 expose builtin /flags and /pprof services that allow a remote attacker to change dump paths (bvar_dump_file, bvar_dump_tabs, mbvar_dump_file) and create directories or overwrite files with the server process privileges. Additionally, the ?seconds= parameter in /pprof is not clamped, enabling an attacker to hold the process-wide CPU profiler for an arbitrarily long time.

HTTP request/response smuggling vulnerability in Apache bRPC versions < 1.18.0 stems from inconsistent HTTP/1.1 header parsing in its bundled parser. bRPC accepts malformed header forms (space before colon, spaces in Content-Length values, obs-fold, chunked trailers merged as headers, Transfer-Encoding lists with whitespace), allowing attackers to smuggle requests or headers when bRPC is deployed behind a proxy or load balancer.

Improper authorization in Apache bRPC (versions < 1.18.0) allows remote attackers to access builtin services through the public port. Protobuf-based protocol dispatch paths computed but did not enforce the security_mode flag, allowing invocation of services such as brpc.vars or hotspots.

A vulnerability in Apache bRPC (versions < 1.18.0) stems from an interpretation conflict in HTTP path handling between bRPC and a front proxy. The FindMethodPropertyByURI() function skips empty path segments (consecutive slashes), so paths like //flags are dispatched as /flags, even though RFC 3986 treats them as distinct. Additionally, HTTP/2 does not validate the :path pseudo-header, allowing bypass of proxy ACL rules and access to internal services.

A use-after-free exists in the RTMP protocol implementation in Apache bRPC (version < 1.18.0). A malicious RTMP peer can crash the process or potentially corrupt memory via a crafted Abort message. The root cause is that the receive path deletes the target RtmpChunkStream object while the send path concurrently dereferences it without synchronization.

A NULL pointer dereference in the RTMP protocol implementation in Apache bRPC (versions < 1.18.0) occurs when the server rejects a createStream request by returning a null stream and then fails to write the error response, causing a crash. A remote attacker can trigger a denial of service by sending a crafted createStream command and closing the connection before the rejection response is written.

A data race in the RDMA transport of Apache bRPC (versions < 1.18.0) allows a remote client to crash the server process (denial of service) when RDMA is enabled at build time and runtime. After the RDMA handshake completes, the server keeps parsing the TCP fd as an RPC channel, sharing the input buffer and parser state with RDMA CQ event processing without synchronization, leading to corruption and a crash.