Nov 20, 2026·9 min read·1 visit
An authenticated user in OpenRemote (< 1.31.0) can terminate arbitrary MQTT sessions across any realm via the GET /{realm}/disconnect/{sessionID} endpoint due to a complete absence of session ownership, role, and realm validation checks.
OpenRemote prior to version 1.31.0 contains a Missing Authorization vulnerability (CWE-862) in the user management REST API endpoint responsible for disconnecting active MQTT sessions. The disconnectUserSession method in UserResourceImpl fails to verify whether the requesting user owns the target MQTT session, holds administrative privileges, or belongs to the realm specified in the request path. As a result, any authenticated user who obtains a valid MQTT session identifier can forcefully terminate active MQTT connections belonging to other users or IoT devices across any tenant realm.
OpenRemote is an open-source Internet of Things (IoT) device management platform built on a multi-tenant architecture using realms. Within OpenRemote Core, real-time telemetry and device communication rely heavily on MQTT connections managed centrally by the MQTTBrokerService component. Administrative and user-level operations over these sessions are exposed via a JAX-RS REST API defined in org.openremote.model.security.UserResource and implemented in org.openremote.manager.security.UserResourceImpl.
Prior to version 1.31.0, the HTTP endpoint GET /{realm}/disconnect/{sessionID} suffered from a Missing Authorization vulnerability, tracked as CVE-2026-104885 (GHSA-3h6w-xcw3-9xjj) and classified under CWE-862 (specifically manifesting as Broken Object Level Authorization / Insecure Direct Object Reference). When invoked, the endpoint directly instructed the underlying MQTT broker service to terminate the connection matching {sessionID} without executing any identity, privilege, or tenant boundary verification.
Because MQTTBrokerService stores all active Netty channel connections in a single global map (connectionIDConnectionMap) shared across all tenants, the absence of authorization checks breaks multi-tenant isolation. An attacker with basic authenticated access in one realm can terminate MQTT sessions belonging to users or edge devices in the same realm (horizontal privilege escalation) or in completely separate realms (cross-tenant disruption).
The impact of this vulnerability is restricted to availability (VA:L in CVSS v4.0). It does not allow the attacker to read session contents, hijack the MQTT connection stream, or modify telemetry data. However, in industrial or automated IoT deployments, repeated unauthorized termination of active MQTT sessions can disrupt real-time telemetry ingestion and command delivery to field devices.
The root cause of CVE-2026-104885 is the omission of security context validation inside UserResourceImpl.disconnectUserSession combined with the absence of a mechanism in MQTTBrokerService to resolve the owning user identity from a raw sessionID prior to disconnection.
In OpenRemote's architecture, REST endpoints that operate on realm-scoped resources are expected to validate three security invariants: that the target resource actually belongs to the {realm} parameter supplied in the URI path, that the authenticated caller has read and access rights to that realm, and that the caller either owns the target resource or holds the write:admin client role (or superuser status). In the vulnerable implementation of disconnectUserSession, none of these checks were present.
When a request reached UserResourceImpl.disconnectUserSession(RequestParams requestParams, String realm, String sessionID), the method completely ignored both the requestParams and realm arguments. It passed sessionID directly to mqttBrokerService.disconnectSession(sessionID). Furthermore, in the JAX-RS interface definition UserResource.java, the route lacked method-level @RolesAllowed annotations or an interceptor enforcing cross-realm access guards.
At the broker layer, MQTTBrokerService maintains active client sessions in connectionIDConnectionMap, which maps the unique Netty channel / connection ID string to a RemotingConnection instance. Because disconnectSession(String connectionID) performs a direct key lookup against this global map and invokes doForceDisconnect(connection) without inspecting the Subject attached to the RemotingConnection, any valid sessionID present in the broker's memory space is unconditionally closed.
Additionally, related user resource operations in UserResourceImpl (such as query, updateCurrent, requestPasswordResetCurrent, and updatePasswordCurrent) lacked consistent enforcement of throwIfNotRealmActiveAndAccessible(realm). While secondary to the session disconnect flaw, this allowed authenticated actors to interact with user management routines even if their associated realm had been deactivated.
Comparing the vulnerable code prior to version 1.31.0 with the fix introduced in commit 51dce18d9e00d671a5e032d942ece186bdada560 illustrates how the authorization gap was closed across both MQTTBrokerService.java and UserResourceImpl.java.
Prior to the patch, disconnectUserSession in manager/src/main/java/org/openremote/manager/security/UserResourceImpl.java consisted of a single conditional check:
@Override
public void disconnectUserSession(RequestParams requestParams, String realm, String sessionID) {
// VULNERABLE: 'realm' parameter is completely unused.
// No check on caller identity (getUserId()), caller roles, or session ownership.
if (!mqttBrokerService.disconnectSession(sessionID)) {
throw new NotFoundException("User session not found");
}
}To enable ownership verification, the patch first updates manager/src/main/java/org/openremote/manager/mqtt/MQTTBrokerService.java to expose a helper method, getConnectionUserId(String connectionID). This method inspects the internal connectionIDConnectionMap, retrieves the RemotingConnection object, and extracts the authenticated subject's user ID via IdentityProvider.getSubjectId():
// Added to manager/src/main/java/org/openremote/manager/mqtt/MQTTBrokerService.java
public String getConnectionUserId(String connectionID) {
RemotingConnection connection = connectionIDConnectionMap.get(connectionID);
return connection == null ? null : IdentityProvider.getSubjectId(connection.getSubject());
}Next, UserResourceImpl.disconnectUserSession was refactored to resolve the session owner, verify realm alignment, enforce realm read permissions, and check caller privileges before allowing the disconnection to proceed:
@Override
public void disconnectUserSession(RequestParams requestParams, String realm, String sessionID) {
// 1. Resolve the user ID associated with the target MQTT session
String connectionUserId = mqttBrokerService.getConnectionUserId(sessionID);
if (connectionUserId == null) {
throw new NotFoundException("User session not found");
}
// 2. Load the owning User entity from the identity provider
User connectionUser = identityService.getIdentityProvider().getUser(connectionUserId);
if (connectionUser == null) {
throw new NotFoundException("User not found");
}
// 3. Verify the target user belongs to the realm specified in the URL path
String connectionRealm = connectionUser.getRealm();
if (!connectionRealm.equals(realm)) {
throw new NotFoundException("User session not found in realm");
}
// 4. Verify the caller has permission to access/read the user in that realm
// (Also transitively checks realm accessibility and active status)
throwIfCannotReadUserInRealm(connectionRealm, connectionUserId);
// 5. Verify the caller either holds the 'write:admin' role / superuser status
// OR is disconnecting their own session
boolean hasAdminWriteRole =
hasResourceRoleOrIsSuperUser(
ClientRole.WRITE_ADMIN.getValue(), Constants.KEYCLOAK_CLIENT_ID);
if (!hasAdminWriteRole && !Objects.equals(getUserId(), connectionUserId)) {
throw new ForbiddenException(
"Can only disconnect own user sessions unless you have role '"
+ ClientRole.WRITE_ADMIN
+ "'");
}
// 6. Execute the disconnect only after all authorization checks pass
if (!mqttBrokerService.disconnectSession(sessionID)) {
throw new NotFoundException("User session not found");
}
}In addition to fixing disconnectUserSession, commit 51dce18d9e00d671a5e032d942ece186bdada560 hardens several other methods in UserResourceImpl.java (query, updateCurrent, requestPasswordResetCurrent, updatePasswordCurrent, throwIfNotSameRealm, and throwIfCannotAdminRealm) by inserting calls to throwIfNotRealmActiveAndAccessible(realm). The fix is comprehensive for this code path: by returning a generic NotFoundException when connectionRealm.equals(realm) fails, it also prevents cross-realm oracle attacks that might otherwise confirm whether a given sessionID belongs to a different tenant.
Exploiting CVE-2026-104885 requires two prerequisites: the attacker must hold a valid authenticated session (e.g., a standard low-privilege user account or OAuth/JWT bearer token) in any active realm on the OpenRemote instance, and the attacker must know or discover the sessionID of an active MQTT connection.
Because OpenRemote uses Netty channel identifiers for MQTT session IDs, these identifiers are high-entropy and not feasible to brute-force over the network. This requirement accounts for the High Attack Complexity (AC:H) rating in the CVSS v4.0 vector. However, an attacker can obtain valid session identifiers through several realistic avenues:
getUserSessions via GET /{realm}/sessions/{userId} with read:admin or similar read permissions, but lacking write:admin), they can harvest active sessionID strings directly from the JSON response and use the vulnerable disconnect endpoint to terminate them.Once a target sessionID (for example, 00112233-4455-6677-8899-aabbccddeeff belonging to a critical gateway in tenant-b) is obtained, an attacker authenticated to tenant-a sends a standard HTTP GET request:
GET /api/master/user/tenant-a/disconnect/00112233-4455-6677-8899-aabbccddeeff HTTP/1.1
Host: openremote.example.com
Authorization: Bearer <low_privilege_jwt_for_tenant_a>
Accept: application/jsonWhen the vulnerable OpenRemote Manager processes this request:
tenant-a and populates authContext.UserResourceImpl.disconnectUserSession with realm = "tenant-a" and sessionID = "00112233-4455-6677-8899-aabbccddeeff".mqttBrokerService.disconnectSession(sessionID) looks up the ID in connectionIDConnectionMap, locates the Netty channel for the tenant-b IoT gateway, and forcefully closes the TCP/MQTT connection.204 No Content, confirming that the session existed and was terminated.> [!NOTE]
> If the supplied sessionID does not exist in connectionIDConnectionMap, the endpoint returns 404 Not Found ("User session not found"). While brute-forcing random Netty IDs is impractical, this differential response confirms whether a leaked session ID is still actively connected.
The security impact of CVE-2026-104885 is scored under CVSS v4.0 at 6.3 (Medium) with the vector string CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N. The vulnerability impacts system availability (VA:L) without compromising confidentiality (VC:N) or integrity (VI:N).
In a multi-tenant OpenRemote deployment, different realms are often assigned to separate customers, organizational units, or geographical sites. By bypassing realm isolation and role checks, an attacker in one realm can repeatedly disconnect MQTT clients operating in other realms. Similarly, within a single realm, a low-privileged user or read-only operator can terminate MQTT connections belonging to administrators or automated service accounts.
Although most well-designed MQTT clients implement automatic reconnection logic with exponential backoff, an attacker who can continuously observe or re-query session IDs (for instance, a user with read-only monitoring rights in the same realm calling getUserSessions in a loop) can automate disconnection requests to cause a sustained Denial of Service (DoS) against specific devices.
For time-sensitive IoT workloads—such as industrial telemetry reporting, real-time asset tracking, or automated command-and-control triggers—forced session drops during critical publish/subscribe windows can result in missed messages (particularly for QoS 0 traffic or non-persistent MQTT sessions), delayed actuation, and state desynchronization between edge gateways and the OpenRemote Manager.
According to current threat intelligence, CVE-2026-104885 has an EPSS score of 0.00321 (25.75th percentile), is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, and has no known public weaponized exploits in the wild.
The primary remediation is to upgrade OpenRemote Core (openremote/core) to version 1.31.0 or later. Version 1.31.0 incorporates commit 51dce18d9e00d671a5e032d942ece186bdada560, which enforces session ownership verification, realm matching, realm active status checks, and write:admin role validation on the GET /{realm}/disconnect/{sessionID} endpoint.
For environments where an immediate upgrade to version 1.31.0 cannot be scheduled, administrators should implement compensating controls at the reverse proxy (e.g., NGINX, HAProxy, Traefik) or API Gateway layer to restrict access to the disconnect route:
# Example NGINX location block to block external access to the MQTT session disconnect endpoint
location ~* ^/api/[^/]+/user/[^/]+/disconnect/ {
# Optionally allow only trusted internal management subnets
# allow 10.0.0.0/8;
deny all;
return 403;
}In addition to blocking or restricting the endpoint at the network edge, operators should review access control policies and logging configurations:
getUserSessions), reducing the likelihood of internal session ID harvesting.sessionID parameters to unauthorized personnel.CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N| Product | Affected Versions | Fixed Version |
|---|---|---|
OpenRemote Core OpenRemote | < 1.31.0 | 1.31.0 |
| Attribute | Detail |
|---|---|
| CVE / GHSA ID | CVE-2026-104885 / GHSA-3h6w-xcw3-9xjj |
| Weakness Class | CWE-862: Missing Authorization (BOLA / IDOR) |
| CVSS v4.0 Score | 6.3 Medium (CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N) |
| EPSS Score | 0.32% (25.75th Percentile) |
| Affected Component | UserResourceImpl.disconnectUserSession (GET /{realm}/disconnect/{sessionID}) |
| Impact | Unauthorized cross-realm and horizontal termination of active MQTT sessions |
| Patched Version | OpenRemote Core 1.31.0 |
| CISA KEV / Exploit Status | Not Listed in KEV / No public weaponized exploits |
The software does not perform an authorization check when an actor attempts to access a resource or perform an action.
CVE-2026-69133 (GHSA-cg26-4c6j-2x8h) is a missing resource release vulnerability (CWE-772) in io.netty.incubator:netty-incubator-codec-ohttp affecting versions 0.0.20.Final through 0.0.26.Final. Both OHttpClientCodec and OHttpServerCodec retain the outer cumulationBuffer at its expanded high-water capacity after an Oblivious HTTP (OHTTP) exchange finishes. A remote unauthenticated attacker can complete a large OHTTP request or response over an HTTP keep-alive connection and leave the connection idle, pinning pooled or direct memory allocations across concurrent connections to induce denial of service.
A session fixation vulnerability (CWE-384) exists in CKAN (Comprehensive Knowledge Archive Network) prior to versions 2.10.11 and 2.11.6. When configured with server-side session storage and active public web registration, the user registration view programmatically authenticates newly created accounts without regenerating the active session identifier. An attacker capable of fixing or capturing a victim's pre-authentication session cookie can hijack the newly registered account immediately after registration completes.
CVE-2026-35374 is a Time-of-Check to Time-of-Use (TOCTOU) race condition (CWE-367) in the split utility of uutils coreutils. The utility validates that the input and output paths do not refer to the same file before opening the output file with truncation flags. A local attacker with write permissions in the destination directory can replace the output file path with a symbolic link during this race window, causing the process to truncate and overwrite arbitrary files accessible to the user executing split.
CVE-2026-35377 is an improper input validation vulnerability (CWE-20) in the env utility of uutils coreutils, the Rust-based reimplementation of GNU coreutils. When processing command-line arguments with the -S (--split-string) option, the uutils split-string tokenizer erroneously validates backslash sequences enclosed within single quotes against a fixed table of known escape characters. Under standard GNU env behavior, backslashes inside single quotes are treated literally (except for \\ and \'). Because uutils rejects unrecognized sequences such as \a, \x, or \| with exit code 125, automated scripts, shebang invocations, and administrative workflows relying on POSIX/GNU compatibility fail to execute, resulting in a local denial of service.
A Time-of-Check to Time-of-Use (TOCTOU) race condition in the chcon utility of uutils coreutils prior to version 0.8.0 allows a local attacker with write access to a directory tree undergoing recursive SELinux context relabeling to redirect extended attribute modifications to arbitrary system files.
A line delimiter injection vulnerability in Git Large File Storage (Git LFS) versions 0.6.0 through 3.8.0 allows remote attackers to execute arbitrary commands via crafted Git submodule URLs containing embedded line feed characters.