Skip to content

armgit / core

Public Imported from GitHub
0

100% open-source IoT Platform - Integrate your devices, add intelligence, build custom apps

Predicted facade security enforcement (#3330)

Eric Bariauxdb199e86c5ce
diff --git a/AGENTS.md b/AGENTS.md
index 46545faba..7d803f141 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -11,7 +11,13 @@ The backend is written in Java, we target JDK 21, use modern language features u
Gradle is used as the build system; run `./gradlew clean installDist` for a full clean build.
In sandboxed environments, add `--offline` (requires dependencies to already be cached).
-## Running tests
+## Tests
+
+### Writing tests
+
+Since Spock 2.0, unrolling is the default, don't add un-necessary @Unroll annotations.
+
+### Running tests
When running integration tests, part of the stack (PostgreSQL and Keycloak) must be running. Start it with `docker compose -f profile/dev-testing.yml -p openremote up -d --no-build`.
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java b/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java
index 63c8c5118..70ac9b527 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java
@@ -181,7 +181,8 @@ public class RulesEngine<T extends Ruleset> {
this.webhooksFacade = new WebhooksFacade<>(id, webhookService);
this.alarmsFacade = new AlarmFacade<>(id, alarmService);
this.historicFacade = new HistoricFacade<>(id, assetDatapointService);
- this.predictedFacade = new PredictedFacade<>(id, assetPredictedDatapointService);
+ this.predictedFacade =
+ new PredictedFacade<>(id, assetStorageService, assetPredictedDatapointService);
this.assetLocationPredicatesConsumer = assetLocationPredicatesConsumer;
this.facts = new RulesFacts(timerService, assetStorageService, assetsFacade, this, LOG);
diff --git a/manager/src/main/java/org/openremote/manager/rules/facade/PredictedFacade.java b/manager/src/main/java/org/openremote/manager/rules/facade/PredictedFacade.java
index f6ddb436b..41559377e 100644
--- a/manager/src/main/java/org/openremote/manager/rules/facade/PredictedFacade.java
+++ b/manager/src/main/java/org/openremote/manager/rules/facade/PredictedFacade.java
@@ -19,29 +19,42 @@
package org.openremote.manager.rules.facade;
import java.time.LocalDateTime;
+import org.openremote.manager.asset.AssetStorageService;
import org.openremote.manager.datapoint.AssetPredictedDatapointService;
import org.openremote.manager.rules.RulesEngineId;
+import org.openremote.model.asset.Asset;
import org.openremote.model.attribute.AttributeRef;
import org.openremote.model.datapoint.ValueDatapoint;
import org.openremote.model.datapoint.query.AssetDatapointQuery;
+import org.openremote.model.query.AssetQuery;
+import org.openremote.model.query.filter.PathPredicate;
+import org.openremote.model.query.filter.RealmPredicate;
+import org.openremote.model.rules.AssetRuleset;
import org.openremote.model.rules.PredictedDatapoints;
+import org.openremote.model.rules.RealmRuleset;
import org.openremote.model.rules.Ruleset;
public class PredictedFacade<T extends Ruleset> extends PredictedDatapoints {
protected final RulesEngineId<T> rulesEngineId;
+ protected final AssetStorageService assetStorageService;
protected final AssetPredictedDatapointService assetPredictedDatapointService;
public PredictedFacade(
RulesEngineId<T> rulesEngineId,
+ AssetStorageService assetStorageService,
AssetPredictedDatapointService assetPredictedDatapointService) {
this.rulesEngineId = rulesEngineId;
+ this.assetStorageService = assetStorageService;
this.assetPredictedDatapointService = assetPredictedDatapointService;
}
@Override
public ValueDatapoint<?>[] getValueDatapoints(
AttributeRef attributeRef, AssetDatapointQuery query) {
+ if (!doesRuleEngineScopeAllowAccess(attributeRef.getId())) {
+ return new ValueDatapoint[0];
+ }
return assetPredictedDatapointService
.queryDatapoints(attributeRef.getId(), attributeRef.getName(), query)
.toArray(ValueDatapoint[]::new);
@@ -50,11 +63,55 @@ public class PredictedFacade<T extends Ruleset> extends PredictedDatapoints {
@Override
public void updateValue(
String assetId, String attributeName, Object value, LocalDateTime timestamp) {
+ if (!doesRuleEngineScopeAllowAccess(assetId)) {
+ return;
+ }
assetPredictedDatapointService.updateValue(assetId, attributeName, value, timestamp);
}
@Override
public void updateValue(AttributeRef attributeRef, Object value, LocalDateTime timestamp) {
+ // No scope check here, it's already done in called method
updateValue(attributeRef.getId(), attributeRef.getName(), value, timestamp);
}
+
+ private boolean doesRuleEngineScopeAllowAccess(String assetId) {
+ AssetQuery assetQuery = new AssetQuery();
+ assetQuery.ids(assetId);
+
+ if (RealmRuleset.class.isAssignableFrom(rulesEngineId.getScope())) {
+ // Realm is restricted to rules
+ assetQuery.realm =
+ new RealmPredicate(
+ rulesEngineId
+ .getRealm()
+ .orElseThrow(
+ () -> new IllegalArgumentException("Realm missing: " + rulesEngineId)));
+ } else if (AssetRuleset.class.isAssignableFrom(rulesEngineId.getScope())) {
+ // Realm is restricted to assets'
+ assetQuery.realm =
+ new RealmPredicate(
+ rulesEngineId
+ .getRealm()
+ .orElseThrow(
+ () -> new IllegalArgumentException("Realm missing: " + rulesEngineId)));
+
+ Asset<?> restrictedAsset =
+ assetStorageService.find(
+ rulesEngineId
+ .getAssetId()
+ .orElseThrow(
+ () -> new IllegalStateException("Asset ID missing: " + rulesEngineId)),
+ true);
+
+ if (restrictedAsset == null) {
+ throw new IllegalStateException("Asset is no longer available: " + rulesEngineId);
+ }
+ assetQuery.paths(new PathPredicate(restrictedAsset.getPath()));
+ }
+
+ assetQuery.select = new AssetQuery.Select().excludeAttributes();
+
+ return assetStorageService.find(assetQuery) != null;
+ }
}
diff --git a/test/src/test/groovy/org/openremote/test/rules/PredictedFacadeTest.groovy b/test/src/test/groovy/org/openremote/test/rules/PredictedFacadeTest.groovy
new file mode 100644
index 000000000..67dd7a06b
--- /dev/null
+++ b/test/src/test/groovy/org/openremote/test/rules/PredictedFacadeTest.groovy
@@ -0,0 +1,294 @@
+/*
+ * Copyright 2026, OpenRemote Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+package org.openremote.test.rules
+
+import org.openremote.manager.asset.AssetStorageService
+import org.openremote.manager.datapoint.AssetPredictedDatapointService
+import org.openremote.manager.rules.RulesEngineId
+import org.openremote.manager.rules.facade.PredictedFacade
+import org.openremote.manager.setup.SetupService
+import org.openremote.model.asset.impl.ThingAsset
+import org.openremote.model.attribute.Attribute
+import org.openremote.model.attribute.AttributeRef
+import org.openremote.model.datapoint.query.AssetDatapointAllQuery
+import org.openremote.model.util.UniqueIdentifierGenerator
+import org.openremote.model.value.ValueType
+import org.openremote.setup.integration.KeycloakTestSetup
+import org.openremote.test.ManagerContainerTrait
+import spock.lang.Specification
+
+import java.time.LocalDateTime
+import java.time.ZoneId
+import java.time.temporal.ChronoUnit
+
+class PredictedFacadeTest extends Specification implements ManagerContainerTrait {
+
+ private static final String ATTRIBUTE_NAME = "prediction"
+ private static final List<String> WRITE_OVERLOADS = ["asset ID", "attribute reference"]
+ private static final List<String> OPERATIONS = ["read", *WRITE_OVERLOADS]
+
+ AssetStorageService assetStorageService
+ AssetPredictedDatapointService predictedService
+ Map<String, ThingAsset> testAssets = [:]
+ List<String> createdAssetIds = []
+ String realm
+ LocalDateTime timestamp
+
+ def setup() {
+ def container = startContainer(defaultConfig(), defaultServices())
+ stopPseudoClock()
+ assetStorageService = container.getService(AssetStorageService.class)
+ predictedService = container.getService(AssetPredictedDatapointService.class)
+ def keycloakSetup = container.getService(SetupService.class).getTaskOfType(KeycloakTestSetup.class)
+ realm = keycloakSetup.realmBuilding.name
+ timestamp = getInstantTimeOf(container).atZone(ZoneId.systemDefault()).toLocalDateTime()
+ .plusDays(1).truncatedTo(ChronoUnit.SECONDS)
+
+ // The scope is below an ancestor; siblings share that ancestor but are outside the scope.
+ testAssets.ancestor = createAsset("Ancestor", realm)
+ testAssets.scoped = createAsset("Scoped", realm, testAssets.ancestor.id)
+ testAssets.child = createAsset("Child", realm, testAssets.scoped.id)
+ testAssets.grandchild = createAsset("Grandchild", realm, testAssets.child.id)
+ testAssets.sibling = createAsset("Sibling", realm, testAssets.ancestor.id)
+ testAssets.unrelated = createAsset("Unrelated", realm)
+ testAssets.otherRealm = createAsset("Other realm", keycloakSetup.realmCity.name)
+
+ // Seed every target so that denied reads cannot pass simply because no predictions exist.
+ testAssets.values().each { asset ->
+ predictedService.upsertValue(asset.id, ATTRIBUTE_NAME, 10d, timestamp)
+ }
+ }
+
+ def cleanup() {
+ try {
+ createdAssetIds.each { assetId ->
+ predictedService.purgeValues(assetId, ATTRIBUTE_NAME)
+ }
+ } finally {
+ // One test deletes its scope asset itself; delete the rest together so descendants
+ // are included even when a test has moved them to another parent.
+ def remainingAssetIds = createdAssetIds.findAll { assetId ->
+ assetStorageService.find(assetId, true) != null
+ }
+ if (!remainingAssetIds.isEmpty()) {
+ assert assetStorageService.delete(remainingAssetIds)
+ }
+ }
+ }
+
+ def "#scope scope reading #targetName predictions is allowed: #allowed"() {
+ given:
+ def facade = facadeFor(scope)
+ def target = testAssets[targetName]
+
+ when:
+ def result = facade.getValueDatapoints(reference(target.id), query())
+
+ then:
+ snapshot(result) == (allowed ? originalDatapoints() : [:])
+ storedDatapoints(target.id) == originalDatapoints()
+
+ where:
+ [scope, targetName, allowed] << scopeCases()
+ }
+
+ def "#scope scope writing #targetName predictions using #overload is allowed: #allowed"() {
+ given:
+ def facade = facadeFor(scope)
+ def target = testAssets[targetName]
+
+ when: "both an overwrite and an insertion are attempted"
+ writePredictions(facade, target.id, overload)
+
+ then:
+ storedDatapoints(target.id) == (allowed ? updatedDatapoints() : originalDatapoints())
+
+ where:
+ [scope, targetName, allowed, overload] << scopeCases().collectMany { row ->
+ WRITE_OVERLOADS.collect { overload -> row + [overload] }
+ }
+ }
+
+ def "#scope scope #operation on a missing target is denied without creating predictions"() {
+ given:
+ def facade = facadeFor(scope)
+ def missingId = UniqueIdentifierGenerator.generateId()
+ assert assetStorageService.find(missingId, true) == null
+
+ when:
+ def result = performOperation(facade, missingId, operation)
+
+ then:
+ notThrown(Exception)
+ operation != "read" || result.length == 0
+ predictedService.getDatapoints(reference(missingId)).isEmpty()
+
+ cleanup: "remove orphan predictions written by the currently unchecked facade"
+ predictedService.purgeValues(missingId, ATTRIBUTE_NAME)
+
+ where:
+ [scope, operation] << ["realm", "asset"].collectMany { scope ->
+ OPERATIONS.collect { operation -> [scope, operation] }
+ }
+ }
+
+ def "Asset scope #operation fails when the scope asset has been deleted"() {
+ given: "a facade whose scope asset exists at construction time"
+ def scopeAsset = createAsset("Deleted scope", realm)
+ def facade = new PredictedFacade(new RulesEngineId(realm, scopeAsset.id), assetStorageService, predictedService)
+ assert assetStorageService.delete([scopeAsset.id])
+ assert assetStorageService.find(scopeAsset.id, true) == null
+
+ when: "an existing target is accessed through the now invalid scope"
+ performOperation(facade, testAssets.unrelated.id, operation)
+
+ then: "the missing scope fails explicitly, as it does in AssetsFacade"
+ thrown(IllegalStateException)
+ storedDatapoints(testAssets.unrelated.id) == originalDatapoints()
+
+ where:
+ operation << OPERATIONS
+ }
+
+ def "Asset scope #operation is denied after a descendant moves outside the subtree"() {
+ given:
+ def facade = facadeFor("asset")
+ def targetId = testAssets.grandchild.id
+
+ and: "the operation succeeds while the target is a descendant"
+ def initialResult = performOperation(facade, targetId, operation)
+ assert operation != "read" || snapshot(initialResult) == originalDatapoints()
+ assert storedDatapoints(targetId) == (operation == "read" ? originalDatapoints() : updatedDatapoints())
+
+ and: "the target's parent is moved into another subtree in the same realm"
+ // Restore the baseline so that repeating a forbidden write would be observable.
+ predictedService.purgeValues(targetId, ATTRIBUTE_NAME)
+ predictedService.upsertValue(targetId, ATTRIBUTE_NAME, 10d, timestamp)
+ def child = assetStorageService.find(testAssets.child.id, true)
+ assetStorageService.merge(child.setParentId(testAssets.unrelated.id))
+ def movedTarget = assetStorageService.find(targetId, true)
+ assert movedTarget.realm == realm
+ assert !movedTarget.path.contains(testAssets.scoped.id)
+ assert movedTarget.path.contains(testAssets.unrelated.id)
+
+ when: "the same facade attempts the operation again"
+ def result = performOperation(facade, targetId, operation)
+
+ then:
+ operation != "read" || result.length == 0
+ storedDatapoints(targetId) == originalDatapoints()
+
+ where:
+ operation << OPERATIONS
+ }
+
+ private ThingAsset createAsset(String name, String assetRealm, String parentId = null) {
+ def asset = new ThingAsset("Predicted facade ${name}")
+ .setRealm(assetRealm)
+ .setParentId(parentId)
+ asset.addOrReplaceAttributes(new Attribute<>(ATTRIBUTE_NAME, ValueType.NUMBER))
+ asset = assetStorageService.merge(asset)
+ createdAssetIds.add(asset.id)
+ return asset
+ }
+
+ private PredictedFacade facadeFor(String scope) {
+ RulesEngineId engineId
+ switch (scope) {
+ case "global":
+ engineId = new RulesEngineId()
+ break
+ case "realm":
+ engineId = new RulesEngineId(realm)
+ break
+ case "asset":
+ engineId = new RulesEngineId(realm, testAssets.scoped.id)
+ break
+ default:
+ throw new IllegalArgumentException("Unknown scope: " + scope)
+ }
+ return new PredictedFacade(engineId, assetStorageService, predictedService)
+ }
+
+ private Object performOperation(PredictedFacade facade, String assetId, String operation) {
+ if (operation == "read") {
+ return facade.getValueDatapoints(reference(assetId), query())
+ }
+ writePredictions(facade, assetId, operation)
+ return null
+ }
+
+ private void writePredictions(PredictedFacade facade, String assetId, String overload) {
+ if (overload == "asset ID") {
+ facade.updateValue(assetId, ATTRIBUTE_NAME, 20d, timestamp)
+ facade.updateValue(assetId, ATTRIBUTE_NAME, 30d, timestamp.plusMinutes(1))
+ } else if (overload == "attribute reference") {
+ facade.updateValue(reference(assetId), 20d, timestamp)
+ facade.updateValue(reference(assetId), 30d, timestamp.plusMinutes(1))
+ } else {
+ throw new IllegalArgumentException("Unknown overload: " + overload)
+ }
+ }
+
+ private static AttributeRef reference(String assetId) {
+ return new AttributeRef(assetId, ATTRIBUTE_NAME)
+ }
+
+ private AssetDatapointAllQuery query() {
+ return new AssetDatapointAllQuery(timestamp.minusMinutes(1), timestamp.plusMinutes(2))
+ }
+
+ private Map storedDatapoints(String assetId) {
+ // Verify persistence directly, independently of the facade being tested.
+ return snapshot(predictedService.getDatapoints(reference(assetId)))
+ }
+
+ private static Map snapshot(def datapoints) {
+ return datapoints.collectEntries { [(it.timestamp): it.value] }
+ }
+
+ private Map originalDatapoints() {
+ return [(epochMillis(timestamp)): 10d]
+ }
+
+ private Map updatedDatapoints() {
+ return [(epochMillis(timestamp)): 20d, (epochMillis(timestamp.plusMinutes(1))): 30d]
+ }
+
+ private static long epochMillis(LocalDateTime time) {
+ return time.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli()
+ }
+
+ private static List<List> scopeCases() {
+ return [
+ ["global", "scoped", true],
+ ["global", "otherRealm", true],
+ ["realm", "scoped", true],
+ ["realm", "unrelated", true],
+ ["realm", "otherRealm", false],
+ ["asset", "scoped", true],
+ ["asset", "child", true],
+ ["asset", "grandchild", true],
+ ["asset", "ancestor", false],
+ ["asset", "sibling", false],
+ ["asset", "unrelated", false],
+ ["asset", "otherRealm", false]
+ ]
+ }
+}