100% open-source IoT Platform - Integrate your devices, add intelligence, build custom apps
Java asset-managementbuildingdashboarddataplatformdevice-managementedge-computingenergyenergy-managementenergy-monitorfleet-managementfleet-telematicsiotiot-applicationiot-platformmodbusmqttmqtt-brokerota-updaterules-enginesmartcity
Historic facade security enforcement (#3335)
Eric Bariauxd07a117b6165
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java b/manager/src/main/java/org/openremote/manager/rules/RulesEngine.javaindex 70ac9b527..990cc1c43 100644--- a/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java+++ b/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java@@ -180,7 +180,7 @@ public class RulesEngine<T extends Ruleset> {this.notificationFacade = new NotificationsFacade<>(id, notificationService);this.webhooksFacade = new WebhooksFacade<>(id, webhookService);this.alarmsFacade = new AlarmFacade<>(id, alarmService);- this.historicFacade = new HistoricFacade<>(id, assetDatapointService);+ this.historicFacade = new HistoricFacade<>(id, assetStorageService, assetDatapointService);this.predictedFacade =new PredictedFacade<>(id, assetStorageService, assetPredictedDatapointService);this.assetLocationPredicatesConsumer = assetLocationPredicatesConsumer;diff --git a/manager/src/main/java/org/openremote/manager/rules/facade/FacadeHelper.java b/manager/src/main/java/org/openremote/manager/rules/facade/FacadeHelper.javanew file mode 100644index 000000000..1415cab8e--- /dev/null+++ b/manager/src/main/java/org/openremote/manager/rules/facade/FacadeHelper.java@@ -0,0 +1,77 @@+/*+ * 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.manager.rules.facade;++import org.openremote.manager.asset.AssetStorageService;+import org.openremote.manager.rules.RulesEngineId;+import org.openremote.model.asset.Asset;+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.RealmRuleset;+import org.openremote.model.rules.Ruleset;++public class FacadeHelper {++ private FacadeHelper() {}++ public static boolean doesRuleEngineScopeAllowAccess(+ RulesEngineId<? extends Ruleset> rulesEngineId,+ String assetId,+ AssetStorageService assetStorageService) {+ 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/manager/src/main/java/org/openremote/manager/rules/facade/HistoricFacade.java b/manager/src/main/java/org/openremote/manager/rules/facade/HistoricFacade.javaindex 60e861ac4..0ed1cc24f 100644--- a/manager/src/main/java/org/openremote/manager/rules/facade/HistoricFacade.java+++ b/manager/src/main/java/org/openremote/manager/rules/facade/HistoricFacade.java@@ -19,6 +19,7 @@package org.openremote.manager.rules.facade;import java.util.logging.Logger;+import org.openremote.manager.asset.AssetStorageService;import org.openremote.manager.datapoint.AssetDatapointService;import org.openremote.manager.rules.RulesEngineId;import org.openremote.model.attribute.AttributeRef;@@ -31,17 +32,25 @@ public class HistoricFacade<T extends Ruleset> extends HistoricDatapoints {private static final Logger LOG = Logger.getLogger(HistoricFacade.class.getName());protected final RulesEngineId<T> rulesEngineId;+ protected final AssetStorageService assetStorageService;protected final AssetDatapointService assetDatapointService;public HistoricFacade(- RulesEngineId<T> rulesEngineId, AssetDatapointService assetDatapointService) {+ RulesEngineId<T> rulesEngineId,+ AssetStorageService assetStorageService,+ AssetDatapointService assetDatapointService) {this.rulesEngineId = rulesEngineId;+ this.assetStorageService = assetStorageService;this.assetDatapointService = assetDatapointService;}@Overridepublic ValueDatapoint<?>[] getValueDatapoints(AttributeRef attributeRef, AssetDatapointQuery query) {+ if (!FacadeHelper.doesRuleEngineScopeAllowAccess(+ rulesEngineId, attributeRef.getId(), assetStorageService)) {+ return new ValueDatapoint[0];+ }return assetDatapointService.queryDatapoints(attributeRef.getId(), attributeRef.getName(), query).toArray(ValueDatapoint[]::new);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.javaindex f72c0927a..8b54413f8 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@@ -23,16 +23,10 @@ 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 {@@ -53,7 +47,8 @@ public class PredictedFacade<T extends Ruleset> extends PredictedDatapoints {@Overridepublic ValueDatapoint<?>[] getValueDatapoints(AttributeRef attributeRef, AssetDatapointQuery query) {- if (!doesRuleEngineScopeAllowAccess(attributeRef.getId())) {+ if (!FacadeHelper.doesRuleEngineScopeAllowAccess(+ rulesEngineId, attributeRef.getId(), assetStorageService)) {return new ValueDatapoint[0];}return assetPredictedDatapointService@@ -64,7 +59,7 @@ public class PredictedFacade<T extends Ruleset> extends PredictedDatapoints {@Overridepublic void updateValue(String assetId, String attributeName, Object value, LocalDateTime timestamp) {- if (!doesRuleEngineScopeAllowAccess(assetId)) {+ if (!FacadeHelper.doesRuleEngineScopeAllowAccess(rulesEngineId, assetId, assetStorageService)) {return;}assetPredictedDatapointService.updateValue(assetId, attributeName, value, timestamp);@@ -78,7 +73,7 @@ public class PredictedFacade<T extends Ruleset> extends PredictedDatapoints {@Overridepublic void purgeValues(String assetId, String attributeName) {- if (!doesRuleEngineScopeAllowAccess(assetId)) {+ if (!FacadeHelper.doesRuleEngineScopeAllowAccess(rulesEngineId, assetId, assetStorageService)) {return;}assetPredictedDatapointService.purgeValues(assetId, attributeName);@@ -86,49 +81,9 @@ public class PredictedFacade<T extends Ruleset> extends PredictedDatapoints {@Overridepublic void purgeValuesBefore(String assetId, String attributeName, Instant timestamp) {- if (!doesRuleEngineScopeAllowAccess(assetId)) {+ if (!FacadeHelper.doesRuleEngineScopeAllowAccess(rulesEngineId, assetId, assetStorageService)) {return;}assetPredictedDatapointService.purgeValuesBefore(assetId, attributeName, 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/HistoricFacadeTest.groovy b/test/src/test/groovy/org/openremote/test/rules/HistoricFacadeTest.groovynew file mode 100644index 000000000..f58a61dc0--- /dev/null+++ b/test/src/test/groovy/org/openremote/test/rules/HistoricFacadeTest.groovy@@ -0,0 +1,240 @@+/*+ * 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.AssetDatapointService+import org.openremote.manager.rules.RulesEngineId+import org.openremote.manager.rules.facade.HistoricFacade+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 HistoricFacadeTest extends Specification implements ManagerContainerTrait {++ private static final String ATTRIBUTE_NAME = "history"++ AssetStorageService assetStorageService+ AssetDatapointService historicService+ Map<String, ThingAsset> testAssets = [:]+ List<String> createdAssetIds = []+ String realm+ LocalDateTime timestamp++ def setup() {+ def container = startContainer(defaultConfig(), defaultServices())+ stopPseudoClock()+ assetStorageService = container.getService(AssetStorageService.class)+ historicService = container.getService(AssetDatapointService.class)+ def keycloakSetup = container.getService(SetupService.class).getTaskOfType(KeycloakTestSetup.class)+ realm = keycloakSetup.realmBuilding.name+ timestamp = getInstantTimeOf(container).atZone(ZoneId.systemDefault()).toLocalDateTime()+ .minusHours(1).truncatedTo(ChronoUnit.SECONDS)++ // Siblings share an ancestor with the scope asset but are outside its subtree.+ 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 a denied read cannot pass just because history is absent.+ testAssets.values().each { asset ->+ historicService.upsertValue(asset.id, ATTRIBUTE_NAME, 10d, timestamp)+ historicService.upsertValue(asset.id, ATTRIBUTE_NAME, 20d, timestamp.plusMinutes(1))+ }+ }++ def cleanup() {+ // Asset deletion cascades to historic datapoints. Include moved descendants and+ // skip the scope asset that the deleted-scope test has already removed.+ def remainingAssetIds = createdAssetIds.findAll { assetId ->+ assetStorageService.find(assetId, true) != null+ }+ if (!remainingAssetIds.isEmpty()) {+ assert assetStorageService.delete(remainingAssetIds)+ }+ }++ def "#scope scope reading #targetName history is allowed: #allowed"() {+ given:+ def facade = facadeFor(scope)+ def targetId = testAssets[targetName].id+ assert storedDatapoints(targetId) == originalDatapoints()++ when:+ def result = facade.getValueDatapoints(reference(targetId), query())++ then:+ snapshot(result) == (allowed ? originalDatapoints() : [:])+ storedDatapoints(targetId) == originalDatapoints()++ where:+ scope | targetName | allowed+ "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+ }++ def "#scope scope reading an attribute without history returns no datapoints"() {+ given:+ def target = createAsset("Without history", realm, testAssets.scoped.id)+ def facade = facadeFor(scope)+ assert storedDatapoints(target.id).isEmpty()++ when:+ def result = facade.getValueDatapoints(reference(target.id), query())++ then:+ result.length == 0++ where:+ scope << ["global", "realm", "asset"]+ }++ def "#scope scope reading a missing target returns no datapoints"() {+ given:+ def facade = facadeFor(scope)+ def missingId = UniqueIdentifierGenerator.generateId()+ assert assetStorageService.find(missingId, true) == null++ when:+ def result = facade.getValueDatapoints(reference(missingId), query())++ then:+ result.length == 0+ testAssets.values().every { storedDatapoints(it.id) == originalDatapoints() }++ where:+ scope << ["realm", "asset"]+ }++ def "Asset scope reading history 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 HistoricFacade(new RulesEngineId(realm, scopeAsset.id), assetStorageService, historicService)+ assert assetStorageService.delete([scopeAsset.id])+ assert assetStorageService.find(scopeAsset.id, true) == null++ when: "an existing target is accessed through the now invalid scope"+ facade.getValueDatapoints(reference(testAssets.unrelated.id), query())++ then: "the missing scope fails explicitly, as in the other scoped facades"+ thrown(IllegalStateException)+ storedDatapoints(testAssets.unrelated.id) == originalDatapoints()+ }++ def "Asset scope reading history is denied after a descendant moves outside the subtree"() {+ given:+ def facade = facadeFor("asset")+ def targetId = testAssets.grandchild.id+ assert snapshot(facade.getValueDatapoints(reference(targetId), query())) == originalDatapoints()++ and: "the target's parent is moved into another subtree in the same realm"+ 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)+ assert storedDatapoints(targetId) == originalDatapoints()++ when: "the same facade reads the target again"+ def result = facade.getValueDatapoints(reference(targetId), query())++ then:+ result.length == 0+ storedDatapoints(targetId) == originalDatapoints()+ }++ private ThingAsset createAsset(String name, String assetRealm, String parentId = null) {+ def asset = new ThingAsset("Historic 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 HistoricFacade 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 HistoricFacade(engineId, assetStorageService, historicService)+ }++ 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 the seeded history independently of the facade under test.+ return snapshot(historicService.getDatapoints(reference(assetId)))+ }++ private static Map snapshot(def datapoints) {+ return datapoints.collectEntries { [(it.timestamp): it.value] }+ }++ private Map originalDatapoints() {+ return [(epochMillis(timestamp)): 10d, (epochMillis(timestamp.plusMinutes(1))): 20d]+ }++ private static long epochMillis(LocalDateTime time) {+ return time.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli()+ }+}