Use-after-free in the RTMP protocol implementation in Apache bRPC (version < 1.18.0) on all platforms allows a malicious RTMP peer to crash the process or potentially corrupt memory via a crafted Abort message.
Root Cause:
When processing an RTMP Abort (protocol control message type 2), the RTMP policy implementation deleted the target RtmpChunkStream object. The send path (RtmpUnsentMessage::AppendAndDestroySelf -> RtmpChunkStream::SerializeMessage) runs concurrently on sender threads and dereferences the same RtmpChunkStream object without synchronization. If a remote peer sends an Abort message naming a chunk stream that is concurrently being used to serialize an outgoing message, the stream object is freed while still in use, resulting in a use-after-free. Additionally, deleting the chunk stream discarded its previous message header, so subsequent compressed (type-3) chunk headers on that stream could no longer be decoded.
Affected Scenarios:
Any application using the bRPC RTMP protocol implementation (rtmp policy), either as an RTMP server or as an RTMP client, where the remote endpoint is untrusted. The attacker needs to send an Abort message targeting a chunk stream id that is concurrently used for sending, which can crash the process or lead to memory corruption.
How to Fix:
(Choose one of the following options)
1. Upgrade bRPC to version 1.18.0, which fixes this issue.
2. Apply this patch: https://github.com/apache/brpc/pull/3515
CVE-2026-80463 is a high-severity vulnerability in Apache bRPC versions prior to 1.18.0 that allows remote attackers to cause a denial of service by exhausting server memory. The issue arises from unbounded memory accumulation in the stream message reassembly process when handling fragmented stream messages without limits on the accumulated size. This can be exploited by sending an endless sequence of continuation data frames, causing the server process to crash or become unavailable. The vulnerability affects services accepting streams from untrusted clients using the built-in streaming protocol.
CVE-2026-78066 is a resource exhaustion vulnerability in Apache bRPC versions prior to 1.18.0. Multiple parsers handling wire-controlled input do not limit the sizes declared by clients or the decompressed output, allowing attackers to cause excessive memory consumption and crash the service. The issue affects gzip/zlib/snappy decompressors, AMF string readers, RTMP chunk headers, sofa-pbrpc parser, and mcpack2pb message handling. The vulnerability is fixed in Apache bRPC version 1.18.0.
Generation of Error Message Containing Sensitive Information vulnerability in Apache Camel gRPC component.
This issue affects Apache Camel: from 4.0.0 before 4.18.5, from 4.19.0 before 4.22.1.
When a route behind a gRPC consumer failed, the exception's message was placed into the gRPC status description. Unlike the status cause, which stays local to the server, the description is transmitted to the calling client, so an external caller able to provoke a failure could read the internal error message. What that discloses depends on the exception, and in practice includes class and package names, paths, host names and connection detail carried in messages. This is the gRPC member of the same unmuted-consumer-exception family as the knative, mina and CXF advisories published alongside it.
Upgrade to Apache Camel 4.23.0, which fixes the issue. Users on the 4.18.x LTS releases stream should upgrade to 4.18.5. Users on the 4.22.x LTS releases stream should upgrade to 4.22.1. A muteException consumer option, defaulting to true, puts a generic description in the status instead of the route exception's message. Set muteException=false to restore the previous output. For deployments that cannot upgrade immediately, map failures onto an explicit status in an onException handler so the framework never copies the exception message into the description.
Generation of Error Message Containing Sensitive Information vulnerability in Apache Camel CXF component.
This issue affects Apache Camel: from 4.0.0 before 4.18.5, from 4.19.0 before 4.22.1.
When a route behind a CXF SOAP consumer failed with an exception the service contract does not declare, the exception was described back to the SOAP client in the fault: CXF copies the message into the SOAP faultstring, and can be configured to place the stack trace in the fault detail. An external caller able to provoke a failure could therefore read internal detail about the deployment - class and package names, and whatever the exception message carries. Declared faults, annotated @WebFault, are a different matter: those are part of the published contract that clients are written against, and suppressing them would break the service rather than protect anything.
Upgrade to Apache Camel 4.23.0, which fixes the issue. Users on the 4.18.x LTS releases stream should upgrade to 4.18.5. Users on the 4.22.x LTS releases stream should upgrade to 4.22.1. A muteException consumer option, defaulting to true, replaces an undeclared route failure with a generic fault carrying no class name, message or stack trace. Faults the contract declares are reported exactly as before. Set muteException=false to restore the previous output. For deployments that cannot upgrade immediately, declare the exceptions the service is allowed to report and map every other failure onto one of them in an onException handler, so no undeclared exception reaches the fault.
A vulnerability in the Linux kernel SMB client was fixed that caused improper handling of compound message IDs (mids) on send failure. Specifically, when sending a compound request fails, the mids remain on a pending queue and are not properly deleted before unlocking the server, leading to double decrementing of credits and kernel warnings. This issue was observed during SMB2 negotiation when socket send fails. The fix involves deleting mids on send failure before unlocking to prevent double credit decrement and warnings.
CVE-2026-105958 is a high-severity vulnerability in the spice-server component of Red Hat Enterprise Linux 6. It involves multiple migration data handlers that use client-supplied offsets without proper bounds validation, allowing an authenticated SPICE client during VM live migration to perform out-of-bounds read and write operations on the message buffer. This can lead to arbitrary heap memory reads or heap corruption, potentially compromising the hypervisor process and breaking virtualization boundaries. Exploitation requires valid SPICE client credentials and the VM to be undergoing live migration. Mitigations include disabling live migration if not needed, restricting SPICE client network access, and enforcing strong authentication. A patch is available in updated Spice Server builds that properly validate migration data offsets and buffer lengths.
CVE-2026-103224 is a high-severity vulnerability in Eclipse Vert.x's MySQL client component. It affects versions 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and version 5.2.0. The vulnerability arises from the MySQL message decoder aggregating inbound multi-packet payloads into a composite direct-memory buffer without enforcing a cumulative size limit. A malicious or compromised MySQL server can exploit this by sending a continuous stream of maximum-length packets, preventing the end-of-message condition and causing unbounded memory allocation on the client, leading to an out-of-memory crash before authentication completes.
CVE-2026-103223 is a high-severity vulnerability in Eclipse Vert.x's PostgreSQL client (io.vertx:vertx-pg-client). In affected versions, the PostgreSQL message decoder reads a 4-byte message length field without validating its maximum size. A malicious or compromised PostgreSQL server can send a message with an extremely large length value, causing unbounded memory allocation on the client and potentially leading to an out-of-memory crash before authentication completes.
Eclipse Vert.x versions 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and version 5.2.0 contain a vulnerability in the vertx-mssql-client component. The TDS message decoder aggregates inbound TDS packets into a composite direct-memory buffer without a cumulative size limit. A malicious or compromised SQL Server can exploit this by sending continuous TDS packets without the END_OF_MESSAGE flag, causing unbounded memory allocation and an out-of-memory crash before authentication completes.
Eclipse Vert.x versions 4.0.0 through 4.5.34, 5.0.0 through 5.0.12, 5.1.0 through 5.1.9, and 5.2.0 contain a vulnerability in the vertx-mail-client component. The issue arises because CR (\r) and LF (\n) characters in user-supplied email header names and values are not sanitized before being written into the SMTP DATA section. This allows an attacker controlling these inputs to inject arbitrary email headers or manipulate the message body. Additionally, MIME part metadata fields are also affected by this lack of validation. A secondary weakness permits a bare LF in a From display-name to bypass encoding and be sent unchanged. Exploitation requires the attacker to control header or attachment metadata fields passed to the mail client, such as through a web form or API. The vulnerability has a CVSS 4.0 score of 6.9 (medium severity).
CVE-2026-103415 is a critical out-of-bounds write vulnerability in the Eclipse Foundation's NetX Duo TLS 1.3 client implementation. When processing a HelloRetryRequest, the client copies the server's cookie into the second ClientHello message without verifying that the cookie fits within the allocated packet buffer. This flaw allows a malicious or compromised server to overwrite memory beyond the intended buffer before certificate authentication completes. Only the client-side TLS path is affected.
CVE-2026-91882 is a high-severity vulnerability in Dell Terraform Provider for OME versions 1.0.0 through 1.2.3. It involves the generation of error messages that contain sensitive information due to improper error handling in the API client component. An unauthenticated remote attacker could exploit this flaw to gain access to sensitive data. The vulnerability is classified under CWE-209, which relates to information exposure through error messages.
Rustls versions before 0.23.46 have a vulnerability where an unauthenticated ServerHello message can cause the client to downgrade future TLS connections to classical key exchange only, losing post-quantum confidentiality. This occurs because the client records the server-selected key exchange group before server authentication and uses it for future connections. A network attacker can exploit this by responding with a ServerHello selecting a classical group, causing subsequent connections to omit the post-quantum hybrid key exchange. There is no key compromise or authentication bypass. The issue is fixed in Rustls 0.23.46.
## Summary
nginx-ui supports two second-factor methods — TOTP (OTP) and WebAuthn passkeys —
and reports an account as 2FA-enabled when **either** is configured. However, the
password login endpoint (`POST /api/login`) only enforces a second factor when a
**TOTP secret** is present. An account that has registered a **passkey but no
TOTP** is logged in after password verification alone — the passkey is never
requested. This silently downgrades a passkey-protected account to single-factor
(password-only) authentication.
## Details
The account's 2FA policy treats passkeys as a valid factor (`model/user.go`):
```go
func (u *User) EnabledOTP() bool { return len(u.OTPSecret) != 0 }
func (u *User) EnabledPasskey() bool { /* true if a passkey row exists */ }
func (u *User) Enabled2FA() bool { return u.EnabledOTP() || u.EnabledPasskey() }
func (u *User) AfterFind(_ *gorm.DB) error {
u.EnabledTwoFA = u.Enabled2FA() // exposed to the UI as `enabled_2fa`
return nil
}
```
But the login handler only checks `EnabledOTP()` (`api/user/auth.go`, `Login`):
```go
u, err := user.Login(json.Name, json.Password)
...
if u.EnabledOTP() { // <-- only TOTP is enforced
if json.OTP == "" && json.RecoveryCode == "" {
c.JSON(http.StatusOK, LoginResponse{Message: "The user has enabled 2FA", Code: Enabled2FA}) // 199
user.BanIP(clientIP)
return
}
if _, err = user.VerifyOTP(u, json.OTP, json.RecoveryCode); err != nil { /* ... */ }
secureSessionID = user.SetSecureSessionID(u.ID)
}
// Passkey-only accounts fall through to here and receive a full session token:
accessToken, err := user.GenerateJWT(u)
```
No branch requires a WebAuthn assertion during password login when
`EnabledPasskey()` is true. The root cause is the mismatch between the
**policy definition** (`Enabled2FA()` = OTP **or** passkey) and the
**enforcement check** (`EnabledOTP()` only).
The same `EnabledOTP()`-only gating in `RequireSecureSession()`
(`internal/middleware/secure_session.go`) means passkey-only users are also
exempted from step-up on sensitive actions.
## Proof of Concept
Tested against nginx-ui built from source (`go build -tags unembed`) on
`127.0.0.1:9000`, with WebAuthn configured and a victim account that has a
registered passkey and **no** TOTP. The vulnerable code is identical on the
production `main` branch (`api/user/auth.go` `Login` gates on `u.EnabledOTP()`
only; verified at commit `6c86e5a`, 2026-05-17).
Account state advertised by `GET /api/2fa_status`:
```json
{"enabled":true,"otp_status":false,"passkey_status":true, ...}
```
Attacker logs in with **password only** (`POST /api/login`, encrypted params as
the client normally sends):
```
HTTP 200
{"message":"ok","code":200,"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...."}
```
`code: 200` + a valid JWT = an authenticated session, with the passkey never
used. For comparison, the identical account with a TOTP secret instead correctly
returns the second-factor challenge:
```
HTTP 200
{"message":"The user has enabled 2FA","code":199}
```
| Account state | `POST /api/login` (password only) |
|---|---|
| Passkey registered, no TOTP | `code 200` + JWT — **2FA NOT enforced** |
| TOTP registered | `code 199` — 2FA challenge enforced |
This isolates the defect: the login path enforces OTP but ignores passkeys.
## Impact
- Any account protected **only** by a passkey is reduced to password-only
authentication. An attacker who obtains the password (phishing, reuse, leak)
gains full access despite the registered security key.
- In nginx-ui all authenticated users are effectively administrators and the
terminal feature grants a host shell, so account takeover leads to full
control of the managed nginx instance / host.
- Users are given a false sense of security: the UI shows the account as
2FA-enabled while the second factor is not enforced at login.
## Remediation
- Gate the second-factor decision on `u.Enabled2FA()` (not `u.EnabledOTP()`) in
`Login`, in both SSO callbacks, and in `RequireSecureSession()`.
- For a passkey-only user logging in with a password, return a
"passkey assertion required" challenge and complete login only after a
successful WebAuthn assertion (the `begin_passkey_login` / `finish_passkey_login`
flow already exists and should be required as the second step).
- Centralize session-token issuance so no login entry point can skip the 2FA
decision.
## Affected components
- `api/user/auth.go` — `Login`
- `model/user.go` — `EnabledOTP`, `EnabledPasskey`, `Enabled2FA`, `AfterFind`
- `api/user/2fa.go` — `get2FAStatus`
- `internal/middleware/secure_session.go` — `RequireSecureSession`