Skip to content

armgit / core

Public Imported from GitHub
0

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

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.java
index 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.java
new file mode 100644
index 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.java
index 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;
}
@Override
public 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.java
index 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 {
@Override
public 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 {
@Override
public 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 {
@Override
public 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 {
@Override
public 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.groovy
new file mode 100644
index 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()
+ }
+}